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