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