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