ParseDecl.cpp revision 42d6d0c91ab089cb252ab2f91c16d4557f458a2c
1//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Declaration portions of the Parser interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "clang/Parse/ParseDiagnostic.h" 16#include "clang/Basic/OpenCL.h" 17#include "clang/Sema/Scope.h" 18#include "clang/Sema/ParsedTemplate.h" 19#include "clang/Sema/PrettyDeclStackTrace.h" 20#include "RAIIObjectsForParser.h" 21#include "llvm/ADT/SmallSet.h" 22#include "llvm/ADT/StringSwitch.h" 23using namespace clang; 24 25//===----------------------------------------------------------------------===// 26// C99 6.7: Declarations. 27//===----------------------------------------------------------------------===// 28 29/// ParseTypeName 30/// type-name: [C99 6.7.6] 31/// specifier-qualifier-list abstract-declarator[opt] 32/// 33/// Called type-id in C++. 34TypeResult Parser::ParseTypeName(SourceRange *Range, 35 Declarator::TheContext Context, 36 AccessSpecifier AS, 37 Decl **OwnedType) { 38 // Parse the common declaration-specifiers piece. 39 DeclSpec DS(AttrFactory); 40 ParseSpecifierQualifierList(DS, AS); 41 if (OwnedType) 42 *OwnedType = DS.isTypeSpecOwned() ? DS.getRepAsDecl() : 0; 43 44 // Parse the abstract-declarator, if present. 45 Declarator DeclaratorInfo(DS, Context); 46 ParseDeclarator(DeclaratorInfo); 47 if (Range) 48 *Range = DeclaratorInfo.getSourceRange(); 49 50 if (DeclaratorInfo.isInvalidType()) 51 return true; 52 53 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 54} 55 56 57/// isAttributeLateParsed - Return true if the attribute has arguments that 58/// require late parsing. 59static bool isAttributeLateParsed(const IdentifierInfo &II) { 60 return llvm::StringSwitch<bool>(II.getName()) 61#include "clang/Parse/AttrLateParsed.inc" 62 .Default(false); 63} 64 65 66/// ParseGNUAttributes - Parse a non-empty attributes list. 67/// 68/// [GNU] attributes: 69/// attribute 70/// attributes attribute 71/// 72/// [GNU] attribute: 73/// '__attribute__' '(' '(' attribute-list ')' ')' 74/// 75/// [GNU] attribute-list: 76/// attrib 77/// attribute_list ',' attrib 78/// 79/// [GNU] attrib: 80/// empty 81/// attrib-name 82/// attrib-name '(' identifier ')' 83/// attrib-name '(' identifier ',' nonempty-expr-list ')' 84/// attrib-name '(' argument-expression-list [C99 6.5.2] ')' 85/// 86/// [GNU] attrib-name: 87/// identifier 88/// typespec 89/// typequal 90/// storageclass 91/// 92/// FIXME: The GCC grammar/code for this construct implies we need two 93/// token lookahead. Comment from gcc: "If they start with an identifier 94/// which is followed by a comma or close parenthesis, then the arguments 95/// start with that identifier; otherwise they are an expression list." 96/// 97/// GCC does not require the ',' between attribs in an attribute-list. 98/// 99/// At the moment, I am not doing 2 token lookahead. I am also unaware of 100/// any attributes that don't work (based on my limited testing). Most 101/// attributes are very simple in practice. Until we find a bug, I don't see 102/// a pressing need to implement the 2 token lookahead. 103 104void Parser::ParseGNUAttributes(ParsedAttributes &attrs, 105 SourceLocation *endLoc, 106 LateParsedAttrList *LateAttrs) { 107 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!"); 108 109 while (Tok.is(tok::kw___attribute)) { 110 ConsumeToken(); 111 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 112 "attribute")) { 113 SkipUntil(tok::r_paren, true); // skip until ) or ; 114 return; 115 } 116 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) { 117 SkipUntil(tok::r_paren, true); // skip until ) or ; 118 return; 119 } 120 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") )) 121 while (Tok.is(tok::identifier) || isDeclarationSpecifier() || 122 Tok.is(tok::comma)) { 123 if (Tok.is(tok::comma)) { 124 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,)) 125 ConsumeToken(); 126 continue; 127 } 128 // we have an identifier or declaration specifier (const, int, etc.) 129 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 130 SourceLocation AttrNameLoc = ConsumeToken(); 131 132 if (Tok.is(tok::l_paren)) { 133 // handle "parameterized" attributes 134 if (LateAttrs && !ClassStack.empty() && 135 isAttributeLateParsed(*AttrName)) { 136 // Delayed parsing is only available for attributes that occur 137 // in certain locations within a class scope. 138 LateParsedAttribute *LA = 139 new LateParsedAttribute(this, *AttrName, AttrNameLoc); 140 LateAttrs->push_back(LA); 141 getCurrentClass().LateParsedDeclarations.push_back(LA); 142 143 // consume everything up to and including the matching right parens 144 ConsumeAndStoreUntil(tok::r_paren, LA->Toks, true, false); 145 146 Token Eof; 147 Eof.startToken(); 148 Eof.setLocation(Tok.getLocation()); 149 LA->Toks.push_back(Eof); 150 } else { 151 ParseGNUAttributeArgs(AttrName, AttrNameLoc, attrs, endLoc); 152 } 153 } else { 154 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 155 0, SourceLocation(), 0, 0); 156 } 157 } 158 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 159 SkipUntil(tok::r_paren, false); 160 SourceLocation Loc = Tok.getLocation(); 161 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) { 162 SkipUntil(tok::r_paren, false); 163 } 164 if (endLoc) 165 *endLoc = Loc; 166 } 167} 168 169 170/// Parse the arguments to a parameterized GNU attribute 171void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName, 172 SourceLocation AttrNameLoc, 173 ParsedAttributes &Attrs, 174 SourceLocation *EndLoc) { 175 176 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('"); 177 178 // Availability attributes have their own grammar. 179 if (AttrName->isStr("availability")) { 180 ParseAvailabilityAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc); 181 return; 182 } 183 // Thread safety attributes fit into the FIXME case above, so we 184 // just parse the arguments as a list of expressions 185 if (IsThreadSafetyAttribute(AttrName->getName())) { 186 ParseThreadSafetyAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc); 187 return; 188 } 189 190 ConsumeParen(); // ignore the left paren loc for now 191 192 IdentifierInfo *ParmName = 0; 193 SourceLocation ParmLoc; 194 bool BuiltinType = false; 195 196 switch (Tok.getKind()) { 197 case tok::kw_char: 198 case tok::kw_wchar_t: 199 case tok::kw_char16_t: 200 case tok::kw_char32_t: 201 case tok::kw_bool: 202 case tok::kw_short: 203 case tok::kw_int: 204 case tok::kw_long: 205 case tok::kw___int64: 206 case tok::kw_signed: 207 case tok::kw_unsigned: 208 case tok::kw_float: 209 case tok::kw_double: 210 case tok::kw_void: 211 case tok::kw_typeof: 212 // __attribute__(( vec_type_hint(char) )) 213 // FIXME: Don't just discard the builtin type token. 214 ConsumeToken(); 215 BuiltinType = true; 216 break; 217 218 case tok::identifier: 219 ParmName = Tok.getIdentifierInfo(); 220 ParmLoc = ConsumeToken(); 221 break; 222 223 default: 224 break; 225 } 226 227 ExprVector ArgExprs(Actions); 228 229 if (!BuiltinType && 230 (ParmLoc.isValid() ? Tok.is(tok::comma) : Tok.isNot(tok::r_paren))) { 231 // Eat the comma. 232 if (ParmLoc.isValid()) 233 ConsumeToken(); 234 235 // Parse the non-empty comma-separated list of expressions. 236 while (1) { 237 ExprResult ArgExpr(ParseAssignmentExpression()); 238 if (ArgExpr.isInvalid()) { 239 SkipUntil(tok::r_paren); 240 return; 241 } 242 ArgExprs.push_back(ArgExpr.release()); 243 if (Tok.isNot(tok::comma)) 244 break; 245 ConsumeToken(); // Eat the comma, move to the next argument 246 } 247 } 248 else if (Tok.is(tok::less) && AttrName->isStr("iboutletcollection")) { 249 if (!ExpectAndConsume(tok::less, diag::err_expected_less_after, "<", 250 tok::greater)) { 251 while (Tok.is(tok::identifier)) { 252 ConsumeToken(); 253 if (Tok.is(tok::greater)) 254 break; 255 if (Tok.is(tok::comma)) { 256 ConsumeToken(); 257 continue; 258 } 259 } 260 if (Tok.isNot(tok::greater)) 261 Diag(Tok, diag::err_iboutletcollection_with_protocol); 262 SkipUntil(tok::r_paren, false, true); // skip until ')' 263 } 264 } 265 266 SourceLocation RParen = Tok.getLocation(); 267 if (!ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) { 268 AttributeList *attr = 269 Attrs.addNew(AttrName, SourceRange(AttrNameLoc, RParen), 0, AttrNameLoc, 270 ParmName, ParmLoc, ArgExprs.take(), ArgExprs.size()); 271 if (BuiltinType && attr->getKind() == AttributeList::AT_IBOutletCollection) 272 Diag(Tok, diag::err_iboutletcollection_builtintype); 273 } 274} 275 276 277/// ParseMicrosoftDeclSpec - Parse an __declspec construct 278/// 279/// [MS] decl-specifier: 280/// __declspec ( extended-decl-modifier-seq ) 281/// 282/// [MS] extended-decl-modifier-seq: 283/// extended-decl-modifier[opt] 284/// extended-decl-modifier extended-decl-modifier-seq 285 286void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &attrs) { 287 assert(Tok.is(tok::kw___declspec) && "Not a declspec!"); 288 289 ConsumeToken(); 290 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 291 "declspec")) { 292 SkipUntil(tok::r_paren, true); // skip until ) or ; 293 return; 294 } 295 296 while (Tok.getIdentifierInfo()) { 297 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 298 SourceLocation AttrNameLoc = ConsumeToken(); 299 300 // FIXME: Remove this when we have proper __declspec(property()) support. 301 // Just skip everything inside property(). 302 if (AttrName->getName() == "property") { 303 ConsumeParen(); 304 SkipUntil(tok::r_paren); 305 } 306 if (Tok.is(tok::l_paren)) { 307 ConsumeParen(); 308 // FIXME: This doesn't parse __declspec(property(get=get_func_name)) 309 // correctly. 310 ExprResult ArgExpr(ParseAssignmentExpression()); 311 if (!ArgExpr.isInvalid()) { 312 Expr *ExprList = ArgExpr.take(); 313 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 314 SourceLocation(), &ExprList, 1, true); 315 } 316 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 317 SkipUntil(tok::r_paren, false); 318 } else { 319 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 320 0, SourceLocation(), 0, 0, true); 321 } 322 } 323 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 324 SkipUntil(tok::r_paren, false); 325 return; 326} 327 328void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) { 329 // Treat these like attributes 330 // FIXME: Allow Sema to distinguish between these and real attributes! 331 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) || 332 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) || 333 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) || 334 Tok.is(tok::kw___ptr32) || 335 Tok.is(tok::kw___unaligned)) { 336 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 337 SourceLocation AttrNameLoc = ConsumeToken(); 338 if (Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64) || 339 Tok.is(tok::kw___ptr32)) 340 // FIXME: Support these properly! 341 continue; 342 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 343 SourceLocation(), 0, 0, true); 344 } 345} 346 347void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) { 348 // Treat these like attributes 349 while (Tok.is(tok::kw___pascal)) { 350 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 351 SourceLocation AttrNameLoc = ConsumeToken(); 352 attrs.addNew(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 353 SourceLocation(), 0, 0, true); 354 } 355} 356 357void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) { 358 // Treat these like attributes 359 while (Tok.is(tok::kw___kernel)) { 360 SourceLocation AttrNameLoc = ConsumeToken(); 361 attrs.addNew(PP.getIdentifierInfo("opencl_kernel_function"), 362 AttrNameLoc, 0, AttrNameLoc, 0, 363 SourceLocation(), 0, 0, false); 364 } 365} 366 367void Parser::ParseOpenCLQualifiers(DeclSpec &DS) { 368 SourceLocation Loc = Tok.getLocation(); 369 switch(Tok.getKind()) { 370 // OpenCL qualifiers: 371 case tok::kw___private: 372 case tok::kw_private: 373 DS.getAttributes().addNewInteger( 374 Actions.getASTContext(), 375 PP.getIdentifierInfo("address_space"), Loc, 0); 376 break; 377 378 case tok::kw___global: 379 DS.getAttributes().addNewInteger( 380 Actions.getASTContext(), 381 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_global); 382 break; 383 384 case tok::kw___local: 385 DS.getAttributes().addNewInteger( 386 Actions.getASTContext(), 387 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_local); 388 break; 389 390 case tok::kw___constant: 391 DS.getAttributes().addNewInteger( 392 Actions.getASTContext(), 393 PP.getIdentifierInfo("address_space"), Loc, LangAS::opencl_constant); 394 break; 395 396 case tok::kw___read_only: 397 DS.getAttributes().addNewInteger( 398 Actions.getASTContext(), 399 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_only); 400 break; 401 402 case tok::kw___write_only: 403 DS.getAttributes().addNewInteger( 404 Actions.getASTContext(), 405 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_write_only); 406 break; 407 408 case tok::kw___read_write: 409 DS.getAttributes().addNewInteger( 410 Actions.getASTContext(), 411 PP.getIdentifierInfo("opencl_image_access"), Loc, CLIA_read_write); 412 break; 413 default: break; 414 } 415} 416 417/// \brief Parse a version number. 418/// 419/// version: 420/// simple-integer 421/// simple-integer ',' simple-integer 422/// simple-integer ',' simple-integer ',' simple-integer 423VersionTuple Parser::ParseVersionTuple(SourceRange &Range) { 424 Range = Tok.getLocation(); 425 426 if (!Tok.is(tok::numeric_constant)) { 427 Diag(Tok, diag::err_expected_version); 428 SkipUntil(tok::comma, tok::r_paren, true, true, true); 429 return VersionTuple(); 430 } 431 432 // Parse the major (and possibly minor and subminor) versions, which 433 // are stored in the numeric constant. We utilize a quirk of the 434 // lexer, which is that it handles something like 1.2.3 as a single 435 // numeric constant, rather than two separate tokens. 436 llvm::SmallString<512> Buffer; 437 Buffer.resize(Tok.getLength()+1); 438 const char *ThisTokBegin = &Buffer[0]; 439 440 // Get the spelling of the token, which eliminates trigraphs, etc. 441 bool Invalid = false; 442 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin, &Invalid); 443 if (Invalid) 444 return VersionTuple(); 445 446 // Parse the major version. 447 unsigned AfterMajor = 0; 448 unsigned Major = 0; 449 while (AfterMajor < ActualLength && isdigit(ThisTokBegin[AfterMajor])) { 450 Major = Major * 10 + ThisTokBegin[AfterMajor] - '0'; 451 ++AfterMajor; 452 } 453 454 if (AfterMajor == 0) { 455 Diag(Tok, diag::err_expected_version); 456 SkipUntil(tok::comma, tok::r_paren, true, true, true); 457 return VersionTuple(); 458 } 459 460 if (AfterMajor == ActualLength) { 461 ConsumeToken(); 462 463 // We only had a single version component. 464 if (Major == 0) { 465 Diag(Tok, diag::err_zero_version); 466 return VersionTuple(); 467 } 468 469 return VersionTuple(Major); 470 } 471 472 if (ThisTokBegin[AfterMajor] != '.' || (AfterMajor + 1 == ActualLength)) { 473 Diag(Tok, diag::err_expected_version); 474 SkipUntil(tok::comma, tok::r_paren, true, true, true); 475 return VersionTuple(); 476 } 477 478 // Parse the minor version. 479 unsigned AfterMinor = AfterMajor + 1; 480 unsigned Minor = 0; 481 while (AfterMinor < ActualLength && isdigit(ThisTokBegin[AfterMinor])) { 482 Minor = Minor * 10 + ThisTokBegin[AfterMinor] - '0'; 483 ++AfterMinor; 484 } 485 486 if (AfterMinor == ActualLength) { 487 ConsumeToken(); 488 489 // We had major.minor. 490 if (Major == 0 && Minor == 0) { 491 Diag(Tok, diag::err_zero_version); 492 return VersionTuple(); 493 } 494 495 return VersionTuple(Major, Minor); 496 } 497 498 // If what follows is not a '.', we have a problem. 499 if (ThisTokBegin[AfterMinor] != '.') { 500 Diag(Tok, diag::err_expected_version); 501 SkipUntil(tok::comma, tok::r_paren, true, true, true); 502 return VersionTuple(); 503 } 504 505 // Parse the subminor version. 506 unsigned AfterSubminor = AfterMinor + 1; 507 unsigned Subminor = 0; 508 while (AfterSubminor < ActualLength && isdigit(ThisTokBegin[AfterSubminor])) { 509 Subminor = Subminor * 10 + ThisTokBegin[AfterSubminor] - '0'; 510 ++AfterSubminor; 511 } 512 513 if (AfterSubminor != ActualLength) { 514 Diag(Tok, diag::err_expected_version); 515 SkipUntil(tok::comma, tok::r_paren, true, true, true); 516 return VersionTuple(); 517 } 518 ConsumeToken(); 519 return VersionTuple(Major, Minor, Subminor); 520} 521 522/// \brief Parse the contents of the "availability" attribute. 523/// 524/// availability-attribute: 525/// 'availability' '(' platform ',' version-arg-list ')' 526/// 527/// platform: 528/// identifier 529/// 530/// version-arg-list: 531/// version-arg 532/// version-arg ',' version-arg-list 533/// 534/// version-arg: 535/// 'introduced' '=' version 536/// 'deprecated' '=' version 537/// 'removed' = version 538/// 'unavailable' 539void Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability, 540 SourceLocation AvailabilityLoc, 541 ParsedAttributes &attrs, 542 SourceLocation *endLoc) { 543 SourceLocation PlatformLoc; 544 IdentifierInfo *Platform = 0; 545 546 enum { Introduced, Deprecated, Obsoleted, Unknown }; 547 AvailabilityChange Changes[Unknown]; 548 549 // Opening '('. 550 BalancedDelimiterTracker T(*this, tok::l_paren); 551 if (T.consumeOpen()) { 552 Diag(Tok, diag::err_expected_lparen); 553 return; 554 } 555 556 // Parse the platform name, 557 if (Tok.isNot(tok::identifier)) { 558 Diag(Tok, diag::err_availability_expected_platform); 559 SkipUntil(tok::r_paren); 560 return; 561 } 562 Platform = Tok.getIdentifierInfo(); 563 PlatformLoc = ConsumeToken(); 564 565 // Parse the ',' following the platform name. 566 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "", tok::r_paren)) 567 return; 568 569 // If we haven't grabbed the pointers for the identifiers 570 // "introduced", "deprecated", and "obsoleted", do so now. 571 if (!Ident_introduced) { 572 Ident_introduced = PP.getIdentifierInfo("introduced"); 573 Ident_deprecated = PP.getIdentifierInfo("deprecated"); 574 Ident_obsoleted = PP.getIdentifierInfo("obsoleted"); 575 Ident_unavailable = PP.getIdentifierInfo("unavailable"); 576 } 577 578 // Parse the set of introductions/deprecations/removals. 579 SourceLocation UnavailableLoc; 580 do { 581 if (Tok.isNot(tok::identifier)) { 582 Diag(Tok, diag::err_availability_expected_change); 583 SkipUntil(tok::r_paren); 584 return; 585 } 586 IdentifierInfo *Keyword = Tok.getIdentifierInfo(); 587 SourceLocation KeywordLoc = ConsumeToken(); 588 589 if (Keyword == Ident_unavailable) { 590 if (UnavailableLoc.isValid()) { 591 Diag(KeywordLoc, diag::err_availability_redundant) 592 << Keyword << SourceRange(UnavailableLoc); 593 } 594 UnavailableLoc = KeywordLoc; 595 596 if (Tok.isNot(tok::comma)) 597 break; 598 599 ConsumeToken(); 600 continue; 601 } 602 603 if (Tok.isNot(tok::equal)) { 604 Diag(Tok, diag::err_expected_equal_after) 605 << Keyword; 606 SkipUntil(tok::r_paren); 607 return; 608 } 609 ConsumeToken(); 610 611 SourceRange VersionRange; 612 VersionTuple Version = ParseVersionTuple(VersionRange); 613 614 if (Version.empty()) { 615 SkipUntil(tok::r_paren); 616 return; 617 } 618 619 unsigned Index; 620 if (Keyword == Ident_introduced) 621 Index = Introduced; 622 else if (Keyword == Ident_deprecated) 623 Index = Deprecated; 624 else if (Keyword == Ident_obsoleted) 625 Index = Obsoleted; 626 else 627 Index = Unknown; 628 629 if (Index < Unknown) { 630 if (!Changes[Index].KeywordLoc.isInvalid()) { 631 Diag(KeywordLoc, diag::err_availability_redundant) 632 << Keyword 633 << SourceRange(Changes[Index].KeywordLoc, 634 Changes[Index].VersionRange.getEnd()); 635 } 636 637 Changes[Index].KeywordLoc = KeywordLoc; 638 Changes[Index].Version = Version; 639 Changes[Index].VersionRange = VersionRange; 640 } else { 641 Diag(KeywordLoc, diag::err_availability_unknown_change) 642 << Keyword << VersionRange; 643 } 644 645 if (Tok.isNot(tok::comma)) 646 break; 647 648 ConsumeToken(); 649 } while (true); 650 651 // Closing ')'. 652 if (T.consumeClose()) 653 return; 654 655 if (endLoc) 656 *endLoc = T.getCloseLocation(); 657 658 // The 'unavailable' availability cannot be combined with any other 659 // availability changes. Make sure that hasn't happened. 660 if (UnavailableLoc.isValid()) { 661 bool Complained = false; 662 for (unsigned Index = Introduced; Index != Unknown; ++Index) { 663 if (Changes[Index].KeywordLoc.isValid()) { 664 if (!Complained) { 665 Diag(UnavailableLoc, diag::warn_availability_and_unavailable) 666 << SourceRange(Changes[Index].KeywordLoc, 667 Changes[Index].VersionRange.getEnd()); 668 Complained = true; 669 } 670 671 // Clear out the availability. 672 Changes[Index] = AvailabilityChange(); 673 } 674 } 675 } 676 677 // Record this attribute 678 attrs.addNew(&Availability, 679 SourceRange(AvailabilityLoc, T.getCloseLocation()), 680 0, SourceLocation(), 681 Platform, PlatformLoc, 682 Changes[Introduced], 683 Changes[Deprecated], 684 Changes[Obsoleted], 685 UnavailableLoc, false, false); 686} 687 688 689// Late Parsed Attributes: 690// See other examples of late parsing in lib/Parse/ParseCXXInlineMethods 691 692void Parser::LateParsedDeclaration::ParseLexedAttributes() {} 693 694void Parser::LateParsedClass::ParseLexedAttributes() { 695 Self->ParseLexedAttributes(*Class); 696} 697 698void Parser::LateParsedAttribute::ParseLexedAttributes() { 699 Self->ParseLexedAttribute(*this); 700} 701 702/// Wrapper class which calls ParseLexedAttribute, after setting up the 703/// scope appropriately. 704void Parser::ParseLexedAttributes(ParsingClass &Class) { 705 // Deal with templates 706 // FIXME: Test cases to make sure this does the right thing for templates. 707 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 708 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, 709 HasTemplateScope); 710 if (HasTemplateScope) 711 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 712 713 // Set or update the scope flags to include Scope::ThisScope. 714 bool AlreadyHasClassScope = Class.TopLevelClass; 715 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope|Scope::ThisScope; 716 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope); 717 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope); 718 719 for (unsigned i = 0, ni = Class.LateParsedDeclarations.size(); i < ni; ++i) { 720 Class.LateParsedDeclarations[i]->ParseLexedAttributes(); 721 } 722} 723 724/// \brief Finish parsing an attribute for which parsing was delayed. 725/// This will be called at the end of parsing a class declaration 726/// for each LateParsedAttribute. We consume the saved tokens and 727/// create an attribute with the arguments filled in. We add this 728/// to the Attribute list for the decl. 729void Parser::ParseLexedAttribute(LateParsedAttribute &LA) { 730 // Save the current token position. 731 SourceLocation OrigLoc = Tok.getLocation(); 732 733 // Append the current token at the end of the new token stream so that it 734 // doesn't get lost. 735 LA.Toks.push_back(Tok); 736 PP.EnterTokenStream(LA.Toks.data(), LA.Toks.size(), true, false); 737 // Consume the previously pushed token. 738 ConsumeAnyToken(); 739 740 ParsedAttributes Attrs(AttrFactory); 741 SourceLocation endLoc; 742 743 // If the Decl is templatized, add template parameters to scope. 744 bool HasTemplateScope = LA.D && LA.D->isTemplateDecl(); 745 ParseScope TempScope(this, Scope::TemplateParamScope, HasTemplateScope); 746 if (HasTemplateScope) 747 Actions.ActOnReenterTemplateScope(Actions.CurScope, LA.D); 748 749 // If the Decl is on a function, add function parameters to the scope. 750 bool HasFunctionScope = LA.D && LA.D->isFunctionOrFunctionTemplate(); 751 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope, HasFunctionScope); 752 if (HasFunctionScope) 753 Actions.ActOnReenterFunctionContext(Actions.CurScope, LA.D); 754 755 ParseGNUAttributeArgs(&LA.AttrName, LA.AttrNameLoc, Attrs, &endLoc); 756 757 if (HasFunctionScope) { 758 Actions.ActOnExitFunctionContext(); 759 FnScope.Exit(); // Pop scope, and remove Decls from IdResolver 760 } 761 if (HasTemplateScope) { 762 TempScope.Exit(); 763 } 764 765 // Late parsed attributes must be attached to Decls by hand. If the 766 // LA.D is not set, then this was not done properly. 767 assert(LA.D && "No decl attached to late parsed attribute"); 768 Actions.ActOnFinishDelayedAttribute(getCurScope(), LA.D, Attrs); 769 770 if (Tok.getLocation() != OrigLoc) { 771 // Due to a parsing error, we either went over the cached tokens or 772 // there are still cached tokens left, so we skip the leftover tokens. 773 // Since this is an uncommon situation that should be avoided, use the 774 // expensive isBeforeInTranslationUnit call. 775 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 776 OrigLoc)) 777 while (Tok.getLocation() != OrigLoc && Tok.isNot(tok::eof)) 778 ConsumeAnyToken(); 779 } 780} 781 782/// \brief Wrapper around a case statement checking if AttrName is 783/// one of the thread safety attributes 784bool Parser::IsThreadSafetyAttribute(llvm::StringRef AttrName){ 785 return llvm::StringSwitch<bool>(AttrName) 786 .Case("guarded_by", true) 787 .Case("guarded_var", true) 788 .Case("pt_guarded_by", true) 789 .Case("pt_guarded_var", true) 790 .Case("lockable", true) 791 .Case("scoped_lockable", true) 792 .Case("no_thread_safety_analysis", true) 793 .Case("acquired_after", true) 794 .Case("acquired_before", true) 795 .Case("exclusive_lock_function", true) 796 .Case("shared_lock_function", true) 797 .Case("exclusive_trylock_function", true) 798 .Case("shared_trylock_function", true) 799 .Case("unlock_function", true) 800 .Case("lock_returned", true) 801 .Case("locks_excluded", true) 802 .Case("exclusive_locks_required", true) 803 .Case("shared_locks_required", true) 804 .Default(false); 805} 806 807/// \brief Parse the contents of thread safety attributes. These 808/// should always be parsed as an expression list. 809/// 810/// We need to special case the parsing due to the fact that if the first token 811/// of the first argument is an identifier, the main parse loop will store 812/// that token as a "parameter" and the rest of 813/// the arguments will be added to a list of "arguments". However, 814/// subsequent tokens in the first argument are lost. We instead parse each 815/// argument as an expression and add all arguments to the list of "arguments". 816/// In future, we will take advantage of this special case to also 817/// deal with some argument scoping issues here (for example, referring to a 818/// function parameter in the attribute on that function). 819void Parser::ParseThreadSafetyAttribute(IdentifierInfo &AttrName, 820 SourceLocation AttrNameLoc, 821 ParsedAttributes &Attrs, 822 SourceLocation *EndLoc) { 823 assert(Tok.is(tok::l_paren) && "Attribute arg list not starting with '('"); 824 825 BalancedDelimiterTracker T(*this, tok::l_paren); 826 T.consumeOpen(); 827 828 ExprVector ArgExprs(Actions); 829 bool ArgExprsOk = true; 830 831 // now parse the list of expressions 832 while (1) { 833 ExprResult ArgExpr(ParseAssignmentExpression()); 834 if (ArgExpr.isInvalid()) { 835 ArgExprsOk = false; 836 T.consumeClose(); 837 break; 838 } else { 839 ArgExprs.push_back(ArgExpr.release()); 840 } 841 if (Tok.isNot(tok::comma)) 842 break; 843 ConsumeToken(); // Eat the comma, move to the next argument 844 } 845 // Match the ')'. 846 if (ArgExprsOk && !T.consumeClose()) { 847 Attrs.addNew(&AttrName, AttrNameLoc, 0, AttrNameLoc, 0, SourceLocation(), 848 ArgExprs.take(), ArgExprs.size()); 849 } 850 if (EndLoc) 851 *EndLoc = T.getCloseLocation(); 852} 853 854void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) { 855 Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed) 856 << attrs.Range; 857} 858 859/// ParseDeclaration - Parse a full 'declaration', which consists of 860/// declaration-specifiers, some number of declarators, and a semicolon. 861/// 'Context' should be a Declarator::TheContext value. This returns the 862/// location of the semicolon in DeclEnd. 863/// 864/// declaration: [C99 6.7] 865/// block-declaration -> 866/// simple-declaration 867/// others [FIXME] 868/// [C++] template-declaration 869/// [C++] namespace-definition 870/// [C++] using-directive 871/// [C++] using-declaration 872/// [C++0x/C1X] static_assert-declaration 873/// others... [FIXME] 874/// 875Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts, 876 unsigned Context, 877 SourceLocation &DeclEnd, 878 ParsedAttributesWithRange &attrs) { 879 ParenBraceBracketBalancer BalancerRAIIObj(*this); 880 // Must temporarily exit the objective-c container scope for 881 // parsing c none objective-c decls. 882 ObjCDeclContextSwitch ObjCDC(*this); 883 884 Decl *SingleDecl = 0; 885 Decl *OwnedType = 0; 886 switch (Tok.getKind()) { 887 case tok::kw_template: 888 case tok::kw_export: 889 ProhibitAttributes(attrs); 890 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd); 891 break; 892 case tok::kw_inline: 893 // Could be the start of an inline namespace. Allowed as an ext in C++03. 894 if (getLang().CPlusPlus && NextToken().is(tok::kw_namespace)) { 895 ProhibitAttributes(attrs); 896 SourceLocation InlineLoc = ConsumeToken(); 897 SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc); 898 break; 899 } 900 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, 901 true); 902 case tok::kw_namespace: 903 ProhibitAttributes(attrs); 904 SingleDecl = ParseNamespace(Context, DeclEnd); 905 break; 906 case tok::kw_using: 907 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(), 908 DeclEnd, attrs, &OwnedType); 909 break; 910 case tok::kw_static_assert: 911 case tok::kw__Static_assert: 912 ProhibitAttributes(attrs); 913 SingleDecl = ParseStaticAssertDeclaration(DeclEnd); 914 break; 915 default: 916 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true); 917 } 918 919 // This routine returns a DeclGroup, if the thing we parsed only contains a 920 // single decl, convert it now. Alias declarations can also declare a type; 921 // include that too if it is present. 922 return Actions.ConvertDeclToDeclGroup(SingleDecl, OwnedType); 923} 924 925/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl] 926/// declaration-specifiers init-declarator-list[opt] ';' 927///[C90/C++]init-declarator-list ';' [TODO] 928/// [OMP] threadprivate-directive [TODO] 929/// 930/// for-range-declaration: [C++0x 6.5p1: stmt.ranged] 931/// attribute-specifier-seq[opt] type-specifier-seq declarator 932/// 933/// If RequireSemi is false, this does not check for a ';' at the end of the 934/// declaration. If it is true, it checks for and eats it. 935/// 936/// If FRI is non-null, we might be parsing a for-range-declaration instead 937/// of a simple-declaration. If we find that we are, we also parse the 938/// for-range-initializer, and place it here. 939Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(StmtVector &Stmts, 940 unsigned Context, 941 SourceLocation &DeclEnd, 942 ParsedAttributes &attrs, 943 bool RequireSemi, 944 ForRangeInit *FRI) { 945 // Parse the common declaration-specifiers piece. 946 ParsingDeclSpec DS(*this); 947 DS.takeAttributesFrom(attrs); 948 949 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, 950 getDeclSpecContextFromDeclaratorContext(Context)); 951 StmtResult R = Actions.ActOnVlaStmt(DS); 952 if (R.isUsable()) 953 Stmts.push_back(R.release()); 954 955 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" 956 // declaration-specifiers init-declarator-list[opt] ';' 957 if (Tok.is(tok::semi)) { 958 if (RequireSemi) ConsumeToken(); 959 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, 960 DS); 961 DS.complete(TheDecl); 962 return Actions.ConvertDeclToDeclGroup(TheDecl); 963 } 964 965 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd, FRI); 966} 967 968/// Returns true if this might be the start of a declarator, or a common typo 969/// for a declarator. 970bool Parser::MightBeDeclarator(unsigned Context) { 971 switch (Tok.getKind()) { 972 case tok::annot_cxxscope: 973 case tok::annot_template_id: 974 case tok::caret: 975 case tok::code_completion: 976 case tok::coloncolon: 977 case tok::ellipsis: 978 case tok::kw___attribute: 979 case tok::kw_operator: 980 case tok::l_paren: 981 case tok::star: 982 return true; 983 984 case tok::amp: 985 case tok::ampamp: 986 case tok::colon: // Might be a typo for '::'. 987 return getLang().CPlusPlus; 988 989 case tok::identifier: 990 switch (NextToken().getKind()) { 991 case tok::code_completion: 992 case tok::coloncolon: 993 case tok::comma: 994 case tok::equal: 995 case tok::equalequal: // Might be a typo for '='. 996 case tok::kw_alignas: 997 case tok::kw_asm: 998 case tok::kw___attribute: 999 case tok::l_brace: 1000 case tok::l_paren: 1001 case tok::l_square: 1002 case tok::less: 1003 case tok::r_brace: 1004 case tok::r_paren: 1005 case tok::r_square: 1006 case tok::semi: 1007 return true; 1008 1009 case tok::colon: 1010 // At namespace scope, 'identifier:' is probably a typo for 'identifier::' 1011 // and in block scope it's probably a label. 1012 return getLang().CPlusPlus && Context == Declarator::FileContext; 1013 1014 default: 1015 return false; 1016 } 1017 1018 default: 1019 return false; 1020 } 1021} 1022 1023/// ParseDeclGroup - Having concluded that this is either a function 1024/// definition or a group of object declarations, actually parse the 1025/// result. 1026Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, 1027 unsigned Context, 1028 bool AllowFunctionDefinitions, 1029 SourceLocation *DeclEnd, 1030 ForRangeInit *FRI) { 1031 // Parse the first declarator. 1032 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context)); 1033 ParseDeclarator(D); 1034 1035 // Bail out if the first declarator didn't seem well-formed. 1036 if (!D.hasName() && !D.mayOmitIdentifier()) { 1037 // Skip until ; or }. 1038 SkipUntil(tok::r_brace, true, true); 1039 if (Tok.is(tok::semi)) 1040 ConsumeToken(); 1041 return DeclGroupPtrTy(); 1042 } 1043 1044 // Check to see if we have a function *definition* which must have a body. 1045 if (AllowFunctionDefinitions && D.isFunctionDeclarator() && 1046 // Look at the next token to make sure that this isn't a function 1047 // declaration. We have to check this because __attribute__ might be the 1048 // start of a function definition in GCC-extended K&R C. 1049 !isDeclarationAfterDeclarator()) { 1050 1051 if (isStartOfFunctionDefinition(D)) { 1052 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 1053 Diag(Tok, diag::err_function_declared_typedef); 1054 1055 // Recover by treating the 'typedef' as spurious. 1056 DS.ClearStorageClassSpecs(); 1057 } 1058 1059 Decl *TheDecl = ParseFunctionDefinition(D); 1060 return Actions.ConvertDeclToDeclGroup(TheDecl); 1061 } 1062 1063 if (isDeclarationSpecifier()) { 1064 // If there is an invalid declaration specifier right after the function 1065 // prototype, then we must be in a missing semicolon case where this isn't 1066 // actually a body. Just fall through into the code that handles it as a 1067 // prototype, and let the top-level code handle the erroneous declspec 1068 // where it would otherwise expect a comma or semicolon. 1069 } else { 1070 Diag(Tok, diag::err_expected_fn_body); 1071 SkipUntil(tok::semi); 1072 return DeclGroupPtrTy(); 1073 } 1074 } 1075 1076 if (ParseAttributesAfterDeclarator(D)) 1077 return DeclGroupPtrTy(); 1078 1079 // C++0x [stmt.iter]p1: Check if we have a for-range-declarator. If so, we 1080 // must parse and analyze the for-range-initializer before the declaration is 1081 // analyzed. 1082 if (FRI && Tok.is(tok::colon)) { 1083 FRI->ColonLoc = ConsumeToken(); 1084 if (Tok.is(tok::l_brace)) 1085 FRI->RangeExpr = ParseBraceInitializer(); 1086 else 1087 FRI->RangeExpr = ParseExpression(); 1088 Decl *ThisDecl = Actions.ActOnDeclarator(getCurScope(), D); 1089 Actions.ActOnCXXForRangeDecl(ThisDecl); 1090 Actions.FinalizeDeclaration(ThisDecl); 1091 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, &ThisDecl, 1); 1092 } 1093 1094 SmallVector<Decl *, 8> DeclsInGroup; 1095 Decl *FirstDecl = ParseDeclarationAfterDeclaratorAndAttributes(D); 1096 D.complete(FirstDecl); 1097 if (FirstDecl) 1098 DeclsInGroup.push_back(FirstDecl); 1099 1100 bool ExpectSemi = Context != Declarator::ForContext; 1101 1102 // If we don't have a comma, it is either the end of the list (a ';') or an 1103 // error, bail out. 1104 while (Tok.is(tok::comma)) { 1105 SourceLocation CommaLoc = ConsumeToken(); 1106 1107 if (Tok.isAtStartOfLine() && ExpectSemi && !MightBeDeclarator(Context)) { 1108 // This comma was followed by a line-break and something which can't be 1109 // the start of a declarator. The comma was probably a typo for a 1110 // semicolon. 1111 Diag(CommaLoc, diag::err_expected_semi_declaration) 1112 << FixItHint::CreateReplacement(CommaLoc, ";"); 1113 ExpectSemi = false; 1114 break; 1115 } 1116 1117 // Parse the next declarator. 1118 D.clear(); 1119 1120 // Accept attributes in an init-declarator. In the first declarator in a 1121 // declaration, these would be part of the declspec. In subsequent 1122 // declarators, they become part of the declarator itself, so that they 1123 // don't apply to declarators after *this* one. Examples: 1124 // short __attribute__((common)) var; -> declspec 1125 // short var __attribute__((common)); -> declarator 1126 // short x, __attribute__((common)) var; -> declarator 1127 MaybeParseGNUAttributes(D); 1128 1129 ParseDeclarator(D); 1130 1131 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D); 1132 D.complete(ThisDecl); 1133 if (ThisDecl) 1134 DeclsInGroup.push_back(ThisDecl); 1135 } 1136 1137 if (DeclEnd) 1138 *DeclEnd = Tok.getLocation(); 1139 1140 if (ExpectSemi && 1141 ExpectAndConsume(tok::semi, 1142 Context == Declarator::FileContext 1143 ? diag::err_invalid_token_after_toplevel_declarator 1144 : diag::err_expected_semi_declaration)) { 1145 // Okay, there was no semicolon and one was expected. If we see a 1146 // declaration specifier, just assume it was missing and continue parsing. 1147 // Otherwise things are very confused and we skip to recover. 1148 if (!isDeclarationSpecifier()) { 1149 SkipUntil(tok::r_brace, true, true); 1150 if (Tok.is(tok::semi)) 1151 ConsumeToken(); 1152 } 1153 } 1154 1155 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, 1156 DeclsInGroup.data(), 1157 DeclsInGroup.size()); 1158} 1159 1160/// Parse an optional simple-asm-expr and attributes, and attach them to a 1161/// declarator. Returns true on an error. 1162bool Parser::ParseAttributesAfterDeclarator(Declarator &D) { 1163 // If a simple-asm-expr is present, parse it. 1164 if (Tok.is(tok::kw_asm)) { 1165 SourceLocation Loc; 1166 ExprResult AsmLabel(ParseSimpleAsm(&Loc)); 1167 if (AsmLabel.isInvalid()) { 1168 SkipUntil(tok::semi, true, true); 1169 return true; 1170 } 1171 1172 D.setAsmLabel(AsmLabel.release()); 1173 D.SetRangeEnd(Loc); 1174 } 1175 1176 MaybeParseGNUAttributes(D); 1177 return false; 1178} 1179 1180/// \brief Parse 'declaration' after parsing 'declaration-specifiers 1181/// declarator'. This method parses the remainder of the declaration 1182/// (including any attributes or initializer, among other things) and 1183/// finalizes the declaration. 1184/// 1185/// init-declarator: [C99 6.7] 1186/// declarator 1187/// declarator '=' initializer 1188/// [GNU] declarator simple-asm-expr[opt] attributes[opt] 1189/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer 1190/// [C++] declarator initializer[opt] 1191/// 1192/// [C++] initializer: 1193/// [C++] '=' initializer-clause 1194/// [C++] '(' expression-list ')' 1195/// [C++0x] '=' 'default' [TODO] 1196/// [C++0x] '=' 'delete' 1197/// [C++0x] braced-init-list 1198/// 1199/// According to the standard grammar, =default and =delete are function 1200/// definitions, but that definitely doesn't fit with the parser here. 1201/// 1202Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D, 1203 const ParsedTemplateInfo &TemplateInfo) { 1204 if (ParseAttributesAfterDeclarator(D)) 1205 return 0; 1206 1207 return ParseDeclarationAfterDeclaratorAndAttributes(D, TemplateInfo); 1208} 1209 1210Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(Declarator &D, 1211 const ParsedTemplateInfo &TemplateInfo) { 1212 // Inform the current actions module that we just parsed this declarator. 1213 Decl *ThisDecl = 0; 1214 switch (TemplateInfo.Kind) { 1215 case ParsedTemplateInfo::NonTemplate: 1216 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D); 1217 break; 1218 1219 case ParsedTemplateInfo::Template: 1220 case ParsedTemplateInfo::ExplicitSpecialization: 1221 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(), 1222 MultiTemplateParamsArg(Actions, 1223 TemplateInfo.TemplateParams->data(), 1224 TemplateInfo.TemplateParams->size()), 1225 D); 1226 break; 1227 1228 case ParsedTemplateInfo::ExplicitInstantiation: { 1229 DeclResult ThisRes 1230 = Actions.ActOnExplicitInstantiation(getCurScope(), 1231 TemplateInfo.ExternLoc, 1232 TemplateInfo.TemplateLoc, 1233 D); 1234 if (ThisRes.isInvalid()) { 1235 SkipUntil(tok::semi, true, true); 1236 return 0; 1237 } 1238 1239 ThisDecl = ThisRes.get(); 1240 break; 1241 } 1242 } 1243 1244 bool TypeContainsAuto = 1245 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto; 1246 1247 // Parse declarator '=' initializer. 1248 if (isTokenEqualOrMistypedEqualEqual( 1249 diag::err_invalid_equalequal_after_declarator)) { 1250 ConsumeToken(); 1251 if (Tok.is(tok::kw_delete)) { 1252 if (D.isFunctionDeclarator()) 1253 Diag(ConsumeToken(), diag::err_default_delete_in_multiple_declaration) 1254 << 1 /* delete */; 1255 else 1256 Diag(ConsumeToken(), diag::err_deleted_non_function); 1257 } else if (Tok.is(tok::kw_default)) { 1258 if (D.isFunctionDeclarator()) 1259 Diag(Tok, diag::err_default_delete_in_multiple_declaration) 1260 << 1 /* delete */; 1261 else 1262 Diag(ConsumeToken(), diag::err_default_special_members); 1263 } else { 1264 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1265 EnterScope(0); 1266 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 1267 } 1268 1269 if (Tok.is(tok::code_completion)) { 1270 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl); 1271 cutOffParsing(); 1272 return 0; 1273 } 1274 1275 ExprResult Init(ParseInitializer()); 1276 1277 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1278 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1279 ExitScope(); 1280 } 1281 1282 if (Init.isInvalid()) { 1283 SkipUntil(tok::comma, true, true); 1284 Actions.ActOnInitializerError(ThisDecl); 1285 } else 1286 Actions.AddInitializerToDecl(ThisDecl, Init.take(), 1287 /*DirectInit=*/false, TypeContainsAuto); 1288 } 1289 } else if (Tok.is(tok::l_paren)) { 1290 // Parse C++ direct initializer: '(' expression-list ')' 1291 BalancedDelimiterTracker T(*this, tok::l_paren); 1292 T.consumeOpen(); 1293 1294 ExprVector Exprs(Actions); 1295 CommaLocsTy CommaLocs; 1296 1297 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1298 EnterScope(0); 1299 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 1300 } 1301 1302 if (ParseExpressionList(Exprs, CommaLocs)) { 1303 SkipUntil(tok::r_paren); 1304 1305 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1306 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1307 ExitScope(); 1308 } 1309 } else { 1310 // Match the ')'. 1311 T.consumeClose(); 1312 1313 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() && 1314 "Unexpected number of commas!"); 1315 1316 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 1317 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1318 ExitScope(); 1319 } 1320 1321 Actions.AddCXXDirectInitializerToDecl(ThisDecl, T.getOpenLocation(), 1322 move_arg(Exprs), 1323 T.getCloseLocation(), 1324 TypeContainsAuto); 1325 } 1326 } else if (getLang().CPlusPlus0x && Tok.is(tok::l_brace)) { 1327 // Parse C++0x braced-init-list. 1328 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 1329 1330 if (D.getCXXScopeSpec().isSet()) { 1331 EnterScope(0); 1332 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 1333 } 1334 1335 ExprResult Init(ParseBraceInitializer()); 1336 1337 if (D.getCXXScopeSpec().isSet()) { 1338 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 1339 ExitScope(); 1340 } 1341 1342 if (Init.isInvalid()) { 1343 Actions.ActOnInitializerError(ThisDecl); 1344 } else 1345 Actions.AddInitializerToDecl(ThisDecl, Init.take(), 1346 /*DirectInit=*/true, TypeContainsAuto); 1347 1348 } else { 1349 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto); 1350 } 1351 1352 Actions.FinalizeDeclaration(ThisDecl); 1353 1354 return ThisDecl; 1355} 1356 1357/// ParseSpecifierQualifierList 1358/// specifier-qualifier-list: 1359/// type-specifier specifier-qualifier-list[opt] 1360/// type-qualifier specifier-qualifier-list[opt] 1361/// [GNU] attributes specifier-qualifier-list[opt] 1362/// 1363void Parser::ParseSpecifierQualifierList(DeclSpec &DS, AccessSpecifier AS) { 1364 /// specifier-qualifier-list is a subset of declaration-specifiers. Just 1365 /// parse declaration-specifiers and complain about extra stuff. 1366 /// TODO: diagnose attribute-specifiers and alignment-specifiers. 1367 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS); 1368 1369 // Validate declspec for type-name. 1370 unsigned Specs = DS.getParsedSpecifiers(); 1371 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() && 1372 !DS.hasAttributes()) 1373 Diag(Tok, diag::err_typename_requires_specqual); 1374 1375 // Issue diagnostic and remove storage class if present. 1376 if (Specs & DeclSpec::PQ_StorageClassSpecifier) { 1377 if (DS.getStorageClassSpecLoc().isValid()) 1378 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass); 1379 else 1380 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass); 1381 DS.ClearStorageClassSpecs(); 1382 } 1383 1384 // Issue diagnostic and remove function specfier if present. 1385 if (Specs & DeclSpec::PQ_FunctionSpecifier) { 1386 if (DS.isInlineSpecified()) 1387 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec); 1388 if (DS.isVirtualSpecified()) 1389 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec); 1390 if (DS.isExplicitSpecified()) 1391 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec); 1392 DS.ClearFunctionSpecs(); 1393 } 1394} 1395 1396/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the 1397/// specified token is valid after the identifier in a declarator which 1398/// immediately follows the declspec. For example, these things are valid: 1399/// 1400/// int x [ 4]; // direct-declarator 1401/// int x ( int y); // direct-declarator 1402/// int(int x ) // direct-declarator 1403/// int x ; // simple-declaration 1404/// int x = 17; // init-declarator-list 1405/// int x , y; // init-declarator-list 1406/// int x __asm__ ("foo"); // init-declarator-list 1407/// int x : 4; // struct-declarator 1408/// int x { 5}; // C++'0x unified initializers 1409/// 1410/// This is not, because 'x' does not immediately follow the declspec (though 1411/// ')' happens to be valid anyway). 1412/// int (x) 1413/// 1414static bool isValidAfterIdentifierInDeclarator(const Token &T) { 1415 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) || 1416 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) || 1417 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon); 1418} 1419 1420 1421/// ParseImplicitInt - This method is called when we have an non-typename 1422/// identifier in a declspec (which normally terminates the decl spec) when 1423/// the declspec has no type specifier. In this case, the declspec is either 1424/// malformed or is "implicit int" (in K&R and C89). 1425/// 1426/// This method handles diagnosing this prettily and returns false if the 1427/// declspec is done being processed. If it recovers and thinks there may be 1428/// other pieces of declspec after it, it returns true. 1429/// 1430bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS, 1431 const ParsedTemplateInfo &TemplateInfo, 1432 AccessSpecifier AS) { 1433 assert(Tok.is(tok::identifier) && "should have identifier"); 1434 1435 SourceLocation Loc = Tok.getLocation(); 1436 // If we see an identifier that is not a type name, we normally would 1437 // parse it as the identifer being declared. However, when a typename 1438 // is typo'd or the definition is not included, this will incorrectly 1439 // parse the typename as the identifier name and fall over misparsing 1440 // later parts of the diagnostic. 1441 // 1442 // As such, we try to do some look-ahead in cases where this would 1443 // otherwise be an "implicit-int" case to see if this is invalid. For 1444 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as 1445 // an identifier with implicit int, we'd get a parse error because the 1446 // next token is obviously invalid for a type. Parse these as a case 1447 // with an invalid type specifier. 1448 assert(!DS.hasTypeSpecifier() && "Type specifier checked above"); 1449 1450 // Since we know that this either implicit int (which is rare) or an 1451 // error, we'd do lookahead to try to do better recovery. 1452 if (isValidAfterIdentifierInDeclarator(NextToken())) { 1453 // If this token is valid for implicit int, e.g. "static x = 4", then 1454 // we just avoid eating the identifier, so it will be parsed as the 1455 // identifier in the declarator. 1456 return false; 1457 } 1458 1459 // Otherwise, if we don't consume this token, we are going to emit an 1460 // error anyway. Try to recover from various common problems. Check 1461 // to see if this was a reference to a tag name without a tag specified. 1462 // This is a common problem in C (saying 'foo' instead of 'struct foo'). 1463 // 1464 // C++ doesn't need this, and isTagName doesn't take SS. 1465 if (SS == 0) { 1466 const char *TagName = 0, *FixitTagName = 0; 1467 tok::TokenKind TagKind = tok::unknown; 1468 1469 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) { 1470 default: break; 1471 case DeclSpec::TST_enum: 1472 TagName="enum" ; FixitTagName = "enum " ; TagKind=tok::kw_enum ;break; 1473 case DeclSpec::TST_union: 1474 TagName="union" ; FixitTagName = "union " ;TagKind=tok::kw_union ;break; 1475 case DeclSpec::TST_struct: 1476 TagName="struct"; FixitTagName = "struct ";TagKind=tok::kw_struct;break; 1477 case DeclSpec::TST_class: 1478 TagName="class" ; FixitTagName = "class " ;TagKind=tok::kw_class ;break; 1479 } 1480 1481 if (TagName) { 1482 Diag(Loc, diag::err_use_of_tag_name_without_tag) 1483 << Tok.getIdentifierInfo() << TagName << getLang().CPlusPlus 1484 << FixItHint::CreateInsertion(Tok.getLocation(),FixitTagName); 1485 1486 // Parse this as a tag as if the missing tag were present. 1487 if (TagKind == tok::kw_enum) 1488 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS); 1489 else 1490 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS); 1491 return true; 1492 } 1493 } 1494 1495 // This is almost certainly an invalid type name. Let the action emit a 1496 // diagnostic and attempt to recover. 1497 ParsedType T; 1498 if (Actions.DiagnoseUnknownTypeName(*Tok.getIdentifierInfo(), Loc, 1499 getCurScope(), SS, T)) { 1500 // The action emitted a diagnostic, so we don't have to. 1501 if (T) { 1502 // The action has suggested that the type T could be used. Set that as 1503 // the type in the declaration specifiers, consume the would-be type 1504 // name token, and we're done. 1505 const char *PrevSpec; 1506 unsigned DiagID; 1507 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T); 1508 DS.SetRangeEnd(Tok.getLocation()); 1509 ConsumeToken(); 1510 1511 // There may be other declaration specifiers after this. 1512 return true; 1513 } 1514 1515 // Fall through; the action had no suggestion for us. 1516 } else { 1517 // The action did not emit a diagnostic, so emit one now. 1518 SourceRange R; 1519 if (SS) R = SS->getRange(); 1520 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R; 1521 } 1522 1523 // Mark this as an error. 1524 const char *PrevSpec; 1525 unsigned DiagID; 1526 DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec, DiagID); 1527 DS.SetRangeEnd(Tok.getLocation()); 1528 ConsumeToken(); 1529 1530 // TODO: Could inject an invalid typedef decl in an enclosing scope to 1531 // avoid rippling error messages on subsequent uses of the same type, 1532 // could be useful if #include was forgotten. 1533 return false; 1534} 1535 1536/// \brief Determine the declaration specifier context from the declarator 1537/// context. 1538/// 1539/// \param Context the declarator context, which is one of the 1540/// Declarator::TheContext enumerator values. 1541Parser::DeclSpecContext 1542Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) { 1543 if (Context == Declarator::MemberContext) 1544 return DSC_class; 1545 if (Context == Declarator::FileContext) 1546 return DSC_top_level; 1547 return DSC_normal; 1548} 1549 1550/// ParseAlignArgument - Parse the argument to an alignment-specifier. 1551/// 1552/// FIXME: Simply returns an alignof() expression if the argument is a 1553/// type. Ideally, the type should be propagated directly into Sema. 1554/// 1555/// [C1X] type-id 1556/// [C1X] constant-expression 1557/// [C++0x] type-id ...[opt] 1558/// [C++0x] assignment-expression ...[opt] 1559ExprResult Parser::ParseAlignArgument(SourceLocation Start, 1560 SourceLocation &EllipsisLoc) { 1561 ExprResult ER; 1562 if (isTypeIdInParens()) { 1563 SourceLocation TypeLoc = Tok.getLocation(); 1564 ParsedType Ty = ParseTypeName().get(); 1565 SourceRange TypeRange(Start, Tok.getLocation()); 1566 ER = Actions.ActOnUnaryExprOrTypeTraitExpr(TypeLoc, UETT_AlignOf, true, 1567 Ty.getAsOpaquePtr(), TypeRange); 1568 } else 1569 ER = ParseConstantExpression(); 1570 1571 if (getLang().CPlusPlus0x && Tok.is(tok::ellipsis)) 1572 EllipsisLoc = ConsumeToken(); 1573 1574 return ER; 1575} 1576 1577/// ParseAlignmentSpecifier - Parse an alignment-specifier, and add the 1578/// attribute to Attrs. 1579/// 1580/// alignment-specifier: 1581/// [C1X] '_Alignas' '(' type-id ')' 1582/// [C1X] '_Alignas' '(' constant-expression ')' 1583/// [C++0x] 'alignas' '(' type-id ...[opt] ')' 1584/// [C++0x] 'alignas' '(' assignment-expression ...[opt] ')' 1585void Parser::ParseAlignmentSpecifier(ParsedAttributes &Attrs, 1586 SourceLocation *endLoc) { 1587 assert((Tok.is(tok::kw_alignas) || Tok.is(tok::kw__Alignas)) && 1588 "Not an alignment-specifier!"); 1589 1590 SourceLocation KWLoc = Tok.getLocation(); 1591 ConsumeToken(); 1592 1593 BalancedDelimiterTracker T(*this, tok::l_paren); 1594 if (T.expectAndConsume(diag::err_expected_lparen)) 1595 return; 1596 1597 SourceLocation EllipsisLoc; 1598 ExprResult ArgExpr = ParseAlignArgument(T.getOpenLocation(), EllipsisLoc); 1599 if (ArgExpr.isInvalid()) { 1600 SkipUntil(tok::r_paren); 1601 return; 1602 } 1603 1604 T.consumeClose(); 1605 if (endLoc) 1606 *endLoc = T.getCloseLocation(); 1607 1608 // FIXME: Handle pack-expansions here. 1609 if (EllipsisLoc.isValid()) { 1610 Diag(EllipsisLoc, diag::err_alignas_pack_exp_unsupported); 1611 return; 1612 } 1613 1614 ExprVector ArgExprs(Actions); 1615 ArgExprs.push_back(ArgExpr.release()); 1616 Attrs.addNew(PP.getIdentifierInfo("aligned"), KWLoc, 0, KWLoc, 1617 0, T.getOpenLocation(), ArgExprs.take(), 1, false, true); 1618} 1619 1620/// ParseDeclarationSpecifiers 1621/// declaration-specifiers: [C99 6.7] 1622/// storage-class-specifier declaration-specifiers[opt] 1623/// type-specifier declaration-specifiers[opt] 1624/// [C99] function-specifier declaration-specifiers[opt] 1625/// [C1X] alignment-specifier declaration-specifiers[opt] 1626/// [GNU] attributes declaration-specifiers[opt] 1627/// [Clang] '__module_private__' declaration-specifiers[opt] 1628/// 1629/// storage-class-specifier: [C99 6.7.1] 1630/// 'typedef' 1631/// 'extern' 1632/// 'static' 1633/// 'auto' 1634/// 'register' 1635/// [C++] 'mutable' 1636/// [GNU] '__thread' 1637/// function-specifier: [C99 6.7.4] 1638/// [C99] 'inline' 1639/// [C++] 'virtual' 1640/// [C++] 'explicit' 1641/// [OpenCL] '__kernel' 1642/// 'friend': [C++ dcl.friend] 1643/// 'constexpr': [C++0x dcl.constexpr] 1644 1645/// 1646void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, 1647 const ParsedTemplateInfo &TemplateInfo, 1648 AccessSpecifier AS, 1649 DeclSpecContext DSContext) { 1650 if (DS.getSourceRange().isInvalid()) { 1651 DS.SetRangeStart(Tok.getLocation()); 1652 DS.SetRangeEnd(Tok.getLocation()); 1653 } 1654 1655 bool EnteringContext = (DSContext == DSC_class || DSContext == DSC_top_level); 1656 while (1) { 1657 bool isInvalid = false; 1658 const char *PrevSpec = 0; 1659 unsigned DiagID = 0; 1660 1661 SourceLocation Loc = Tok.getLocation(); 1662 1663 switch (Tok.getKind()) { 1664 default: 1665 DoneWithDeclSpec: 1666 // [C++0x] decl-specifier-seq: decl-specifier attribute-specifier-seq[opt] 1667 MaybeParseCXX0XAttributes(DS.getAttributes()); 1668 1669 // If this is not a declaration specifier token, we're done reading decl 1670 // specifiers. First verify that DeclSpec's are consistent. 1671 DS.Finish(Diags, PP); 1672 return; 1673 1674 case tok::code_completion: { 1675 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace; 1676 if (DS.hasTypeSpecifier()) { 1677 bool AllowNonIdentifiers 1678 = (getCurScope()->getFlags() & (Scope::ControlScope | 1679 Scope::BlockScope | 1680 Scope::TemplateParamScope | 1681 Scope::FunctionPrototypeScope | 1682 Scope::AtCatchScope)) == 0; 1683 bool AllowNestedNameSpecifiers 1684 = DSContext == DSC_top_level || 1685 (DSContext == DSC_class && DS.isFriendSpecified()); 1686 1687 Actions.CodeCompleteDeclSpec(getCurScope(), DS, 1688 AllowNonIdentifiers, 1689 AllowNestedNameSpecifiers); 1690 return cutOffParsing(); 1691 } 1692 1693 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent()) 1694 CCC = Sema::PCC_LocalDeclarationSpecifiers; 1695 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) 1696 CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate 1697 : Sema::PCC_Template; 1698 else if (DSContext == DSC_class) 1699 CCC = Sema::PCC_Class; 1700 else if (ObjCImpDecl) 1701 CCC = Sema::PCC_ObjCImplementation; 1702 1703 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC); 1704 return cutOffParsing(); 1705 } 1706 1707 case tok::coloncolon: // ::foo::bar 1708 // C++ scope specifier. Annotate and loop, or bail out on error. 1709 if (TryAnnotateCXXScopeToken(true)) { 1710 if (!DS.hasTypeSpecifier()) 1711 DS.SetTypeSpecError(); 1712 goto DoneWithDeclSpec; 1713 } 1714 if (Tok.is(tok::coloncolon)) // ::new or ::delete 1715 goto DoneWithDeclSpec; 1716 continue; 1717 1718 case tok::annot_cxxscope: { 1719 if (DS.hasTypeSpecifier()) 1720 goto DoneWithDeclSpec; 1721 1722 CXXScopeSpec SS; 1723 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(), 1724 Tok.getAnnotationRange(), 1725 SS); 1726 1727 // We are looking for a qualified typename. 1728 Token Next = NextToken(); 1729 if (Next.is(tok::annot_template_id) && 1730 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()) 1731 ->Kind == TNK_Type_template) { 1732 // We have a qualified template-id, e.g., N::A<int> 1733 1734 // C++ [class.qual]p2: 1735 // In a lookup in which the constructor is an acceptable lookup 1736 // result and the nested-name-specifier nominates a class C: 1737 // 1738 // - if the name specified after the 1739 // nested-name-specifier, when looked up in C, is the 1740 // injected-class-name of C (Clause 9), or 1741 // 1742 // - if the name specified after the nested-name-specifier 1743 // is the same as the identifier or the 1744 // simple-template-id's template-name in the last 1745 // component of the nested-name-specifier, 1746 // 1747 // the name is instead considered to name the constructor of 1748 // class C. 1749 // 1750 // Thus, if the template-name is actually the constructor 1751 // name, then the code is ill-formed; this interpretation is 1752 // reinforced by the NAD status of core issue 635. 1753 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Next); 1754 if ((DSContext == DSC_top_level || 1755 (DSContext == DSC_class && DS.isFriendSpecified())) && 1756 TemplateId->Name && 1757 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) { 1758 if (isConstructorDeclarator()) { 1759 // The user meant this to be an out-of-line constructor 1760 // definition, but template arguments are not allowed 1761 // there. Just allow this as a constructor; we'll 1762 // complain about it later. 1763 goto DoneWithDeclSpec; 1764 } 1765 1766 // The user meant this to name a type, but it actually names 1767 // a constructor with some extraneous template 1768 // arguments. Complain, then parse it as a type as the user 1769 // intended. 1770 Diag(TemplateId->TemplateNameLoc, 1771 diag::err_out_of_line_template_id_names_constructor) 1772 << TemplateId->Name; 1773 } 1774 1775 DS.getTypeSpecScope() = SS; 1776 ConsumeToken(); // The C++ scope. 1777 assert(Tok.is(tok::annot_template_id) && 1778 "ParseOptionalCXXScopeSpecifier not working"); 1779 AnnotateTemplateIdTokenAsType(); 1780 continue; 1781 } 1782 1783 if (Next.is(tok::annot_typename)) { 1784 DS.getTypeSpecScope() = SS; 1785 ConsumeToken(); // The C++ scope. 1786 if (Tok.getAnnotationValue()) { 1787 ParsedType T = getTypeAnnotation(Tok); 1788 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, 1789 Tok.getAnnotationEndLoc(), 1790 PrevSpec, DiagID, T); 1791 } 1792 else 1793 DS.SetTypeSpecError(); 1794 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1795 ConsumeToken(); // The typename 1796 } 1797 1798 if (Next.isNot(tok::identifier)) 1799 goto DoneWithDeclSpec; 1800 1801 // If we're in a context where the identifier could be a class name, 1802 // check whether this is a constructor declaration. 1803 if ((DSContext == DSC_top_level || 1804 (DSContext == DSC_class && DS.isFriendSpecified())) && 1805 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(), 1806 &SS)) { 1807 if (isConstructorDeclarator()) 1808 goto DoneWithDeclSpec; 1809 1810 // As noted in C++ [class.qual]p2 (cited above), when the name 1811 // of the class is qualified in a context where it could name 1812 // a constructor, its a constructor name. However, we've 1813 // looked at the declarator, and the user probably meant this 1814 // to be a type. Complain that it isn't supposed to be treated 1815 // as a type, then proceed to parse it as a type. 1816 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor) 1817 << Next.getIdentifierInfo(); 1818 } 1819 1820 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(), 1821 Next.getLocation(), 1822 getCurScope(), &SS, 1823 false, false, ParsedType(), 1824 /*NonTrivialSourceInfo=*/true); 1825 1826 // If the referenced identifier is not a type, then this declspec is 1827 // erroneous: We already checked about that it has no type specifier, and 1828 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the 1829 // typename. 1830 if (TypeRep == 0) { 1831 ConsumeToken(); // Eat the scope spec so the identifier is current. 1832 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue; 1833 goto DoneWithDeclSpec; 1834 } 1835 1836 DS.getTypeSpecScope() = SS; 1837 ConsumeToken(); // The C++ scope. 1838 1839 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1840 DiagID, TypeRep); 1841 if (isInvalid) 1842 break; 1843 1844 DS.SetRangeEnd(Tok.getLocation()); 1845 ConsumeToken(); // The typename. 1846 1847 continue; 1848 } 1849 1850 case tok::annot_typename: { 1851 if (Tok.getAnnotationValue()) { 1852 ParsedType T = getTypeAnnotation(Tok); 1853 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1854 DiagID, T); 1855 } else 1856 DS.SetTypeSpecError(); 1857 1858 if (isInvalid) 1859 break; 1860 1861 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1862 ConsumeToken(); // The typename 1863 1864 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1865 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1866 // Objective-C interface. 1867 if (Tok.is(tok::less) && getLang().ObjC1) 1868 ParseObjCProtocolQualifiers(DS); 1869 1870 continue; 1871 } 1872 1873 case tok::kw___is_signed: 1874 // GNU libstdc++ 4.4 uses __is_signed as an identifier, but Clang 1875 // typically treats it as a trait. If we see __is_signed as it appears 1876 // in libstdc++, e.g., 1877 // 1878 // static const bool __is_signed; 1879 // 1880 // then treat __is_signed as an identifier rather than as a keyword. 1881 if (DS.getTypeSpecType() == TST_bool && 1882 DS.getTypeQualifiers() == DeclSpec::TQ_const && 1883 DS.getStorageClassSpec() == DeclSpec::SCS_static) { 1884 Tok.getIdentifierInfo()->RevertTokenIDToIdentifier(); 1885 Tok.setKind(tok::identifier); 1886 } 1887 1888 // We're done with the declaration-specifiers. 1889 goto DoneWithDeclSpec; 1890 1891 // typedef-name 1892 case tok::kw_decltype: 1893 case tok::identifier: { 1894 // In C++, check to see if this is a scope specifier like foo::bar::, if 1895 // so handle it as such. This is important for ctor parsing. 1896 if (getLang().CPlusPlus) { 1897 if (TryAnnotateCXXScopeToken(true)) { 1898 if (!DS.hasTypeSpecifier()) 1899 DS.SetTypeSpecError(); 1900 goto DoneWithDeclSpec; 1901 } 1902 if (!Tok.is(tok::identifier)) 1903 continue; 1904 } 1905 1906 // This identifier can only be a typedef name if we haven't already seen 1907 // a type-specifier. Without this check we misparse: 1908 // typedef int X; struct Y { short X; }; as 'short int'. 1909 if (DS.hasTypeSpecifier()) 1910 goto DoneWithDeclSpec; 1911 1912 // Check for need to substitute AltiVec keyword tokens. 1913 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid)) 1914 break; 1915 1916 // It has to be available as a typedef too! 1917 ParsedType TypeRep = 1918 Actions.getTypeName(*Tok.getIdentifierInfo(), 1919 Tok.getLocation(), getCurScope()); 1920 1921 // If this is not a typedef name, don't parse it as part of the declspec, 1922 // it must be an implicit int or an error. 1923 if (!TypeRep) { 1924 if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue; 1925 goto DoneWithDeclSpec; 1926 } 1927 1928 // If we're in a context where the identifier could be a class name, 1929 // check whether this is a constructor declaration. 1930 if (getLang().CPlusPlus && DSContext == DSC_class && 1931 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) && 1932 isConstructorDeclarator()) 1933 goto DoneWithDeclSpec; 1934 1935 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1936 DiagID, TypeRep); 1937 if (isInvalid) 1938 break; 1939 1940 DS.SetRangeEnd(Tok.getLocation()); 1941 ConsumeToken(); // The identifier 1942 1943 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1944 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1945 // Objective-C interface. 1946 if (Tok.is(tok::less) && getLang().ObjC1) 1947 ParseObjCProtocolQualifiers(DS); 1948 1949 // Need to support trailing type qualifiers (e.g. "id<p> const"). 1950 // If a type specifier follows, it will be diagnosed elsewhere. 1951 continue; 1952 } 1953 1954 // type-name 1955 case tok::annot_template_id: { 1956 TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok); 1957 if (TemplateId->Kind != TNK_Type_template) { 1958 // This template-id does not refer to a type name, so we're 1959 // done with the type-specifiers. 1960 goto DoneWithDeclSpec; 1961 } 1962 1963 // If we're in a context where the template-id could be a 1964 // constructor name or specialization, check whether this is a 1965 // constructor declaration. 1966 if (getLang().CPlusPlus && DSContext == DSC_class && 1967 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) && 1968 isConstructorDeclarator()) 1969 goto DoneWithDeclSpec; 1970 1971 // Turn the template-id annotation token into a type annotation 1972 // token, then try again to parse it as a type-specifier. 1973 AnnotateTemplateIdTokenAsType(); 1974 continue; 1975 } 1976 1977 // GNU attributes support. 1978 case tok::kw___attribute: 1979 ParseGNUAttributes(DS.getAttributes()); 1980 continue; 1981 1982 // Microsoft declspec support. 1983 case tok::kw___declspec: 1984 ParseMicrosoftDeclSpec(DS.getAttributes()); 1985 continue; 1986 1987 // Microsoft single token adornments. 1988 case tok::kw___forceinline: 1989 // FIXME: Add handling here! 1990 break; 1991 1992 case tok::kw___ptr64: 1993 case tok::kw___ptr32: 1994 case tok::kw___w64: 1995 case tok::kw___cdecl: 1996 case tok::kw___stdcall: 1997 case tok::kw___fastcall: 1998 case tok::kw___thiscall: 1999 case tok::kw___unaligned: 2000 ParseMicrosoftTypeAttributes(DS.getAttributes()); 2001 continue; 2002 2003 // Borland single token adornments. 2004 case tok::kw___pascal: 2005 ParseBorlandTypeAttributes(DS.getAttributes()); 2006 continue; 2007 2008 // OpenCL single token adornments. 2009 case tok::kw___kernel: 2010 ParseOpenCLAttributes(DS.getAttributes()); 2011 continue; 2012 2013 // storage-class-specifier 2014 case tok::kw_typedef: 2015 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_typedef, Loc, 2016 PrevSpec, DiagID); 2017 break; 2018 case tok::kw_extern: 2019 if (DS.isThreadSpecified()) 2020 Diag(Tok, diag::ext_thread_before) << "extern"; 2021 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_extern, Loc, 2022 PrevSpec, DiagID); 2023 break; 2024 case tok::kw___private_extern__: 2025 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_private_extern, 2026 Loc, PrevSpec, DiagID); 2027 break; 2028 case tok::kw_static: 2029 if (DS.isThreadSpecified()) 2030 Diag(Tok, diag::ext_thread_before) << "static"; 2031 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_static, Loc, 2032 PrevSpec, DiagID); 2033 break; 2034 case tok::kw_auto: 2035 if (getLang().CPlusPlus0x) { 2036 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { 2037 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc, 2038 PrevSpec, DiagID); 2039 if (!isInvalid) 2040 Diag(Tok, diag::ext_auto_storage_class) 2041 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 2042 } else 2043 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, 2044 DiagID); 2045 } else 2046 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_auto, Loc, 2047 PrevSpec, DiagID); 2048 break; 2049 case tok::kw_register: 2050 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_register, Loc, 2051 PrevSpec, DiagID); 2052 break; 2053 case tok::kw_mutable: 2054 isInvalid = DS.SetStorageClassSpec(Actions, DeclSpec::SCS_mutable, Loc, 2055 PrevSpec, DiagID); 2056 break; 2057 case tok::kw___thread: 2058 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID); 2059 break; 2060 2061 // function-specifier 2062 case tok::kw_inline: 2063 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID); 2064 break; 2065 case tok::kw_virtual: 2066 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID); 2067 break; 2068 case tok::kw_explicit: 2069 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID); 2070 break; 2071 2072 // alignment-specifier 2073 case tok::kw__Alignas: 2074 if (!getLang().C1X) 2075 Diag(Tok, diag::ext_c1x_alignas); 2076 ParseAlignmentSpecifier(DS.getAttributes()); 2077 continue; 2078 2079 // friend 2080 case tok::kw_friend: 2081 if (DSContext == DSC_class) 2082 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID); 2083 else { 2084 PrevSpec = ""; // not actually used by the diagnostic 2085 DiagID = diag::err_friend_invalid_in_context; 2086 isInvalid = true; 2087 } 2088 break; 2089 2090 // Modules 2091 case tok::kw___module_private__: 2092 isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID); 2093 break; 2094 2095 // constexpr 2096 case tok::kw_constexpr: 2097 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID); 2098 break; 2099 2100 // type-specifier 2101 case tok::kw_short: 2102 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, 2103 DiagID); 2104 break; 2105 case tok::kw_long: 2106 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 2107 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, 2108 DiagID); 2109 else 2110 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 2111 DiagID); 2112 break; 2113 case tok::kw___int64: 2114 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 2115 DiagID); 2116 break; 2117 case tok::kw_signed: 2118 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, 2119 DiagID); 2120 break; 2121 case tok::kw_unsigned: 2122 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, 2123 DiagID); 2124 break; 2125 case tok::kw__Complex: 2126 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec, 2127 DiagID); 2128 break; 2129 case tok::kw__Imaginary: 2130 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec, 2131 DiagID); 2132 break; 2133 case tok::kw_void: 2134 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, 2135 DiagID); 2136 break; 2137 case tok::kw_char: 2138 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, 2139 DiagID); 2140 break; 2141 case tok::kw_int: 2142 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, 2143 DiagID); 2144 break; 2145 case tok::kw_half: 2146 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, 2147 DiagID); 2148 break; 2149 case tok::kw_float: 2150 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, 2151 DiagID); 2152 break; 2153 case tok::kw_double: 2154 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, 2155 DiagID); 2156 break; 2157 case tok::kw_wchar_t: 2158 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, 2159 DiagID); 2160 break; 2161 case tok::kw_char16_t: 2162 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, 2163 DiagID); 2164 break; 2165 case tok::kw_char32_t: 2166 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, 2167 DiagID); 2168 break; 2169 case tok::kw_bool: 2170 case tok::kw__Bool: 2171 if (Tok.is(tok::kw_bool) && 2172 DS.getTypeSpecType() != DeclSpec::TST_unspecified && 2173 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 2174 PrevSpec = ""; // Not used by the diagnostic. 2175 DiagID = diag::err_bool_redeclaration; 2176 // For better error recovery. 2177 Tok.setKind(tok::identifier); 2178 isInvalid = true; 2179 } else { 2180 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, 2181 DiagID); 2182 } 2183 break; 2184 case tok::kw__Decimal32: 2185 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec, 2186 DiagID); 2187 break; 2188 case tok::kw__Decimal64: 2189 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec, 2190 DiagID); 2191 break; 2192 case tok::kw__Decimal128: 2193 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec, 2194 DiagID); 2195 break; 2196 case tok::kw___vector: 2197 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 2198 break; 2199 case tok::kw___pixel: 2200 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 2201 break; 2202 case tok::kw___unknown_anytype: 2203 isInvalid = DS.SetTypeSpecType(TST_unknown_anytype, Loc, 2204 PrevSpec, DiagID); 2205 break; 2206 2207 // class-specifier: 2208 case tok::kw_class: 2209 case tok::kw_struct: 2210 case tok::kw_union: { 2211 tok::TokenKind Kind = Tok.getKind(); 2212 ConsumeToken(); 2213 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS, EnteringContext); 2214 continue; 2215 } 2216 2217 // enum-specifier: 2218 case tok::kw_enum: 2219 ConsumeToken(); 2220 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS); 2221 continue; 2222 2223 // cv-qualifier: 2224 case tok::kw_const: 2225 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID, 2226 getLang()); 2227 break; 2228 case tok::kw_volatile: 2229 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID, 2230 getLang()); 2231 break; 2232 case tok::kw_restrict: 2233 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID, 2234 getLang()); 2235 break; 2236 2237 // C++ typename-specifier: 2238 case tok::kw_typename: 2239 if (TryAnnotateTypeOrScopeToken()) { 2240 DS.SetTypeSpecError(); 2241 goto DoneWithDeclSpec; 2242 } 2243 if (!Tok.is(tok::kw_typename)) 2244 continue; 2245 break; 2246 2247 // GNU typeof support. 2248 case tok::kw_typeof: 2249 ParseTypeofSpecifier(DS); 2250 continue; 2251 2252 case tok::annot_decltype: 2253 ParseDecltypeSpecifier(DS); 2254 continue; 2255 2256 case tok::kw___underlying_type: 2257 ParseUnderlyingTypeSpecifier(DS); 2258 continue; 2259 2260 case tok::kw__Atomic: 2261 ParseAtomicSpecifier(DS); 2262 continue; 2263 2264 // OpenCL qualifiers: 2265 case tok::kw_private: 2266 if (!getLang().OpenCL) 2267 goto DoneWithDeclSpec; 2268 case tok::kw___private: 2269 case tok::kw___global: 2270 case tok::kw___local: 2271 case tok::kw___constant: 2272 case tok::kw___read_only: 2273 case tok::kw___write_only: 2274 case tok::kw___read_write: 2275 ParseOpenCLQualifiers(DS); 2276 break; 2277 2278 case tok::less: 2279 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for 2280 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous, 2281 // but we support it. 2282 if (DS.hasTypeSpecifier() || !getLang().ObjC1) 2283 goto DoneWithDeclSpec; 2284 2285 if (!ParseObjCProtocolQualifiers(DS)) 2286 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id) 2287 << FixItHint::CreateInsertion(Loc, "id") 2288 << SourceRange(Loc, DS.getSourceRange().getEnd()); 2289 2290 // Need to support trailing type qualifiers (e.g. "id<p> const"). 2291 // If a type specifier follows, it will be diagnosed elsewhere. 2292 continue; 2293 } 2294 // If the specifier wasn't legal, issue a diagnostic. 2295 if (isInvalid) { 2296 assert(PrevSpec && "Method did not return previous specifier!"); 2297 assert(DiagID); 2298 2299 if (DiagID == diag::ext_duplicate_declspec) 2300 Diag(Tok, DiagID) 2301 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation()); 2302 else 2303 Diag(Tok, DiagID) << PrevSpec; 2304 } 2305 2306 DS.SetRangeEnd(Tok.getLocation()); 2307 if (DiagID != diag::err_bool_redeclaration) 2308 ConsumeToken(); 2309 } 2310} 2311 2312/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We 2313/// primarily follow the C++ grammar with additions for C99 and GNU, 2314/// which together subsume the C grammar. Note that the C++ 2315/// type-specifier also includes the C type-qualifier (for const, 2316/// volatile, and C99 restrict). Returns true if a type-specifier was 2317/// found (and parsed), false otherwise. 2318/// 2319/// type-specifier: [C++ 7.1.5] 2320/// simple-type-specifier 2321/// class-specifier 2322/// enum-specifier 2323/// elaborated-type-specifier [TODO] 2324/// cv-qualifier 2325/// 2326/// cv-qualifier: [C++ 7.1.5.1] 2327/// 'const' 2328/// 'volatile' 2329/// [C99] 'restrict' 2330/// 2331/// simple-type-specifier: [ C++ 7.1.5.2] 2332/// '::'[opt] nested-name-specifier[opt] type-name [TODO] 2333/// '::'[opt] nested-name-specifier 'template' template-id [TODO] 2334/// 'char' 2335/// 'wchar_t' 2336/// 'bool' 2337/// 'short' 2338/// 'int' 2339/// 'long' 2340/// 'signed' 2341/// 'unsigned' 2342/// 'float' 2343/// 'double' 2344/// 'void' 2345/// [C99] '_Bool' 2346/// [C99] '_Complex' 2347/// [C99] '_Imaginary' // Removed in TC2? 2348/// [GNU] '_Decimal32' 2349/// [GNU] '_Decimal64' 2350/// [GNU] '_Decimal128' 2351/// [GNU] typeof-specifier 2352/// [OBJC] class-name objc-protocol-refs[opt] [TODO] 2353/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO] 2354/// [C++0x] 'decltype' ( expression ) 2355/// [AltiVec] '__vector' 2356bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, bool& isInvalid, 2357 const char *&PrevSpec, 2358 unsigned &DiagID, 2359 const ParsedTemplateInfo &TemplateInfo, 2360 bool SuppressDeclarations) { 2361 SourceLocation Loc = Tok.getLocation(); 2362 2363 switch (Tok.getKind()) { 2364 case tok::identifier: // foo::bar 2365 // If we already have a type specifier, this identifier is not a type. 2366 if (DS.getTypeSpecType() != DeclSpec::TST_unspecified || 2367 DS.getTypeSpecWidth() != DeclSpec::TSW_unspecified || 2368 DS.getTypeSpecSign() != DeclSpec::TSS_unspecified) 2369 return false; 2370 // Check for need to substitute AltiVec keyword tokens. 2371 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid)) 2372 break; 2373 // Fall through. 2374 case tok::kw_decltype: 2375 case tok::kw_typename: // typename foo::bar 2376 // Annotate typenames and C++ scope specifiers. If we get one, just 2377 // recurse to handle whatever we get. 2378 if (TryAnnotateTypeOrScopeToken(/*EnteringContext=*/false, 2379 /*NeedType=*/true)) 2380 return true; 2381 if (Tok.is(tok::identifier)) 2382 return false; 2383 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID, 2384 TemplateInfo, SuppressDeclarations); 2385 case tok::coloncolon: // ::foo::bar 2386 if (NextToken().is(tok::kw_new) || // ::new 2387 NextToken().is(tok::kw_delete)) // ::delete 2388 return false; 2389 2390 // Annotate typenames and C++ scope specifiers. If we get one, just 2391 // recurse to handle whatever we get. 2392 if (TryAnnotateTypeOrScopeToken(/*EnteringContext=*/false, 2393 /*NeedType=*/true)) 2394 return true; 2395 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID, 2396 TemplateInfo, SuppressDeclarations); 2397 2398 // simple-type-specifier: 2399 case tok::annot_typename: { 2400 if (ParsedType T = getTypeAnnotation(Tok)) { 2401 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, 2402 Tok.getAnnotationEndLoc(), PrevSpec, 2403 DiagID, T); 2404 } else 2405 DS.SetTypeSpecError(); 2406 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 2407 ConsumeToken(); // The typename 2408 2409 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 2410 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 2411 // Objective-C interface. If we don't have Objective-C or a '<', this is 2412 // just a normal reference to a typedef name. 2413 if (Tok.is(tok::less) && getLang().ObjC1) 2414 ParseObjCProtocolQualifiers(DS); 2415 2416 return true; 2417 } 2418 2419 case tok::kw_short: 2420 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID); 2421 break; 2422 case tok::kw_long: 2423 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 2424 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, 2425 DiagID); 2426 else 2427 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 2428 DiagID); 2429 break; 2430 case tok::kw___int64: 2431 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 2432 DiagID); 2433 break; 2434 case tok::kw_signed: 2435 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID); 2436 break; 2437 case tok::kw_unsigned: 2438 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, 2439 DiagID); 2440 break; 2441 case tok::kw__Complex: 2442 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec, 2443 DiagID); 2444 break; 2445 case tok::kw__Imaginary: 2446 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec, 2447 DiagID); 2448 break; 2449 case tok::kw_void: 2450 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID); 2451 break; 2452 case tok::kw_char: 2453 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID); 2454 break; 2455 case tok::kw_int: 2456 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID); 2457 break; 2458 case tok::kw_half: 2459 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID); 2460 break; 2461 case tok::kw_float: 2462 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID); 2463 break; 2464 case tok::kw_double: 2465 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID); 2466 break; 2467 case tok::kw_wchar_t: 2468 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID); 2469 break; 2470 case tok::kw_char16_t: 2471 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID); 2472 break; 2473 case tok::kw_char32_t: 2474 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID); 2475 break; 2476 case tok::kw_bool: 2477 case tok::kw__Bool: 2478 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID); 2479 break; 2480 case tok::kw__Decimal32: 2481 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec, 2482 DiagID); 2483 break; 2484 case tok::kw__Decimal64: 2485 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec, 2486 DiagID); 2487 break; 2488 case tok::kw__Decimal128: 2489 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec, 2490 DiagID); 2491 break; 2492 case tok::kw___vector: 2493 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 2494 break; 2495 case tok::kw___pixel: 2496 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 2497 break; 2498 2499 // class-specifier: 2500 case tok::kw_class: 2501 case tok::kw_struct: 2502 case tok::kw_union: { 2503 tok::TokenKind Kind = Tok.getKind(); 2504 ConsumeToken(); 2505 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS_none, 2506 /*EnteringContext=*/false, 2507 SuppressDeclarations); 2508 return true; 2509 } 2510 2511 // enum-specifier: 2512 case tok::kw_enum: 2513 ConsumeToken(); 2514 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS_none); 2515 return true; 2516 2517 // cv-qualifier: 2518 case tok::kw_const: 2519 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, 2520 DiagID, getLang()); 2521 break; 2522 case tok::kw_volatile: 2523 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 2524 DiagID, getLang()); 2525 break; 2526 case tok::kw_restrict: 2527 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 2528 DiagID, getLang()); 2529 break; 2530 2531 // GNU typeof support. 2532 case tok::kw_typeof: 2533 ParseTypeofSpecifier(DS); 2534 return true; 2535 2536 // C++0x decltype support. 2537 case tok::annot_decltype: 2538 ParseDecltypeSpecifier(DS); 2539 return true; 2540 2541 // C++0x type traits support. 2542 case tok::kw___underlying_type: 2543 ParseUnderlyingTypeSpecifier(DS); 2544 return true; 2545 2546 case tok::kw__Atomic: 2547 ParseAtomicSpecifier(DS); 2548 return true; 2549 2550 // OpenCL qualifiers: 2551 case tok::kw_private: 2552 if (!getLang().OpenCL) 2553 return false; 2554 case tok::kw___private: 2555 case tok::kw___global: 2556 case tok::kw___local: 2557 case tok::kw___constant: 2558 case tok::kw___read_only: 2559 case tok::kw___write_only: 2560 case tok::kw___read_write: 2561 ParseOpenCLQualifiers(DS); 2562 break; 2563 2564 // C++0x auto support. 2565 case tok::kw_auto: 2566 // This is only called in situations where a storage-class specifier is 2567 // illegal, so we can assume an auto type specifier was intended even in 2568 // C++98. In C++98 mode, DeclSpec::Finish will produce an appropriate 2569 // extension diagnostic. 2570 if (!getLang().CPlusPlus) 2571 return false; 2572 2573 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID); 2574 break; 2575 2576 case tok::kw___ptr64: 2577 case tok::kw___ptr32: 2578 case tok::kw___w64: 2579 case tok::kw___cdecl: 2580 case tok::kw___stdcall: 2581 case tok::kw___fastcall: 2582 case tok::kw___thiscall: 2583 case tok::kw___unaligned: 2584 ParseMicrosoftTypeAttributes(DS.getAttributes()); 2585 return true; 2586 2587 case tok::kw___pascal: 2588 ParseBorlandTypeAttributes(DS.getAttributes()); 2589 return true; 2590 2591 default: 2592 // Not a type-specifier; do nothing. 2593 return false; 2594 } 2595 2596 // If the specifier combination wasn't legal, issue a diagnostic. 2597 if (isInvalid) { 2598 assert(PrevSpec && "Method did not return previous specifier!"); 2599 // Pick between error or extwarn. 2600 Diag(Tok, DiagID) << PrevSpec; 2601 } 2602 DS.SetRangeEnd(Tok.getLocation()); 2603 ConsumeToken(); // whatever we parsed above. 2604 return true; 2605} 2606 2607/// ParseStructDeclaration - Parse a struct declaration without the terminating 2608/// semicolon. 2609/// 2610/// struct-declaration: 2611/// specifier-qualifier-list struct-declarator-list 2612/// [GNU] __extension__ struct-declaration 2613/// [GNU] specifier-qualifier-list 2614/// struct-declarator-list: 2615/// struct-declarator 2616/// struct-declarator-list ',' struct-declarator 2617/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator 2618/// struct-declarator: 2619/// declarator 2620/// [GNU] declarator attributes[opt] 2621/// declarator[opt] ':' constant-expression 2622/// [GNU] declarator[opt] ':' constant-expression attributes[opt] 2623/// 2624void Parser:: 2625ParseStructDeclaration(DeclSpec &DS, FieldCallback &Fields) { 2626 2627 if (Tok.is(tok::kw___extension__)) { 2628 // __extension__ silences extension warnings in the subexpression. 2629 ExtensionRAIIObject O(Diags); // Use RAII to do this. 2630 ConsumeToken(); 2631 return ParseStructDeclaration(DS, Fields); 2632 } 2633 2634 // Parse the common specifier-qualifiers-list piece. 2635 ParseSpecifierQualifierList(DS); 2636 2637 // If there are no declarators, this is a free-standing declaration 2638 // specifier. Let the actions module cope with it. 2639 if (Tok.is(tok::semi)) { 2640 Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS); 2641 return; 2642 } 2643 2644 // Read struct-declarators until we find the semicolon. 2645 bool FirstDeclarator = true; 2646 while (1) { 2647 ParsingDeclRAIIObject PD(*this); 2648 FieldDeclarator DeclaratorInfo(DS); 2649 2650 // Attributes are only allowed here on successive declarators. 2651 if (!FirstDeclarator) 2652 MaybeParseGNUAttributes(DeclaratorInfo.D); 2653 2654 /// struct-declarator: declarator 2655 /// struct-declarator: declarator[opt] ':' constant-expression 2656 if (Tok.isNot(tok::colon)) { 2657 // Don't parse FOO:BAR as if it were a typo for FOO::BAR. 2658 ColonProtectionRAIIObject X(*this); 2659 ParseDeclarator(DeclaratorInfo.D); 2660 } 2661 2662 if (Tok.is(tok::colon)) { 2663 ConsumeToken(); 2664 ExprResult Res(ParseConstantExpression()); 2665 if (Res.isInvalid()) 2666 SkipUntil(tok::semi, true, true); 2667 else 2668 DeclaratorInfo.BitfieldSize = Res.release(); 2669 } 2670 2671 // If attributes exist after the declarator, parse them. 2672 MaybeParseGNUAttributes(DeclaratorInfo.D); 2673 2674 // We're done with this declarator; invoke the callback. 2675 Decl *D = Fields.invoke(DeclaratorInfo); 2676 PD.complete(D); 2677 2678 // If we don't have a comma, it is either the end of the list (a ';') 2679 // or an error, bail out. 2680 if (Tok.isNot(tok::comma)) 2681 return; 2682 2683 // Consume the comma. 2684 ConsumeToken(); 2685 2686 FirstDeclarator = false; 2687 } 2688} 2689 2690/// ParseStructUnionBody 2691/// struct-contents: 2692/// struct-declaration-list 2693/// [EXT] empty 2694/// [GNU] "struct-declaration-list" without terminatoring ';' 2695/// struct-declaration-list: 2696/// struct-declaration 2697/// struct-declaration-list struct-declaration 2698/// [OBC] '@' 'defs' '(' class-name ')' 2699/// 2700void Parser::ParseStructUnionBody(SourceLocation RecordLoc, 2701 unsigned TagType, Decl *TagDecl) { 2702 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc, 2703 "parsing struct/union body"); 2704 2705 BalancedDelimiterTracker T(*this, tok::l_brace); 2706 if (T.consumeOpen()) 2707 return; 2708 2709 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope); 2710 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl); 2711 2712 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 2713 // C++. 2714 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 2715 Diag(Tok, diag::ext_empty_struct_union) 2716 << (TagType == TST_union); 2717 2718 SmallVector<Decl *, 32> FieldDecls; 2719 2720 // While we still have something to read, read the declarations in the struct. 2721 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 2722 // Each iteration of this loop reads one struct-declaration. 2723 2724 // Check for extraneous top-level semicolon. 2725 if (Tok.is(tok::semi)) { 2726 Diag(Tok, diag::ext_extra_struct_semi) 2727 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType) 2728 << FixItHint::CreateRemoval(Tok.getLocation()); 2729 ConsumeToken(); 2730 continue; 2731 } 2732 2733 // Parse all the comma separated declarators. 2734 DeclSpec DS(AttrFactory); 2735 2736 if (!Tok.is(tok::at)) { 2737 struct CFieldCallback : FieldCallback { 2738 Parser &P; 2739 Decl *TagDecl; 2740 SmallVectorImpl<Decl *> &FieldDecls; 2741 2742 CFieldCallback(Parser &P, Decl *TagDecl, 2743 SmallVectorImpl<Decl *> &FieldDecls) : 2744 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {} 2745 2746 virtual Decl *invoke(FieldDeclarator &FD) { 2747 // Install the declarator into the current TagDecl. 2748 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl, 2749 FD.D.getDeclSpec().getSourceRange().getBegin(), 2750 FD.D, FD.BitfieldSize); 2751 FieldDecls.push_back(Field); 2752 return Field; 2753 } 2754 } Callback(*this, TagDecl, FieldDecls); 2755 2756 ParseStructDeclaration(DS, Callback); 2757 } else { // Handle @defs 2758 ConsumeToken(); 2759 if (!Tok.isObjCAtKeyword(tok::objc_defs)) { 2760 Diag(Tok, diag::err_unexpected_at); 2761 SkipUntil(tok::semi, true); 2762 continue; 2763 } 2764 ConsumeToken(); 2765 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen); 2766 if (!Tok.is(tok::identifier)) { 2767 Diag(Tok, diag::err_expected_ident); 2768 SkipUntil(tok::semi, true); 2769 continue; 2770 } 2771 SmallVector<Decl *, 16> Fields; 2772 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(), 2773 Tok.getIdentifierInfo(), Fields); 2774 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end()); 2775 ConsumeToken(); 2776 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen); 2777 } 2778 2779 if (Tok.is(tok::semi)) { 2780 ConsumeToken(); 2781 } else if (Tok.is(tok::r_brace)) { 2782 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list); 2783 break; 2784 } else { 2785 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list); 2786 // Skip to end of block or statement to avoid ext-warning on extra ';'. 2787 SkipUntil(tok::r_brace, true, true); 2788 // If we stopped at a ';', eat it. 2789 if (Tok.is(tok::semi)) ConsumeToken(); 2790 } 2791 } 2792 2793 T.consumeClose(); 2794 2795 ParsedAttributes attrs(AttrFactory); 2796 // If attributes exist after struct contents, parse them. 2797 MaybeParseGNUAttributes(attrs); 2798 2799 Actions.ActOnFields(getCurScope(), 2800 RecordLoc, TagDecl, FieldDecls, 2801 T.getOpenLocation(), T.getCloseLocation(), 2802 attrs.getList()); 2803 StructScope.Exit(); 2804 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, 2805 T.getCloseLocation()); 2806} 2807 2808/// ParseEnumSpecifier 2809/// enum-specifier: [C99 6.7.2.2] 2810/// 'enum' identifier[opt] '{' enumerator-list '}' 2811///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}' 2812/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt] 2813/// '}' attributes[opt] 2814/// 'enum' identifier 2815/// [GNU] 'enum' attributes[opt] identifier 2816/// 2817/// [C++0x] enum-head '{' enumerator-list[opt] '}' 2818/// [C++0x] enum-head '{' enumerator-list ',' '}' 2819/// 2820/// enum-head: [C++0x] 2821/// enum-key attributes[opt] identifier[opt] enum-base[opt] 2822/// enum-key attributes[opt] nested-name-specifier identifier enum-base[opt] 2823/// 2824/// enum-key: [C++0x] 2825/// 'enum' 2826/// 'enum' 'class' 2827/// 'enum' 'struct' 2828/// 2829/// enum-base: [C++0x] 2830/// ':' type-specifier-seq 2831/// 2832/// [C++] elaborated-type-specifier: 2833/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier 2834/// 2835void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, 2836 const ParsedTemplateInfo &TemplateInfo, 2837 AccessSpecifier AS) { 2838 // Parse the tag portion of this. 2839 if (Tok.is(tok::code_completion)) { 2840 // Code completion for an enum name. 2841 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum); 2842 return cutOffParsing(); 2843 } 2844 2845 bool IsScopedEnum = false; 2846 bool IsScopedUsingClassTag = false; 2847 2848 if (getLang().CPlusPlus0x && 2849 (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) { 2850 Diag(Tok, diag::warn_cxx98_compat_scoped_enum); 2851 IsScopedEnum = true; 2852 IsScopedUsingClassTag = Tok.is(tok::kw_class); 2853 ConsumeToken(); 2854 } 2855 2856 // If attributes exist after tag, parse them. 2857 ParsedAttributes attrs(AttrFactory); 2858 MaybeParseGNUAttributes(attrs); 2859 2860 bool AllowFixedUnderlyingType 2861 = getLang().CPlusPlus0x || getLang().MicrosoftExt || getLang().ObjC2; 2862 2863 CXXScopeSpec &SS = DS.getTypeSpecScope(); 2864 if (getLang().CPlusPlus) { 2865 // "enum foo : bar;" is not a potential typo for "enum foo::bar;" 2866 // if a fixed underlying type is allowed. 2867 ColonProtectionRAIIObject X(*this, AllowFixedUnderlyingType); 2868 2869 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), 2870 /*EnteringContext=*/false)) 2871 return; 2872 2873 if (SS.isSet() && Tok.isNot(tok::identifier)) { 2874 Diag(Tok, diag::err_expected_ident); 2875 if (Tok.isNot(tok::l_brace)) { 2876 // Has no name and is not a definition. 2877 // Skip the rest of this declarator, up until the comma or semicolon. 2878 SkipUntil(tok::comma, true); 2879 return; 2880 } 2881 } 2882 } 2883 2884 // Must have either 'enum name' or 'enum {...}'. 2885 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) && 2886 (AllowFixedUnderlyingType && Tok.isNot(tok::colon))) { 2887 Diag(Tok, diag::err_expected_ident_lbrace); 2888 2889 // Skip the rest of this declarator, up until the comma or semicolon. 2890 SkipUntil(tok::comma, true); 2891 return; 2892 } 2893 2894 // If an identifier is present, consume and remember it. 2895 IdentifierInfo *Name = 0; 2896 SourceLocation NameLoc; 2897 if (Tok.is(tok::identifier)) { 2898 Name = Tok.getIdentifierInfo(); 2899 NameLoc = ConsumeToken(); 2900 } 2901 2902 if (!Name && IsScopedEnum) { 2903 // C++0x 7.2p2: The optional identifier shall not be omitted in the 2904 // declaration of a scoped enumeration. 2905 Diag(Tok, diag::err_scoped_enum_missing_identifier); 2906 IsScopedEnum = false; 2907 IsScopedUsingClassTag = false; 2908 } 2909 2910 TypeResult BaseType; 2911 2912 // Parse the fixed underlying type. 2913 if (AllowFixedUnderlyingType && Tok.is(tok::colon)) { 2914 bool PossibleBitfield = false; 2915 if (getCurScope()->getFlags() & Scope::ClassScope) { 2916 // If we're in class scope, this can either be an enum declaration with 2917 // an underlying type, or a declaration of a bitfield member. We try to 2918 // use a simple disambiguation scheme first to catch the common cases 2919 // (integer literal, sizeof); if it's still ambiguous, we then consider 2920 // anything that's a simple-type-specifier followed by '(' as an 2921 // expression. This suffices because function types are not valid 2922 // underlying types anyway. 2923 TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind()); 2924 // If the next token starts an expression, we know we're parsing a 2925 // bit-field. This is the common case. 2926 if (TPR == TPResult::True()) 2927 PossibleBitfield = true; 2928 // If the next token starts a type-specifier-seq, it may be either a 2929 // a fixed underlying type or the start of a function-style cast in C++; 2930 // lookahead one more token to see if it's obvious that we have a 2931 // fixed underlying type. 2932 else if (TPR == TPResult::False() && 2933 GetLookAheadToken(2).getKind() == tok::semi) { 2934 // Consume the ':'. 2935 ConsumeToken(); 2936 } else { 2937 // We have the start of a type-specifier-seq, so we have to perform 2938 // tentative parsing to determine whether we have an expression or a 2939 // type. 2940 TentativeParsingAction TPA(*this); 2941 2942 // Consume the ':'. 2943 ConsumeToken(); 2944 2945 if ((getLang().CPlusPlus && 2946 isCXXDeclarationSpecifier() != TPResult::True()) || 2947 (!getLang().CPlusPlus && !isDeclarationSpecifier(true))) { 2948 // We'll parse this as a bitfield later. 2949 PossibleBitfield = true; 2950 TPA.Revert(); 2951 } else { 2952 // We have a type-specifier-seq. 2953 TPA.Commit(); 2954 } 2955 } 2956 } else { 2957 // Consume the ':'. 2958 ConsumeToken(); 2959 } 2960 2961 if (!PossibleBitfield) { 2962 SourceRange Range; 2963 BaseType = ParseTypeName(&Range); 2964 2965 if (!getLang().CPlusPlus0x && !getLang().ObjC2) 2966 Diag(StartLoc, diag::ext_ms_enum_fixed_underlying_type) 2967 << Range; 2968 if (getLang().CPlusPlus0x) 2969 Diag(StartLoc, diag::warn_cxx98_compat_enum_fixed_underlying_type); 2970 } 2971 } 2972 2973 // There are three options here. If we have 'enum foo;', then this is a 2974 // forward declaration. If we have 'enum foo {...' then this is a 2975 // definition. Otherwise we have something like 'enum foo xyz', a reference. 2976 // 2977 // This is needed to handle stuff like this right (C99 6.7.2.3p11): 2978 // enum foo {..}; void bar() { enum foo; } <- new foo in bar. 2979 // enum foo {..}; void bar() { enum foo x; } <- use of old foo. 2980 // 2981 Sema::TagUseKind TUK; 2982 if (Tok.is(tok::l_brace)) 2983 TUK = Sema::TUK_Definition; 2984 else if (Tok.is(tok::semi)) 2985 TUK = Sema::TUK_Declaration; 2986 else 2987 TUK = Sema::TUK_Reference; 2988 2989 // enums cannot be templates, although they can be referenced from a 2990 // template. 2991 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate && 2992 TUK != Sema::TUK_Reference) { 2993 Diag(Tok, diag::err_enum_template); 2994 2995 // Skip the rest of this declarator, up until the comma or semicolon. 2996 SkipUntil(tok::comma, true); 2997 return; 2998 } 2999 3000 if (!Name && TUK != Sema::TUK_Definition) { 3001 Diag(Tok, diag::err_enumerator_unnamed_no_def); 3002 3003 // Skip the rest of this declarator, up until the comma or semicolon. 3004 SkipUntil(tok::comma, true); 3005 return; 3006 } 3007 3008 bool Owned = false; 3009 bool IsDependent = false; 3010 const char *PrevSpec = 0; 3011 unsigned DiagID; 3012 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK, 3013 StartLoc, SS, Name, NameLoc, attrs.getList(), 3014 AS, DS.getModulePrivateSpecLoc(), 3015 MultiTemplateParamsArg(Actions), 3016 Owned, IsDependent, IsScopedEnum, 3017 IsScopedUsingClassTag, BaseType); 3018 3019 if (IsDependent) { 3020 // This enum has a dependent nested-name-specifier. Handle it as a 3021 // dependent tag. 3022 if (!Name) { 3023 DS.SetTypeSpecError(); 3024 Diag(Tok, diag::err_expected_type_name_after_typename); 3025 return; 3026 } 3027 3028 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum, 3029 TUK, SS, Name, StartLoc, 3030 NameLoc); 3031 if (Type.isInvalid()) { 3032 DS.SetTypeSpecError(); 3033 return; 3034 } 3035 3036 if (DS.SetTypeSpecType(DeclSpec::TST_typename, StartLoc, 3037 NameLoc.isValid() ? NameLoc : StartLoc, 3038 PrevSpec, DiagID, Type.get())) 3039 Diag(StartLoc, DiagID) << PrevSpec; 3040 3041 return; 3042 } 3043 3044 if (!TagDecl) { 3045 // The action failed to produce an enumeration tag. If this is a 3046 // definition, consume the entire definition. 3047 if (Tok.is(tok::l_brace)) { 3048 ConsumeBrace(); 3049 SkipUntil(tok::r_brace); 3050 } 3051 3052 DS.SetTypeSpecError(); 3053 return; 3054 } 3055 3056 if (Tok.is(tok::l_brace)) 3057 ParseEnumBody(StartLoc, TagDecl); 3058 3059 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, 3060 NameLoc.isValid() ? NameLoc : StartLoc, 3061 PrevSpec, DiagID, TagDecl, Owned)) 3062 Diag(StartLoc, DiagID) << PrevSpec; 3063} 3064 3065/// ParseEnumBody - Parse a {} enclosed enumerator-list. 3066/// enumerator-list: 3067/// enumerator 3068/// enumerator-list ',' enumerator 3069/// enumerator: 3070/// enumeration-constant 3071/// enumeration-constant '=' constant-expression 3072/// enumeration-constant: 3073/// identifier 3074/// 3075void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) { 3076 // Enter the scope of the enum body and start the definition. 3077 ParseScope EnumScope(this, Scope::DeclScope); 3078 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl); 3079 3080 BalancedDelimiterTracker T(*this, tok::l_brace); 3081 T.consumeOpen(); 3082 3083 // C does not allow an empty enumerator-list, C++ does [dcl.enum]. 3084 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 3085 Diag(Tok, diag::error_empty_enum); 3086 3087 SmallVector<Decl *, 32> EnumConstantDecls; 3088 3089 Decl *LastEnumConstDecl = 0; 3090 3091 // Parse the enumerator-list. 3092 while (Tok.is(tok::identifier)) { 3093 IdentifierInfo *Ident = Tok.getIdentifierInfo(); 3094 SourceLocation IdentLoc = ConsumeToken(); 3095 3096 // If attributes exist after the enumerator, parse them. 3097 ParsedAttributes attrs(AttrFactory); 3098 MaybeParseGNUAttributes(attrs); 3099 3100 SourceLocation EqualLoc; 3101 ExprResult AssignedVal; 3102 if (Tok.is(tok::equal)) { 3103 EqualLoc = ConsumeToken(); 3104 AssignedVal = ParseConstantExpression(); 3105 if (AssignedVal.isInvalid()) 3106 SkipUntil(tok::comma, tok::r_brace, true, true); 3107 } 3108 3109 // Install the enumerator constant into EnumDecl. 3110 Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl, 3111 LastEnumConstDecl, 3112 IdentLoc, Ident, 3113 attrs.getList(), EqualLoc, 3114 AssignedVal.release()); 3115 EnumConstantDecls.push_back(EnumConstDecl); 3116 LastEnumConstDecl = EnumConstDecl; 3117 3118 if (Tok.is(tok::identifier)) { 3119 // We're missing a comma between enumerators. 3120 SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation); 3121 Diag(Loc, diag::err_enumerator_list_missing_comma) 3122 << FixItHint::CreateInsertion(Loc, ", "); 3123 continue; 3124 } 3125 3126 if (Tok.isNot(tok::comma)) 3127 break; 3128 SourceLocation CommaLoc = ConsumeToken(); 3129 3130 if (Tok.isNot(tok::identifier)) { 3131 if (!getLang().C99 && !getLang().CPlusPlus0x) 3132 Diag(CommaLoc, diag::ext_enumerator_list_comma) 3133 << getLang().CPlusPlus 3134 << FixItHint::CreateRemoval(CommaLoc); 3135 else if (getLang().CPlusPlus0x) 3136 Diag(CommaLoc, diag::warn_cxx98_compat_enumerator_list_comma) 3137 << FixItHint::CreateRemoval(CommaLoc); 3138 } 3139 } 3140 3141 // Eat the }. 3142 T.consumeClose(); 3143 3144 // If attributes exist after the identifier list, parse them. 3145 ParsedAttributes attrs(AttrFactory); 3146 MaybeParseGNUAttributes(attrs); 3147 3148 Actions.ActOnEnumBody(StartLoc, T.getOpenLocation(), T.getCloseLocation(), 3149 EnumDecl, EnumConstantDecls.data(), 3150 EnumConstantDecls.size(), getCurScope(), 3151 attrs.getList()); 3152 3153 EnumScope.Exit(); 3154 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, 3155 T.getCloseLocation()); 3156} 3157 3158/// isTypeSpecifierQualifier - Return true if the current token could be the 3159/// start of a type-qualifier-list. 3160bool Parser::isTypeQualifier() const { 3161 switch (Tok.getKind()) { 3162 default: return false; 3163 3164 // type-qualifier only in OpenCL 3165 case tok::kw_private: 3166 return getLang().OpenCL; 3167 3168 // type-qualifier 3169 case tok::kw_const: 3170 case tok::kw_volatile: 3171 case tok::kw_restrict: 3172 case tok::kw___private: 3173 case tok::kw___local: 3174 case tok::kw___global: 3175 case tok::kw___constant: 3176 case tok::kw___read_only: 3177 case tok::kw___read_write: 3178 case tok::kw___write_only: 3179 return true; 3180 } 3181} 3182 3183/// isKnownToBeTypeSpecifier - Return true if we know that the specified token 3184/// is definitely a type-specifier. Return false if it isn't part of a type 3185/// specifier or if we're not sure. 3186bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const { 3187 switch (Tok.getKind()) { 3188 default: return false; 3189 // type-specifiers 3190 case tok::kw_short: 3191 case tok::kw_long: 3192 case tok::kw___int64: 3193 case tok::kw_signed: 3194 case tok::kw_unsigned: 3195 case tok::kw__Complex: 3196 case tok::kw__Imaginary: 3197 case tok::kw_void: 3198 case tok::kw_char: 3199 case tok::kw_wchar_t: 3200 case tok::kw_char16_t: 3201 case tok::kw_char32_t: 3202 case tok::kw_int: 3203 case tok::kw_half: 3204 case tok::kw_float: 3205 case tok::kw_double: 3206 case tok::kw_bool: 3207 case tok::kw__Bool: 3208 case tok::kw__Decimal32: 3209 case tok::kw__Decimal64: 3210 case tok::kw__Decimal128: 3211 case tok::kw___vector: 3212 3213 // struct-or-union-specifier (C99) or class-specifier (C++) 3214 case tok::kw_class: 3215 case tok::kw_struct: 3216 case tok::kw_union: 3217 // enum-specifier 3218 case tok::kw_enum: 3219 3220 // typedef-name 3221 case tok::annot_typename: 3222 return true; 3223 } 3224} 3225 3226/// isTypeSpecifierQualifier - Return true if the current token could be the 3227/// start of a specifier-qualifier-list. 3228bool Parser::isTypeSpecifierQualifier() { 3229 switch (Tok.getKind()) { 3230 default: return false; 3231 3232 case tok::identifier: // foo::bar 3233 if (TryAltiVecVectorToken()) 3234 return true; 3235 // Fall through. 3236 case tok::kw_typename: // typename T::type 3237 // Annotate typenames and C++ scope specifiers. If we get one, just 3238 // recurse to handle whatever we get. 3239 if (TryAnnotateTypeOrScopeToken()) 3240 return true; 3241 if (Tok.is(tok::identifier)) 3242 return false; 3243 return isTypeSpecifierQualifier(); 3244 3245 case tok::coloncolon: // ::foo::bar 3246 if (NextToken().is(tok::kw_new) || // ::new 3247 NextToken().is(tok::kw_delete)) // ::delete 3248 return false; 3249 3250 if (TryAnnotateTypeOrScopeToken()) 3251 return true; 3252 return isTypeSpecifierQualifier(); 3253 3254 // GNU attributes support. 3255 case tok::kw___attribute: 3256 // GNU typeof support. 3257 case tok::kw_typeof: 3258 3259 // type-specifiers 3260 case tok::kw_short: 3261 case tok::kw_long: 3262 case tok::kw___int64: 3263 case tok::kw_signed: 3264 case tok::kw_unsigned: 3265 case tok::kw__Complex: 3266 case tok::kw__Imaginary: 3267 case tok::kw_void: 3268 case tok::kw_char: 3269 case tok::kw_wchar_t: 3270 case tok::kw_char16_t: 3271 case tok::kw_char32_t: 3272 case tok::kw_int: 3273 case tok::kw_half: 3274 case tok::kw_float: 3275 case tok::kw_double: 3276 case tok::kw_bool: 3277 case tok::kw__Bool: 3278 case tok::kw__Decimal32: 3279 case tok::kw__Decimal64: 3280 case tok::kw__Decimal128: 3281 case tok::kw___vector: 3282 3283 // struct-or-union-specifier (C99) or class-specifier (C++) 3284 case tok::kw_class: 3285 case tok::kw_struct: 3286 case tok::kw_union: 3287 // enum-specifier 3288 case tok::kw_enum: 3289 3290 // type-qualifier 3291 case tok::kw_const: 3292 case tok::kw_volatile: 3293 case tok::kw_restrict: 3294 3295 // typedef-name 3296 case tok::annot_typename: 3297 return true; 3298 3299 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 3300 case tok::less: 3301 return getLang().ObjC1; 3302 3303 case tok::kw___cdecl: 3304 case tok::kw___stdcall: 3305 case tok::kw___fastcall: 3306 case tok::kw___thiscall: 3307 case tok::kw___w64: 3308 case tok::kw___ptr64: 3309 case tok::kw___ptr32: 3310 case tok::kw___pascal: 3311 case tok::kw___unaligned: 3312 3313 case tok::kw___private: 3314 case tok::kw___local: 3315 case tok::kw___global: 3316 case tok::kw___constant: 3317 case tok::kw___read_only: 3318 case tok::kw___read_write: 3319 case tok::kw___write_only: 3320 3321 return true; 3322 3323 case tok::kw_private: 3324 return getLang().OpenCL; 3325 3326 // C1x _Atomic() 3327 case tok::kw__Atomic: 3328 return true; 3329 } 3330} 3331 3332/// isDeclarationSpecifier() - Return true if the current token is part of a 3333/// declaration specifier. 3334/// 3335/// \param DisambiguatingWithExpression True to indicate that the purpose of 3336/// this check is to disambiguate between an expression and a declaration. 3337bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) { 3338 switch (Tok.getKind()) { 3339 default: return false; 3340 3341 case tok::kw_private: 3342 return getLang().OpenCL; 3343 3344 case tok::identifier: // foo::bar 3345 // Unfortunate hack to support "Class.factoryMethod" notation. 3346 if (getLang().ObjC1 && NextToken().is(tok::period)) 3347 return false; 3348 if (TryAltiVecVectorToken()) 3349 return true; 3350 // Fall through. 3351 case tok::kw_decltype: // decltype(T())::type 3352 case tok::kw_typename: // typename T::type 3353 // Annotate typenames and C++ scope specifiers. If we get one, just 3354 // recurse to handle whatever we get. 3355 if (TryAnnotateTypeOrScopeToken()) 3356 return true; 3357 if (Tok.is(tok::identifier)) 3358 return false; 3359 3360 // If we're in Objective-C and we have an Objective-C class type followed 3361 // by an identifier and then either ':' or ']', in a place where an 3362 // expression is permitted, then this is probably a class message send 3363 // missing the initial '['. In this case, we won't consider this to be 3364 // the start of a declaration. 3365 if (DisambiguatingWithExpression && 3366 isStartOfObjCClassMessageMissingOpenBracket()) 3367 return false; 3368 3369 return isDeclarationSpecifier(); 3370 3371 case tok::coloncolon: // ::foo::bar 3372 if (NextToken().is(tok::kw_new) || // ::new 3373 NextToken().is(tok::kw_delete)) // ::delete 3374 return false; 3375 3376 // Annotate typenames and C++ scope specifiers. If we get one, just 3377 // recurse to handle whatever we get. 3378 if (TryAnnotateTypeOrScopeToken()) 3379 return true; 3380 return isDeclarationSpecifier(); 3381 3382 // storage-class-specifier 3383 case tok::kw_typedef: 3384 case tok::kw_extern: 3385 case tok::kw___private_extern__: 3386 case tok::kw_static: 3387 case tok::kw_auto: 3388 case tok::kw_register: 3389 case tok::kw___thread: 3390 3391 // Modules 3392 case tok::kw___module_private__: 3393 3394 // type-specifiers 3395 case tok::kw_short: 3396 case tok::kw_long: 3397 case tok::kw___int64: 3398 case tok::kw_signed: 3399 case tok::kw_unsigned: 3400 case tok::kw__Complex: 3401 case tok::kw__Imaginary: 3402 case tok::kw_void: 3403 case tok::kw_char: 3404 case tok::kw_wchar_t: 3405 case tok::kw_char16_t: 3406 case tok::kw_char32_t: 3407 3408 case tok::kw_int: 3409 case tok::kw_half: 3410 case tok::kw_float: 3411 case tok::kw_double: 3412 case tok::kw_bool: 3413 case tok::kw__Bool: 3414 case tok::kw__Decimal32: 3415 case tok::kw__Decimal64: 3416 case tok::kw__Decimal128: 3417 case tok::kw___vector: 3418 3419 // struct-or-union-specifier (C99) or class-specifier (C++) 3420 case tok::kw_class: 3421 case tok::kw_struct: 3422 case tok::kw_union: 3423 // enum-specifier 3424 case tok::kw_enum: 3425 3426 // type-qualifier 3427 case tok::kw_const: 3428 case tok::kw_volatile: 3429 case tok::kw_restrict: 3430 3431 // function-specifier 3432 case tok::kw_inline: 3433 case tok::kw_virtual: 3434 case tok::kw_explicit: 3435 3436 // static_assert-declaration 3437 case tok::kw__Static_assert: 3438 3439 // GNU typeof support. 3440 case tok::kw_typeof: 3441 3442 // GNU attributes. 3443 case tok::kw___attribute: 3444 return true; 3445 3446 // C++0x decltype. 3447 case tok::annot_decltype: 3448 return true; 3449 3450 // C1x _Atomic() 3451 case tok::kw__Atomic: 3452 return true; 3453 3454 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 3455 case tok::less: 3456 return getLang().ObjC1; 3457 3458 // typedef-name 3459 case tok::annot_typename: 3460 return !DisambiguatingWithExpression || 3461 !isStartOfObjCClassMessageMissingOpenBracket(); 3462 3463 case tok::kw___declspec: 3464 case tok::kw___cdecl: 3465 case tok::kw___stdcall: 3466 case tok::kw___fastcall: 3467 case tok::kw___thiscall: 3468 case tok::kw___w64: 3469 case tok::kw___ptr64: 3470 case tok::kw___ptr32: 3471 case tok::kw___forceinline: 3472 case tok::kw___pascal: 3473 case tok::kw___unaligned: 3474 3475 case tok::kw___private: 3476 case tok::kw___local: 3477 case tok::kw___global: 3478 case tok::kw___constant: 3479 case tok::kw___read_only: 3480 case tok::kw___read_write: 3481 case tok::kw___write_only: 3482 3483 return true; 3484 } 3485} 3486 3487bool Parser::isConstructorDeclarator() { 3488 TentativeParsingAction TPA(*this); 3489 3490 // Parse the C++ scope specifier. 3491 CXXScopeSpec SS; 3492 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), 3493 /*EnteringContext=*/true)) { 3494 TPA.Revert(); 3495 return false; 3496 } 3497 3498 // Parse the constructor name. 3499 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) { 3500 // We already know that we have a constructor name; just consume 3501 // the token. 3502 ConsumeToken(); 3503 } else { 3504 TPA.Revert(); 3505 return false; 3506 } 3507 3508 // Current class name must be followed by a left parentheses. 3509 if (Tok.isNot(tok::l_paren)) { 3510 TPA.Revert(); 3511 return false; 3512 } 3513 ConsumeParen(); 3514 3515 // A right parentheses or ellipsis signals that we have a constructor. 3516 if (Tok.is(tok::r_paren) || Tok.is(tok::ellipsis)) { 3517 TPA.Revert(); 3518 return true; 3519 } 3520 3521 // If we need to, enter the specified scope. 3522 DeclaratorScopeObj DeclScopeObj(*this, SS); 3523 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS)) 3524 DeclScopeObj.EnterDeclaratorScope(); 3525 3526 // Optionally skip Microsoft attributes. 3527 ParsedAttributes Attrs(AttrFactory); 3528 MaybeParseMicrosoftAttributes(Attrs); 3529 3530 // Check whether the next token(s) are part of a declaration 3531 // specifier, in which case we have the start of a parameter and, 3532 // therefore, we know that this is a constructor. 3533 bool IsConstructor = isDeclarationSpecifier(); 3534 TPA.Revert(); 3535 return IsConstructor; 3536} 3537 3538/// ParseTypeQualifierListOpt 3539/// type-qualifier-list: [C99 6.7.5] 3540/// type-qualifier 3541/// [vendor] attributes 3542/// [ only if VendorAttributesAllowed=true ] 3543/// type-qualifier-list type-qualifier 3544/// [vendor] type-qualifier-list attributes 3545/// [ only if VendorAttributesAllowed=true ] 3546/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq 3547/// [ only if CXX0XAttributesAllowed=true ] 3548/// Note: vendor can be GNU, MS, etc. 3549/// 3550void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, 3551 bool VendorAttributesAllowed, 3552 bool CXX0XAttributesAllowed) { 3553 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) { 3554 SourceLocation Loc = Tok.getLocation(); 3555 ParsedAttributesWithRange attrs(AttrFactory); 3556 ParseCXX0XAttributes(attrs); 3557 if (CXX0XAttributesAllowed) 3558 DS.takeAttributesFrom(attrs); 3559 else 3560 Diag(Loc, diag::err_attributes_not_allowed); 3561 } 3562 3563 SourceLocation EndLoc; 3564 3565 while (1) { 3566 bool isInvalid = false; 3567 const char *PrevSpec = 0; 3568 unsigned DiagID = 0; 3569 SourceLocation Loc = Tok.getLocation(); 3570 3571 switch (Tok.getKind()) { 3572 case tok::code_completion: 3573 Actions.CodeCompleteTypeQualifiers(DS); 3574 return cutOffParsing(); 3575 3576 case tok::kw_const: 3577 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID, 3578 getLang()); 3579 break; 3580 case tok::kw_volatile: 3581 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID, 3582 getLang()); 3583 break; 3584 case tok::kw_restrict: 3585 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID, 3586 getLang()); 3587 break; 3588 3589 // OpenCL qualifiers: 3590 case tok::kw_private: 3591 if (!getLang().OpenCL) 3592 goto DoneWithTypeQuals; 3593 case tok::kw___private: 3594 case tok::kw___global: 3595 case tok::kw___local: 3596 case tok::kw___constant: 3597 case tok::kw___read_only: 3598 case tok::kw___write_only: 3599 case tok::kw___read_write: 3600 ParseOpenCLQualifiers(DS); 3601 break; 3602 3603 case tok::kw___w64: 3604 case tok::kw___ptr64: 3605 case tok::kw___ptr32: 3606 case tok::kw___cdecl: 3607 case tok::kw___stdcall: 3608 case tok::kw___fastcall: 3609 case tok::kw___thiscall: 3610 case tok::kw___unaligned: 3611 if (VendorAttributesAllowed) { 3612 ParseMicrosoftTypeAttributes(DS.getAttributes()); 3613 continue; 3614 } 3615 goto DoneWithTypeQuals; 3616 case tok::kw___pascal: 3617 if (VendorAttributesAllowed) { 3618 ParseBorlandTypeAttributes(DS.getAttributes()); 3619 continue; 3620 } 3621 goto DoneWithTypeQuals; 3622 case tok::kw___attribute: 3623 if (VendorAttributesAllowed) { 3624 ParseGNUAttributes(DS.getAttributes()); 3625 continue; // do *not* consume the next token! 3626 } 3627 // otherwise, FALL THROUGH! 3628 default: 3629 DoneWithTypeQuals: 3630 // If this is not a type-qualifier token, we're done reading type 3631 // qualifiers. First verify that DeclSpec's are consistent. 3632 DS.Finish(Diags, PP); 3633 if (EndLoc.isValid()) 3634 DS.SetRangeEnd(EndLoc); 3635 return; 3636 } 3637 3638 // If the specifier combination wasn't legal, issue a diagnostic. 3639 if (isInvalid) { 3640 assert(PrevSpec && "Method did not return previous specifier!"); 3641 Diag(Tok, DiagID) << PrevSpec; 3642 } 3643 EndLoc = ConsumeToken(); 3644 } 3645} 3646 3647 3648/// ParseDeclarator - Parse and verify a newly-initialized declarator. 3649/// 3650void Parser::ParseDeclarator(Declarator &D) { 3651 /// This implements the 'declarator' production in the C grammar, then checks 3652 /// for well-formedness and issues diagnostics. 3653 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator); 3654} 3655 3656/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator 3657/// is parsed by the function passed to it. Pass null, and the direct-declarator 3658/// isn't parsed at all, making this function effectively parse the C++ 3659/// ptr-operator production. 3660/// 3661/// If the grammar of this construct is extended, matching changes must also be 3662/// made to TryParseDeclarator and MightBeDeclarator. 3663/// 3664/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl] 3665/// [C] pointer[opt] direct-declarator 3666/// [C++] direct-declarator 3667/// [C++] ptr-operator declarator 3668/// 3669/// pointer: [C99 6.7.5] 3670/// '*' type-qualifier-list[opt] 3671/// '*' type-qualifier-list[opt] pointer 3672/// 3673/// ptr-operator: 3674/// '*' cv-qualifier-seq[opt] 3675/// '&' 3676/// [C++0x] '&&' 3677/// [GNU] '&' restrict[opt] attributes[opt] 3678/// [GNU?] '&&' restrict[opt] attributes[opt] 3679/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt] 3680void Parser::ParseDeclaratorInternal(Declarator &D, 3681 DirectDeclParseFunction DirectDeclParser) { 3682 if (Diags.hasAllExtensionsSilenced()) 3683 D.setExtension(); 3684 3685 // C++ member pointers start with a '::' or a nested-name. 3686 // Member pointers get special handling, since there's no place for the 3687 // scope spec in the generic path below. 3688 if (getLang().CPlusPlus && 3689 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) || 3690 Tok.is(tok::annot_cxxscope))) { 3691 bool EnteringContext = D.getContext() == Declarator::FileContext || 3692 D.getContext() == Declarator::MemberContext; 3693 CXXScopeSpec SS; 3694 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), EnteringContext); 3695 3696 if (SS.isNotEmpty()) { 3697 if (Tok.isNot(tok::star)) { 3698 // The scope spec really belongs to the direct-declarator. 3699 D.getCXXScopeSpec() = SS; 3700 if (DirectDeclParser) 3701 (this->*DirectDeclParser)(D); 3702 return; 3703 } 3704 3705 SourceLocation Loc = ConsumeToken(); 3706 D.SetRangeEnd(Loc); 3707 DeclSpec DS(AttrFactory); 3708 ParseTypeQualifierListOpt(DS); 3709 D.ExtendWithDeclSpec(DS); 3710 3711 // Recurse to parse whatever is left. 3712 ParseDeclaratorInternal(D, DirectDeclParser); 3713 3714 // Sema will have to catch (syntactically invalid) pointers into global 3715 // scope. It has to catch pointers into namespace scope anyway. 3716 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(), 3717 Loc), 3718 DS.getAttributes(), 3719 /* Don't replace range end. */SourceLocation()); 3720 return; 3721 } 3722 } 3723 3724 tok::TokenKind Kind = Tok.getKind(); 3725 // Not a pointer, C++ reference, or block. 3726 if (Kind != tok::star && Kind != tok::caret && 3727 (Kind != tok::amp || !getLang().CPlusPlus) && 3728 // We parse rvalue refs in C++03, because otherwise the errors are scary. 3729 (Kind != tok::ampamp || !getLang().CPlusPlus)) { 3730 if (DirectDeclParser) 3731 (this->*DirectDeclParser)(D); 3732 return; 3733 } 3734 3735 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference, 3736 // '&&' -> rvalue reference 3737 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&. 3738 D.SetRangeEnd(Loc); 3739 3740 if (Kind == tok::star || Kind == tok::caret) { 3741 // Is a pointer. 3742 DeclSpec DS(AttrFactory); 3743 3744 ParseTypeQualifierListOpt(DS); 3745 D.ExtendWithDeclSpec(DS); 3746 3747 // Recursively parse the declarator. 3748 ParseDeclaratorInternal(D, DirectDeclParser); 3749 if (Kind == tok::star) 3750 // Remember that we parsed a pointer type, and remember the type-quals. 3751 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc, 3752 DS.getConstSpecLoc(), 3753 DS.getVolatileSpecLoc(), 3754 DS.getRestrictSpecLoc()), 3755 DS.getAttributes(), 3756 SourceLocation()); 3757 else 3758 // Remember that we parsed a Block type, and remember the type-quals. 3759 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), 3760 Loc), 3761 DS.getAttributes(), 3762 SourceLocation()); 3763 } else { 3764 // Is a reference 3765 DeclSpec DS(AttrFactory); 3766 3767 // Complain about rvalue references in C++03, but then go on and build 3768 // the declarator. 3769 if (Kind == tok::ampamp) 3770 Diag(Loc, getLang().CPlusPlus0x ? 3771 diag::warn_cxx98_compat_rvalue_reference : 3772 diag::ext_rvalue_reference); 3773 3774 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the 3775 // cv-qualifiers are introduced through the use of a typedef or of a 3776 // template type argument, in which case the cv-qualifiers are ignored. 3777 // 3778 // [GNU] Retricted references are allowed. 3779 // [GNU] Attributes on references are allowed. 3780 // [C++0x] Attributes on references are not allowed. 3781 ParseTypeQualifierListOpt(DS, true, false); 3782 D.ExtendWithDeclSpec(DS); 3783 3784 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) { 3785 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 3786 Diag(DS.getConstSpecLoc(), 3787 diag::err_invalid_reference_qualifier_application) << "const"; 3788 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 3789 Diag(DS.getVolatileSpecLoc(), 3790 diag::err_invalid_reference_qualifier_application) << "volatile"; 3791 } 3792 3793 // Recursively parse the declarator. 3794 ParseDeclaratorInternal(D, DirectDeclParser); 3795 3796 if (D.getNumTypeObjects() > 0) { 3797 // C++ [dcl.ref]p4: There shall be no references to references. 3798 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1); 3799 if (InnerChunk.Kind == DeclaratorChunk::Reference) { 3800 if (const IdentifierInfo *II = D.getIdentifier()) 3801 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference) 3802 << II; 3803 else 3804 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference) 3805 << "type name"; 3806 3807 // Once we've complained about the reference-to-reference, we 3808 // can go ahead and build the (technically ill-formed) 3809 // declarator: reference collapsing will take care of it. 3810 } 3811 } 3812 3813 // Remember that we parsed a reference type. It doesn't have type-quals. 3814 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc, 3815 Kind == tok::amp), 3816 DS.getAttributes(), 3817 SourceLocation()); 3818 } 3819} 3820 3821/// ParseDirectDeclarator 3822/// direct-declarator: [C99 6.7.5] 3823/// [C99] identifier 3824/// '(' declarator ')' 3825/// [GNU] '(' attributes declarator ')' 3826/// [C90] direct-declarator '[' constant-expression[opt] ']' 3827/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 3828/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 3829/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 3830/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 3831/// direct-declarator '(' parameter-type-list ')' 3832/// direct-declarator '(' identifier-list[opt] ')' 3833/// [GNU] direct-declarator '(' parameter-forward-declarations 3834/// parameter-type-list[opt] ')' 3835/// [C++] direct-declarator '(' parameter-declaration-clause ')' 3836/// cv-qualifier-seq[opt] exception-specification[opt] 3837/// [C++] declarator-id 3838/// 3839/// declarator-id: [C++ 8] 3840/// '...'[opt] id-expression 3841/// '::'[opt] nested-name-specifier[opt] type-name 3842/// 3843/// id-expression: [C++ 5.1] 3844/// unqualified-id 3845/// qualified-id 3846/// 3847/// unqualified-id: [C++ 5.1] 3848/// identifier 3849/// operator-function-id 3850/// conversion-function-id 3851/// '~' class-name 3852/// template-id 3853/// 3854void Parser::ParseDirectDeclarator(Declarator &D) { 3855 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec()); 3856 3857 if (getLang().CPlusPlus && D.mayHaveIdentifier()) { 3858 // ParseDeclaratorInternal might already have parsed the scope. 3859 if (D.getCXXScopeSpec().isEmpty()) { 3860 bool EnteringContext = D.getContext() == Declarator::FileContext || 3861 D.getContext() == Declarator::MemberContext; 3862 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(), 3863 EnteringContext); 3864 } 3865 3866 if (D.getCXXScopeSpec().isValid()) { 3867 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec())) 3868 // Change the declaration context for name lookup, until this function 3869 // is exited (and the declarator has been parsed). 3870 DeclScopeObj.EnterDeclaratorScope(); 3871 } 3872 3873 // C++0x [dcl.fct]p14: 3874 // There is a syntactic ambiguity when an ellipsis occurs at the end 3875 // of a parameter-declaration-clause without a preceding comma. In 3876 // this case, the ellipsis is parsed as part of the 3877 // abstract-declarator if the type of the parameter names a template 3878 // parameter pack that has not been expanded; otherwise, it is parsed 3879 // as part of the parameter-declaration-clause. 3880 if (Tok.is(tok::ellipsis) && 3881 !((D.getContext() == Declarator::PrototypeContext || 3882 D.getContext() == Declarator::BlockLiteralContext) && 3883 NextToken().is(tok::r_paren) && 3884 !Actions.containsUnexpandedParameterPacks(D))) 3885 D.setEllipsisLoc(ConsumeToken()); 3886 3887 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) || 3888 Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) { 3889 // We found something that indicates the start of an unqualified-id. 3890 // Parse that unqualified-id. 3891 bool AllowConstructorName; 3892 if (D.getDeclSpec().hasTypeSpecifier()) 3893 AllowConstructorName = false; 3894 else if (D.getCXXScopeSpec().isSet()) 3895 AllowConstructorName = 3896 (D.getContext() == Declarator::FileContext || 3897 (D.getContext() == Declarator::MemberContext && 3898 D.getDeclSpec().isFriendSpecified())); 3899 else 3900 AllowConstructorName = (D.getContext() == Declarator::MemberContext); 3901 3902 if (ParseUnqualifiedId(D.getCXXScopeSpec(), 3903 /*EnteringContext=*/true, 3904 /*AllowDestructorName=*/true, 3905 AllowConstructorName, 3906 ParsedType(), 3907 D.getName()) || 3908 // Once we're past the identifier, if the scope was bad, mark the 3909 // whole declarator bad. 3910 D.getCXXScopeSpec().isInvalid()) { 3911 D.SetIdentifier(0, Tok.getLocation()); 3912 D.setInvalidType(true); 3913 } else { 3914 // Parsed the unqualified-id; update range information and move along. 3915 if (D.getSourceRange().getBegin().isInvalid()) 3916 D.SetRangeBegin(D.getName().getSourceRange().getBegin()); 3917 D.SetRangeEnd(D.getName().getSourceRange().getEnd()); 3918 } 3919 goto PastIdentifier; 3920 } 3921 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) { 3922 assert(!getLang().CPlusPlus && 3923 "There's a C++-specific check for tok::identifier above"); 3924 assert(Tok.getIdentifierInfo() && "Not an identifier?"); 3925 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 3926 ConsumeToken(); 3927 goto PastIdentifier; 3928 } 3929 3930 if (Tok.is(tok::l_paren)) { 3931 // direct-declarator: '(' declarator ')' 3932 // direct-declarator: '(' attributes declarator ')' 3933 // Example: 'char (*X)' or 'int (*XX)(void)' 3934 ParseParenDeclarator(D); 3935 3936 // If the declarator was parenthesized, we entered the declarator 3937 // scope when parsing the parenthesized declarator, then exited 3938 // the scope already. Re-enter the scope, if we need to. 3939 if (D.getCXXScopeSpec().isSet()) { 3940 // If there was an error parsing parenthesized declarator, declarator 3941 // scope may have been enterred before. Don't do it again. 3942 if (!D.isInvalidType() && 3943 Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec())) 3944 // Change the declaration context for name lookup, until this function 3945 // is exited (and the declarator has been parsed). 3946 DeclScopeObj.EnterDeclaratorScope(); 3947 } 3948 } else if (D.mayOmitIdentifier()) { 3949 // This could be something simple like "int" (in which case the declarator 3950 // portion is empty), if an abstract-declarator is allowed. 3951 D.SetIdentifier(0, Tok.getLocation()); 3952 } else { 3953 if (D.getContext() == Declarator::MemberContext) 3954 Diag(Tok, diag::err_expected_member_name_or_semi) 3955 << D.getDeclSpec().getSourceRange(); 3956 else if (getLang().CPlusPlus) 3957 Diag(Tok, diag::err_expected_unqualified_id) << getLang().CPlusPlus; 3958 else 3959 Diag(Tok, diag::err_expected_ident_lparen); 3960 D.SetIdentifier(0, Tok.getLocation()); 3961 D.setInvalidType(true); 3962 } 3963 3964 PastIdentifier: 3965 assert(D.isPastIdentifier() && 3966 "Haven't past the location of the identifier yet?"); 3967 3968 // Don't parse attributes unless we have an identifier. 3969 if (D.getIdentifier()) 3970 MaybeParseCXX0XAttributes(D); 3971 3972 while (1) { 3973 if (Tok.is(tok::l_paren)) { 3974 // Enter function-declaration scope, limiting any declarators to the 3975 // function prototype scope, including parameter declarators. 3976 ParseScope PrototypeScope(this, 3977 Scope::FunctionPrototypeScope|Scope::DeclScope); 3978 // The paren may be part of a C++ direct initializer, eg. "int x(1);". 3979 // In such a case, check if we actually have a function declarator; if it 3980 // is not, the declarator has been fully parsed. 3981 if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) { 3982 // When not in file scope, warn for ambiguous function declarators, just 3983 // in case the author intended it as a variable definition. 3984 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext; 3985 if (!isCXXFunctionDeclarator(warnIfAmbiguous)) 3986 break; 3987 } 3988 ParsedAttributes attrs(AttrFactory); 3989 BalancedDelimiterTracker T(*this, tok::l_paren); 3990 T.consumeOpen(); 3991 ParseFunctionDeclarator(D, attrs, T); 3992 PrototypeScope.Exit(); 3993 } else if (Tok.is(tok::l_square)) { 3994 ParseBracketDeclarator(D); 3995 } else { 3996 break; 3997 } 3998 } 3999} 4000 4001/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is 4002/// only called before the identifier, so these are most likely just grouping 4003/// parens for precedence. If we find that these are actually function 4004/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator. 4005/// 4006/// direct-declarator: 4007/// '(' declarator ')' 4008/// [GNU] '(' attributes declarator ')' 4009/// direct-declarator '(' parameter-type-list ')' 4010/// direct-declarator '(' identifier-list[opt] ')' 4011/// [GNU] direct-declarator '(' parameter-forward-declarations 4012/// parameter-type-list[opt] ')' 4013/// 4014void Parser::ParseParenDeclarator(Declarator &D) { 4015 BalancedDelimiterTracker T(*this, tok::l_paren); 4016 T.consumeOpen(); 4017 4018 assert(!D.isPastIdentifier() && "Should be called before passing identifier"); 4019 4020 // Eat any attributes before we look at whether this is a grouping or function 4021 // declarator paren. If this is a grouping paren, the attribute applies to 4022 // the type being built up, for example: 4023 // int (__attribute__(()) *x)(long y) 4024 // If this ends up not being a grouping paren, the attribute applies to the 4025 // first argument, for example: 4026 // int (__attribute__(()) int x) 4027 // In either case, we need to eat any attributes to be able to determine what 4028 // sort of paren this is. 4029 // 4030 ParsedAttributes attrs(AttrFactory); 4031 bool RequiresArg = false; 4032 if (Tok.is(tok::kw___attribute)) { 4033 ParseGNUAttributes(attrs); 4034 4035 // We require that the argument list (if this is a non-grouping paren) be 4036 // present even if the attribute list was empty. 4037 RequiresArg = true; 4038 } 4039 // Eat any Microsoft extensions. 4040 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) || 4041 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) || 4042 Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64) || 4043 Tok.is(tok::kw___ptr32) || Tok.is(tok::kw___unaligned)) { 4044 ParseMicrosoftTypeAttributes(attrs); 4045 } 4046 // Eat any Borland extensions. 4047 if (Tok.is(tok::kw___pascal)) 4048 ParseBorlandTypeAttributes(attrs); 4049 4050 // If we haven't past the identifier yet (or where the identifier would be 4051 // stored, if this is an abstract declarator), then this is probably just 4052 // grouping parens. However, if this could be an abstract-declarator, then 4053 // this could also be the start of function arguments (consider 'void()'). 4054 bool isGrouping; 4055 4056 if (!D.mayOmitIdentifier()) { 4057 // If this can't be an abstract-declarator, this *must* be a grouping 4058 // paren, because we haven't seen the identifier yet. 4059 isGrouping = true; 4060 } else if (Tok.is(tok::r_paren) || // 'int()' is a function. 4061 (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...) 4062 isDeclarationSpecifier()) { // 'int(int)' is a function. 4063 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is 4064 // considered to be a type, not a K&R identifier-list. 4065 isGrouping = false; 4066 } else { 4067 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'. 4068 isGrouping = true; 4069 } 4070 4071 // If this is a grouping paren, handle: 4072 // direct-declarator: '(' declarator ')' 4073 // direct-declarator: '(' attributes declarator ')' 4074 if (isGrouping) { 4075 bool hadGroupingParens = D.hasGroupingParens(); 4076 D.setGroupingParens(true); 4077 4078 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator); 4079 // Match the ')'. 4080 T.consumeClose(); 4081 D.AddTypeInfo(DeclaratorChunk::getParen(T.getOpenLocation(), 4082 T.getCloseLocation()), 4083 attrs, T.getCloseLocation()); 4084 4085 D.setGroupingParens(hadGroupingParens); 4086 return; 4087 } 4088 4089 // Okay, if this wasn't a grouping paren, it must be the start of a function 4090 // argument list. Recognize that this declarator will never have an 4091 // identifier (and remember where it would have been), then call into 4092 // ParseFunctionDeclarator to handle of argument list. 4093 D.SetIdentifier(0, Tok.getLocation()); 4094 4095 // Enter function-declaration scope, limiting any declarators to the 4096 // function prototype scope, including parameter declarators. 4097 ParseScope PrototypeScope(this, 4098 Scope::FunctionPrototypeScope|Scope::DeclScope); 4099 ParseFunctionDeclarator(D, attrs, T, RequiresArg); 4100 PrototypeScope.Exit(); 4101} 4102 4103/// ParseFunctionDeclarator - We are after the identifier and have parsed the 4104/// declarator D up to a paren, which indicates that we are parsing function 4105/// arguments. 4106/// 4107/// If attrs is non-null, then the caller parsed those arguments immediately 4108/// after the open paren - they should be considered to be the first argument of 4109/// a parameter. If RequiresArg is true, then the first argument of the 4110/// function is required to be present and required to not be an identifier 4111/// list. 4112/// 4113/// For C++, after the parameter-list, it also parses cv-qualifier-seq[opt], 4114/// (C++0x) ref-qualifier[opt], exception-specification[opt], and 4115/// (C++0x) trailing-return-type[opt]. 4116/// 4117/// [C++0x] exception-specification: 4118/// dynamic-exception-specification 4119/// noexcept-specification 4120/// 4121void Parser::ParseFunctionDeclarator(Declarator &D, 4122 ParsedAttributes &attrs, 4123 BalancedDelimiterTracker &Tracker, 4124 bool RequiresArg) { 4125 assert(getCurScope()->isFunctionPrototypeScope() && 4126 "Should call from a Function scope"); 4127 // lparen is already consumed! 4128 assert(D.isPastIdentifier() && "Should not call before identifier!"); 4129 4130 // This should be true when the function has typed arguments. 4131 // Otherwise, it is treated as a K&R-style function. 4132 bool HasProto = false; 4133 // Build up an array of information about the parsed arguments. 4134 SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 4135 // Remember where we see an ellipsis, if any. 4136 SourceLocation EllipsisLoc; 4137 4138 DeclSpec DS(AttrFactory); 4139 bool RefQualifierIsLValueRef = true; 4140 SourceLocation RefQualifierLoc; 4141 SourceLocation ConstQualifierLoc; 4142 SourceLocation VolatileQualifierLoc; 4143 ExceptionSpecificationType ESpecType = EST_None; 4144 SourceRange ESpecRange; 4145 SmallVector<ParsedType, 2> DynamicExceptions; 4146 SmallVector<SourceRange, 2> DynamicExceptionRanges; 4147 ExprResult NoexceptExpr; 4148 ParsedType TrailingReturnType; 4149 4150 SourceLocation EndLoc; 4151 if (isFunctionDeclaratorIdentifierList()) { 4152 if (RequiresArg) 4153 Diag(Tok, diag::err_argument_required_after_attribute); 4154 4155 ParseFunctionDeclaratorIdentifierList(D, ParamInfo); 4156 4157 Tracker.consumeClose(); 4158 EndLoc = Tracker.getCloseLocation(); 4159 } else { 4160 if (Tok.isNot(tok::r_paren)) 4161 ParseParameterDeclarationClause(D, attrs, ParamInfo, EllipsisLoc); 4162 else if (RequiresArg) 4163 Diag(Tok, diag::err_argument_required_after_attribute); 4164 4165 HasProto = ParamInfo.size() || getLang().CPlusPlus; 4166 4167 // If we have the closing ')', eat it. 4168 Tracker.consumeClose(); 4169 EndLoc = Tracker.getCloseLocation(); 4170 4171 if (getLang().CPlusPlus) { 4172 MaybeParseCXX0XAttributes(attrs); 4173 4174 // Parse cv-qualifier-seq[opt]. 4175 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 4176 if (!DS.getSourceRange().getEnd().isInvalid()) { 4177 EndLoc = DS.getSourceRange().getEnd(); 4178 ConstQualifierLoc = DS.getConstSpecLoc(); 4179 VolatileQualifierLoc = DS.getVolatileSpecLoc(); 4180 } 4181 4182 // Parse ref-qualifier[opt]. 4183 if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) { 4184 Diag(Tok, getLang().CPlusPlus0x ? 4185 diag::warn_cxx98_compat_ref_qualifier : 4186 diag::ext_ref_qualifier); 4187 4188 RefQualifierIsLValueRef = Tok.is(tok::amp); 4189 RefQualifierLoc = ConsumeToken(); 4190 EndLoc = RefQualifierLoc; 4191 } 4192 4193 // Parse exception-specification[opt]. 4194 ESpecType = MaybeParseExceptionSpecification(ESpecRange, 4195 DynamicExceptions, 4196 DynamicExceptionRanges, 4197 NoexceptExpr); 4198 if (ESpecType != EST_None) 4199 EndLoc = ESpecRange.getEnd(); 4200 4201 // Parse trailing-return-type[opt]. 4202 if (getLang().CPlusPlus0x && Tok.is(tok::arrow)) { 4203 Diag(Tok, diag::warn_cxx98_compat_trailing_return_type); 4204 SourceRange Range; 4205 TrailingReturnType = ParseTrailingReturnType(Range).get(); 4206 if (Range.getEnd().isValid()) 4207 EndLoc = Range.getEnd(); 4208 } 4209 } 4210 } 4211 4212 // Remember that we parsed a function type, and remember the attributes. 4213 D.AddTypeInfo(DeclaratorChunk::getFunction(HasProto, 4214 /*isVariadic=*/EllipsisLoc.isValid(), 4215 EllipsisLoc, 4216 ParamInfo.data(), ParamInfo.size(), 4217 DS.getTypeQualifiers(), 4218 RefQualifierIsLValueRef, 4219 RefQualifierLoc, ConstQualifierLoc, 4220 VolatileQualifierLoc, 4221 /*MutableLoc=*/SourceLocation(), 4222 ESpecType, ESpecRange.getBegin(), 4223 DynamicExceptions.data(), 4224 DynamicExceptionRanges.data(), 4225 DynamicExceptions.size(), 4226 NoexceptExpr.isUsable() ? 4227 NoexceptExpr.get() : 0, 4228 Tracker.getOpenLocation(), 4229 EndLoc, D, 4230 TrailingReturnType), 4231 attrs, EndLoc); 4232} 4233 4234/// isFunctionDeclaratorIdentifierList - This parameter list may have an 4235/// identifier list form for a K&R-style function: void foo(a,b,c) 4236/// 4237/// Note that identifier-lists are only allowed for normal declarators, not for 4238/// abstract-declarators. 4239bool Parser::isFunctionDeclaratorIdentifierList() { 4240 return !getLang().CPlusPlus 4241 && Tok.is(tok::identifier) 4242 && !TryAltiVecVectorToken() 4243 // K&R identifier lists can't have typedefs as identifiers, per C99 4244 // 6.7.5.3p11. 4245 && (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename)) 4246 // Identifier lists follow a really simple grammar: the identifiers can 4247 // be followed *only* by a ", identifier" or ")". However, K&R 4248 // identifier lists are really rare in the brave new modern world, and 4249 // it is very common for someone to typo a type in a non-K&R style 4250 // list. If we are presented with something like: "void foo(intptr x, 4251 // float y)", we don't want to start parsing the function declarator as 4252 // though it is a K&R style declarator just because intptr is an 4253 // invalid type. 4254 // 4255 // To handle this, we check to see if the token after the first 4256 // identifier is a "," or ")". Only then do we parse it as an 4257 // identifier list. 4258 && (NextToken().is(tok::comma) || NextToken().is(tok::r_paren)); 4259} 4260 4261/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator 4262/// we found a K&R-style identifier list instead of a typed parameter list. 4263/// 4264/// After returning, ParamInfo will hold the parsed parameters. 4265/// 4266/// identifier-list: [C99 6.7.5] 4267/// identifier 4268/// identifier-list ',' identifier 4269/// 4270void Parser::ParseFunctionDeclaratorIdentifierList( 4271 Declarator &D, 4272 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo) { 4273 // If there was no identifier specified for the declarator, either we are in 4274 // an abstract-declarator, or we are in a parameter declarator which was found 4275 // to be abstract. In abstract-declarators, identifier lists are not valid: 4276 // diagnose this. 4277 if (!D.getIdentifier()) 4278 Diag(Tok, diag::ext_ident_list_in_param); 4279 4280 // Maintain an efficient lookup of params we have seen so far. 4281 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar; 4282 4283 while (1) { 4284 // If this isn't an identifier, report the error and skip until ')'. 4285 if (Tok.isNot(tok::identifier)) { 4286 Diag(Tok, diag::err_expected_ident); 4287 SkipUntil(tok::r_paren, /*StopAtSemi=*/true, /*DontConsume=*/true); 4288 // Forget we parsed anything. 4289 ParamInfo.clear(); 4290 return; 4291 } 4292 4293 IdentifierInfo *ParmII = Tok.getIdentifierInfo(); 4294 4295 // Reject 'typedef int y; int test(x, y)', but continue parsing. 4296 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope())) 4297 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII; 4298 4299 // Verify that the argument identifier has not already been mentioned. 4300 if (!ParamsSoFar.insert(ParmII)) { 4301 Diag(Tok, diag::err_param_redefinition) << ParmII; 4302 } else { 4303 // Remember this identifier in ParamInfo. 4304 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 4305 Tok.getLocation(), 4306 0)); 4307 } 4308 4309 // Eat the identifier. 4310 ConsumeToken(); 4311 4312 // The list continues if we see a comma. 4313 if (Tok.isNot(tok::comma)) 4314 break; 4315 ConsumeToken(); 4316 } 4317} 4318 4319/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list 4320/// after the opening parenthesis. This function will not parse a K&R-style 4321/// identifier list. 4322/// 4323/// D is the declarator being parsed. If attrs is non-null, then the caller 4324/// parsed those arguments immediately after the open paren - they should be 4325/// considered to be the first argument of a parameter. 4326/// 4327/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will 4328/// be the location of the ellipsis, if any was parsed. 4329/// 4330/// parameter-type-list: [C99 6.7.5] 4331/// parameter-list 4332/// parameter-list ',' '...' 4333/// [C++] parameter-list '...' 4334/// 4335/// parameter-list: [C99 6.7.5] 4336/// parameter-declaration 4337/// parameter-list ',' parameter-declaration 4338/// 4339/// parameter-declaration: [C99 6.7.5] 4340/// declaration-specifiers declarator 4341/// [C++] declaration-specifiers declarator '=' assignment-expression 4342/// [GNU] declaration-specifiers declarator attributes 4343/// declaration-specifiers abstract-declarator[opt] 4344/// [C++] declaration-specifiers abstract-declarator[opt] 4345/// '=' assignment-expression 4346/// [GNU] declaration-specifiers abstract-declarator[opt] attributes 4347/// 4348void Parser::ParseParameterDeclarationClause( 4349 Declarator &D, 4350 ParsedAttributes &attrs, 4351 SmallVector<DeclaratorChunk::ParamInfo, 16> &ParamInfo, 4352 SourceLocation &EllipsisLoc) { 4353 4354 while (1) { 4355 if (Tok.is(tok::ellipsis)) { 4356 EllipsisLoc = ConsumeToken(); // Consume the ellipsis. 4357 break; 4358 } 4359 4360 // Parse the declaration-specifiers. 4361 // Just use the ParsingDeclaration "scope" of the declarator. 4362 DeclSpec DS(AttrFactory); 4363 4364 // Skip any Microsoft attributes before a param. 4365 if (getLang().MicrosoftExt && Tok.is(tok::l_square)) 4366 ParseMicrosoftAttributes(DS.getAttributes()); 4367 4368 SourceLocation DSStart = Tok.getLocation(); 4369 4370 // If the caller parsed attributes for the first argument, add them now. 4371 // Take them so that we only apply the attributes to the first parameter. 4372 // FIXME: If we saw an ellipsis first, this code is not reached. Are the 4373 // attributes lost? Should they even be allowed? 4374 // FIXME: If we can leave the attributes in the token stream somehow, we can 4375 // get rid of a parameter (attrs) and this statement. It might be too much 4376 // hassle. 4377 DS.takeAttributesFrom(attrs); 4378 4379 ParseDeclarationSpecifiers(DS); 4380 4381 // Parse the declarator. This is "PrototypeContext", because we must 4382 // accept either 'declarator' or 'abstract-declarator' here. 4383 Declarator ParmDecl(DS, Declarator::PrototypeContext); 4384 ParseDeclarator(ParmDecl); 4385 4386 // Parse GNU attributes, if present. 4387 MaybeParseGNUAttributes(ParmDecl); 4388 4389 // Remember this parsed parameter in ParamInfo. 4390 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 4391 4392 // DefArgToks is used when the parsing of default arguments needs 4393 // to be delayed. 4394 CachedTokens *DefArgToks = 0; 4395 4396 // If no parameter was specified, verify that *something* was specified, 4397 // otherwise we have a missing type and identifier. 4398 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 && 4399 ParmDecl.getNumTypeObjects() == 0) { 4400 // Completely missing, emit error. 4401 Diag(DSStart, diag::err_missing_param); 4402 } else { 4403 // Otherwise, we have something. Add it and let semantic analysis try 4404 // to grok it and add the result to the ParamInfo we are building. 4405 4406 // Inform the actions module about the parameter declarator, so it gets 4407 // added to the current scope. 4408 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl); 4409 4410 // Parse the default argument, if any. We parse the default 4411 // arguments in all dialects; the semantic analysis in 4412 // ActOnParamDefaultArgument will reject the default argument in 4413 // C. 4414 if (Tok.is(tok::equal)) { 4415 SourceLocation EqualLoc = Tok.getLocation(); 4416 4417 // Parse the default argument 4418 if (D.getContext() == Declarator::MemberContext) { 4419 // If we're inside a class definition, cache the tokens 4420 // corresponding to the default argument. We'll actually parse 4421 // them when we see the end of the class definition. 4422 // FIXME: Templates will require something similar. 4423 // FIXME: Can we use a smart pointer for Toks? 4424 DefArgToks = new CachedTokens; 4425 4426 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks, 4427 /*StopAtSemi=*/true, 4428 /*ConsumeFinalToken=*/false)) { 4429 delete DefArgToks; 4430 DefArgToks = 0; 4431 Actions.ActOnParamDefaultArgumentError(Param); 4432 } else { 4433 // Mark the end of the default argument so that we know when to 4434 // stop when we parse it later on. 4435 Token DefArgEnd; 4436 DefArgEnd.startToken(); 4437 DefArgEnd.setKind(tok::cxx_defaultarg_end); 4438 DefArgEnd.setLocation(Tok.getLocation()); 4439 DefArgToks->push_back(DefArgEnd); 4440 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc, 4441 (*DefArgToks)[1].getLocation()); 4442 } 4443 } else { 4444 // Consume the '='. 4445 ConsumeToken(); 4446 4447 // The argument isn't actually potentially evaluated unless it is 4448 // used. 4449 EnterExpressionEvaluationContext Eval(Actions, 4450 Sema::PotentiallyEvaluatedIfUsed); 4451 4452 ExprResult DefArgResult(ParseAssignmentExpression()); 4453 if (DefArgResult.isInvalid()) { 4454 Actions.ActOnParamDefaultArgumentError(Param); 4455 SkipUntil(tok::comma, tok::r_paren, true, true); 4456 } else { 4457 // Inform the actions module about the default argument 4458 Actions.ActOnParamDefaultArgument(Param, EqualLoc, 4459 DefArgResult.take()); 4460 } 4461 } 4462 } 4463 4464 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 4465 ParmDecl.getIdentifierLoc(), Param, 4466 DefArgToks)); 4467 } 4468 4469 // If the next token is a comma, consume it and keep reading arguments. 4470 if (Tok.isNot(tok::comma)) { 4471 if (Tok.is(tok::ellipsis)) { 4472 EllipsisLoc = ConsumeToken(); // Consume the ellipsis. 4473 4474 if (!getLang().CPlusPlus) { 4475 // We have ellipsis without a preceding ',', which is ill-formed 4476 // in C. Complain and provide the fix. 4477 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis) 4478 << FixItHint::CreateInsertion(EllipsisLoc, ", "); 4479 } 4480 } 4481 4482 break; 4483 } 4484 4485 // Consume the comma. 4486 ConsumeToken(); 4487 } 4488 4489} 4490 4491/// [C90] direct-declarator '[' constant-expression[opt] ']' 4492/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 4493/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 4494/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 4495/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 4496void Parser::ParseBracketDeclarator(Declarator &D) { 4497 BalancedDelimiterTracker T(*this, tok::l_square); 4498 T.consumeOpen(); 4499 4500 // C array syntax has many features, but by-far the most common is [] and [4]. 4501 // This code does a fast path to handle some of the most obvious cases. 4502 if (Tok.getKind() == tok::r_square) { 4503 T.consumeClose(); 4504 ParsedAttributes attrs(AttrFactory); 4505 MaybeParseCXX0XAttributes(attrs); 4506 4507 // Remember that we parsed the empty array type. 4508 ExprResult NumElements; 4509 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0, 4510 T.getOpenLocation(), 4511 T.getCloseLocation()), 4512 attrs, T.getCloseLocation()); 4513 return; 4514 } else if (Tok.getKind() == tok::numeric_constant && 4515 GetLookAheadToken(1).is(tok::r_square)) { 4516 // [4] is very common. Parse the numeric constant expression. 4517 ExprResult ExprRes(Actions.ActOnNumericConstant(Tok)); 4518 ConsumeToken(); 4519 4520 T.consumeClose(); 4521 ParsedAttributes attrs(AttrFactory); 4522 MaybeParseCXX0XAttributes(attrs); 4523 4524 // Remember that we parsed a array type, and remember its features. 4525 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0, 4526 ExprRes.release(), 4527 T.getOpenLocation(), 4528 T.getCloseLocation()), 4529 attrs, T.getCloseLocation()); 4530 return; 4531 } 4532 4533 // If valid, this location is the position where we read the 'static' keyword. 4534 SourceLocation StaticLoc; 4535 if (Tok.is(tok::kw_static)) 4536 StaticLoc = ConsumeToken(); 4537 4538 // If there is a type-qualifier-list, read it now. 4539 // Type qualifiers in an array subscript are a C99 feature. 4540 DeclSpec DS(AttrFactory); 4541 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 4542 4543 // If we haven't already read 'static', check to see if there is one after the 4544 // type-qualifier-list. 4545 if (!StaticLoc.isValid() && Tok.is(tok::kw_static)) 4546 StaticLoc = ConsumeToken(); 4547 4548 // Handle "direct-declarator [ type-qual-list[opt] * ]". 4549 bool isStar = false; 4550 ExprResult NumElements; 4551 4552 // Handle the case where we have '[*]' as the array size. However, a leading 4553 // star could be the start of an expression, for example 'X[*p + 4]'. Verify 4554 // the the token after the star is a ']'. Since stars in arrays are 4555 // infrequent, use of lookahead is not costly here. 4556 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) { 4557 ConsumeToken(); // Eat the '*'. 4558 4559 if (StaticLoc.isValid()) { 4560 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static); 4561 StaticLoc = SourceLocation(); // Drop the static. 4562 } 4563 isStar = true; 4564 } else if (Tok.isNot(tok::r_square)) { 4565 // Note, in C89, this production uses the constant-expr production instead 4566 // of assignment-expr. The only difference is that assignment-expr allows 4567 // things like '=' and '*='. Sema rejects these in C89 mode because they 4568 // are not i-c-e's, so we don't need to distinguish between the two here. 4569 4570 // Parse the constant-expression or assignment-expression now (depending 4571 // on dialect). 4572 if (getLang().CPlusPlus) 4573 NumElements = ParseConstantExpression(); 4574 else 4575 NumElements = ParseAssignmentExpression(); 4576 } 4577 4578 // If there was an error parsing the assignment-expression, recover. 4579 if (NumElements.isInvalid()) { 4580 D.setInvalidType(true); 4581 // If the expression was invalid, skip it. 4582 SkipUntil(tok::r_square); 4583 return; 4584 } 4585 4586 T.consumeClose(); 4587 4588 ParsedAttributes attrs(AttrFactory); 4589 MaybeParseCXX0XAttributes(attrs); 4590 4591 // Remember that we parsed a array type, and remember its features. 4592 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(), 4593 StaticLoc.isValid(), isStar, 4594 NumElements.release(), 4595 T.getOpenLocation(), 4596 T.getCloseLocation()), 4597 attrs, T.getCloseLocation()); 4598} 4599 4600/// [GNU] typeof-specifier: 4601/// typeof ( expressions ) 4602/// typeof ( type-name ) 4603/// [GNU/C++] typeof unary-expression 4604/// 4605void Parser::ParseTypeofSpecifier(DeclSpec &DS) { 4606 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier"); 4607 Token OpTok = Tok; 4608 SourceLocation StartLoc = ConsumeToken(); 4609 4610 const bool hasParens = Tok.is(tok::l_paren); 4611 4612 bool isCastExpr; 4613 ParsedType CastTy; 4614 SourceRange CastRange; 4615 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, 4616 CastTy, CastRange); 4617 if (hasParens) 4618 DS.setTypeofParensRange(CastRange); 4619 4620 if (CastRange.getEnd().isInvalid()) 4621 // FIXME: Not accurate, the range gets one token more than it should. 4622 DS.SetRangeEnd(Tok.getLocation()); 4623 else 4624 DS.SetRangeEnd(CastRange.getEnd()); 4625 4626 if (isCastExpr) { 4627 if (!CastTy) { 4628 DS.SetTypeSpecError(); 4629 return; 4630 } 4631 4632 const char *PrevSpec = 0; 4633 unsigned DiagID; 4634 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 4635 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, 4636 DiagID, CastTy)) 4637 Diag(StartLoc, DiagID) << PrevSpec; 4638 return; 4639 } 4640 4641 // If we get here, the operand to the typeof was an expresion. 4642 if (Operand.isInvalid()) { 4643 DS.SetTypeSpecError(); 4644 return; 4645 } 4646 4647 const char *PrevSpec = 0; 4648 unsigned DiagID; 4649 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 4650 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 4651 DiagID, Operand.get())) 4652 Diag(StartLoc, DiagID) << PrevSpec; 4653} 4654 4655/// [C1X] atomic-specifier: 4656/// _Atomic ( type-name ) 4657/// 4658void Parser::ParseAtomicSpecifier(DeclSpec &DS) { 4659 assert(Tok.is(tok::kw__Atomic) && "Not an atomic specifier"); 4660 4661 SourceLocation StartLoc = ConsumeToken(); 4662 BalancedDelimiterTracker T(*this, tok::l_paren); 4663 if (T.expectAndConsume(diag::err_expected_lparen_after, "_Atomic")) { 4664 SkipUntil(tok::r_paren); 4665 return; 4666 } 4667 4668 TypeResult Result = ParseTypeName(); 4669 if (Result.isInvalid()) { 4670 SkipUntil(tok::r_paren); 4671 return; 4672 } 4673 4674 // Match the ')' 4675 T.consumeClose(); 4676 4677 if (T.getCloseLocation().isInvalid()) 4678 return; 4679 4680 DS.setTypeofParensRange(T.getRange()); 4681 DS.SetRangeEnd(T.getCloseLocation()); 4682 4683 const char *PrevSpec = 0; 4684 unsigned DiagID; 4685 if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec, 4686 DiagID, Result.release())) 4687 Diag(StartLoc, DiagID) << PrevSpec; 4688} 4689 4690 4691/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called 4692/// from TryAltiVecVectorToken. 4693bool Parser::TryAltiVecVectorTokenOutOfLine() { 4694 Token Next = NextToken(); 4695 switch (Next.getKind()) { 4696 default: return false; 4697 case tok::kw_short: 4698 case tok::kw_long: 4699 case tok::kw_signed: 4700 case tok::kw_unsigned: 4701 case tok::kw_void: 4702 case tok::kw_char: 4703 case tok::kw_int: 4704 case tok::kw_float: 4705 case tok::kw_double: 4706 case tok::kw_bool: 4707 case tok::kw___pixel: 4708 Tok.setKind(tok::kw___vector); 4709 return true; 4710 case tok::identifier: 4711 if (Next.getIdentifierInfo() == Ident_pixel) { 4712 Tok.setKind(tok::kw___vector); 4713 return true; 4714 } 4715 return false; 4716 } 4717} 4718 4719bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc, 4720 const char *&PrevSpec, unsigned &DiagID, 4721 bool &isInvalid) { 4722 if (Tok.getIdentifierInfo() == Ident_vector) { 4723 Token Next = NextToken(); 4724 switch (Next.getKind()) { 4725 case tok::kw_short: 4726 case tok::kw_long: 4727 case tok::kw_signed: 4728 case tok::kw_unsigned: 4729 case tok::kw_void: 4730 case tok::kw_char: 4731 case tok::kw_int: 4732 case tok::kw_float: 4733 case tok::kw_double: 4734 case tok::kw_bool: 4735 case tok::kw___pixel: 4736 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 4737 return true; 4738 case tok::identifier: 4739 if (Next.getIdentifierInfo() == Ident_pixel) { 4740 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 4741 return true; 4742 } 4743 break; 4744 default: 4745 break; 4746 } 4747 } else if ((Tok.getIdentifierInfo() == Ident_pixel) && 4748 DS.isTypeAltiVecVector()) { 4749 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 4750 return true; 4751 } 4752 return false; 4753} 4754