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