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