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