ParseDecl.cpp revision c1dc653b08226c1d8e1732f9d8b03b82869900bc
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/Parse/Scope.h" 17#include "ExtensionRAIIObject.h" 18#include "llvm/ADT/SmallSet.h" 19using namespace clang; 20 21//===----------------------------------------------------------------------===// 22// C99 6.7: Declarations. 23//===----------------------------------------------------------------------===// 24 25/// ParseTypeName 26/// type-name: [C99 6.7.6] 27/// specifier-qualifier-list abstract-declarator[opt] 28/// 29/// Called type-id in C++. 30Action::TypeResult Parser::ParseTypeName() { 31 // Parse the common declaration-specifiers piece. 32 DeclSpec DS; 33 ParseSpecifierQualifierList(DS); 34 35 // Parse the abstract-declarator, if present. 36 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 37 ParseDeclarator(DeclaratorInfo); 38 39 if (DeclaratorInfo.isInvalidType()) 40 return true; 41 42 return Actions.ActOnTypeName(CurScope, DeclaratorInfo); 43} 44 45/// ParseAttributes - Parse a non-empty attributes list. 46/// 47/// [GNU] attributes: 48/// attribute 49/// attributes attribute 50/// 51/// [GNU] attribute: 52/// '__attribute__' '(' '(' attribute-list ')' ')' 53/// 54/// [GNU] attribute-list: 55/// attrib 56/// attribute_list ',' attrib 57/// 58/// [GNU] attrib: 59/// empty 60/// attrib-name 61/// attrib-name '(' identifier ')' 62/// attrib-name '(' identifier ',' nonempty-expr-list ')' 63/// attrib-name '(' argument-expression-list [C99 6.5.2] ')' 64/// 65/// [GNU] attrib-name: 66/// identifier 67/// typespec 68/// typequal 69/// storageclass 70/// 71/// FIXME: The GCC grammar/code for this construct implies we need two 72/// token lookahead. Comment from gcc: "If they start with an identifier 73/// which is followed by a comma or close parenthesis, then the arguments 74/// start with that identifier; otherwise they are an expression list." 75/// 76/// At the moment, I am not doing 2 token lookahead. I am also unaware of 77/// any attributes that don't work (based on my limited testing). Most 78/// attributes are very simple in practice. Until we find a bug, I don't see 79/// a pressing need to implement the 2 token lookahead. 80 81AttributeList *Parser::ParseAttributes(SourceLocation *EndLoc) { 82 assert(Tok.is(tok::kw___attribute) && "Not an attribute list!"); 83 84 AttributeList *CurrAttr = 0; 85 86 while (Tok.is(tok::kw___attribute)) { 87 ConsumeToken(); 88 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 89 "attribute")) { 90 SkipUntil(tok::r_paren, true); // skip until ) or ; 91 return CurrAttr; 92 } 93 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) { 94 SkipUntil(tok::r_paren, true); // skip until ) or ; 95 return CurrAttr; 96 } 97 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") )) 98 while (Tok.is(tok::identifier) || isDeclarationSpecifier() || 99 Tok.is(tok::comma)) { 100 101 if (Tok.is(tok::comma)) { 102 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,)) 103 ConsumeToken(); 104 continue; 105 } 106 // we have an identifier or declaration specifier (const, int, etc.) 107 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 108 SourceLocation AttrNameLoc = ConsumeToken(); 109 110 // check if we have a "paramterized" attribute 111 if (Tok.is(tok::l_paren)) { 112 ConsumeParen(); // ignore the left paren loc for now 113 114 if (Tok.is(tok::identifier)) { 115 IdentifierInfo *ParmName = Tok.getIdentifierInfo(); 116 SourceLocation ParmLoc = ConsumeToken(); 117 118 if (Tok.is(tok::r_paren)) { 119 // __attribute__(( mode(byte) )) 120 ConsumeParen(); // ignore the right paren loc for now 121 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 122 ParmName, ParmLoc, 0, 0, CurrAttr); 123 } else if (Tok.is(tok::comma)) { 124 ConsumeToken(); 125 // __attribute__(( format(printf, 1, 2) )) 126 ExprVector ArgExprs(Actions); 127 bool ArgExprsOk = true; 128 129 // now parse the non-empty comma separated list of expressions 130 while (1) { 131 OwningExprResult ArgExpr(ParseAssignmentExpression()); 132 if (ArgExpr.isInvalid()) { 133 ArgExprsOk = false; 134 SkipUntil(tok::r_paren); 135 break; 136 } else { 137 ArgExprs.push_back(ArgExpr.release()); 138 } 139 if (Tok.isNot(tok::comma)) 140 break; 141 ConsumeToken(); // Eat the comma, move to the next argument 142 } 143 if (ArgExprsOk && Tok.is(tok::r_paren)) { 144 ConsumeParen(); // ignore the right paren loc for now 145 CurrAttr = new AttributeList(AttrName, AttrNameLoc, ParmName, 146 ParmLoc, ArgExprs.take(), ArgExprs.size(), CurrAttr); 147 } 148 } 149 } else { // not an identifier 150 // parse a possibly empty comma separated list of expressions 151 if (Tok.is(tok::r_paren)) { 152 // __attribute__(( nonnull() )) 153 ConsumeParen(); // ignore the right paren loc for now 154 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 155 0, SourceLocation(), 0, 0, CurrAttr); 156 } else { 157 // __attribute__(( aligned(16) )) 158 ExprVector ArgExprs(Actions); 159 bool ArgExprsOk = true; 160 161 // now parse the list of expressions 162 while (1) { 163 OwningExprResult ArgExpr(ParseAssignmentExpression()); 164 if (ArgExpr.isInvalid()) { 165 ArgExprsOk = false; 166 SkipUntil(tok::r_paren); 167 break; 168 } else { 169 ArgExprs.push_back(ArgExpr.release()); 170 } 171 if (Tok.isNot(tok::comma)) 172 break; 173 ConsumeToken(); // Eat the comma, move to the next argument 174 } 175 // Match the ')'. 176 if (ArgExprsOk && Tok.is(tok::r_paren)) { 177 ConsumeParen(); // ignore the right paren loc for now 178 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, 179 SourceLocation(), ArgExprs.take(), ArgExprs.size(), 180 CurrAttr); 181 } 182 } 183 } 184 } else { 185 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 186 0, SourceLocation(), 0, 0, CurrAttr); 187 } 188 } 189 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 190 SkipUntil(tok::r_paren, false); 191 SourceLocation Loc = Tok.getLocation();; 192 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) { 193 SkipUntil(tok::r_paren, false); 194 } 195 if (EndLoc) 196 *EndLoc = Loc; 197 } 198 return CurrAttr; 199} 200 201/// FuzzyParseMicrosoftDeclSpec. When -fms-extensions is enabled, this 202/// routine is called to skip/ignore tokens that comprise the MS declspec. 203void Parser::FuzzyParseMicrosoftDeclSpec() { 204 assert(Tok.is(tok::kw___declspec) && "Not a declspec!"); 205 ConsumeToken(); 206 if (Tok.is(tok::l_paren)) { 207 unsigned short savedParenCount = ParenCount; 208 do { 209 ConsumeAnyToken(); 210 } while (ParenCount > savedParenCount && Tok.isNot(tok::eof)); 211 } 212 return; 213} 214 215/// ParseDeclaration - Parse a full 'declaration', which consists of 216/// declaration-specifiers, some number of declarators, and a semicolon. 217/// 'Context' should be a Declarator::TheContext value. This returns the 218/// location of the semicolon in DeclEnd. 219/// 220/// declaration: [C99 6.7] 221/// block-declaration -> 222/// simple-declaration 223/// others [FIXME] 224/// [C++] template-declaration 225/// [C++] namespace-definition 226/// [C++] using-directive 227/// [C++] using-declaration [TODO] 228/// [C++0x] static_assert-declaration 229/// others... [FIXME] 230/// 231Parser::DeclGroupPtrTy Parser::ParseDeclaration(unsigned Context, 232 SourceLocation &DeclEnd) { 233 DeclPtrTy SingleDecl; 234 switch (Tok.getKind()) { 235 case tok::kw_template: 236 case tok::kw_export: 237 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd); 238 break; 239 case tok::kw_namespace: 240 SingleDecl = ParseNamespace(Context, DeclEnd); 241 break; 242 case tok::kw_using: 243 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, DeclEnd); 244 break; 245 case tok::kw_static_assert: 246 SingleDecl = ParseStaticAssertDeclaration(DeclEnd); 247 break; 248 default: 249 return ParseSimpleDeclaration(Context, DeclEnd); 250 } 251 252 // This routine returns a DeclGroup, if the thing we parsed only contains a 253 // single decl, convert it now. 254 return Actions.ConvertDeclToDeclGroup(SingleDecl); 255} 256 257/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl] 258/// declaration-specifiers init-declarator-list[opt] ';' 259///[C90/C++]init-declarator-list ';' [TODO] 260/// [OMP] threadprivate-directive [TODO] 261/// 262/// If RequireSemi is false, this does not check for a ';' at the end of the 263/// declaration. 264Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(unsigned Context, 265 SourceLocation &DeclEnd, 266 bool RequireSemi) { 267 // Parse the common declaration-specifiers piece. 268 DeclSpec DS; 269 ParseDeclarationSpecifiers(DS); 270 271 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" 272 // declaration-specifiers init-declarator-list[opt] ';' 273 if (Tok.is(tok::semi)) { 274 ConsumeToken(); 275 DeclPtrTy TheDecl = Actions.ParsedFreeStandingDeclSpec(CurScope, DS); 276 return Actions.ConvertDeclToDeclGroup(TheDecl); 277 } 278 279 Declarator DeclaratorInfo(DS, (Declarator::TheContext)Context); 280 ParseDeclarator(DeclaratorInfo); 281 282 DeclGroupPtrTy DG = 283 ParseInitDeclaratorListAfterFirstDeclarator(DeclaratorInfo); 284 285 DeclEnd = Tok.getLocation(); 286 287 // If the client wants to check what comes after the declaration, just return 288 // immediately without checking anything! 289 if (!RequireSemi) return DG; 290 291 if (Tok.is(tok::semi)) { 292 ConsumeToken(); 293 return DG; 294 } 295 296 Diag(Tok, diag::err_expected_semi_declation); 297 // Skip to end of block or statement 298 SkipUntil(tok::r_brace, true, true); 299 if (Tok.is(tok::semi)) 300 ConsumeToken(); 301 return DG; 302} 303 304/// \brief Parse 'declaration' after parsing 'declaration-specifiers 305/// declarator'. This method parses the remainder of the declaration 306/// (including any attributes or initializer, among other things) and 307/// finalizes the declaration. 308/// 309/// init-declarator: [C99 6.7] 310/// declarator 311/// declarator '=' initializer 312/// [GNU] declarator simple-asm-expr[opt] attributes[opt] 313/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer 314/// [C++] declarator initializer[opt] 315/// 316/// [C++] initializer: 317/// [C++] '=' initializer-clause 318/// [C++] '(' expression-list ')' 319/// [C++0x] '=' 'default' [TODO] 320/// [C++0x] '=' 'delete' 321/// 322/// According to the standard grammar, =default and =delete are function 323/// definitions, but that definitely doesn't fit with the parser here. 324/// 325Parser::DeclPtrTy Parser::ParseDeclarationAfterDeclarator(Declarator &D) { 326 // If a simple-asm-expr is present, parse it. 327 if (Tok.is(tok::kw_asm)) { 328 SourceLocation Loc; 329 OwningExprResult AsmLabel(ParseSimpleAsm(&Loc)); 330 if (AsmLabel.isInvalid()) { 331 SkipUntil(tok::semi, true, true); 332 return DeclPtrTy(); 333 } 334 335 D.setAsmLabel(AsmLabel.release()); 336 D.SetRangeEnd(Loc); 337 } 338 339 // If attributes are present, parse them. 340 if (Tok.is(tok::kw___attribute)) { 341 SourceLocation Loc; 342 AttributeList *AttrList = ParseAttributes(&Loc); 343 D.AddAttributes(AttrList, Loc); 344 } 345 346 // Inform the current actions module that we just parsed this declarator. 347 DeclPtrTy ThisDecl = Actions.ActOnDeclarator(CurScope, D); 348 349 // Parse declarator '=' initializer. 350 if (Tok.is(tok::equal)) { 351 ConsumeToken(); 352 if (getLang().CPlusPlus0x && Tok.is(tok::kw_delete)) { 353 SourceLocation DelLoc = ConsumeToken(); 354 Actions.SetDeclDeleted(ThisDecl, DelLoc); 355 } else { 356 OwningExprResult Init(ParseInitializer()); 357 if (Init.isInvalid()) { 358 SkipUntil(tok::semi, true, true); 359 return DeclPtrTy(); 360 } 361 Actions.AddInitializerToDecl(ThisDecl, move(Init)); 362 } 363 } else if (Tok.is(tok::l_paren)) { 364 // Parse C++ direct initializer: '(' expression-list ')' 365 SourceLocation LParenLoc = ConsumeParen(); 366 ExprVector Exprs(Actions); 367 CommaLocsTy CommaLocs; 368 369 if (ParseExpressionList(Exprs, CommaLocs)) { 370 SkipUntil(tok::r_paren); 371 } else { 372 // Match the ')'. 373 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 374 375 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() && 376 "Unexpected number of commas!"); 377 Actions.AddCXXDirectInitializerToDecl(ThisDecl, LParenLoc, 378 move_arg(Exprs), 379 CommaLocs.data(), RParenLoc); 380 } 381 } else { 382 Actions.ActOnUninitializedDecl(ThisDecl); 383 } 384 385 return ThisDecl; 386} 387 388/// ParseInitDeclaratorListAfterFirstDeclarator - Parse 'declaration' after 389/// parsing 'declaration-specifiers declarator'. This method is split out this 390/// way to handle the ambiguity between top-level function-definitions and 391/// declarations. 392/// 393/// init-declarator-list: [C99 6.7] 394/// init-declarator 395/// init-declarator-list ',' init-declarator 396/// 397/// According to the standard grammar, =default and =delete are function 398/// definitions, but that definitely doesn't fit with the parser here. 399/// 400Parser::DeclGroupPtrTy Parser:: 401ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) { 402 // Declarators may be grouped together ("int X, *Y, Z();"). Remember the decls 403 // that we parse together here. 404 llvm::SmallVector<DeclPtrTy, 8> DeclsInGroup; 405 406 // At this point, we know that it is not a function definition. Parse the 407 // rest of the init-declarator-list. 408 while (1) { 409 DeclPtrTy ThisDecl = ParseDeclarationAfterDeclarator(D); 410 if (ThisDecl.get()) 411 DeclsInGroup.push_back(ThisDecl); 412 413 // If we don't have a comma, it is either the end of the list (a ';') or an 414 // error, bail out. 415 if (Tok.isNot(tok::comma)) 416 break; 417 418 // Consume the comma. 419 ConsumeToken(); 420 421 // Parse the next declarator. 422 D.clear(); 423 424 // Accept attributes in an init-declarator. In the first declarator in a 425 // declaration, these would be part of the declspec. In subsequent 426 // declarators, they become part of the declarator itself, so that they 427 // don't apply to declarators after *this* one. Examples: 428 // short __attribute__((common)) var; -> declspec 429 // short var __attribute__((common)); -> declarator 430 // short x, __attribute__((common)) var; -> declarator 431 if (Tok.is(tok::kw___attribute)) { 432 SourceLocation Loc; 433 AttributeList *AttrList = ParseAttributes(&Loc); 434 D.AddAttributes(AttrList, Loc); 435 } 436 437 ParseDeclarator(D); 438 } 439 440 return Actions.FinalizeDeclaratorGroup(CurScope, D.getDeclSpec(), 441 DeclsInGroup.data(), 442 DeclsInGroup.size()); 443} 444 445/// ParseSpecifierQualifierList 446/// specifier-qualifier-list: 447/// type-specifier specifier-qualifier-list[opt] 448/// type-qualifier specifier-qualifier-list[opt] 449/// [GNU] attributes specifier-qualifier-list[opt] 450/// 451void Parser::ParseSpecifierQualifierList(DeclSpec &DS) { 452 /// specifier-qualifier-list is a subset of declaration-specifiers. Just 453 /// parse declaration-specifiers and complain about extra stuff. 454 ParseDeclarationSpecifiers(DS); 455 456 // Validate declspec for type-name. 457 unsigned Specs = DS.getParsedSpecifiers(); 458 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() && 459 !DS.getAttributes()) 460 Diag(Tok, diag::err_typename_requires_specqual); 461 462 // Issue diagnostic and remove storage class if present. 463 if (Specs & DeclSpec::PQ_StorageClassSpecifier) { 464 if (DS.getStorageClassSpecLoc().isValid()) 465 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass); 466 else 467 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass); 468 DS.ClearStorageClassSpecs(); 469 } 470 471 // Issue diagnostic and remove function specfier if present. 472 if (Specs & DeclSpec::PQ_FunctionSpecifier) { 473 if (DS.isInlineSpecified()) 474 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec); 475 if (DS.isVirtualSpecified()) 476 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec); 477 if (DS.isExplicitSpecified()) 478 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec); 479 DS.ClearFunctionSpecs(); 480 } 481} 482 483/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the 484/// specified token is valid after the identifier in a declarator which 485/// immediately follows the declspec. For example, these things are valid: 486/// 487/// int x [ 4]; // direct-declarator 488/// int x ( int y); // direct-declarator 489/// int(int x ) // direct-declarator 490/// int x ; // simple-declaration 491/// int x = 17; // init-declarator-list 492/// int x , y; // init-declarator-list 493/// int x __asm__ ("foo"); // init-declarator-list 494/// int x : 4; // struct-declarator 495/// int x { 5}; // C++'0x unified initializers 496/// 497/// This is not, because 'x' does not immediately follow the declspec (though 498/// ')' happens to be valid anyway). 499/// int (x) 500/// 501static bool isValidAfterIdentifierInDeclarator(const Token &T) { 502 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) || 503 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) || 504 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon); 505} 506 507 508/// ParseImplicitInt - This method is called when we have an non-typename 509/// identifier in a declspec (which normally terminates the decl spec) when 510/// the declspec has no type specifier. In this case, the declspec is either 511/// malformed or is "implicit int" (in K&R and C89). 512/// 513/// This method handles diagnosing this prettily and returns false if the 514/// declspec is done being processed. If it recovers and thinks there may be 515/// other pieces of declspec after it, it returns true. 516/// 517bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS, 518 const ParsedTemplateInfo &TemplateInfo, 519 AccessSpecifier AS) { 520 assert(Tok.is(tok::identifier) && "should have identifier"); 521 522 SourceLocation Loc = Tok.getLocation(); 523 // If we see an identifier that is not a type name, we normally would 524 // parse it as the identifer being declared. However, when a typename 525 // is typo'd or the definition is not included, this will incorrectly 526 // parse the typename as the identifier name and fall over misparsing 527 // later parts of the diagnostic. 528 // 529 // As such, we try to do some look-ahead in cases where this would 530 // otherwise be an "implicit-int" case to see if this is invalid. For 531 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as 532 // an identifier with implicit int, we'd get a parse error because the 533 // next token is obviously invalid for a type. Parse these as a case 534 // with an invalid type specifier. 535 assert(!DS.hasTypeSpecifier() && "Type specifier checked above"); 536 537 // Since we know that this either implicit int (which is rare) or an 538 // error, we'd do lookahead to try to do better recovery. 539 if (isValidAfterIdentifierInDeclarator(NextToken())) { 540 // If this token is valid for implicit int, e.g. "static x = 4", then 541 // we just avoid eating the identifier, so it will be parsed as the 542 // identifier in the declarator. 543 return false; 544 } 545 546 // Otherwise, if we don't consume this token, we are going to emit an 547 // error anyway. Try to recover from various common problems. Check 548 // to see if this was a reference to a tag name without a tag specified. 549 // This is a common problem in C (saying 'foo' instead of 'struct foo'). 550 // 551 // C++ doesn't need this, and isTagName doesn't take SS. 552 if (SS == 0) { 553 const char *TagName = 0; 554 tok::TokenKind TagKind = tok::unknown; 555 556 switch (Actions.isTagName(*Tok.getIdentifierInfo(), CurScope)) { 557 default: break; 558 case DeclSpec::TST_enum: TagName="enum" ;TagKind=tok::kw_enum ;break; 559 case DeclSpec::TST_union: TagName="union" ;TagKind=tok::kw_union ;break; 560 case DeclSpec::TST_struct:TagName="struct";TagKind=tok::kw_struct;break; 561 case DeclSpec::TST_class: TagName="class" ;TagKind=tok::kw_class ;break; 562 } 563 564 if (TagName) { 565 Diag(Loc, diag::err_use_of_tag_name_without_tag) 566 << Tok.getIdentifierInfo() << TagName 567 << CodeModificationHint::CreateInsertion(Tok.getLocation(),TagName); 568 569 // Parse this as a tag as if the missing tag were present. 570 if (TagKind == tok::kw_enum) 571 ParseEnumSpecifier(Loc, DS, AS); 572 else 573 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS); 574 return true; 575 } 576 } 577 578 // Since this is almost certainly an invalid type name, emit a 579 // diagnostic that says it, eat the token, and mark the declspec as 580 // invalid. 581 SourceRange R; 582 if (SS) R = SS->getRange(); 583 584 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R; 585 const char *PrevSpec; 586 DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec); 587 DS.SetRangeEnd(Tok.getLocation()); 588 ConsumeToken(); 589 590 // TODO: Could inject an invalid typedef decl in an enclosing scope to 591 // avoid rippling error messages on subsequent uses of the same type, 592 // could be useful if #include was forgotten. 593 return false; 594} 595 596/// ParseDeclarationSpecifiers 597/// declaration-specifiers: [C99 6.7] 598/// storage-class-specifier declaration-specifiers[opt] 599/// type-specifier declaration-specifiers[opt] 600/// [C99] function-specifier declaration-specifiers[opt] 601/// [GNU] attributes declaration-specifiers[opt] 602/// 603/// storage-class-specifier: [C99 6.7.1] 604/// 'typedef' 605/// 'extern' 606/// 'static' 607/// 'auto' 608/// 'register' 609/// [C++] 'mutable' 610/// [GNU] '__thread' 611/// function-specifier: [C99 6.7.4] 612/// [C99] 'inline' 613/// [C++] 'virtual' 614/// [C++] 'explicit' 615/// 'friend': [C++ dcl.friend] 616 617/// 618void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, 619 const ParsedTemplateInfo &TemplateInfo, 620 AccessSpecifier AS) { 621 DS.SetRangeStart(Tok.getLocation()); 622 while (1) { 623 int isInvalid = false; 624 const char *PrevSpec = 0; 625 SourceLocation Loc = Tok.getLocation(); 626 627 switch (Tok.getKind()) { 628 default: 629 DoneWithDeclSpec: 630 // If this is not a declaration specifier token, we're done reading decl 631 // specifiers. First verify that DeclSpec's are consistent. 632 DS.Finish(Diags, PP); 633 return; 634 635 case tok::coloncolon: // ::foo::bar 636 // Annotate C++ scope specifiers. If we get one, loop. 637 if (TryAnnotateCXXScopeToken()) 638 continue; 639 goto DoneWithDeclSpec; 640 641 case tok::annot_cxxscope: { 642 if (DS.hasTypeSpecifier()) 643 goto DoneWithDeclSpec; 644 645 // We are looking for a qualified typename. 646 Token Next = NextToken(); 647 if (Next.is(tok::annot_template_id) && 648 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()) 649 ->Kind == TNK_Type_template) { 650 // We have a qualified template-id, e.g., N::A<int> 651 CXXScopeSpec SS; 652 ParseOptionalCXXScopeSpecifier(SS); 653 assert(Tok.is(tok::annot_template_id) && 654 "ParseOptionalCXXScopeSpecifier not working"); 655 AnnotateTemplateIdTokenAsType(&SS); 656 continue; 657 } 658 659 if (Next.isNot(tok::identifier)) 660 goto DoneWithDeclSpec; 661 662 CXXScopeSpec SS; 663 SS.setScopeRep(Tok.getAnnotationValue()); 664 SS.setRange(Tok.getAnnotationRange()); 665 666 // If the next token is the name of the class type that the C++ scope 667 // denotes, followed by a '(', then this is a constructor declaration. 668 // We're done with the decl-specifiers. 669 if (Actions.isCurrentClassName(*Next.getIdentifierInfo(), 670 CurScope, &SS) && 671 GetLookAheadToken(2).is(tok::l_paren)) 672 goto DoneWithDeclSpec; 673 674 TypeTy *TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(), 675 Next.getLocation(), CurScope, &SS); 676 677 // If the referenced identifier is not a type, then this declspec is 678 // erroneous: We already checked about that it has no type specifier, and 679 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the 680 // typename. 681 if (TypeRep == 0) { 682 ConsumeToken(); // Eat the scope spec so the identifier is current. 683 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue; 684 goto DoneWithDeclSpec; 685 } 686 687 ConsumeToken(); // The C++ scope. 688 689 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 690 TypeRep); 691 if (isInvalid) 692 break; 693 694 DS.SetRangeEnd(Tok.getLocation()); 695 ConsumeToken(); // The typename. 696 697 continue; 698 } 699 700 case tok::annot_typename: { 701 if (Tok.getAnnotationValue()) 702 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 703 Tok.getAnnotationValue()); 704 else 705 DS.SetTypeSpecError(); 706 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 707 ConsumeToken(); // The typename 708 709 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 710 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 711 // Objective-C interface. If we don't have Objective-C or a '<', this is 712 // just a normal reference to a typedef name. 713 if (!Tok.is(tok::less) || !getLang().ObjC1) 714 continue; 715 716 SourceLocation EndProtoLoc; 717 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl; 718 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc); 719 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size()); 720 721 DS.SetRangeEnd(EndProtoLoc); 722 continue; 723 } 724 725 // typedef-name 726 case tok::identifier: { 727 // In C++, check to see if this is a scope specifier like foo::bar::, if 728 // so handle it as such. This is important for ctor parsing. 729 if (getLang().CPlusPlus && TryAnnotateCXXScopeToken()) 730 continue; 731 732 // This identifier can only be a typedef name if we haven't already seen 733 // a type-specifier. Without this check we misparse: 734 // typedef int X; struct Y { short X; }; as 'short int'. 735 if (DS.hasTypeSpecifier()) 736 goto DoneWithDeclSpec; 737 738 // It has to be available as a typedef too! 739 TypeTy *TypeRep = Actions.getTypeName(*Tok.getIdentifierInfo(), 740 Tok.getLocation(), CurScope); 741 742 // If this is not a typedef name, don't parse it as part of the declspec, 743 // it must be an implicit int or an error. 744 if (TypeRep == 0) { 745 if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue; 746 goto DoneWithDeclSpec; 747 } 748 749 // C++: If the identifier is actually the name of the class type 750 // being defined and the next token is a '(', then this is a 751 // constructor declaration. We're done with the decl-specifiers 752 // and will treat this token as an identifier. 753 if (getLang().CPlusPlus && CurScope->isClassScope() && 754 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), CurScope) && 755 NextToken().getKind() == tok::l_paren) 756 goto DoneWithDeclSpec; 757 758 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 759 TypeRep); 760 if (isInvalid) 761 break; 762 763 DS.SetRangeEnd(Tok.getLocation()); 764 ConsumeToken(); // The identifier 765 766 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 767 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 768 // Objective-C interface. If we don't have Objective-C or a '<', this is 769 // just a normal reference to a typedef name. 770 if (!Tok.is(tok::less) || !getLang().ObjC1) 771 continue; 772 773 SourceLocation EndProtoLoc; 774 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl; 775 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc); 776 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size()); 777 778 DS.SetRangeEnd(EndProtoLoc); 779 780 // Need to support trailing type qualifiers (e.g. "id<p> const"). 781 // If a type specifier follows, it will be diagnosed elsewhere. 782 continue; 783 } 784 785 // type-name 786 case tok::annot_template_id: { 787 TemplateIdAnnotation *TemplateId 788 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 789 if (TemplateId->Kind != TNK_Type_template) { 790 // This template-id does not refer to a type name, so we're 791 // done with the type-specifiers. 792 goto DoneWithDeclSpec; 793 } 794 795 // Turn the template-id annotation token into a type annotation 796 // token, then try again to parse it as a type-specifier. 797 AnnotateTemplateIdTokenAsType(); 798 continue; 799 } 800 801 // GNU attributes support. 802 case tok::kw___attribute: 803 DS.AddAttributes(ParseAttributes()); 804 continue; 805 806 // Microsoft declspec support. 807 case tok::kw___declspec: 808 if (!PP.getLangOptions().Microsoft) 809 goto DoneWithDeclSpec; 810 FuzzyParseMicrosoftDeclSpec(); 811 continue; 812 813 // Microsoft single token adornments. 814 case tok::kw___forceinline: 815 case tok::kw___w64: 816 case tok::kw___cdecl: 817 case tok::kw___stdcall: 818 case tok::kw___fastcall: 819 if (!PP.getLangOptions().Microsoft) 820 goto DoneWithDeclSpec; 821 // Just ignore it. 822 break; 823 824 // storage-class-specifier 825 case tok::kw_typedef: 826 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec); 827 break; 828 case tok::kw_extern: 829 if (DS.isThreadSpecified()) 830 Diag(Tok, diag::ext_thread_before) << "extern"; 831 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_extern, Loc, PrevSpec); 832 break; 833 case tok::kw___private_extern__: 834 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_private_extern, Loc, 835 PrevSpec); 836 break; 837 case tok::kw_static: 838 if (DS.isThreadSpecified()) 839 Diag(Tok, diag::ext_thread_before) << "static"; 840 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_static, Loc, PrevSpec); 841 break; 842 case tok::kw_auto: 843 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec); 844 break; 845 case tok::kw_register: 846 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_register, Loc, PrevSpec); 847 break; 848 case tok::kw_mutable: 849 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_mutable, Loc, PrevSpec); 850 break; 851 case tok::kw___thread: 852 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec)*2; 853 break; 854 855 // function-specifier 856 case tok::kw_inline: 857 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec); 858 break; 859 case tok::kw_virtual: 860 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec); 861 break; 862 case tok::kw_explicit: 863 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec); 864 break; 865 866 // friend 867 case tok::kw_friend: 868 isInvalid = DS.SetFriendSpec(Loc, PrevSpec); 869 break; 870 871 // type-specifier 872 case tok::kw_short: 873 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec); 874 break; 875 case tok::kw_long: 876 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 877 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec); 878 else 879 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec); 880 break; 881 case tok::kw_signed: 882 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec); 883 break; 884 case tok::kw_unsigned: 885 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec); 886 break; 887 case tok::kw__Complex: 888 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec); 889 break; 890 case tok::kw__Imaginary: 891 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec); 892 break; 893 case tok::kw_void: 894 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec); 895 break; 896 case tok::kw_char: 897 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec); 898 break; 899 case tok::kw_int: 900 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec); 901 break; 902 case tok::kw_float: 903 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec); 904 break; 905 case tok::kw_double: 906 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec); 907 break; 908 case tok::kw_wchar_t: 909 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec); 910 break; 911 case tok::kw_bool: 912 case tok::kw__Bool: 913 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec); 914 break; 915 case tok::kw__Decimal32: 916 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec); 917 break; 918 case tok::kw__Decimal64: 919 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec); 920 break; 921 case tok::kw__Decimal128: 922 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec); 923 break; 924 925 // class-specifier: 926 case tok::kw_class: 927 case tok::kw_struct: 928 case tok::kw_union: { 929 tok::TokenKind Kind = Tok.getKind(); 930 ConsumeToken(); 931 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS); 932 continue; 933 } 934 935 // enum-specifier: 936 case tok::kw_enum: 937 ConsumeToken(); 938 ParseEnumSpecifier(Loc, DS, AS); 939 continue; 940 941 // cv-qualifier: 942 case tok::kw_const: 943 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec,getLang())*2; 944 break; 945 case tok::kw_volatile: 946 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 947 getLang())*2; 948 break; 949 case tok::kw_restrict: 950 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 951 getLang())*2; 952 break; 953 954 // C++ typename-specifier: 955 case tok::kw_typename: 956 if (TryAnnotateTypeOrScopeToken()) 957 continue; 958 break; 959 960 // GNU typeof support. 961 case tok::kw_typeof: 962 ParseTypeofSpecifier(DS); 963 continue; 964 965 case tok::less: 966 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for 967 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous, 968 // but we support it. 969 if (DS.hasTypeSpecifier() || !getLang().ObjC1) 970 goto DoneWithDeclSpec; 971 972 { 973 SourceLocation EndProtoLoc; 974 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl; 975 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc); 976 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size()); 977 DS.SetRangeEnd(EndProtoLoc); 978 979 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id) 980 << CodeModificationHint::CreateInsertion(Loc, "id") 981 << SourceRange(Loc, EndProtoLoc); 982 // Need to support trailing type qualifiers (e.g. "id<p> const"). 983 // If a type specifier follows, it will be diagnosed elsewhere. 984 continue; 985 } 986 } 987 // If the specifier combination wasn't legal, issue a diagnostic. 988 if (isInvalid) { 989 assert(PrevSpec && "Method did not return previous specifier!"); 990 // Pick between error or extwarn. 991 unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination 992 : diag::ext_duplicate_declspec; 993 Diag(Tok, DiagID) << PrevSpec; 994 } 995 DS.SetRangeEnd(Tok.getLocation()); 996 ConsumeToken(); 997 } 998} 999 1000/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We 1001/// primarily follow the C++ grammar with additions for C99 and GNU, 1002/// which together subsume the C grammar. Note that the C++ 1003/// type-specifier also includes the C type-qualifier (for const, 1004/// volatile, and C99 restrict). Returns true if a type-specifier was 1005/// found (and parsed), false otherwise. 1006/// 1007/// type-specifier: [C++ 7.1.5] 1008/// simple-type-specifier 1009/// class-specifier 1010/// enum-specifier 1011/// elaborated-type-specifier [TODO] 1012/// cv-qualifier 1013/// 1014/// cv-qualifier: [C++ 7.1.5.1] 1015/// 'const' 1016/// 'volatile' 1017/// [C99] 'restrict' 1018/// 1019/// simple-type-specifier: [ C++ 7.1.5.2] 1020/// '::'[opt] nested-name-specifier[opt] type-name [TODO] 1021/// '::'[opt] nested-name-specifier 'template' template-id [TODO] 1022/// 'char' 1023/// 'wchar_t' 1024/// 'bool' 1025/// 'short' 1026/// 'int' 1027/// 'long' 1028/// 'signed' 1029/// 'unsigned' 1030/// 'float' 1031/// 'double' 1032/// 'void' 1033/// [C99] '_Bool' 1034/// [C99] '_Complex' 1035/// [C99] '_Imaginary' // Removed in TC2? 1036/// [GNU] '_Decimal32' 1037/// [GNU] '_Decimal64' 1038/// [GNU] '_Decimal128' 1039/// [GNU] typeof-specifier 1040/// [OBJC] class-name objc-protocol-refs[opt] [TODO] 1041/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO] 1042bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, int& isInvalid, 1043 const char *&PrevSpec, 1044 const ParsedTemplateInfo &TemplateInfo) { 1045 SourceLocation Loc = Tok.getLocation(); 1046 1047 switch (Tok.getKind()) { 1048 case tok::identifier: // foo::bar 1049 case tok::kw_typename: // typename foo::bar 1050 // Annotate typenames and C++ scope specifiers. If we get one, just 1051 // recurse to handle whatever we get. 1052 if (TryAnnotateTypeOrScopeToken()) 1053 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, TemplateInfo); 1054 // Otherwise, not a type specifier. 1055 return false; 1056 case tok::coloncolon: // ::foo::bar 1057 if (NextToken().is(tok::kw_new) || // ::new 1058 NextToken().is(tok::kw_delete)) // ::delete 1059 return false; 1060 1061 // Annotate typenames and C++ scope specifiers. If we get one, just 1062 // recurse to handle whatever we get. 1063 if (TryAnnotateTypeOrScopeToken()) 1064 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, TemplateInfo); 1065 // Otherwise, not a type specifier. 1066 return false; 1067 1068 // simple-type-specifier: 1069 case tok::annot_typename: { 1070 if (Tok.getAnnotationValue()) 1071 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1072 Tok.getAnnotationValue()); 1073 else 1074 DS.SetTypeSpecError(); 1075 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1076 ConsumeToken(); // The typename 1077 1078 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1079 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1080 // Objective-C interface. If we don't have Objective-C or a '<', this is 1081 // just a normal reference to a typedef name. 1082 if (!Tok.is(tok::less) || !getLang().ObjC1) 1083 return true; 1084 1085 SourceLocation EndProtoLoc; 1086 llvm::SmallVector<DeclPtrTy, 8> ProtocolDecl; 1087 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc); 1088 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size()); 1089 1090 DS.SetRangeEnd(EndProtoLoc); 1091 return true; 1092 } 1093 1094 case tok::kw_short: 1095 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec); 1096 break; 1097 case tok::kw_long: 1098 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 1099 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec); 1100 else 1101 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec); 1102 break; 1103 case tok::kw_signed: 1104 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec); 1105 break; 1106 case tok::kw_unsigned: 1107 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec); 1108 break; 1109 case tok::kw__Complex: 1110 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec); 1111 break; 1112 case tok::kw__Imaginary: 1113 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec); 1114 break; 1115 case tok::kw_void: 1116 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec); 1117 break; 1118 case tok::kw_char: 1119 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec); 1120 break; 1121 case tok::kw_int: 1122 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec); 1123 break; 1124 case tok::kw_float: 1125 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec); 1126 break; 1127 case tok::kw_double: 1128 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec); 1129 break; 1130 case tok::kw_wchar_t: 1131 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec); 1132 break; 1133 case tok::kw_bool: 1134 case tok::kw__Bool: 1135 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec); 1136 break; 1137 case tok::kw__Decimal32: 1138 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec); 1139 break; 1140 case tok::kw__Decimal64: 1141 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec); 1142 break; 1143 case tok::kw__Decimal128: 1144 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec); 1145 break; 1146 1147 // class-specifier: 1148 case tok::kw_class: 1149 case tok::kw_struct: 1150 case tok::kw_union: { 1151 tok::TokenKind Kind = Tok.getKind(); 1152 ConsumeToken(); 1153 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo); 1154 return true; 1155 } 1156 1157 // enum-specifier: 1158 case tok::kw_enum: 1159 ConsumeToken(); 1160 ParseEnumSpecifier(Loc, DS); 1161 return true; 1162 1163 // cv-qualifier: 1164 case tok::kw_const: 1165 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, 1166 getLang())*2; 1167 break; 1168 case tok::kw_volatile: 1169 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 1170 getLang())*2; 1171 break; 1172 case tok::kw_restrict: 1173 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 1174 getLang())*2; 1175 break; 1176 1177 // GNU typeof support. 1178 case tok::kw_typeof: 1179 ParseTypeofSpecifier(DS); 1180 return true; 1181 1182 case tok::kw___cdecl: 1183 case tok::kw___stdcall: 1184 case tok::kw___fastcall: 1185 if (!PP.getLangOptions().Microsoft) return false; 1186 ConsumeToken(); 1187 return true; 1188 1189 default: 1190 // Not a type-specifier; do nothing. 1191 return false; 1192 } 1193 1194 // If the specifier combination wasn't legal, issue a diagnostic. 1195 if (isInvalid) { 1196 assert(PrevSpec && "Method did not return previous specifier!"); 1197 // Pick between error or extwarn. 1198 unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination 1199 : diag::ext_duplicate_declspec; 1200 Diag(Tok, DiagID) << PrevSpec; 1201 } 1202 DS.SetRangeEnd(Tok.getLocation()); 1203 ConsumeToken(); // whatever we parsed above. 1204 return true; 1205} 1206 1207/// ParseStructDeclaration - Parse a struct declaration without the terminating 1208/// semicolon. 1209/// 1210/// struct-declaration: 1211/// specifier-qualifier-list struct-declarator-list 1212/// [GNU] __extension__ struct-declaration 1213/// [GNU] specifier-qualifier-list 1214/// struct-declarator-list: 1215/// struct-declarator 1216/// struct-declarator-list ',' struct-declarator 1217/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator 1218/// struct-declarator: 1219/// declarator 1220/// [GNU] declarator attributes[opt] 1221/// declarator[opt] ':' constant-expression 1222/// [GNU] declarator[opt] ':' constant-expression attributes[opt] 1223/// 1224void Parser:: 1225ParseStructDeclaration(DeclSpec &DS, 1226 llvm::SmallVectorImpl<FieldDeclarator> &Fields) { 1227 if (Tok.is(tok::kw___extension__)) { 1228 // __extension__ silences extension warnings in the subexpression. 1229 ExtensionRAIIObject O(Diags); // Use RAII to do this. 1230 ConsumeToken(); 1231 return ParseStructDeclaration(DS, Fields); 1232 } 1233 1234 // Parse the common specifier-qualifiers-list piece. 1235 SourceLocation DSStart = Tok.getLocation(); 1236 ParseSpecifierQualifierList(DS); 1237 1238 // If there are no declarators, this is a free-standing declaration 1239 // specifier. Let the actions module cope with it. 1240 if (Tok.is(tok::semi)) { 1241 Actions.ParsedFreeStandingDeclSpec(CurScope, DS); 1242 return; 1243 } 1244 1245 // Read struct-declarators until we find the semicolon. 1246 Fields.push_back(FieldDeclarator(DS)); 1247 while (1) { 1248 FieldDeclarator &DeclaratorInfo = Fields.back(); 1249 1250 /// struct-declarator: declarator 1251 /// struct-declarator: declarator[opt] ':' constant-expression 1252 if (Tok.isNot(tok::colon)) 1253 ParseDeclarator(DeclaratorInfo.D); 1254 1255 if (Tok.is(tok::colon)) { 1256 ConsumeToken(); 1257 OwningExprResult Res(ParseConstantExpression()); 1258 if (Res.isInvalid()) 1259 SkipUntil(tok::semi, true, true); 1260 else 1261 DeclaratorInfo.BitfieldSize = Res.release(); 1262 } 1263 1264 // If attributes exist after the declarator, parse them. 1265 if (Tok.is(tok::kw___attribute)) { 1266 SourceLocation Loc; 1267 AttributeList *AttrList = ParseAttributes(&Loc); 1268 DeclaratorInfo.D.AddAttributes(AttrList, Loc); 1269 } 1270 1271 // If we don't have a comma, it is either the end of the list (a ';') 1272 // or an error, bail out. 1273 if (Tok.isNot(tok::comma)) 1274 return; 1275 1276 // Consume the comma. 1277 ConsumeToken(); 1278 1279 // Parse the next declarator. 1280 Fields.push_back(FieldDeclarator(DS)); 1281 1282 // Attributes are only allowed on the second declarator. 1283 if (Tok.is(tok::kw___attribute)) { 1284 SourceLocation Loc; 1285 AttributeList *AttrList = ParseAttributes(&Loc); 1286 Fields.back().D.AddAttributes(AttrList, Loc); 1287 } 1288 } 1289} 1290 1291/// ParseStructUnionBody 1292/// struct-contents: 1293/// struct-declaration-list 1294/// [EXT] empty 1295/// [GNU] "struct-declaration-list" without terminatoring ';' 1296/// struct-declaration-list: 1297/// struct-declaration 1298/// struct-declaration-list struct-declaration 1299/// [OBC] '@' 'defs' '(' class-name ')' 1300/// 1301void Parser::ParseStructUnionBody(SourceLocation RecordLoc, 1302 unsigned TagType, DeclPtrTy TagDecl) { 1303 PrettyStackTraceActionsDecl CrashInfo(TagDecl, RecordLoc, Actions, 1304 PP.getSourceManager(), 1305 "parsing struct/union body"); 1306 1307 SourceLocation LBraceLoc = ConsumeBrace(); 1308 1309 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope); 1310 Actions.ActOnTagStartDefinition(CurScope, TagDecl); 1311 1312 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 1313 // C++. 1314 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 1315 Diag(Tok, diag::ext_empty_struct_union_enum) 1316 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType); 1317 1318 llvm::SmallVector<DeclPtrTy, 32> FieldDecls; 1319 llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators; 1320 1321 // While we still have something to read, read the declarations in the struct. 1322 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 1323 // Each iteration of this loop reads one struct-declaration. 1324 1325 // Check for extraneous top-level semicolon. 1326 if (Tok.is(tok::semi)) { 1327 Diag(Tok, diag::ext_extra_struct_semi) 1328 << CodeModificationHint::CreateRemoval(SourceRange(Tok.getLocation())); 1329 ConsumeToken(); 1330 continue; 1331 } 1332 1333 // Parse all the comma separated declarators. 1334 DeclSpec DS; 1335 FieldDeclarators.clear(); 1336 if (!Tok.is(tok::at)) { 1337 ParseStructDeclaration(DS, FieldDeclarators); 1338 1339 // Convert them all to fields. 1340 for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) { 1341 FieldDeclarator &FD = FieldDeclarators[i]; 1342 // Install the declarator into the current TagDecl. 1343 DeclPtrTy Field = Actions.ActOnField(CurScope, TagDecl, 1344 DS.getSourceRange().getBegin(), 1345 FD.D, FD.BitfieldSize); 1346 FieldDecls.push_back(Field); 1347 } 1348 } else { // Handle @defs 1349 ConsumeToken(); 1350 if (!Tok.isObjCAtKeyword(tok::objc_defs)) { 1351 Diag(Tok, diag::err_unexpected_at); 1352 SkipUntil(tok::semi, true, true); 1353 continue; 1354 } 1355 ConsumeToken(); 1356 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen); 1357 if (!Tok.is(tok::identifier)) { 1358 Diag(Tok, diag::err_expected_ident); 1359 SkipUntil(tok::semi, true, true); 1360 continue; 1361 } 1362 llvm::SmallVector<DeclPtrTy, 16> Fields; 1363 Actions.ActOnDefs(CurScope, TagDecl, Tok.getLocation(), 1364 Tok.getIdentifierInfo(), Fields); 1365 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end()); 1366 ConsumeToken(); 1367 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen); 1368 } 1369 1370 if (Tok.is(tok::semi)) { 1371 ConsumeToken(); 1372 } else if (Tok.is(tok::r_brace)) { 1373 Diag(Tok, diag::ext_expected_semi_decl_list); 1374 break; 1375 } else { 1376 Diag(Tok, diag::err_expected_semi_decl_list); 1377 // Skip to end of block or statement 1378 SkipUntil(tok::r_brace, true, true); 1379 } 1380 } 1381 1382 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 1383 1384 AttributeList *AttrList = 0; 1385 // If attributes exist after struct contents, parse them. 1386 if (Tok.is(tok::kw___attribute)) 1387 AttrList = ParseAttributes(); 1388 1389 Actions.ActOnFields(CurScope, 1390 RecordLoc, TagDecl, FieldDecls.data(), FieldDecls.size(), 1391 LBraceLoc, RBraceLoc, 1392 AttrList); 1393 StructScope.Exit(); 1394 Actions.ActOnTagFinishDefinition(CurScope, TagDecl); 1395} 1396 1397 1398/// ParseEnumSpecifier 1399/// enum-specifier: [C99 6.7.2.2] 1400/// 'enum' identifier[opt] '{' enumerator-list '}' 1401///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}' 1402/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt] 1403/// '}' attributes[opt] 1404/// 'enum' identifier 1405/// [GNU] 'enum' attributes[opt] identifier 1406/// 1407/// [C++] elaborated-type-specifier: 1408/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier 1409/// 1410void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, 1411 AccessSpecifier AS) { 1412 // Parse the tag portion of this. 1413 1414 AttributeList *Attr = 0; 1415 // If attributes exist after tag, parse them. 1416 if (Tok.is(tok::kw___attribute)) 1417 Attr = ParseAttributes(); 1418 1419 CXXScopeSpec SS; 1420 if (getLang().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS)) { 1421 if (Tok.isNot(tok::identifier)) { 1422 Diag(Tok, diag::err_expected_ident); 1423 if (Tok.isNot(tok::l_brace)) { 1424 // Has no name and is not a definition. 1425 // Skip the rest of this declarator, up until the comma or semicolon. 1426 SkipUntil(tok::comma, true); 1427 return; 1428 } 1429 } 1430 } 1431 1432 // Must have either 'enum name' or 'enum {...}'. 1433 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace)) { 1434 Diag(Tok, diag::err_expected_ident_lbrace); 1435 1436 // Skip the rest of this declarator, up until the comma or semicolon. 1437 SkipUntil(tok::comma, true); 1438 return; 1439 } 1440 1441 // If an identifier is present, consume and remember it. 1442 IdentifierInfo *Name = 0; 1443 SourceLocation NameLoc; 1444 if (Tok.is(tok::identifier)) { 1445 Name = Tok.getIdentifierInfo(); 1446 NameLoc = ConsumeToken(); 1447 } 1448 1449 // There are three options here. If we have 'enum foo;', then this is a 1450 // forward declaration. If we have 'enum foo {...' then this is a 1451 // definition. Otherwise we have something like 'enum foo xyz', a reference. 1452 // 1453 // This is needed to handle stuff like this right (C99 6.7.2.3p11): 1454 // enum foo {..}; void bar() { enum foo; } <- new foo in bar. 1455 // enum foo {..}; void bar() { enum foo x; } <- use of old foo. 1456 // 1457 Action::TagKind TK; 1458 if (Tok.is(tok::l_brace)) 1459 TK = Action::TK_Definition; 1460 else if (Tok.is(tok::semi)) 1461 TK = Action::TK_Declaration; 1462 else 1463 TK = Action::TK_Reference; 1464 bool Owned = false; 1465 DeclPtrTy TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TK, 1466 StartLoc, SS, Name, NameLoc, Attr, AS, 1467 Owned); 1468 1469 if (Tok.is(tok::l_brace)) 1470 ParseEnumBody(StartLoc, TagDecl); 1471 1472 // TODO: semantic analysis on the declspec for enums. 1473 const char *PrevSpec = 0; 1474 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, PrevSpec, 1475 TagDecl.getAs<void>(), Owned)) 1476 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec; 1477} 1478 1479/// ParseEnumBody - Parse a {} enclosed enumerator-list. 1480/// enumerator-list: 1481/// enumerator 1482/// enumerator-list ',' enumerator 1483/// enumerator: 1484/// enumeration-constant 1485/// enumeration-constant '=' constant-expression 1486/// enumeration-constant: 1487/// identifier 1488/// 1489void Parser::ParseEnumBody(SourceLocation StartLoc, DeclPtrTy EnumDecl) { 1490 // Enter the scope of the enum body and start the definition. 1491 ParseScope EnumScope(this, Scope::DeclScope); 1492 Actions.ActOnTagStartDefinition(CurScope, EnumDecl); 1493 1494 SourceLocation LBraceLoc = ConsumeBrace(); 1495 1496 // C does not allow an empty enumerator-list, C++ does [dcl.enum]. 1497 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 1498 Diag(Tok, diag::ext_empty_struct_union_enum) << "enum"; 1499 1500 llvm::SmallVector<DeclPtrTy, 32> EnumConstantDecls; 1501 1502 DeclPtrTy LastEnumConstDecl; 1503 1504 // Parse the enumerator-list. 1505 while (Tok.is(tok::identifier)) { 1506 IdentifierInfo *Ident = Tok.getIdentifierInfo(); 1507 SourceLocation IdentLoc = ConsumeToken(); 1508 1509 SourceLocation EqualLoc; 1510 OwningExprResult AssignedVal(Actions); 1511 if (Tok.is(tok::equal)) { 1512 EqualLoc = ConsumeToken(); 1513 AssignedVal = ParseConstantExpression(); 1514 if (AssignedVal.isInvalid()) 1515 SkipUntil(tok::comma, tok::r_brace, true, true); 1516 } 1517 1518 // Install the enumerator constant into EnumDecl. 1519 DeclPtrTy EnumConstDecl = Actions.ActOnEnumConstant(CurScope, EnumDecl, 1520 LastEnumConstDecl, 1521 IdentLoc, Ident, 1522 EqualLoc, 1523 AssignedVal.release()); 1524 EnumConstantDecls.push_back(EnumConstDecl); 1525 LastEnumConstDecl = EnumConstDecl; 1526 1527 if (Tok.isNot(tok::comma)) 1528 break; 1529 SourceLocation CommaLoc = ConsumeToken(); 1530 1531 if (Tok.isNot(tok::identifier) && 1532 !(getLang().C99 || getLang().CPlusPlus0x)) 1533 Diag(CommaLoc, diag::ext_enumerator_list_comma) 1534 << getLang().CPlusPlus 1535 << CodeModificationHint::CreateRemoval((SourceRange(CommaLoc))); 1536 } 1537 1538 // Eat the }. 1539 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 1540 1541 Actions.ActOnEnumBody(StartLoc, LBraceLoc, RBraceLoc, EnumDecl, 1542 EnumConstantDecls.data(), EnumConstantDecls.size()); 1543 1544 Action::AttrTy *AttrList = 0; 1545 // If attributes exist after the identifier list, parse them. 1546 if (Tok.is(tok::kw___attribute)) 1547 AttrList = ParseAttributes(); // FIXME: where do they do? 1548 1549 EnumScope.Exit(); 1550 Actions.ActOnTagFinishDefinition(CurScope, EnumDecl); 1551} 1552 1553/// isTypeSpecifierQualifier - Return true if the current token could be the 1554/// start of a type-qualifier-list. 1555bool Parser::isTypeQualifier() const { 1556 switch (Tok.getKind()) { 1557 default: return false; 1558 // type-qualifier 1559 case tok::kw_const: 1560 case tok::kw_volatile: 1561 case tok::kw_restrict: 1562 return true; 1563 } 1564} 1565 1566/// isTypeSpecifierQualifier - Return true if the current token could be the 1567/// start of a specifier-qualifier-list. 1568bool Parser::isTypeSpecifierQualifier() { 1569 switch (Tok.getKind()) { 1570 default: return false; 1571 1572 case tok::identifier: // foo::bar 1573 case tok::kw_typename: // typename T::type 1574 // Annotate typenames and C++ scope specifiers. If we get one, just 1575 // recurse to handle whatever we get. 1576 if (TryAnnotateTypeOrScopeToken()) 1577 return isTypeSpecifierQualifier(); 1578 // Otherwise, not a type specifier. 1579 return false; 1580 1581 case tok::coloncolon: // ::foo::bar 1582 if (NextToken().is(tok::kw_new) || // ::new 1583 NextToken().is(tok::kw_delete)) // ::delete 1584 return false; 1585 1586 // Annotate typenames and C++ scope specifiers. If we get one, just 1587 // recurse to handle whatever we get. 1588 if (TryAnnotateTypeOrScopeToken()) 1589 return isTypeSpecifierQualifier(); 1590 // Otherwise, not a type specifier. 1591 return false; 1592 1593 // GNU attributes support. 1594 case tok::kw___attribute: 1595 // GNU typeof support. 1596 case tok::kw_typeof: 1597 1598 // type-specifiers 1599 case tok::kw_short: 1600 case tok::kw_long: 1601 case tok::kw_signed: 1602 case tok::kw_unsigned: 1603 case tok::kw__Complex: 1604 case tok::kw__Imaginary: 1605 case tok::kw_void: 1606 case tok::kw_char: 1607 case tok::kw_wchar_t: 1608 case tok::kw_int: 1609 case tok::kw_float: 1610 case tok::kw_double: 1611 case tok::kw_bool: 1612 case tok::kw__Bool: 1613 case tok::kw__Decimal32: 1614 case tok::kw__Decimal64: 1615 case tok::kw__Decimal128: 1616 1617 // struct-or-union-specifier (C99) or class-specifier (C++) 1618 case tok::kw_class: 1619 case tok::kw_struct: 1620 case tok::kw_union: 1621 // enum-specifier 1622 case tok::kw_enum: 1623 1624 // type-qualifier 1625 case tok::kw_const: 1626 case tok::kw_volatile: 1627 case tok::kw_restrict: 1628 1629 // typedef-name 1630 case tok::annot_typename: 1631 return true; 1632 1633 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 1634 case tok::less: 1635 return getLang().ObjC1; 1636 1637 case tok::kw___cdecl: 1638 case tok::kw___stdcall: 1639 case tok::kw___fastcall: 1640 return PP.getLangOptions().Microsoft; 1641 } 1642} 1643 1644/// isDeclarationSpecifier() - Return true if the current token is part of a 1645/// declaration specifier. 1646bool Parser::isDeclarationSpecifier() { 1647 switch (Tok.getKind()) { 1648 default: return false; 1649 1650 case tok::identifier: // foo::bar 1651 // Unfortunate hack to support "Class.factoryMethod" notation. 1652 if (getLang().ObjC1 && NextToken().is(tok::period)) 1653 return false; 1654 // Fall through 1655 1656 case tok::kw_typename: // typename T::type 1657 // Annotate typenames and C++ scope specifiers. If we get one, just 1658 // recurse to handle whatever we get. 1659 if (TryAnnotateTypeOrScopeToken()) 1660 return isDeclarationSpecifier(); 1661 // Otherwise, not a declaration specifier. 1662 return false; 1663 case tok::coloncolon: // ::foo::bar 1664 if (NextToken().is(tok::kw_new) || // ::new 1665 NextToken().is(tok::kw_delete)) // ::delete 1666 return false; 1667 1668 // Annotate typenames and C++ scope specifiers. If we get one, just 1669 // recurse to handle whatever we get. 1670 if (TryAnnotateTypeOrScopeToken()) 1671 return isDeclarationSpecifier(); 1672 // Otherwise, not a declaration specifier. 1673 return false; 1674 1675 // storage-class-specifier 1676 case tok::kw_typedef: 1677 case tok::kw_extern: 1678 case tok::kw___private_extern__: 1679 case tok::kw_static: 1680 case tok::kw_auto: 1681 case tok::kw_register: 1682 case tok::kw___thread: 1683 1684 // type-specifiers 1685 case tok::kw_short: 1686 case tok::kw_long: 1687 case tok::kw_signed: 1688 case tok::kw_unsigned: 1689 case tok::kw__Complex: 1690 case tok::kw__Imaginary: 1691 case tok::kw_void: 1692 case tok::kw_char: 1693 case tok::kw_wchar_t: 1694 case tok::kw_int: 1695 case tok::kw_float: 1696 case tok::kw_double: 1697 case tok::kw_bool: 1698 case tok::kw__Bool: 1699 case tok::kw__Decimal32: 1700 case tok::kw__Decimal64: 1701 case tok::kw__Decimal128: 1702 1703 // struct-or-union-specifier (C99) or class-specifier (C++) 1704 case tok::kw_class: 1705 case tok::kw_struct: 1706 case tok::kw_union: 1707 // enum-specifier 1708 case tok::kw_enum: 1709 1710 // type-qualifier 1711 case tok::kw_const: 1712 case tok::kw_volatile: 1713 case tok::kw_restrict: 1714 1715 // function-specifier 1716 case tok::kw_inline: 1717 case tok::kw_virtual: 1718 case tok::kw_explicit: 1719 1720 // typedef-name 1721 case tok::annot_typename: 1722 1723 // GNU typeof support. 1724 case tok::kw_typeof: 1725 1726 // GNU attributes. 1727 case tok::kw___attribute: 1728 return true; 1729 1730 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 1731 case tok::less: 1732 return getLang().ObjC1; 1733 1734 case tok::kw___declspec: 1735 case tok::kw___cdecl: 1736 case tok::kw___stdcall: 1737 case tok::kw___fastcall: 1738 return PP.getLangOptions().Microsoft; 1739 } 1740} 1741 1742 1743/// ParseTypeQualifierListOpt 1744/// type-qualifier-list: [C99 6.7.5] 1745/// type-qualifier 1746/// [GNU] attributes [ only if AttributesAllowed=true ] 1747/// type-qualifier-list type-qualifier 1748/// [GNU] type-qualifier-list attributes [ only if AttributesAllowed=true ] 1749/// 1750void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, bool AttributesAllowed) { 1751 while (1) { 1752 int isInvalid = false; 1753 const char *PrevSpec = 0; 1754 SourceLocation Loc = Tok.getLocation(); 1755 1756 switch (Tok.getKind()) { 1757 case tok::kw_const: 1758 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, 1759 getLang())*2; 1760 break; 1761 case tok::kw_volatile: 1762 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 1763 getLang())*2; 1764 break; 1765 case tok::kw_restrict: 1766 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 1767 getLang())*2; 1768 break; 1769 case tok::kw___ptr64: 1770 case tok::kw___cdecl: 1771 case tok::kw___stdcall: 1772 case tok::kw___fastcall: 1773 if (!PP.getLangOptions().Microsoft) 1774 goto DoneWithTypeQuals; 1775 // Just ignore it. 1776 break; 1777 case tok::kw___attribute: 1778 if (AttributesAllowed) { 1779 DS.AddAttributes(ParseAttributes()); 1780 continue; // do *not* consume the next token! 1781 } 1782 // otherwise, FALL THROUGH! 1783 default: 1784 DoneWithTypeQuals: 1785 // If this is not a type-qualifier token, we're done reading type 1786 // qualifiers. First verify that DeclSpec's are consistent. 1787 DS.Finish(Diags, PP); 1788 return; 1789 } 1790 1791 // If the specifier combination wasn't legal, issue a diagnostic. 1792 if (isInvalid) { 1793 assert(PrevSpec && "Method did not return previous specifier!"); 1794 // Pick between error or extwarn. 1795 unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination 1796 : diag::ext_duplicate_declspec; 1797 Diag(Tok, DiagID) << PrevSpec; 1798 } 1799 ConsumeToken(); 1800 } 1801} 1802 1803 1804/// ParseDeclarator - Parse and verify a newly-initialized declarator. 1805/// 1806void Parser::ParseDeclarator(Declarator &D) { 1807 /// This implements the 'declarator' production in the C grammar, then checks 1808 /// for well-formedness and issues diagnostics. 1809 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator); 1810} 1811 1812/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator 1813/// is parsed by the function passed to it. Pass null, and the direct-declarator 1814/// isn't parsed at all, making this function effectively parse the C++ 1815/// ptr-operator production. 1816/// 1817/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl] 1818/// [C] pointer[opt] direct-declarator 1819/// [C++] direct-declarator 1820/// [C++] ptr-operator declarator 1821/// 1822/// pointer: [C99 6.7.5] 1823/// '*' type-qualifier-list[opt] 1824/// '*' type-qualifier-list[opt] pointer 1825/// 1826/// ptr-operator: 1827/// '*' cv-qualifier-seq[opt] 1828/// '&' 1829/// [C++0x] '&&' 1830/// [GNU] '&' restrict[opt] attributes[opt] 1831/// [GNU?] '&&' restrict[opt] attributes[opt] 1832/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt] 1833void Parser::ParseDeclaratorInternal(Declarator &D, 1834 DirectDeclParseFunction DirectDeclParser) { 1835 1836 // C++ member pointers start with a '::' or a nested-name. 1837 // Member pointers get special handling, since there's no place for the 1838 // scope spec in the generic path below. 1839 if (getLang().CPlusPlus && 1840 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) || 1841 Tok.is(tok::annot_cxxscope))) { 1842 CXXScopeSpec SS; 1843 if (ParseOptionalCXXScopeSpecifier(SS)) { 1844 if(Tok.isNot(tok::star)) { 1845 // The scope spec really belongs to the direct-declarator. 1846 D.getCXXScopeSpec() = SS; 1847 if (DirectDeclParser) 1848 (this->*DirectDeclParser)(D); 1849 return; 1850 } 1851 1852 SourceLocation Loc = ConsumeToken(); 1853 D.SetRangeEnd(Loc); 1854 DeclSpec DS; 1855 ParseTypeQualifierListOpt(DS); 1856 D.ExtendWithDeclSpec(DS); 1857 1858 // Recurse to parse whatever is left. 1859 ParseDeclaratorInternal(D, DirectDeclParser); 1860 1861 // Sema will have to catch (syntactically invalid) pointers into global 1862 // scope. It has to catch pointers into namespace scope anyway. 1863 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(), 1864 Loc, DS.TakeAttributes()), 1865 /* Don't replace range end. */SourceLocation()); 1866 return; 1867 } 1868 } 1869 1870 tok::TokenKind Kind = Tok.getKind(); 1871 // Not a pointer, C++ reference, or block. 1872 if (Kind != tok::star && Kind != tok::caret && 1873 (Kind != tok::amp || !getLang().CPlusPlus) && 1874 // We parse rvalue refs in C++03, because otherwise the errors are scary. 1875 (Kind != tok::ampamp || !getLang().CPlusPlus)) { 1876 if (DirectDeclParser) 1877 (this->*DirectDeclParser)(D); 1878 return; 1879 } 1880 1881 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference, 1882 // '&&' -> rvalue reference 1883 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&. 1884 D.SetRangeEnd(Loc); 1885 1886 if (Kind == tok::star || Kind == tok::caret) { 1887 // Is a pointer. 1888 DeclSpec DS; 1889 1890 ParseTypeQualifierListOpt(DS); 1891 D.ExtendWithDeclSpec(DS); 1892 1893 // Recursively parse the declarator. 1894 ParseDeclaratorInternal(D, DirectDeclParser); 1895 if (Kind == tok::star) 1896 // Remember that we parsed a pointer type, and remember the type-quals. 1897 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc, 1898 DS.TakeAttributes()), 1899 SourceLocation()); 1900 else 1901 // Remember that we parsed a Block type, and remember the type-quals. 1902 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), 1903 Loc, DS.TakeAttributes()), 1904 SourceLocation()); 1905 } else { 1906 // Is a reference 1907 DeclSpec DS; 1908 1909 // Complain about rvalue references in C++03, but then go on and build 1910 // the declarator. 1911 if (Kind == tok::ampamp && !getLang().CPlusPlus0x) 1912 Diag(Loc, diag::err_rvalue_reference); 1913 1914 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the 1915 // cv-qualifiers are introduced through the use of a typedef or of a 1916 // template type argument, in which case the cv-qualifiers are ignored. 1917 // 1918 // [GNU] Retricted references are allowed. 1919 // [GNU] Attributes on references are allowed. 1920 ParseTypeQualifierListOpt(DS); 1921 D.ExtendWithDeclSpec(DS); 1922 1923 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) { 1924 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 1925 Diag(DS.getConstSpecLoc(), 1926 diag::err_invalid_reference_qualifier_application) << "const"; 1927 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 1928 Diag(DS.getVolatileSpecLoc(), 1929 diag::err_invalid_reference_qualifier_application) << "volatile"; 1930 } 1931 1932 // Recursively parse the declarator. 1933 ParseDeclaratorInternal(D, DirectDeclParser); 1934 1935 if (D.getNumTypeObjects() > 0) { 1936 // C++ [dcl.ref]p4: There shall be no references to references. 1937 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1); 1938 if (InnerChunk.Kind == DeclaratorChunk::Reference) { 1939 if (const IdentifierInfo *II = D.getIdentifier()) 1940 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference) 1941 << II; 1942 else 1943 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference) 1944 << "type name"; 1945 1946 // Once we've complained about the reference-to-reference, we 1947 // can go ahead and build the (technically ill-formed) 1948 // declarator: reference collapsing will take care of it. 1949 } 1950 } 1951 1952 // Remember that we parsed a reference type. It doesn't have type-quals. 1953 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc, 1954 DS.TakeAttributes(), 1955 Kind == tok::amp), 1956 SourceLocation()); 1957 } 1958} 1959 1960/// ParseDirectDeclarator 1961/// direct-declarator: [C99 6.7.5] 1962/// [C99] identifier 1963/// '(' declarator ')' 1964/// [GNU] '(' attributes declarator ')' 1965/// [C90] direct-declarator '[' constant-expression[opt] ']' 1966/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 1967/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 1968/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 1969/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 1970/// direct-declarator '(' parameter-type-list ')' 1971/// direct-declarator '(' identifier-list[opt] ')' 1972/// [GNU] direct-declarator '(' parameter-forward-declarations 1973/// parameter-type-list[opt] ')' 1974/// [C++] direct-declarator '(' parameter-declaration-clause ')' 1975/// cv-qualifier-seq[opt] exception-specification[opt] 1976/// [C++] declarator-id 1977/// 1978/// declarator-id: [C++ 8] 1979/// id-expression 1980/// '::'[opt] nested-name-specifier[opt] type-name 1981/// 1982/// id-expression: [C++ 5.1] 1983/// unqualified-id 1984/// qualified-id [TODO] 1985/// 1986/// unqualified-id: [C++ 5.1] 1987/// identifier 1988/// operator-function-id 1989/// conversion-function-id [TODO] 1990/// '~' class-name 1991/// template-id 1992/// 1993void Parser::ParseDirectDeclarator(Declarator &D) { 1994 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec()); 1995 1996 if (getLang().CPlusPlus) { 1997 if (D.mayHaveIdentifier()) { 1998 // ParseDeclaratorInternal might already have parsed the scope. 1999 bool afterCXXScope = D.getCXXScopeSpec().isSet() || 2000 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec()); 2001 if (afterCXXScope) { 2002 // Change the declaration context for name lookup, until this function 2003 // is exited (and the declarator has been parsed). 2004 DeclScopeObj.EnterDeclaratorScope(); 2005 } 2006 2007 if (Tok.is(tok::identifier)) { 2008 assert(Tok.getIdentifierInfo() && "Not an identifier?"); 2009 2010 // If this identifier is the name of the current class, it's a 2011 // constructor name. 2012 if (!D.getDeclSpec().hasTypeSpecifier() && 2013 Actions.isCurrentClassName(*Tok.getIdentifierInfo(),CurScope)) { 2014 D.setConstructor(Actions.getTypeName(*Tok.getIdentifierInfo(), 2015 Tok.getLocation(), CurScope), 2016 Tok.getLocation()); 2017 // This is a normal identifier. 2018 } else 2019 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 2020 ConsumeToken(); 2021 goto PastIdentifier; 2022 } else if (Tok.is(tok::annot_template_id)) { 2023 TemplateIdAnnotation *TemplateId 2024 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 2025 2026 // FIXME: Could this template-id name a constructor? 2027 2028 // FIXME: This is an egregious hack, where we silently ignore 2029 // the specialization (which should be a function template 2030 // specialization name) and use the name instead. This hack 2031 // will go away when we have support for function 2032 // specializations. 2033 D.SetIdentifier(TemplateId->Name, Tok.getLocation()); 2034 TemplateId->Destroy(); 2035 ConsumeToken(); 2036 goto PastIdentifier; 2037 } else if (Tok.is(tok::kw_operator)) { 2038 SourceLocation OperatorLoc = Tok.getLocation(); 2039 SourceLocation EndLoc; 2040 2041 // First try the name of an overloaded operator 2042 if (OverloadedOperatorKind Op = TryParseOperatorFunctionId(&EndLoc)) { 2043 D.setOverloadedOperator(Op, OperatorLoc, EndLoc); 2044 } else { 2045 // This must be a conversion function (C++ [class.conv.fct]). 2046 if (TypeTy *ConvType = ParseConversionFunctionId(&EndLoc)) 2047 D.setConversionFunction(ConvType, OperatorLoc, EndLoc); 2048 else { 2049 D.SetIdentifier(0, Tok.getLocation()); 2050 } 2051 } 2052 goto PastIdentifier; 2053 } else if (Tok.is(tok::tilde)) { 2054 // This should be a C++ destructor. 2055 SourceLocation TildeLoc = ConsumeToken(); 2056 if (Tok.is(tok::identifier)) { 2057 // FIXME: Inaccurate. 2058 SourceLocation NameLoc = Tok.getLocation(); 2059 SourceLocation EndLoc; 2060 TypeResult Type = ParseClassName(EndLoc); 2061 if (Type.isInvalid()) 2062 D.SetIdentifier(0, TildeLoc); 2063 else 2064 D.setDestructor(Type.get(), TildeLoc, NameLoc); 2065 } else { 2066 Diag(Tok, diag::err_expected_class_name); 2067 D.SetIdentifier(0, TildeLoc); 2068 } 2069 goto PastIdentifier; 2070 } 2071 2072 // If we reached this point, token is not identifier and not '~'. 2073 2074 if (afterCXXScope) { 2075 Diag(Tok, diag::err_expected_unqualified_id); 2076 D.SetIdentifier(0, Tok.getLocation()); 2077 D.setInvalidType(true); 2078 goto PastIdentifier; 2079 } 2080 } 2081 } 2082 2083 // If we reached this point, we are either in C/ObjC or the token didn't 2084 // satisfy any of the C++-specific checks. 2085 if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) { 2086 assert(!getLang().CPlusPlus && 2087 "There's a C++-specific check for tok::identifier above"); 2088 assert(Tok.getIdentifierInfo() && "Not an identifier?"); 2089 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 2090 ConsumeToken(); 2091 } else if (Tok.is(tok::l_paren)) { 2092 // direct-declarator: '(' declarator ')' 2093 // direct-declarator: '(' attributes declarator ')' 2094 // Example: 'char (*X)' or 'int (*XX)(void)' 2095 ParseParenDeclarator(D); 2096 } else if (D.mayOmitIdentifier()) { 2097 // This could be something simple like "int" (in which case the declarator 2098 // portion is empty), if an abstract-declarator is allowed. 2099 D.SetIdentifier(0, Tok.getLocation()); 2100 } else { 2101 if (D.getContext() == Declarator::MemberContext) 2102 Diag(Tok, diag::err_expected_member_name_or_semi) 2103 << D.getDeclSpec().getSourceRange(); 2104 else if (getLang().CPlusPlus) 2105 Diag(Tok, diag::err_expected_unqualified_id); 2106 else 2107 Diag(Tok, diag::err_expected_ident_lparen); 2108 D.SetIdentifier(0, Tok.getLocation()); 2109 D.setInvalidType(true); 2110 } 2111 2112 PastIdentifier: 2113 assert(D.isPastIdentifier() && 2114 "Haven't past the location of the identifier yet?"); 2115 2116 while (1) { 2117 if (Tok.is(tok::l_paren)) { 2118 // The paren may be part of a C++ direct initializer, eg. "int x(1);". 2119 // In such a case, check if we actually have a function declarator; if it 2120 // is not, the declarator has been fully parsed. 2121 if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) { 2122 // When not in file scope, warn for ambiguous function declarators, just 2123 // in case the author intended it as a variable definition. 2124 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext; 2125 if (!isCXXFunctionDeclarator(warnIfAmbiguous)) 2126 break; 2127 } 2128 ParseFunctionDeclarator(ConsumeParen(), D); 2129 } else if (Tok.is(tok::l_square)) { 2130 ParseBracketDeclarator(D); 2131 } else { 2132 break; 2133 } 2134 } 2135} 2136 2137/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is 2138/// only called before the identifier, so these are most likely just grouping 2139/// parens for precedence. If we find that these are actually function 2140/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator. 2141/// 2142/// direct-declarator: 2143/// '(' declarator ')' 2144/// [GNU] '(' attributes declarator ')' 2145/// direct-declarator '(' parameter-type-list ')' 2146/// direct-declarator '(' identifier-list[opt] ')' 2147/// [GNU] direct-declarator '(' parameter-forward-declarations 2148/// parameter-type-list[opt] ')' 2149/// 2150void Parser::ParseParenDeclarator(Declarator &D) { 2151 SourceLocation StartLoc = ConsumeParen(); 2152 assert(!D.isPastIdentifier() && "Should be called before passing identifier"); 2153 2154 // Eat any attributes before we look at whether this is a grouping or function 2155 // declarator paren. If this is a grouping paren, the attribute applies to 2156 // the type being built up, for example: 2157 // int (__attribute__(()) *x)(long y) 2158 // If this ends up not being a grouping paren, the attribute applies to the 2159 // first argument, for example: 2160 // int (__attribute__(()) int x) 2161 // In either case, we need to eat any attributes to be able to determine what 2162 // sort of paren this is. 2163 // 2164 AttributeList *AttrList = 0; 2165 bool RequiresArg = false; 2166 if (Tok.is(tok::kw___attribute)) { 2167 AttrList = ParseAttributes(); 2168 2169 // We require that the argument list (if this is a non-grouping paren) be 2170 // present even if the attribute list was empty. 2171 RequiresArg = true; 2172 } 2173 // Eat any Microsoft extensions. 2174 while ((Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) || 2175 (Tok.is(tok::kw___fastcall))) && PP.getLangOptions().Microsoft) 2176 ConsumeToken(); 2177 2178 // If we haven't past the identifier yet (or where the identifier would be 2179 // stored, if this is an abstract declarator), then this is probably just 2180 // grouping parens. However, if this could be an abstract-declarator, then 2181 // this could also be the start of function arguments (consider 'void()'). 2182 bool isGrouping; 2183 2184 if (!D.mayOmitIdentifier()) { 2185 // If this can't be an abstract-declarator, this *must* be a grouping 2186 // paren, because we haven't seen the identifier yet. 2187 isGrouping = true; 2188 } else if (Tok.is(tok::r_paren) || // 'int()' is a function. 2189 (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...) 2190 isDeclarationSpecifier()) { // 'int(int)' is a function. 2191 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is 2192 // considered to be a type, not a K&R identifier-list. 2193 isGrouping = false; 2194 } else { 2195 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'. 2196 isGrouping = true; 2197 } 2198 2199 // If this is a grouping paren, handle: 2200 // direct-declarator: '(' declarator ')' 2201 // direct-declarator: '(' attributes declarator ')' 2202 if (isGrouping) { 2203 bool hadGroupingParens = D.hasGroupingParens(); 2204 D.setGroupingParens(true); 2205 if (AttrList) 2206 D.AddAttributes(AttrList, SourceLocation()); 2207 2208 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator); 2209 // Match the ')'. 2210 SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, StartLoc); 2211 2212 D.setGroupingParens(hadGroupingParens); 2213 D.SetRangeEnd(Loc); 2214 return; 2215 } 2216 2217 // Okay, if this wasn't a grouping paren, it must be the start of a function 2218 // argument list. Recognize that this declarator will never have an 2219 // identifier (and remember where it would have been), then call into 2220 // ParseFunctionDeclarator to handle of argument list. 2221 D.SetIdentifier(0, Tok.getLocation()); 2222 2223 ParseFunctionDeclarator(StartLoc, D, AttrList, RequiresArg); 2224} 2225 2226/// ParseFunctionDeclarator - We are after the identifier and have parsed the 2227/// declarator D up to a paren, which indicates that we are parsing function 2228/// arguments. 2229/// 2230/// If AttrList is non-null, then the caller parsed those arguments immediately 2231/// after the open paren - they should be considered to be the first argument of 2232/// a parameter. If RequiresArg is true, then the first argument of the 2233/// function is required to be present and required to not be an identifier 2234/// list. 2235/// 2236/// This method also handles this portion of the grammar: 2237/// parameter-type-list: [C99 6.7.5] 2238/// parameter-list 2239/// parameter-list ',' '...' 2240/// 2241/// parameter-list: [C99 6.7.5] 2242/// parameter-declaration 2243/// parameter-list ',' parameter-declaration 2244/// 2245/// parameter-declaration: [C99 6.7.5] 2246/// declaration-specifiers declarator 2247/// [C++] declaration-specifiers declarator '=' assignment-expression 2248/// [GNU] declaration-specifiers declarator attributes 2249/// declaration-specifiers abstract-declarator[opt] 2250/// [C++] declaration-specifiers abstract-declarator[opt] 2251/// '=' assignment-expression 2252/// [GNU] declaration-specifiers abstract-declarator[opt] attributes 2253/// 2254/// For C++, after the parameter-list, it also parses "cv-qualifier-seq[opt]" 2255/// and "exception-specification[opt]". 2256/// 2257void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D, 2258 AttributeList *AttrList, 2259 bool RequiresArg) { 2260 // lparen is already consumed! 2261 assert(D.isPastIdentifier() && "Should not call before identifier!"); 2262 2263 // This parameter list may be empty. 2264 if (Tok.is(tok::r_paren)) { 2265 if (RequiresArg) { 2266 Diag(Tok, diag::err_argument_required_after_attribute); 2267 delete AttrList; 2268 } 2269 2270 SourceLocation Loc = ConsumeParen(); // Eat the closing ')'. 2271 2272 // cv-qualifier-seq[opt]. 2273 DeclSpec DS; 2274 bool hasExceptionSpec = false; 2275 bool hasAnyExceptionSpec = false; 2276 // FIXME: Does an empty vector ever allocate? Exception specifications are 2277 // extremely rare, so we want something like a SmallVector<TypeTy*, 0>. :-) 2278 std::vector<TypeTy*> Exceptions; 2279 if (getLang().CPlusPlus) { 2280 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 2281 if (!DS.getSourceRange().getEnd().isInvalid()) 2282 Loc = DS.getSourceRange().getEnd(); 2283 2284 // Parse exception-specification[opt]. 2285 if (Tok.is(tok::kw_throw)) { 2286 hasExceptionSpec = true; 2287 ParseExceptionSpecification(Loc, Exceptions, hasAnyExceptionSpec); 2288 } 2289 } 2290 2291 // Remember that we parsed a function type, and remember the attributes. 2292 // int() -> no prototype, no '...'. 2293 D.AddTypeInfo(DeclaratorChunk::getFunction(/*prototype*/getLang().CPlusPlus, 2294 /*variadic*/ false, 2295 SourceLocation(), 2296 /*arglist*/ 0, 0, 2297 DS.getTypeQualifiers(), 2298 hasExceptionSpec, 2299 hasAnyExceptionSpec, 2300 Exceptions.empty() ? 0 : 2301 &Exceptions[0], 2302 Exceptions.size(), 2303 LParenLoc, D), 2304 Loc); 2305 return; 2306 } 2307 2308 // Alternatively, this parameter list may be an identifier list form for a 2309 // K&R-style function: void foo(a,b,c) 2310 if (!getLang().CPlusPlus && Tok.is(tok::identifier)) { 2311 if (!TryAnnotateTypeOrScopeToken()) { 2312 // K&R identifier lists can't have typedefs as identifiers, per 2313 // C99 6.7.5.3p11. 2314 if (RequiresArg) { 2315 Diag(Tok, diag::err_argument_required_after_attribute); 2316 delete AttrList; 2317 } 2318 // Identifier list. Note that '(' identifier-list ')' is only allowed for 2319 // normal declarators, not for abstract-declarators. 2320 return ParseFunctionDeclaratorIdentifierList(LParenLoc, D); 2321 } 2322 } 2323 2324 // Finally, a normal, non-empty parameter type list. 2325 2326 // Build up an array of information about the parsed arguments. 2327 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 2328 2329 // Enter function-declaration scope, limiting any declarators to the 2330 // function prototype scope, including parameter declarators. 2331 ParseScope PrototypeScope(this, 2332 Scope::FunctionPrototypeScope|Scope::DeclScope); 2333 2334 bool IsVariadic = false; 2335 SourceLocation EllipsisLoc; 2336 while (1) { 2337 if (Tok.is(tok::ellipsis)) { 2338 IsVariadic = true; 2339 EllipsisLoc = ConsumeToken(); // Consume the ellipsis. 2340 break; 2341 } 2342 2343 SourceLocation DSStart = Tok.getLocation(); 2344 2345 // Parse the declaration-specifiers. 2346 DeclSpec DS; 2347 2348 // If the caller parsed attributes for the first argument, add them now. 2349 if (AttrList) { 2350 DS.AddAttributes(AttrList); 2351 AttrList = 0; // Only apply the attributes to the first parameter. 2352 } 2353 ParseDeclarationSpecifiers(DS); 2354 2355 // Parse the declarator. This is "PrototypeContext", because we must 2356 // accept either 'declarator' or 'abstract-declarator' here. 2357 Declarator ParmDecl(DS, Declarator::PrototypeContext); 2358 ParseDeclarator(ParmDecl); 2359 2360 // Parse GNU attributes, if present. 2361 if (Tok.is(tok::kw___attribute)) { 2362 SourceLocation Loc; 2363 AttributeList *AttrList = ParseAttributes(&Loc); 2364 ParmDecl.AddAttributes(AttrList, Loc); 2365 } 2366 2367 // Remember this parsed parameter in ParamInfo. 2368 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 2369 2370 // DefArgToks is used when the parsing of default arguments needs 2371 // to be delayed. 2372 CachedTokens *DefArgToks = 0; 2373 2374 // If no parameter was specified, verify that *something* was specified, 2375 // otherwise we have a missing type and identifier. 2376 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 && 2377 ParmDecl.getNumTypeObjects() == 0) { 2378 // Completely missing, emit error. 2379 Diag(DSStart, diag::err_missing_param); 2380 } else { 2381 // Otherwise, we have something. Add it and let semantic analysis try 2382 // to grok it and add the result to the ParamInfo we are building. 2383 2384 // Inform the actions module about the parameter declarator, so it gets 2385 // added to the current scope. 2386 DeclPtrTy Param = Actions.ActOnParamDeclarator(CurScope, ParmDecl); 2387 2388 // Parse the default argument, if any. We parse the default 2389 // arguments in all dialects; the semantic analysis in 2390 // ActOnParamDefaultArgument will reject the default argument in 2391 // C. 2392 if (Tok.is(tok::equal)) { 2393 SourceLocation EqualLoc = Tok.getLocation(); 2394 2395 // Parse the default argument 2396 if (D.getContext() == Declarator::MemberContext) { 2397 // If we're inside a class definition, cache the tokens 2398 // corresponding to the default argument. We'll actually parse 2399 // them when we see the end of the class definition. 2400 // FIXME: Templates will require something similar. 2401 // FIXME: Can we use a smart pointer for Toks? 2402 DefArgToks = new CachedTokens; 2403 2404 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks, 2405 tok::semi, false)) { 2406 delete DefArgToks; 2407 DefArgToks = 0; 2408 Actions.ActOnParamDefaultArgumentError(Param); 2409 } else 2410 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc); 2411 } else { 2412 // Consume the '='. 2413 ConsumeToken(); 2414 2415 OwningExprResult DefArgResult(ParseAssignmentExpression()); 2416 if (DefArgResult.isInvalid()) { 2417 Actions.ActOnParamDefaultArgumentError(Param); 2418 SkipUntil(tok::comma, tok::r_paren, true, true); 2419 } else { 2420 // Inform the actions module about the default argument 2421 Actions.ActOnParamDefaultArgument(Param, EqualLoc, 2422 move(DefArgResult)); 2423 } 2424 } 2425 } 2426 2427 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 2428 ParmDecl.getIdentifierLoc(), Param, 2429 DefArgToks)); 2430 } 2431 2432 // If the next token is a comma, consume it and keep reading arguments. 2433 if (Tok.isNot(tok::comma)) break; 2434 2435 // Consume the comma. 2436 ConsumeToken(); 2437 } 2438 2439 // Leave prototype scope. 2440 PrototypeScope.Exit(); 2441 2442 // If we have the closing ')', eat it. 2443 SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 2444 2445 DeclSpec DS; 2446 bool hasExceptionSpec = false; 2447 bool hasAnyExceptionSpec = false; 2448 // FIXME: Does an empty vector ever allocate? Exception specifications are 2449 // extremely rare, so we want something like a SmallVector<TypeTy*, 0>. :-) 2450 std::vector<TypeTy*> Exceptions; 2451 if (getLang().CPlusPlus) { 2452 // Parse cv-qualifier-seq[opt]. 2453 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 2454 if (!DS.getSourceRange().getEnd().isInvalid()) 2455 Loc = DS.getSourceRange().getEnd(); 2456 2457 // Parse exception-specification[opt]. 2458 if (Tok.is(tok::kw_throw)) { 2459 hasExceptionSpec = true; 2460 ParseExceptionSpecification(Loc, Exceptions, hasAnyExceptionSpec); 2461 } 2462 } 2463 2464 // Remember that we parsed a function type, and remember the attributes. 2465 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/true, IsVariadic, 2466 EllipsisLoc, 2467 ParamInfo.data(), ParamInfo.size(), 2468 DS.getTypeQualifiers(), 2469 hasExceptionSpec, 2470 hasAnyExceptionSpec, 2471 Exceptions.empty() ? 0 : 2472 &Exceptions[0], 2473 Exceptions.size(), LParenLoc, D), 2474 Loc); 2475} 2476 2477/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator 2478/// we found a K&R-style identifier list instead of a type argument list. The 2479/// current token is known to be the first identifier in the list. 2480/// 2481/// identifier-list: [C99 6.7.5] 2482/// identifier 2483/// identifier-list ',' identifier 2484/// 2485void Parser::ParseFunctionDeclaratorIdentifierList(SourceLocation LParenLoc, 2486 Declarator &D) { 2487 // Build up an array of information about the parsed arguments. 2488 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 2489 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar; 2490 2491 // If there was no identifier specified for the declarator, either we are in 2492 // an abstract-declarator, or we are in a parameter declarator which was found 2493 // to be abstract. In abstract-declarators, identifier lists are not valid: 2494 // diagnose this. 2495 if (!D.getIdentifier()) 2496 Diag(Tok, diag::ext_ident_list_in_param); 2497 2498 // Tok is known to be the first identifier in the list. Remember this 2499 // identifier in ParamInfo. 2500 ParamsSoFar.insert(Tok.getIdentifierInfo()); 2501 ParamInfo.push_back(DeclaratorChunk::ParamInfo(Tok.getIdentifierInfo(), 2502 Tok.getLocation(), 2503 DeclPtrTy())); 2504 2505 ConsumeToken(); // eat the first identifier. 2506 2507 while (Tok.is(tok::comma)) { 2508 // Eat the comma. 2509 ConsumeToken(); 2510 2511 // If this isn't an identifier, report the error and skip until ')'. 2512 if (Tok.isNot(tok::identifier)) { 2513 Diag(Tok, diag::err_expected_ident); 2514 SkipUntil(tok::r_paren); 2515 return; 2516 } 2517 2518 IdentifierInfo *ParmII = Tok.getIdentifierInfo(); 2519 2520 // Reject 'typedef int y; int test(x, y)', but continue parsing. 2521 if (Actions.getTypeName(*ParmII, Tok.getLocation(), CurScope)) 2522 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII; 2523 2524 // Verify that the argument identifier has not already been mentioned. 2525 if (!ParamsSoFar.insert(ParmII)) { 2526 Diag(Tok, diag::err_param_redefinition) << ParmII; 2527 } else { 2528 // Remember this identifier in ParamInfo. 2529 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 2530 Tok.getLocation(), 2531 DeclPtrTy())); 2532 } 2533 2534 // Eat the identifier. 2535 ConsumeToken(); 2536 } 2537 2538 // If we have the closing ')', eat it and we're done. 2539 SourceLocation RLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 2540 2541 // Remember that we parsed a function type, and remember the attributes. This 2542 // function type is always a K&R style function type, which is not varargs and 2543 // has no prototype. 2544 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/false, /*varargs*/false, 2545 SourceLocation(), 2546 &ParamInfo[0], ParamInfo.size(), 2547 /*TypeQuals*/0, 2548 /*exception*/false, false, 0, 0, 2549 LParenLoc, D), 2550 RLoc); 2551} 2552 2553/// [C90] direct-declarator '[' constant-expression[opt] ']' 2554/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 2555/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 2556/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 2557/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 2558void Parser::ParseBracketDeclarator(Declarator &D) { 2559 SourceLocation StartLoc = ConsumeBracket(); 2560 2561 // C array syntax has many features, but by-far the most common is [] and [4]. 2562 // This code does a fast path to handle some of the most obvious cases. 2563 if (Tok.getKind() == tok::r_square) { 2564 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 2565 // Remember that we parsed the empty array type. 2566 OwningExprResult NumElements(Actions); 2567 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0, StartLoc), 2568 EndLoc); 2569 return; 2570 } else if (Tok.getKind() == tok::numeric_constant && 2571 GetLookAheadToken(1).is(tok::r_square)) { 2572 // [4] is very common. Parse the numeric constant expression. 2573 OwningExprResult ExprRes(Actions.ActOnNumericConstant(Tok)); 2574 ConsumeToken(); 2575 2576 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 2577 2578 // If there was an error parsing the assignment-expression, recover. 2579 if (ExprRes.isInvalid()) 2580 ExprRes.release(); // Deallocate expr, just use []. 2581 2582 // Remember that we parsed a array type, and remember its features. 2583 D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0, 2584 ExprRes.release(), StartLoc), 2585 EndLoc); 2586 return; 2587 } 2588 2589 // If valid, this location is the position where we read the 'static' keyword. 2590 SourceLocation StaticLoc; 2591 if (Tok.is(tok::kw_static)) 2592 StaticLoc = ConsumeToken(); 2593 2594 // If there is a type-qualifier-list, read it now. 2595 // Type qualifiers in an array subscript are a C99 feature. 2596 DeclSpec DS; 2597 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 2598 2599 // If we haven't already read 'static', check to see if there is one after the 2600 // type-qualifier-list. 2601 if (!StaticLoc.isValid() && Tok.is(tok::kw_static)) 2602 StaticLoc = ConsumeToken(); 2603 2604 // Handle "direct-declarator [ type-qual-list[opt] * ]". 2605 bool isStar = false; 2606 OwningExprResult NumElements(Actions); 2607 2608 // Handle the case where we have '[*]' as the array size. However, a leading 2609 // star could be the start of an expression, for example 'X[*p + 4]'. Verify 2610 // the the token after the star is a ']'. Since stars in arrays are 2611 // infrequent, use of lookahead is not costly here. 2612 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) { 2613 ConsumeToken(); // Eat the '*'. 2614 2615 if (StaticLoc.isValid()) { 2616 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static); 2617 StaticLoc = SourceLocation(); // Drop the static. 2618 } 2619 isStar = true; 2620 } else if (Tok.isNot(tok::r_square)) { 2621 // Note, in C89, this production uses the constant-expr production instead 2622 // of assignment-expr. The only difference is that assignment-expr allows 2623 // things like '=' and '*='. Sema rejects these in C89 mode because they 2624 // are not i-c-e's, so we don't need to distinguish between the two here. 2625 2626 // Parse the assignment-expression now. 2627 NumElements = ParseAssignmentExpression(); 2628 } 2629 2630 // If there was an error parsing the assignment-expression, recover. 2631 if (NumElements.isInvalid()) { 2632 D.setInvalidType(true); 2633 // If the expression was invalid, skip it. 2634 SkipUntil(tok::r_square); 2635 return; 2636 } 2637 2638 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 2639 2640 // Remember that we parsed a array type, and remember its features. 2641 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(), 2642 StaticLoc.isValid(), isStar, 2643 NumElements.release(), StartLoc), 2644 EndLoc); 2645} 2646 2647/// [GNU] typeof-specifier: 2648/// typeof ( expressions ) 2649/// typeof ( type-name ) 2650/// [GNU/C++] typeof unary-expression 2651/// 2652void Parser::ParseTypeofSpecifier(DeclSpec &DS) { 2653 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier"); 2654 Token OpTok = Tok; 2655 SourceLocation StartLoc = ConsumeToken(); 2656 2657 bool isCastExpr; 2658 TypeTy *CastTy; 2659 SourceRange CastRange; 2660 OwningExprResult Operand = ParseExprAfterTypeofSizeofAlignof(OpTok, 2661 isCastExpr, 2662 CastTy, 2663 CastRange); 2664 2665 if (CastRange.getEnd().isInvalid()) 2666 // FIXME: Not accurate, the range gets one token more than it should. 2667 DS.SetRangeEnd(Tok.getLocation()); 2668 else 2669 DS.SetRangeEnd(CastRange.getEnd()); 2670 2671 if (isCastExpr) { 2672 if (!CastTy) { 2673 DS.SetTypeSpecError(); 2674 return; 2675 } 2676 2677 const char *PrevSpec = 0; 2678 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 2679 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, 2680 CastTy)) 2681 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec; 2682 return; 2683 } 2684 2685 // If we get here, the operand to the typeof was an expresion. 2686 if (Operand.isInvalid()) { 2687 DS.SetTypeSpecError(); 2688 return; 2689 } 2690 2691 const char *PrevSpec = 0; 2692 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 2693 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 2694 Operand.release())) 2695 Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec; 2696} 2697