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