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