ParseDecl.cpp revision f4e3cfbe8abd124be6341ef5d714819b4fbd9082
1//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Declaration portions of the Parser interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "clang/Parse/ParseDiagnostic.h" 16#include "clang/Sema/Scope.h" 17#include "clang/Sema/ParsedTemplate.h" 18#include "clang/Sema/PrettyDeclStackTrace.h" 19#include "RAIIObjectsForParser.h" 20#include "llvm/ADT/SmallSet.h" 21using namespace clang; 22 23//===----------------------------------------------------------------------===// 24// C99 6.7: Declarations. 25//===----------------------------------------------------------------------===// 26 27/// ParseTypeName 28/// type-name: [C99 6.7.6] 29/// specifier-qualifier-list abstract-declarator[opt] 30/// 31/// Called type-id in C++. 32TypeResult Parser::ParseTypeName(SourceRange *Range, 33 Declarator::TheContext Context) { 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, Context); 40 ParseDeclarator(DeclaratorInfo); 41 if (Range) 42 *Range = DeclaratorInfo.getSourceRange(); 43 44 if (DeclaratorInfo.isInvalidType()) 45 return true; 46 47 return Actions.ActOnTypeName(getCurScope(), DeclaratorInfo); 48} 49 50/// ParseGNUAttributes - Parse a non-empty attributes list. 51/// 52/// [GNU] attributes: 53/// attribute 54/// attributes attribute 55/// 56/// [GNU] attribute: 57/// '__attribute__' '(' '(' attribute-list ')' ')' 58/// 59/// [GNU] attribute-list: 60/// attrib 61/// attribute_list ',' attrib 62/// 63/// [GNU] attrib: 64/// empty 65/// attrib-name 66/// attrib-name '(' identifier ')' 67/// attrib-name '(' identifier ',' nonempty-expr-list ')' 68/// attrib-name '(' argument-expression-list [C99 6.5.2] ')' 69/// 70/// [GNU] attrib-name: 71/// identifier 72/// typespec 73/// typequal 74/// storageclass 75/// 76/// FIXME: The GCC grammar/code for this construct implies we need two 77/// token lookahead. Comment from gcc: "If they start with an identifier 78/// which is followed by a comma or close parenthesis, then the arguments 79/// start with that identifier; otherwise they are an expression list." 80/// 81/// At the moment, I am not doing 2 token lookahead. I am also unaware of 82/// any attributes that don't work (based on my limited testing). Most 83/// attributes are very simple in practice. Until we find a bug, I don't see 84/// a pressing need to implement the 2 token lookahead. 85 86void Parser::ParseGNUAttributes(ParsedAttributes &attrs, 87 SourceLocation *endLoc) { 88 assert(Tok.is(tok::kw___attribute) && "Not a GNU attribute list!"); 89 90 while (Tok.is(tok::kw___attribute)) { 91 ConsumeToken(); 92 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 93 "attribute")) { 94 SkipUntil(tok::r_paren, true); // skip until ) or ; 95 return; 96 } 97 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) { 98 SkipUntil(tok::r_paren, true); // skip until ) or ; 99 return; 100 } 101 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") )) 102 while (Tok.is(tok::identifier) || isDeclarationSpecifier() || 103 Tok.is(tok::comma)) { 104 105 if (Tok.is(tok::comma)) { 106 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,)) 107 ConsumeToken(); 108 continue; 109 } 110 // we have an identifier or declaration specifier (const, int, etc.) 111 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 112 SourceLocation AttrNameLoc = ConsumeToken(); 113 114 // check if we have a "parameterized" attribute 115 if (Tok.is(tok::l_paren)) { 116 ConsumeParen(); // ignore the left paren loc for now 117 118 if (Tok.is(tok::identifier)) { 119 IdentifierInfo *ParmName = Tok.getIdentifierInfo(); 120 SourceLocation ParmLoc = ConsumeToken(); 121 122 if (Tok.is(tok::r_paren)) { 123 // __attribute__(( mode(byte) )) 124 ConsumeParen(); // ignore the right paren loc for now 125 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 126 ParmName, ParmLoc, 0, 0)); 127 } else if (Tok.is(tok::comma)) { 128 ConsumeToken(); 129 // __attribute__(( format(printf, 1, 2) )) 130 ExprVector ArgExprs(Actions); 131 bool ArgExprsOk = true; 132 133 // now parse the non-empty comma separated list of expressions 134 while (1) { 135 ExprResult ArgExpr(ParseAssignmentExpression()); 136 if (ArgExpr.isInvalid()) { 137 ArgExprsOk = false; 138 SkipUntil(tok::r_paren); 139 break; 140 } else { 141 ArgExprs.push_back(ArgExpr.release()); 142 } 143 if (Tok.isNot(tok::comma)) 144 break; 145 ConsumeToken(); // Eat the comma, move to the next argument 146 } 147 if (ArgExprsOk && Tok.is(tok::r_paren)) { 148 ConsumeParen(); // ignore the right paren loc for now 149 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, 150 AttrNameLoc, ParmName, ParmLoc, 151 ArgExprs.take(), ArgExprs.size())); 152 } 153 } 154 } else { // not an identifier 155 switch (Tok.getKind()) { 156 case tok::r_paren: 157 // parse a possibly empty comma separated list of expressions 158 // __attribute__(( nonnull() )) 159 ConsumeParen(); // ignore the right paren loc for now 160 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 161 0, SourceLocation(), 0, 0)); 162 break; 163 case tok::kw_char: 164 case tok::kw_wchar_t: 165 case tok::kw_char16_t: 166 case tok::kw_char32_t: 167 case tok::kw_bool: 168 case tok::kw_short: 169 case tok::kw_int: 170 case tok::kw_long: 171 case tok::kw_signed: 172 case tok::kw_unsigned: 173 case tok::kw_float: 174 case tok::kw_double: 175 case tok::kw_void: 176 case tok::kw_typeof: { 177 AttributeList *attr 178 = AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 179 0, SourceLocation(), 0, 0); 180 attrs.add(attr); 181 if (attr->getKind() == AttributeList::AT_IBOutletCollection) 182 Diag(Tok, diag::err_iboutletcollection_builtintype); 183 // If it's a builtin type name, eat it and expect a rparen 184 // __attribute__(( vec_type_hint(char) )) 185 ConsumeToken(); 186 if (Tok.is(tok::r_paren)) 187 ConsumeParen(); 188 break; 189 } 190 default: 191 // __attribute__(( aligned(16) )) 192 ExprVector ArgExprs(Actions); 193 bool ArgExprsOk = true; 194 195 // now parse the list of expressions 196 while (1) { 197 ExprResult ArgExpr(ParseAssignmentExpression()); 198 if (ArgExpr.isInvalid()) { 199 ArgExprsOk = false; 200 SkipUntil(tok::r_paren); 201 break; 202 } else { 203 ArgExprs.push_back(ArgExpr.release()); 204 } 205 if (Tok.isNot(tok::comma)) 206 break; 207 ConsumeToken(); // Eat the comma, move to the next argument 208 } 209 // Match the ')'. 210 if (ArgExprsOk && Tok.is(tok::r_paren)) { 211 ConsumeParen(); // ignore the right paren loc for now 212 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, 213 AttrNameLoc, 0, SourceLocation(), 214 ArgExprs.take(), ArgExprs.size())); 215 } 216 break; 217 } 218 } 219 } else { 220 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 221 0, SourceLocation(), 0, 0)); 222 } 223 } 224 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 225 SkipUntil(tok::r_paren, false); 226 SourceLocation Loc = Tok.getLocation(); 227 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) { 228 SkipUntil(tok::r_paren, false); 229 } 230 if (endLoc) 231 *endLoc = Loc; 232 } 233} 234 235/// ParseMicrosoftDeclSpec - Parse an __declspec construct 236/// 237/// [MS] decl-specifier: 238/// __declspec ( extended-decl-modifier-seq ) 239/// 240/// [MS] extended-decl-modifier-seq: 241/// extended-decl-modifier[opt] 242/// extended-decl-modifier extended-decl-modifier-seq 243 244void Parser::ParseMicrosoftDeclSpec(ParsedAttributes &attrs) { 245 assert(Tok.is(tok::kw___declspec) && "Not a declspec!"); 246 247 ConsumeToken(); 248 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 249 "declspec")) { 250 SkipUntil(tok::r_paren, true); // skip until ) or ; 251 return; 252 } 253 while (Tok.getIdentifierInfo()) { 254 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 255 SourceLocation AttrNameLoc = ConsumeToken(); 256 if (Tok.is(tok::l_paren)) { 257 ConsumeParen(); 258 // FIXME: This doesn't parse __declspec(property(get=get_func_name)) 259 // correctly. 260 ExprResult ArgExpr(ParseAssignmentExpression()); 261 if (!ArgExpr.isInvalid()) { 262 Expr *ExprList = ArgExpr.take(); 263 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 264 SourceLocation(), &ExprList, 1, true)); 265 } 266 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 267 SkipUntil(tok::r_paren, false); 268 } else { 269 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 270 0, SourceLocation(), 0, 0, true)); 271 } 272 } 273 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 274 SkipUntil(tok::r_paren, false); 275 return; 276} 277 278void Parser::ParseMicrosoftTypeAttributes(ParsedAttributes &attrs) { 279 // Treat these like attributes 280 // FIXME: Allow Sema to distinguish between these and real attributes! 281 while (Tok.is(tok::kw___fastcall) || Tok.is(tok::kw___stdcall) || 282 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___cdecl) || 283 Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64)) { 284 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 285 SourceLocation AttrNameLoc = ConsumeToken(); 286 if (Tok.is(tok::kw___ptr64) || Tok.is(tok::kw___w64)) 287 // FIXME: Support these properly! 288 continue; 289 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 290 SourceLocation(), 0, 0, true)); 291 } 292} 293 294void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) { 295 // Treat these like attributes 296 while (Tok.is(tok::kw___pascal)) { 297 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 298 SourceLocation AttrNameLoc = ConsumeToken(); 299 attrs.add(AttrFactory.Create(AttrName, AttrNameLoc, 0, AttrNameLoc, 0, 300 SourceLocation(), 0, 0, true)); 301 } 302} 303 304void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) { 305 // Treat these like attributes 306 while (Tok.is(tok::kw___kernel)) { 307 SourceLocation AttrNameLoc = ConsumeToken(); 308 attrs.add(AttrFactory.Create(PP.getIdentifierInfo("opencl_kernel_function"), 309 AttrNameLoc, 0, AttrNameLoc, 0, 310 SourceLocation(), 0, 0, false)); 311 } 312} 313 314void Parser::DiagnoseProhibitedAttributes(ParsedAttributesWithRange &attrs) { 315 Diag(attrs.Range.getBegin(), diag::err_attributes_not_allowed) 316 << attrs.Range; 317} 318 319/// ParseDeclaration - Parse a full 'declaration', which consists of 320/// declaration-specifiers, some number of declarators, and a semicolon. 321/// 'Context' should be a Declarator::TheContext value. This returns the 322/// location of the semicolon in DeclEnd. 323/// 324/// declaration: [C99 6.7] 325/// block-declaration -> 326/// simple-declaration 327/// others [FIXME] 328/// [C++] template-declaration 329/// [C++] namespace-definition 330/// [C++] using-directive 331/// [C++] using-declaration 332/// [C++0x] static_assert-declaration 333/// others... [FIXME] 334/// 335Parser::DeclGroupPtrTy Parser::ParseDeclaration(StmtVector &Stmts, 336 unsigned Context, 337 SourceLocation &DeclEnd, 338 ParsedAttributesWithRange &attrs) { 339 ParenBraceBracketBalancer BalancerRAIIObj(*this); 340 341 Decl *SingleDecl = 0; 342 switch (Tok.getKind()) { 343 case tok::kw_template: 344 case tok::kw_export: 345 ProhibitAttributes(attrs); 346 SingleDecl = ParseDeclarationStartingWithTemplate(Context, DeclEnd); 347 break; 348 case tok::kw_inline: 349 // Could be the start of an inline namespace. Allowed as an ext in C++03. 350 if (getLang().CPlusPlus && NextToken().is(tok::kw_namespace)) { 351 ProhibitAttributes(attrs); 352 SourceLocation InlineLoc = ConsumeToken(); 353 SingleDecl = ParseNamespace(Context, DeclEnd, InlineLoc); 354 break; 355 } 356 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, 357 true); 358 case tok::kw_namespace: 359 ProhibitAttributes(attrs); 360 SingleDecl = ParseNamespace(Context, DeclEnd); 361 break; 362 case tok::kw_using: 363 SingleDecl = ParseUsingDirectiveOrDeclaration(Context, ParsedTemplateInfo(), 364 DeclEnd, attrs); 365 break; 366 case tok::kw_static_assert: 367 ProhibitAttributes(attrs); 368 SingleDecl = ParseStaticAssertDeclaration(DeclEnd); 369 break; 370 default: 371 return ParseSimpleDeclaration(Stmts, Context, DeclEnd, attrs, true); 372 } 373 374 // This routine returns a DeclGroup, if the thing we parsed only contains a 375 // single decl, convert it now. 376 return Actions.ConvertDeclToDeclGroup(SingleDecl); 377} 378 379/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl] 380/// declaration-specifiers init-declarator-list[opt] ';' 381///[C90/C++]init-declarator-list ';' [TODO] 382/// [OMP] threadprivate-directive [TODO] 383/// 384/// If RequireSemi is false, this does not check for a ';' at the end of the 385/// declaration. If it is true, it checks for and eats it. 386Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration(StmtVector &Stmts, 387 unsigned Context, 388 SourceLocation &DeclEnd, 389 ParsedAttributes &attrs, 390 bool RequireSemi) { 391 // Parse the common declaration-specifiers piece. 392 ParsingDeclSpec DS(*this); 393 DS.takeAttributesFrom(attrs); 394 ParseDeclarationSpecifiers(DS, ParsedTemplateInfo(), AS_none, 395 getDeclSpecContextFromDeclaratorContext(Context)); 396 StmtResult R = Actions.ActOnVlaStmt(DS); 397 if (R.isUsable()) 398 Stmts.push_back(R.release()); 399 400 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" 401 // declaration-specifiers init-declarator-list[opt] ';' 402 if (Tok.is(tok::semi)) { 403 if (RequireSemi) ConsumeToken(); 404 Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, 405 DS); 406 DS.complete(TheDecl); 407 return Actions.ConvertDeclToDeclGroup(TheDecl); 408 } 409 410 return ParseDeclGroup(DS, Context, /*FunctionDefs=*/ false, &DeclEnd); 411} 412 413/// ParseDeclGroup - Having concluded that this is either a function 414/// definition or a group of object declarations, actually parse the 415/// result. 416Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, 417 unsigned Context, 418 bool AllowFunctionDefinitions, 419 SourceLocation *DeclEnd) { 420 // Parse the first declarator. 421 ParsingDeclarator D(*this, DS, static_cast<Declarator::TheContext>(Context)); 422 ParseDeclarator(D); 423 424 // Bail out if the first declarator didn't seem well-formed. 425 if (!D.hasName() && !D.mayOmitIdentifier()) { 426 // Skip until ; or }. 427 SkipUntil(tok::r_brace, true, true); 428 if (Tok.is(tok::semi)) 429 ConsumeToken(); 430 return DeclGroupPtrTy(); 431 } 432 433 // Check to see if we have a function *definition* which must have a body. 434 if (AllowFunctionDefinitions && D.isFunctionDeclarator() && 435 // Look at the next token to make sure that this isn't a function 436 // declaration. We have to check this because __attribute__ might be the 437 // start of a function definition in GCC-extended K&R C. 438 !isDeclarationAfterDeclarator()) { 439 440 if (isStartOfFunctionDefinition(D)) { 441 if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 442 Diag(Tok, diag::err_function_declared_typedef); 443 444 // Recover by treating the 'typedef' as spurious. 445 DS.ClearStorageClassSpecs(); 446 } 447 448 Decl *TheDecl = ParseFunctionDefinition(D); 449 return Actions.ConvertDeclToDeclGroup(TheDecl); 450 } 451 452 if (isDeclarationSpecifier()) { 453 // If there is an invalid declaration specifier right after the function 454 // prototype, then we must be in a missing semicolon case where this isn't 455 // actually a body. Just fall through into the code that handles it as a 456 // prototype, and let the top-level code handle the erroneous declspec 457 // where it would otherwise expect a comma or semicolon. 458 } else { 459 Diag(Tok, diag::err_expected_fn_body); 460 SkipUntil(tok::semi); 461 return DeclGroupPtrTy(); 462 } 463 } 464 465 llvm::SmallVector<Decl *, 8> DeclsInGroup; 466 Decl *FirstDecl = ParseDeclarationAfterDeclarator(D); 467 D.complete(FirstDecl); 468 if (FirstDecl) 469 DeclsInGroup.push_back(FirstDecl); 470 471 // If we don't have a comma, it is either the end of the list (a ';') or an 472 // error, bail out. 473 while (Tok.is(tok::comma)) { 474 // Consume the comma. 475 ConsumeToken(); 476 477 // Parse the next declarator. 478 D.clear(); 479 480 // Accept attributes in an init-declarator. In the first declarator in a 481 // declaration, these would be part of the declspec. In subsequent 482 // declarators, they become part of the declarator itself, so that they 483 // don't apply to declarators after *this* one. Examples: 484 // short __attribute__((common)) var; -> declspec 485 // short var __attribute__((common)); -> declarator 486 // short x, __attribute__((common)) var; -> declarator 487 MaybeParseGNUAttributes(D); 488 489 ParseDeclarator(D); 490 491 Decl *ThisDecl = ParseDeclarationAfterDeclarator(D); 492 D.complete(ThisDecl); 493 if (ThisDecl) 494 DeclsInGroup.push_back(ThisDecl); 495 } 496 497 if (DeclEnd) 498 *DeclEnd = Tok.getLocation(); 499 500 if (Context != Declarator::ForContext && 501 ExpectAndConsume(tok::semi, 502 Context == Declarator::FileContext 503 ? diag::err_invalid_token_after_toplevel_declarator 504 : diag::err_expected_semi_declaration)) { 505 // Okay, there was no semicolon and one was expected. If we see a 506 // declaration specifier, just assume it was missing and continue parsing. 507 // Otherwise things are very confused and we skip to recover. 508 if (!isDeclarationSpecifier()) { 509 SkipUntil(tok::r_brace, true, true); 510 if (Tok.is(tok::semi)) 511 ConsumeToken(); 512 } 513 } 514 515 return Actions.FinalizeDeclaratorGroup(getCurScope(), DS, 516 DeclsInGroup.data(), 517 DeclsInGroup.size()); 518} 519 520/// \brief Parse 'declaration' after parsing 'declaration-specifiers 521/// declarator'. This method parses the remainder of the declaration 522/// (including any attributes or initializer, among other things) and 523/// finalizes the declaration. 524/// 525/// init-declarator: [C99 6.7] 526/// declarator 527/// declarator '=' initializer 528/// [GNU] declarator simple-asm-expr[opt] attributes[opt] 529/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer 530/// [C++] declarator initializer[opt] 531/// 532/// [C++] initializer: 533/// [C++] '=' initializer-clause 534/// [C++] '(' expression-list ')' 535/// [C++0x] '=' 'default' [TODO] 536/// [C++0x] '=' 'delete' 537/// 538/// According to the standard grammar, =default and =delete are function 539/// definitions, but that definitely doesn't fit with the parser here. 540/// 541Decl *Parser::ParseDeclarationAfterDeclarator(Declarator &D, 542 const ParsedTemplateInfo &TemplateInfo) { 543 // If a simple-asm-expr is present, parse it. 544 if (Tok.is(tok::kw_asm)) { 545 SourceLocation Loc; 546 ExprResult AsmLabel(ParseSimpleAsm(&Loc)); 547 if (AsmLabel.isInvalid()) { 548 SkipUntil(tok::semi, true, true); 549 return 0; 550 } 551 552 D.setAsmLabel(AsmLabel.release()); 553 D.SetRangeEnd(Loc); 554 } 555 556 MaybeParseGNUAttributes(D); 557 558 // Inform the current actions module that we just parsed this declarator. 559 Decl *ThisDecl = 0; 560 switch (TemplateInfo.Kind) { 561 case ParsedTemplateInfo::NonTemplate: 562 ThisDecl = Actions.ActOnDeclarator(getCurScope(), D); 563 break; 564 565 case ParsedTemplateInfo::Template: 566 case ParsedTemplateInfo::ExplicitSpecialization: 567 ThisDecl = Actions.ActOnTemplateDeclarator(getCurScope(), 568 MultiTemplateParamsArg(Actions, 569 TemplateInfo.TemplateParams->data(), 570 TemplateInfo.TemplateParams->size()), 571 D); 572 break; 573 574 case ParsedTemplateInfo::ExplicitInstantiation: { 575 DeclResult ThisRes 576 = Actions.ActOnExplicitInstantiation(getCurScope(), 577 TemplateInfo.ExternLoc, 578 TemplateInfo.TemplateLoc, 579 D); 580 if (ThisRes.isInvalid()) { 581 SkipUntil(tok::semi, true, true); 582 return 0; 583 } 584 585 ThisDecl = ThisRes.get(); 586 break; 587 } 588 } 589 590 bool TypeContainsAuto = 591 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto; 592 593 // Parse declarator '=' initializer. 594 if (isTokenEqualOrMistypedEqualEqual( 595 diag::err_invalid_equalequal_after_declarator)) { 596 ConsumeToken(); 597 if (Tok.is(tok::kw_delete)) { 598 SourceLocation DelLoc = ConsumeToken(); 599 600 if (!getLang().CPlusPlus0x) 601 Diag(DelLoc, diag::warn_deleted_function_accepted_as_extension); 602 603 Actions.SetDeclDeleted(ThisDecl, DelLoc); 604 } else { 605 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 606 EnterScope(0); 607 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 608 } 609 610 if (Tok.is(tok::code_completion)) { 611 Actions.CodeCompleteInitializer(getCurScope(), ThisDecl); 612 ConsumeCodeCompletionToken(); 613 SkipUntil(tok::comma, true, true); 614 return ThisDecl; 615 } 616 617 ExprResult Init(ParseInitializer()); 618 619 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 620 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 621 ExitScope(); 622 } 623 624 if (Init.isInvalid()) { 625 SkipUntil(tok::comma, true, true); 626 Actions.ActOnInitializerError(ThisDecl); 627 } else 628 Actions.AddInitializerToDecl(ThisDecl, Init.take(), 629 /*DirectInit=*/false, TypeContainsAuto); 630 } 631 } else if (Tok.is(tok::l_paren)) { 632 // Parse C++ direct initializer: '(' expression-list ')' 633 SourceLocation LParenLoc = ConsumeParen(); 634 ExprVector Exprs(Actions); 635 CommaLocsTy CommaLocs; 636 637 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 638 EnterScope(0); 639 Actions.ActOnCXXEnterDeclInitializer(getCurScope(), ThisDecl); 640 } 641 642 if (ParseExpressionList(Exprs, CommaLocs)) { 643 SkipUntil(tok::r_paren); 644 645 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 646 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 647 ExitScope(); 648 } 649 } else { 650 // Match the ')'. 651 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 652 653 assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() && 654 "Unexpected number of commas!"); 655 656 if (getLang().CPlusPlus && D.getCXXScopeSpec().isSet()) { 657 Actions.ActOnCXXExitDeclInitializer(getCurScope(), ThisDecl); 658 ExitScope(); 659 } 660 661 Actions.AddCXXDirectInitializerToDecl(ThisDecl, LParenLoc, 662 move_arg(Exprs), 663 RParenLoc, 664 TypeContainsAuto); 665 } 666 } else { 667 Actions.ActOnUninitializedDecl(ThisDecl, TypeContainsAuto); 668 } 669 670 Actions.FinalizeDeclaration(ThisDecl); 671 672 return ThisDecl; 673} 674 675/// ParseSpecifierQualifierList 676/// specifier-qualifier-list: 677/// type-specifier specifier-qualifier-list[opt] 678/// type-qualifier specifier-qualifier-list[opt] 679/// [GNU] attributes specifier-qualifier-list[opt] 680/// 681void Parser::ParseSpecifierQualifierList(DeclSpec &DS) { 682 /// specifier-qualifier-list is a subset of declaration-specifiers. Just 683 /// parse declaration-specifiers and complain about extra stuff. 684 ParseDeclarationSpecifiers(DS); 685 686 // Validate declspec for type-name. 687 unsigned Specs = DS.getParsedSpecifiers(); 688 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers() && 689 !DS.hasAttributes()) 690 Diag(Tok, diag::err_typename_requires_specqual); 691 692 // Issue diagnostic and remove storage class if present. 693 if (Specs & DeclSpec::PQ_StorageClassSpecifier) { 694 if (DS.getStorageClassSpecLoc().isValid()) 695 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass); 696 else 697 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass); 698 DS.ClearStorageClassSpecs(); 699 } 700 701 // Issue diagnostic and remove function specfier if present. 702 if (Specs & DeclSpec::PQ_FunctionSpecifier) { 703 if (DS.isInlineSpecified()) 704 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec); 705 if (DS.isVirtualSpecified()) 706 Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec); 707 if (DS.isExplicitSpecified()) 708 Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec); 709 DS.ClearFunctionSpecs(); 710 } 711} 712 713/// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the 714/// specified token is valid after the identifier in a declarator which 715/// immediately follows the declspec. For example, these things are valid: 716/// 717/// int x [ 4]; // direct-declarator 718/// int x ( int y); // direct-declarator 719/// int(int x ) // direct-declarator 720/// int x ; // simple-declaration 721/// int x = 17; // init-declarator-list 722/// int x , y; // init-declarator-list 723/// int x __asm__ ("foo"); // init-declarator-list 724/// int x : 4; // struct-declarator 725/// int x { 5}; // C++'0x unified initializers 726/// 727/// This is not, because 'x' does not immediately follow the declspec (though 728/// ')' happens to be valid anyway). 729/// int (x) 730/// 731static bool isValidAfterIdentifierInDeclarator(const Token &T) { 732 return T.is(tok::l_square) || T.is(tok::l_paren) || T.is(tok::r_paren) || 733 T.is(tok::semi) || T.is(tok::comma) || T.is(tok::equal) || 734 T.is(tok::kw_asm) || T.is(tok::l_brace) || T.is(tok::colon); 735} 736 737 738/// ParseImplicitInt - This method is called when we have an non-typename 739/// identifier in a declspec (which normally terminates the decl spec) when 740/// the declspec has no type specifier. In this case, the declspec is either 741/// malformed or is "implicit int" (in K&R and C89). 742/// 743/// This method handles diagnosing this prettily and returns false if the 744/// declspec is done being processed. If it recovers and thinks there may be 745/// other pieces of declspec after it, it returns true. 746/// 747bool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS, 748 const ParsedTemplateInfo &TemplateInfo, 749 AccessSpecifier AS) { 750 assert(Tok.is(tok::identifier) && "should have identifier"); 751 752 SourceLocation Loc = Tok.getLocation(); 753 // If we see an identifier that is not a type name, we normally would 754 // parse it as the identifer being declared. However, when a typename 755 // is typo'd or the definition is not included, this will incorrectly 756 // parse the typename as the identifier name and fall over misparsing 757 // later parts of the diagnostic. 758 // 759 // As such, we try to do some look-ahead in cases where this would 760 // otherwise be an "implicit-int" case to see if this is invalid. For 761 // example: "static foo_t x = 4;" In this case, if we parsed foo_t as 762 // an identifier with implicit int, we'd get a parse error because the 763 // next token is obviously invalid for a type. Parse these as a case 764 // with an invalid type specifier. 765 assert(!DS.hasTypeSpecifier() && "Type specifier checked above"); 766 767 // Since we know that this either implicit int (which is rare) or an 768 // error, we'd do lookahead to try to do better recovery. 769 if (isValidAfterIdentifierInDeclarator(NextToken())) { 770 // If this token is valid for implicit int, e.g. "static x = 4", then 771 // we just avoid eating the identifier, so it will be parsed as the 772 // identifier in the declarator. 773 return false; 774 } 775 776 // Otherwise, if we don't consume this token, we are going to emit an 777 // error anyway. Try to recover from various common problems. Check 778 // to see if this was a reference to a tag name without a tag specified. 779 // This is a common problem in C (saying 'foo' instead of 'struct foo'). 780 // 781 // C++ doesn't need this, and isTagName doesn't take SS. 782 if (SS == 0) { 783 const char *TagName = 0; 784 tok::TokenKind TagKind = tok::unknown; 785 786 switch (Actions.isTagName(*Tok.getIdentifierInfo(), getCurScope())) { 787 default: break; 788 case DeclSpec::TST_enum: TagName="enum" ;TagKind=tok::kw_enum ;break; 789 case DeclSpec::TST_union: TagName="union" ;TagKind=tok::kw_union ;break; 790 case DeclSpec::TST_struct:TagName="struct";TagKind=tok::kw_struct;break; 791 case DeclSpec::TST_class: TagName="class" ;TagKind=tok::kw_class ;break; 792 } 793 794 if (TagName) { 795 Diag(Loc, diag::err_use_of_tag_name_without_tag) 796 << Tok.getIdentifierInfo() << TagName << getLang().CPlusPlus 797 << FixItHint::CreateInsertion(Tok.getLocation(),TagName); 798 799 // Parse this as a tag as if the missing tag were present. 800 if (TagKind == tok::kw_enum) 801 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS); 802 else 803 ParseClassSpecifier(TagKind, Loc, DS, TemplateInfo, AS); 804 return true; 805 } 806 } 807 808 // This is almost certainly an invalid type name. Let the action emit a 809 // diagnostic and attempt to recover. 810 ParsedType T; 811 if (Actions.DiagnoseUnknownTypeName(*Tok.getIdentifierInfo(), Loc, 812 getCurScope(), SS, T)) { 813 // The action emitted a diagnostic, so we don't have to. 814 if (T) { 815 // The action has suggested that the type T could be used. Set that as 816 // the type in the declaration specifiers, consume the would-be type 817 // name token, and we're done. 818 const char *PrevSpec; 819 unsigned DiagID; 820 DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, DiagID, T); 821 DS.SetRangeEnd(Tok.getLocation()); 822 ConsumeToken(); 823 824 // There may be other declaration specifiers after this. 825 return true; 826 } 827 828 // Fall through; the action had no suggestion for us. 829 } else { 830 // The action did not emit a diagnostic, so emit one now. 831 SourceRange R; 832 if (SS) R = SS->getRange(); 833 Diag(Loc, diag::err_unknown_typename) << Tok.getIdentifierInfo() << R; 834 } 835 836 // Mark this as an error. 837 const char *PrevSpec; 838 unsigned DiagID; 839 DS.SetTypeSpecType(DeclSpec::TST_error, Loc, PrevSpec, DiagID); 840 DS.SetRangeEnd(Tok.getLocation()); 841 ConsumeToken(); 842 843 // TODO: Could inject an invalid typedef decl in an enclosing scope to 844 // avoid rippling error messages on subsequent uses of the same type, 845 // could be useful if #include was forgotten. 846 return false; 847} 848 849/// \brief Determine the declaration specifier context from the declarator 850/// context. 851/// 852/// \param Context the declarator context, which is one of the 853/// Declarator::TheContext enumerator values. 854Parser::DeclSpecContext 855Parser::getDeclSpecContextFromDeclaratorContext(unsigned Context) { 856 if (Context == Declarator::MemberContext) 857 return DSC_class; 858 if (Context == Declarator::FileContext) 859 return DSC_top_level; 860 return DSC_normal; 861} 862 863/// ParseDeclarationSpecifiers 864/// declaration-specifiers: [C99 6.7] 865/// storage-class-specifier declaration-specifiers[opt] 866/// type-specifier declaration-specifiers[opt] 867/// [C99] function-specifier declaration-specifiers[opt] 868/// [GNU] attributes declaration-specifiers[opt] 869/// 870/// storage-class-specifier: [C99 6.7.1] 871/// 'typedef' 872/// 'extern' 873/// 'static' 874/// 'auto' 875/// 'register' 876/// [C++] 'mutable' 877/// [GNU] '__thread' 878/// function-specifier: [C99 6.7.4] 879/// [C99] 'inline' 880/// [C++] 'virtual' 881/// [C++] 'explicit' 882/// [OpenCL] '__kernel' 883/// 'friend': [C++ dcl.friend] 884/// 'constexpr': [C++0x dcl.constexpr] 885 886/// 887void Parser::ParseDeclarationSpecifiers(DeclSpec &DS, 888 const ParsedTemplateInfo &TemplateInfo, 889 AccessSpecifier AS, 890 DeclSpecContext DSContext) { 891 DS.SetRangeStart(Tok.getLocation()); 892 DS.SetRangeEnd(Tok.getLocation()); 893 while (1) { 894 bool isInvalid = false; 895 const char *PrevSpec = 0; 896 unsigned DiagID = 0; 897 898 SourceLocation Loc = Tok.getLocation(); 899 900 switch (Tok.getKind()) { 901 default: 902 DoneWithDeclSpec: 903 // If this is not a declaration specifier token, we're done reading decl 904 // specifiers. First verify that DeclSpec's are consistent. 905 DS.Finish(Diags, PP); 906 return; 907 908 case tok::code_completion: { 909 Sema::ParserCompletionContext CCC = Sema::PCC_Namespace; 910 if (DS.hasTypeSpecifier()) { 911 bool AllowNonIdentifiers 912 = (getCurScope()->getFlags() & (Scope::ControlScope | 913 Scope::BlockScope | 914 Scope::TemplateParamScope | 915 Scope::FunctionPrototypeScope | 916 Scope::AtCatchScope)) == 0; 917 bool AllowNestedNameSpecifiers 918 = DSContext == DSC_top_level || 919 (DSContext == DSC_class && DS.isFriendSpecified()); 920 921 Actions.CodeCompleteDeclSpec(getCurScope(), DS, 922 AllowNonIdentifiers, 923 AllowNestedNameSpecifiers); 924 ConsumeCodeCompletionToken(); 925 return; 926 } 927 928 if (getCurScope()->getFnParent() || getCurScope()->getBlockParent()) 929 CCC = Sema::PCC_LocalDeclarationSpecifiers; 930 else if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) 931 CCC = DSContext == DSC_class? Sema::PCC_MemberTemplate 932 : Sema::PCC_Template; 933 else if (DSContext == DSC_class) 934 CCC = Sema::PCC_Class; 935 else if (ObjCImpDecl) 936 CCC = Sema::PCC_ObjCImplementation; 937 938 Actions.CodeCompleteOrdinaryName(getCurScope(), CCC); 939 ConsumeCodeCompletionToken(); 940 return; 941 } 942 943 case tok::coloncolon: // ::foo::bar 944 // C++ scope specifier. Annotate and loop, or bail out on error. 945 if (TryAnnotateCXXScopeToken(true)) { 946 if (!DS.hasTypeSpecifier()) 947 DS.SetTypeSpecError(); 948 goto DoneWithDeclSpec; 949 } 950 if (Tok.is(tok::coloncolon)) // ::new or ::delete 951 goto DoneWithDeclSpec; 952 continue; 953 954 case tok::annot_cxxscope: { 955 if (DS.hasTypeSpecifier()) 956 goto DoneWithDeclSpec; 957 958 CXXScopeSpec SS; 959 Actions.RestoreNestedNameSpecifierAnnotation(Tok.getAnnotationValue(), 960 Tok.getAnnotationRange(), 961 SS); 962 963 // We are looking for a qualified typename. 964 Token Next = NextToken(); 965 if (Next.is(tok::annot_template_id) && 966 static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()) 967 ->Kind == TNK_Type_template) { 968 // We have a qualified template-id, e.g., N::A<int> 969 970 // C++ [class.qual]p2: 971 // In a lookup in which the constructor is an acceptable lookup 972 // result and the nested-name-specifier nominates a class C: 973 // 974 // - if the name specified after the 975 // nested-name-specifier, when looked up in C, is the 976 // injected-class-name of C (Clause 9), or 977 // 978 // - if the name specified after the nested-name-specifier 979 // is the same as the identifier or the 980 // simple-template-id's template-name in the last 981 // component of the nested-name-specifier, 982 // 983 // the name is instead considered to name the constructor of 984 // class C. 985 // 986 // Thus, if the template-name is actually the constructor 987 // name, then the code is ill-formed; this interpretation is 988 // reinforced by the NAD status of core issue 635. 989 TemplateIdAnnotation *TemplateId 990 = static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()); 991 if ((DSContext == DSC_top_level || 992 (DSContext == DSC_class && DS.isFriendSpecified())) && 993 TemplateId->Name && 994 Actions.isCurrentClassName(*TemplateId->Name, getCurScope(), &SS)) { 995 if (isConstructorDeclarator()) { 996 // The user meant this to be an out-of-line constructor 997 // definition, but template arguments are not allowed 998 // there. Just allow this as a constructor; we'll 999 // complain about it later. 1000 goto DoneWithDeclSpec; 1001 } 1002 1003 // The user meant this to name a type, but it actually names 1004 // a constructor with some extraneous template 1005 // arguments. Complain, then parse it as a type as the user 1006 // intended. 1007 Diag(TemplateId->TemplateNameLoc, 1008 diag::err_out_of_line_template_id_names_constructor) 1009 << TemplateId->Name; 1010 } 1011 1012 DS.getTypeSpecScope() = SS; 1013 ConsumeToken(); // The C++ scope. 1014 assert(Tok.is(tok::annot_template_id) && 1015 "ParseOptionalCXXScopeSpecifier not working"); 1016 AnnotateTemplateIdTokenAsType(); 1017 continue; 1018 } 1019 1020 if (Next.is(tok::annot_typename)) { 1021 DS.getTypeSpecScope() = SS; 1022 ConsumeToken(); // The C++ scope. 1023 if (Tok.getAnnotationValue()) { 1024 ParsedType T = getTypeAnnotation(Tok); 1025 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, 1026 Tok.getAnnotationEndLoc(), 1027 PrevSpec, DiagID, T); 1028 } 1029 else 1030 DS.SetTypeSpecError(); 1031 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1032 ConsumeToken(); // The typename 1033 } 1034 1035 if (Next.isNot(tok::identifier)) 1036 goto DoneWithDeclSpec; 1037 1038 // If we're in a context where the identifier could be a class name, 1039 // check whether this is a constructor declaration. 1040 if ((DSContext == DSC_top_level || 1041 (DSContext == DSC_class && DS.isFriendSpecified())) && 1042 Actions.isCurrentClassName(*Next.getIdentifierInfo(), getCurScope(), 1043 &SS)) { 1044 if (isConstructorDeclarator()) 1045 goto DoneWithDeclSpec; 1046 1047 // As noted in C++ [class.qual]p2 (cited above), when the name 1048 // of the class is qualified in a context where it could name 1049 // a constructor, its a constructor name. However, we've 1050 // looked at the declarator, and the user probably meant this 1051 // to be a type. Complain that it isn't supposed to be treated 1052 // as a type, then proceed to parse it as a type. 1053 Diag(Next.getLocation(), diag::err_out_of_line_type_names_constructor) 1054 << Next.getIdentifierInfo(); 1055 } 1056 1057 ParsedType TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(), 1058 Next.getLocation(), 1059 getCurScope(), &SS, 1060 false, false, ParsedType(), 1061 /*NonTrivialSourceInfo=*/true); 1062 1063 // If the referenced identifier is not a type, then this declspec is 1064 // erroneous: We already checked about that it has no type specifier, and 1065 // C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the 1066 // typename. 1067 if (TypeRep == 0) { 1068 ConsumeToken(); // Eat the scope spec so the identifier is current. 1069 if (ParseImplicitInt(DS, &SS, TemplateInfo, AS)) continue; 1070 goto DoneWithDeclSpec; 1071 } 1072 1073 DS.getTypeSpecScope() = SS; 1074 ConsumeToken(); // The C++ scope. 1075 1076 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1077 DiagID, TypeRep); 1078 if (isInvalid) 1079 break; 1080 1081 DS.SetRangeEnd(Tok.getLocation()); 1082 ConsumeToken(); // The typename. 1083 1084 continue; 1085 } 1086 1087 case tok::annot_typename: { 1088 if (Tok.getAnnotationValue()) { 1089 ParsedType T = getTypeAnnotation(Tok); 1090 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1091 DiagID, T); 1092 } else 1093 DS.SetTypeSpecError(); 1094 1095 if (isInvalid) 1096 break; 1097 1098 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1099 ConsumeToken(); // The typename 1100 1101 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1102 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1103 // Objective-C interface. 1104 if (Tok.is(tok::less) && getLang().ObjC1) 1105 ParseObjCProtocolQualifiers(DS); 1106 1107 continue; 1108 } 1109 1110 // typedef-name 1111 case tok::identifier: { 1112 // In C++, check to see if this is a scope specifier like foo::bar::, if 1113 // so handle it as such. This is important for ctor parsing. 1114 if (getLang().CPlusPlus) { 1115 if (TryAnnotateCXXScopeToken(true)) { 1116 if (!DS.hasTypeSpecifier()) 1117 DS.SetTypeSpecError(); 1118 goto DoneWithDeclSpec; 1119 } 1120 if (!Tok.is(tok::identifier)) 1121 continue; 1122 } 1123 1124 // This identifier can only be a typedef name if we haven't already seen 1125 // a type-specifier. Without this check we misparse: 1126 // typedef int X; struct Y { short X; }; as 'short int'. 1127 if (DS.hasTypeSpecifier()) 1128 goto DoneWithDeclSpec; 1129 1130 // Check for need to substitute AltiVec keyword tokens. 1131 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid)) 1132 break; 1133 1134 // It has to be available as a typedef too! 1135 ParsedType TypeRep = 1136 Actions.getTypeName(*Tok.getIdentifierInfo(), 1137 Tok.getLocation(), getCurScope()); 1138 1139 // If this is not a typedef name, don't parse it as part of the declspec, 1140 // it must be an implicit int or an error. 1141 if (!TypeRep) { 1142 if (ParseImplicitInt(DS, 0, TemplateInfo, AS)) continue; 1143 goto DoneWithDeclSpec; 1144 } 1145 1146 // If we're in a context where the identifier could be a class name, 1147 // check whether this is a constructor declaration. 1148 if (getLang().CPlusPlus && DSContext == DSC_class && 1149 Actions.isCurrentClassName(*Tok.getIdentifierInfo(), getCurScope()) && 1150 isConstructorDeclarator()) 1151 goto DoneWithDeclSpec; 1152 1153 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec, 1154 DiagID, TypeRep); 1155 if (isInvalid) 1156 break; 1157 1158 DS.SetRangeEnd(Tok.getLocation()); 1159 ConsumeToken(); // The identifier 1160 1161 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1162 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1163 // Objective-C interface. 1164 if (Tok.is(tok::less) && getLang().ObjC1) 1165 ParseObjCProtocolQualifiers(DS); 1166 1167 // Need to support trailing type qualifiers (e.g. "id<p> const"). 1168 // If a type specifier follows, it will be diagnosed elsewhere. 1169 continue; 1170 } 1171 1172 // type-name 1173 case tok::annot_template_id: { 1174 TemplateIdAnnotation *TemplateId 1175 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 1176 if (TemplateId->Kind != TNK_Type_template) { 1177 // This template-id does not refer to a type name, so we're 1178 // done with the type-specifiers. 1179 goto DoneWithDeclSpec; 1180 } 1181 1182 // If we're in a context where the template-id could be a 1183 // constructor name or specialization, check whether this is a 1184 // constructor declaration. 1185 if (getLang().CPlusPlus && DSContext == DSC_class && 1186 Actions.isCurrentClassName(*TemplateId->Name, getCurScope()) && 1187 isConstructorDeclarator()) 1188 goto DoneWithDeclSpec; 1189 1190 // Turn the template-id annotation token into a type annotation 1191 // token, then try again to parse it as a type-specifier. 1192 AnnotateTemplateIdTokenAsType(); 1193 continue; 1194 } 1195 1196 // GNU attributes support. 1197 case tok::kw___attribute: 1198 ParseGNUAttributes(DS.getAttributes()); 1199 continue; 1200 1201 // Microsoft declspec support. 1202 case tok::kw___declspec: 1203 ParseMicrosoftDeclSpec(DS.getAttributes()); 1204 continue; 1205 1206 // Microsoft single token adornments. 1207 case tok::kw___forceinline: 1208 // FIXME: Add handling here! 1209 break; 1210 1211 case tok::kw___ptr64: 1212 case tok::kw___w64: 1213 case tok::kw___cdecl: 1214 case tok::kw___stdcall: 1215 case tok::kw___fastcall: 1216 case tok::kw___thiscall: 1217 ParseMicrosoftTypeAttributes(DS.getAttributes()); 1218 continue; 1219 1220 // Borland single token adornments. 1221 case tok::kw___pascal: 1222 ParseBorlandTypeAttributes(DS.getAttributes()); 1223 continue; 1224 1225 // OpenCL single token adornments. 1226 case tok::kw___kernel: 1227 ParseOpenCLAttributes(DS.getAttributes()); 1228 continue; 1229 1230 // storage-class-specifier 1231 case tok::kw_typedef: 1232 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec, 1233 DiagID, getLang()); 1234 break; 1235 case tok::kw_extern: 1236 if (DS.isThreadSpecified()) 1237 Diag(Tok, diag::ext_thread_before) << "extern"; 1238 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_extern, Loc, PrevSpec, 1239 DiagID, getLang()); 1240 break; 1241 case tok::kw___private_extern__: 1242 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_private_extern, Loc, 1243 PrevSpec, DiagID, getLang()); 1244 break; 1245 case tok::kw_static: 1246 if (DS.isThreadSpecified()) 1247 Diag(Tok, diag::ext_thread_before) << "static"; 1248 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_static, Loc, PrevSpec, 1249 DiagID, getLang()); 1250 break; 1251 case tok::kw_auto: 1252 if (getLang().CPlusPlus0x || getLang().ObjC2) { 1253 if (isKnownToBeTypeSpecifier(GetLookAheadToken(1))) { 1254 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec, 1255 DiagID, getLang()); 1256 if (!isInvalid) 1257 Diag(Tok, diag::auto_storage_class) 1258 << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc()); 1259 } 1260 else 1261 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, 1262 DiagID); 1263 } 1264 else 1265 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec, 1266 DiagID, getLang()); 1267 break; 1268 case tok::kw_register: 1269 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_register, Loc, PrevSpec, 1270 DiagID, getLang()); 1271 break; 1272 case tok::kw_mutable: 1273 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_mutable, Loc, PrevSpec, 1274 DiagID, getLang()); 1275 break; 1276 case tok::kw___thread: 1277 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec, DiagID); 1278 break; 1279 1280 // function-specifier 1281 case tok::kw_inline: 1282 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec, DiagID); 1283 break; 1284 case tok::kw_virtual: 1285 isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec, DiagID); 1286 break; 1287 case tok::kw_explicit: 1288 isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec, DiagID); 1289 break; 1290 1291 // friend 1292 case tok::kw_friend: 1293 if (DSContext == DSC_class) 1294 isInvalid = DS.SetFriendSpec(Loc, PrevSpec, DiagID); 1295 else { 1296 PrevSpec = ""; // not actually used by the diagnostic 1297 DiagID = diag::err_friend_invalid_in_context; 1298 isInvalid = true; 1299 } 1300 break; 1301 1302 // constexpr 1303 case tok::kw_constexpr: 1304 isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID); 1305 break; 1306 1307 // type-specifier 1308 case tok::kw_short: 1309 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, 1310 DiagID); 1311 break; 1312 case tok::kw_long: 1313 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 1314 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, 1315 DiagID); 1316 else 1317 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 1318 DiagID); 1319 break; 1320 case tok::kw_signed: 1321 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, 1322 DiagID); 1323 break; 1324 case tok::kw_unsigned: 1325 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, 1326 DiagID); 1327 break; 1328 case tok::kw__Complex: 1329 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec, 1330 DiagID); 1331 break; 1332 case tok::kw__Imaginary: 1333 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec, 1334 DiagID); 1335 break; 1336 case tok::kw_void: 1337 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, 1338 DiagID); 1339 break; 1340 case tok::kw_char: 1341 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, 1342 DiagID); 1343 break; 1344 case tok::kw_int: 1345 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, 1346 DiagID); 1347 break; 1348 case tok::kw_float: 1349 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, 1350 DiagID); 1351 break; 1352 case tok::kw_double: 1353 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, 1354 DiagID); 1355 break; 1356 case tok::kw_wchar_t: 1357 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, 1358 DiagID); 1359 break; 1360 case tok::kw_char16_t: 1361 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, 1362 DiagID); 1363 break; 1364 case tok::kw_char32_t: 1365 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, 1366 DiagID); 1367 break; 1368 case tok::kw_bool: 1369 case tok::kw__Bool: 1370 if (Tok.is(tok::kw_bool) && 1371 DS.getTypeSpecType() != DeclSpec::TST_unspecified && 1372 DS.getStorageClassSpec() == DeclSpec::SCS_typedef) { 1373 PrevSpec = ""; // Not used by the diagnostic. 1374 DiagID = diag::err_bool_redeclaration; 1375 isInvalid = true; 1376 } else { 1377 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, 1378 DiagID); 1379 } 1380 break; 1381 case tok::kw__Decimal32: 1382 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec, 1383 DiagID); 1384 break; 1385 case tok::kw__Decimal64: 1386 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec, 1387 DiagID); 1388 break; 1389 case tok::kw__Decimal128: 1390 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec, 1391 DiagID); 1392 break; 1393 case tok::kw___vector: 1394 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 1395 break; 1396 case tok::kw___pixel: 1397 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 1398 break; 1399 1400 // class-specifier: 1401 case tok::kw_class: 1402 case tok::kw_struct: 1403 case tok::kw_union: { 1404 tok::TokenKind Kind = Tok.getKind(); 1405 ConsumeToken(); 1406 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS); 1407 continue; 1408 } 1409 1410 // enum-specifier: 1411 case tok::kw_enum: 1412 ConsumeToken(); 1413 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS); 1414 continue; 1415 1416 // cv-qualifier: 1417 case tok::kw_const: 1418 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec, DiagID, 1419 getLang()); 1420 break; 1421 case tok::kw_volatile: 1422 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID, 1423 getLang()); 1424 break; 1425 case tok::kw_restrict: 1426 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID, 1427 getLang()); 1428 break; 1429 1430 // C++ typename-specifier: 1431 case tok::kw_typename: 1432 if (TryAnnotateTypeOrScopeToken()) { 1433 DS.SetTypeSpecError(); 1434 goto DoneWithDeclSpec; 1435 } 1436 if (!Tok.is(tok::kw_typename)) 1437 continue; 1438 break; 1439 1440 // GNU typeof support. 1441 case tok::kw_typeof: 1442 ParseTypeofSpecifier(DS); 1443 continue; 1444 1445 case tok::kw_decltype: 1446 ParseDecltypeSpecifier(DS); 1447 continue; 1448 1449 case tok::less: 1450 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for 1451 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous, 1452 // but we support it. 1453 if (DS.hasTypeSpecifier() || !getLang().ObjC1) 1454 goto DoneWithDeclSpec; 1455 1456 if (!ParseObjCProtocolQualifiers(DS)) 1457 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id) 1458 << FixItHint::CreateInsertion(Loc, "id") 1459 << SourceRange(Loc, DS.getSourceRange().getEnd()); 1460 1461 // Need to support trailing type qualifiers (e.g. "id<p> const"). 1462 // If a type specifier follows, it will be diagnosed elsewhere. 1463 continue; 1464 } 1465 // If the specifier wasn't legal, issue a diagnostic. 1466 if (isInvalid) { 1467 assert(PrevSpec && "Method did not return previous specifier!"); 1468 assert(DiagID); 1469 1470 if (DiagID == diag::ext_duplicate_declspec) 1471 Diag(Tok, DiagID) 1472 << PrevSpec << FixItHint::CreateRemoval(Tok.getLocation()); 1473 else 1474 Diag(Tok, DiagID) << PrevSpec; 1475 } 1476 1477 DS.SetRangeEnd(Tok.getLocation()); 1478 ConsumeToken(); 1479 } 1480} 1481 1482/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We 1483/// primarily follow the C++ grammar with additions for C99 and GNU, 1484/// which together subsume the C grammar. Note that the C++ 1485/// type-specifier also includes the C type-qualifier (for const, 1486/// volatile, and C99 restrict). Returns true if a type-specifier was 1487/// found (and parsed), false otherwise. 1488/// 1489/// type-specifier: [C++ 7.1.5] 1490/// simple-type-specifier 1491/// class-specifier 1492/// enum-specifier 1493/// elaborated-type-specifier [TODO] 1494/// cv-qualifier 1495/// 1496/// cv-qualifier: [C++ 7.1.5.1] 1497/// 'const' 1498/// 'volatile' 1499/// [C99] 'restrict' 1500/// 1501/// simple-type-specifier: [ C++ 7.1.5.2] 1502/// '::'[opt] nested-name-specifier[opt] type-name [TODO] 1503/// '::'[opt] nested-name-specifier 'template' template-id [TODO] 1504/// 'char' 1505/// 'wchar_t' 1506/// 'bool' 1507/// 'short' 1508/// 'int' 1509/// 'long' 1510/// 'signed' 1511/// 'unsigned' 1512/// 'float' 1513/// 'double' 1514/// 'void' 1515/// [C99] '_Bool' 1516/// [C99] '_Complex' 1517/// [C99] '_Imaginary' // Removed in TC2? 1518/// [GNU] '_Decimal32' 1519/// [GNU] '_Decimal64' 1520/// [GNU] '_Decimal128' 1521/// [GNU] typeof-specifier 1522/// [OBJC] class-name objc-protocol-refs[opt] [TODO] 1523/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO] 1524/// [C++0x] 'decltype' ( expression ) 1525/// [AltiVec] '__vector' 1526bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, bool& isInvalid, 1527 const char *&PrevSpec, 1528 unsigned &DiagID, 1529 const ParsedTemplateInfo &TemplateInfo, 1530 bool SuppressDeclarations) { 1531 SourceLocation Loc = Tok.getLocation(); 1532 1533 switch (Tok.getKind()) { 1534 case tok::identifier: // foo::bar 1535 // If we already have a type specifier, this identifier is not a type. 1536 if (DS.getTypeSpecType() != DeclSpec::TST_unspecified || 1537 DS.getTypeSpecWidth() != DeclSpec::TSW_unspecified || 1538 DS.getTypeSpecSign() != DeclSpec::TSS_unspecified) 1539 return false; 1540 // Check for need to substitute AltiVec keyword tokens. 1541 if (TryAltiVecToken(DS, Loc, PrevSpec, DiagID, isInvalid)) 1542 break; 1543 // Fall through. 1544 case tok::kw_typename: // typename foo::bar 1545 // Annotate typenames and C++ scope specifiers. If we get one, just 1546 // recurse to handle whatever we get. 1547 if (TryAnnotateTypeOrScopeToken()) 1548 return true; 1549 if (Tok.is(tok::identifier)) 1550 return false; 1551 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID, 1552 TemplateInfo, SuppressDeclarations); 1553 case tok::coloncolon: // ::foo::bar 1554 if (NextToken().is(tok::kw_new) || // ::new 1555 NextToken().is(tok::kw_delete)) // ::delete 1556 return false; 1557 1558 // Annotate typenames and C++ scope specifiers. If we get one, just 1559 // recurse to handle whatever we get. 1560 if (TryAnnotateTypeOrScopeToken()) 1561 return true; 1562 return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec, DiagID, 1563 TemplateInfo, SuppressDeclarations); 1564 1565 // simple-type-specifier: 1566 case tok::annot_typename: { 1567 if (ParsedType T = getTypeAnnotation(Tok)) { 1568 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, 1569 Tok.getAnnotationEndLoc(), PrevSpec, 1570 DiagID, T); 1571 } else 1572 DS.SetTypeSpecError(); 1573 DS.SetRangeEnd(Tok.getAnnotationEndLoc()); 1574 ConsumeToken(); // The typename 1575 1576 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 1577 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 1578 // Objective-C interface. If we don't have Objective-C or a '<', this is 1579 // just a normal reference to a typedef name. 1580 if (Tok.is(tok::less) && getLang().ObjC1) 1581 ParseObjCProtocolQualifiers(DS); 1582 1583 return true; 1584 } 1585 1586 case tok::kw_short: 1587 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec, DiagID); 1588 break; 1589 case tok::kw_long: 1590 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 1591 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec, 1592 DiagID); 1593 else 1594 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec, 1595 DiagID); 1596 break; 1597 case tok::kw_signed: 1598 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec, DiagID); 1599 break; 1600 case tok::kw_unsigned: 1601 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec, 1602 DiagID); 1603 break; 1604 case tok::kw__Complex: 1605 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec, 1606 DiagID); 1607 break; 1608 case tok::kw__Imaginary: 1609 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec, 1610 DiagID); 1611 break; 1612 case tok::kw_void: 1613 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec, DiagID); 1614 break; 1615 case tok::kw_char: 1616 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec, DiagID); 1617 break; 1618 case tok::kw_int: 1619 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID); 1620 break; 1621 case tok::kw_float: 1622 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID); 1623 break; 1624 case tok::kw_double: 1625 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID); 1626 break; 1627 case tok::kw_wchar_t: 1628 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID); 1629 break; 1630 case tok::kw_char16_t: 1631 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID); 1632 break; 1633 case tok::kw_char32_t: 1634 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID); 1635 break; 1636 case tok::kw_bool: 1637 case tok::kw__Bool: 1638 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec, DiagID); 1639 break; 1640 case tok::kw__Decimal32: 1641 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec, 1642 DiagID); 1643 break; 1644 case tok::kw__Decimal64: 1645 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec, 1646 DiagID); 1647 break; 1648 case tok::kw__Decimal128: 1649 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec, 1650 DiagID); 1651 break; 1652 case tok::kw___vector: 1653 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 1654 break; 1655 case tok::kw___pixel: 1656 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 1657 break; 1658 1659 // class-specifier: 1660 case tok::kw_class: 1661 case tok::kw_struct: 1662 case tok::kw_union: { 1663 tok::TokenKind Kind = Tok.getKind(); 1664 ConsumeToken(); 1665 ParseClassSpecifier(Kind, Loc, DS, TemplateInfo, AS_none, 1666 SuppressDeclarations); 1667 return true; 1668 } 1669 1670 // enum-specifier: 1671 case tok::kw_enum: 1672 ConsumeToken(); 1673 ParseEnumSpecifier(Loc, DS, TemplateInfo, AS_none); 1674 return true; 1675 1676 // cv-qualifier: 1677 case tok::kw_const: 1678 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, 1679 DiagID, getLang()); 1680 break; 1681 case tok::kw_volatile: 1682 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 1683 DiagID, getLang()); 1684 break; 1685 case tok::kw_restrict: 1686 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 1687 DiagID, getLang()); 1688 break; 1689 1690 // GNU typeof support. 1691 case tok::kw_typeof: 1692 ParseTypeofSpecifier(DS); 1693 return true; 1694 1695 // C++0x decltype support. 1696 case tok::kw_decltype: 1697 ParseDecltypeSpecifier(DS); 1698 return true; 1699 1700 // C++0x auto support. 1701 case tok::kw_auto: 1702 if (!getLang().CPlusPlus0x) 1703 return false; 1704 1705 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_auto, Loc, PrevSpec, DiagID); 1706 break; 1707 1708 case tok::kw___ptr64: 1709 case tok::kw___w64: 1710 case tok::kw___cdecl: 1711 case tok::kw___stdcall: 1712 case tok::kw___fastcall: 1713 case tok::kw___thiscall: 1714 ParseMicrosoftTypeAttributes(DS.getAttributes()); 1715 return true; 1716 1717 case tok::kw___pascal: 1718 ParseBorlandTypeAttributes(DS.getAttributes()); 1719 return true; 1720 1721 default: 1722 // Not a type-specifier; do nothing. 1723 return false; 1724 } 1725 1726 // If the specifier combination wasn't legal, issue a diagnostic. 1727 if (isInvalid) { 1728 assert(PrevSpec && "Method did not return previous specifier!"); 1729 // Pick between error or extwarn. 1730 Diag(Tok, DiagID) << PrevSpec; 1731 } 1732 DS.SetRangeEnd(Tok.getLocation()); 1733 ConsumeToken(); // whatever we parsed above. 1734 return true; 1735} 1736 1737/// ParseStructDeclaration - Parse a struct declaration without the terminating 1738/// semicolon. 1739/// 1740/// struct-declaration: 1741/// specifier-qualifier-list struct-declarator-list 1742/// [GNU] __extension__ struct-declaration 1743/// [GNU] specifier-qualifier-list 1744/// struct-declarator-list: 1745/// struct-declarator 1746/// struct-declarator-list ',' struct-declarator 1747/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator 1748/// struct-declarator: 1749/// declarator 1750/// [GNU] declarator attributes[opt] 1751/// declarator[opt] ':' constant-expression 1752/// [GNU] declarator[opt] ':' constant-expression attributes[opt] 1753/// 1754void Parser:: 1755ParseStructDeclaration(DeclSpec &DS, FieldCallback &Fields) { 1756 if (Tok.is(tok::kw___extension__)) { 1757 // __extension__ silences extension warnings in the subexpression. 1758 ExtensionRAIIObject O(Diags); // Use RAII to do this. 1759 ConsumeToken(); 1760 return ParseStructDeclaration(DS, Fields); 1761 } 1762 1763 // Parse the common specifier-qualifiers-list piece. 1764 ParseSpecifierQualifierList(DS); 1765 1766 // If there are no declarators, this is a free-standing declaration 1767 // specifier. Let the actions module cope with it. 1768 if (Tok.is(tok::semi)) { 1769 Actions.ParsedFreeStandingDeclSpec(getCurScope(), AS_none, DS); 1770 return; 1771 } 1772 1773 // Read struct-declarators until we find the semicolon. 1774 bool FirstDeclarator = true; 1775 while (1) { 1776 ParsingDeclRAIIObject PD(*this); 1777 FieldDeclarator DeclaratorInfo(DS); 1778 1779 // Attributes are only allowed here on successive declarators. 1780 if (!FirstDeclarator) 1781 MaybeParseGNUAttributes(DeclaratorInfo.D); 1782 1783 /// struct-declarator: declarator 1784 /// struct-declarator: declarator[opt] ':' constant-expression 1785 if (Tok.isNot(tok::colon)) { 1786 // Don't parse FOO:BAR as if it were a typo for FOO::BAR. 1787 ColonProtectionRAIIObject X(*this); 1788 ParseDeclarator(DeclaratorInfo.D); 1789 } 1790 1791 if (Tok.is(tok::colon)) { 1792 ConsumeToken(); 1793 ExprResult Res(ParseConstantExpression()); 1794 if (Res.isInvalid()) 1795 SkipUntil(tok::semi, true, true); 1796 else 1797 DeclaratorInfo.BitfieldSize = Res.release(); 1798 } 1799 1800 // If attributes exist after the declarator, parse them. 1801 MaybeParseGNUAttributes(DeclaratorInfo.D); 1802 1803 // We're done with this declarator; invoke the callback. 1804 Decl *D = Fields.invoke(DeclaratorInfo); 1805 PD.complete(D); 1806 1807 // If we don't have a comma, it is either the end of the list (a ';') 1808 // or an error, bail out. 1809 if (Tok.isNot(tok::comma)) 1810 return; 1811 1812 // Consume the comma. 1813 ConsumeToken(); 1814 1815 FirstDeclarator = false; 1816 } 1817} 1818 1819/// ParseStructUnionBody 1820/// struct-contents: 1821/// struct-declaration-list 1822/// [EXT] empty 1823/// [GNU] "struct-declaration-list" without terminatoring ';' 1824/// struct-declaration-list: 1825/// struct-declaration 1826/// struct-declaration-list struct-declaration 1827/// [OBC] '@' 'defs' '(' class-name ')' 1828/// 1829void Parser::ParseStructUnionBody(SourceLocation RecordLoc, 1830 unsigned TagType, Decl *TagDecl) { 1831 PrettyDeclStackTraceEntry CrashInfo(Actions, TagDecl, RecordLoc, 1832 "parsing struct/union body"); 1833 1834 SourceLocation LBraceLoc = ConsumeBrace(); 1835 1836 ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope); 1837 Actions.ActOnTagStartDefinition(getCurScope(), TagDecl); 1838 1839 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 1840 // C++. 1841 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 1842 Diag(Tok, diag::ext_empty_struct_union) 1843 << (TagType == TST_union); 1844 1845 llvm::SmallVector<Decl *, 32> FieldDecls; 1846 1847 // While we still have something to read, read the declarations in the struct. 1848 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 1849 // Each iteration of this loop reads one struct-declaration. 1850 1851 // Check for extraneous top-level semicolon. 1852 if (Tok.is(tok::semi)) { 1853 Diag(Tok, diag::ext_extra_struct_semi) 1854 << DeclSpec::getSpecifierName((DeclSpec::TST)TagType) 1855 << FixItHint::CreateRemoval(Tok.getLocation()); 1856 ConsumeToken(); 1857 continue; 1858 } 1859 1860 // Parse all the comma separated declarators. 1861 DeclSpec DS; 1862 1863 if (!Tok.is(tok::at)) { 1864 struct CFieldCallback : FieldCallback { 1865 Parser &P; 1866 Decl *TagDecl; 1867 llvm::SmallVectorImpl<Decl *> &FieldDecls; 1868 1869 CFieldCallback(Parser &P, Decl *TagDecl, 1870 llvm::SmallVectorImpl<Decl *> &FieldDecls) : 1871 P(P), TagDecl(TagDecl), FieldDecls(FieldDecls) {} 1872 1873 virtual Decl *invoke(FieldDeclarator &FD) { 1874 // Install the declarator into the current TagDecl. 1875 Decl *Field = P.Actions.ActOnField(P.getCurScope(), TagDecl, 1876 FD.D.getDeclSpec().getSourceRange().getBegin(), 1877 FD.D, FD.BitfieldSize); 1878 FieldDecls.push_back(Field); 1879 return Field; 1880 } 1881 } Callback(*this, TagDecl, FieldDecls); 1882 1883 ParseStructDeclaration(DS, Callback); 1884 } else { // Handle @defs 1885 ConsumeToken(); 1886 if (!Tok.isObjCAtKeyword(tok::objc_defs)) { 1887 Diag(Tok, diag::err_unexpected_at); 1888 SkipUntil(tok::semi, true); 1889 continue; 1890 } 1891 ConsumeToken(); 1892 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen); 1893 if (!Tok.is(tok::identifier)) { 1894 Diag(Tok, diag::err_expected_ident); 1895 SkipUntil(tok::semi, true); 1896 continue; 1897 } 1898 llvm::SmallVector<Decl *, 16> Fields; 1899 Actions.ActOnDefs(getCurScope(), TagDecl, Tok.getLocation(), 1900 Tok.getIdentifierInfo(), Fields); 1901 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end()); 1902 ConsumeToken(); 1903 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen); 1904 } 1905 1906 if (Tok.is(tok::semi)) { 1907 ConsumeToken(); 1908 } else if (Tok.is(tok::r_brace)) { 1909 ExpectAndConsume(tok::semi, diag::ext_expected_semi_decl_list); 1910 break; 1911 } else { 1912 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list); 1913 // Skip to end of block or statement to avoid ext-warning on extra ';'. 1914 SkipUntil(tok::r_brace, true, true); 1915 // If we stopped at a ';', eat it. 1916 if (Tok.is(tok::semi)) ConsumeToken(); 1917 } 1918 } 1919 1920 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 1921 1922 ParsedAttributes attrs; 1923 // If attributes exist after struct contents, parse them. 1924 MaybeParseGNUAttributes(attrs); 1925 1926 Actions.ActOnFields(getCurScope(), 1927 RecordLoc, TagDecl, FieldDecls.data(), FieldDecls.size(), 1928 LBraceLoc, RBraceLoc, 1929 attrs.getList()); 1930 StructScope.Exit(); 1931 Actions.ActOnTagFinishDefinition(getCurScope(), TagDecl, RBraceLoc); 1932} 1933 1934/// ParseEnumSpecifier 1935/// enum-specifier: [C99 6.7.2.2] 1936/// 'enum' identifier[opt] '{' enumerator-list '}' 1937///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}' 1938/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt] 1939/// '}' attributes[opt] 1940/// 'enum' identifier 1941/// [GNU] 'enum' attributes[opt] identifier 1942/// 1943/// [C++0x] enum-head '{' enumerator-list[opt] '}' 1944/// [C++0x] enum-head '{' enumerator-list ',' '}' 1945/// 1946/// enum-head: [C++0x] 1947/// enum-key attributes[opt] identifier[opt] enum-base[opt] 1948/// enum-key attributes[opt] nested-name-specifier identifier enum-base[opt] 1949/// 1950/// enum-key: [C++0x] 1951/// 'enum' 1952/// 'enum' 'class' 1953/// 'enum' 'struct' 1954/// 1955/// enum-base: [C++0x] 1956/// ':' type-specifier-seq 1957/// 1958/// [C++] elaborated-type-specifier: 1959/// [C++] 'enum' '::'[opt] nested-name-specifier[opt] identifier 1960/// 1961void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, 1962 const ParsedTemplateInfo &TemplateInfo, 1963 AccessSpecifier AS) { 1964 // Parse the tag portion of this. 1965 if (Tok.is(tok::code_completion)) { 1966 // Code completion for an enum name. 1967 Actions.CodeCompleteTag(getCurScope(), DeclSpec::TST_enum); 1968 ConsumeCodeCompletionToken(); 1969 } 1970 1971 // If attributes exist after tag, parse them. 1972 ParsedAttributes attrs; 1973 MaybeParseGNUAttributes(attrs); 1974 1975 CXXScopeSpec &SS = DS.getTypeSpecScope(); 1976 if (getLang().CPlusPlus) { 1977 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false)) 1978 return; 1979 1980 if (SS.isSet() && Tok.isNot(tok::identifier)) { 1981 Diag(Tok, diag::err_expected_ident); 1982 if (Tok.isNot(tok::l_brace)) { 1983 // Has no name and is not a definition. 1984 // Skip the rest of this declarator, up until the comma or semicolon. 1985 SkipUntil(tok::comma, true); 1986 return; 1987 } 1988 } 1989 } 1990 1991 bool AllowFixedUnderlyingType = getLang().CPlusPlus0x || getLang().Microsoft; 1992 bool IsScopedEnum = false; 1993 bool IsScopedUsingClassTag = false; 1994 1995 if (getLang().CPlusPlus0x && 1996 (Tok.is(tok::kw_class) || Tok.is(tok::kw_struct))) { 1997 IsScopedEnum = true; 1998 IsScopedUsingClassTag = Tok.is(tok::kw_class); 1999 ConsumeToken(); 2000 } 2001 2002 // Must have either 'enum name' or 'enum {...}'. 2003 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace) && 2004 (AllowFixedUnderlyingType && Tok.isNot(tok::colon))) { 2005 Diag(Tok, diag::err_expected_ident_lbrace); 2006 2007 // Skip the rest of this declarator, up until the comma or semicolon. 2008 SkipUntil(tok::comma, true); 2009 return; 2010 } 2011 2012 // If an identifier is present, consume and remember it. 2013 IdentifierInfo *Name = 0; 2014 SourceLocation NameLoc; 2015 if (Tok.is(tok::identifier)) { 2016 Name = Tok.getIdentifierInfo(); 2017 NameLoc = ConsumeToken(); 2018 } 2019 2020 if (!Name && IsScopedEnum) { 2021 // C++0x 7.2p2: The optional identifier shall not be omitted in the 2022 // declaration of a scoped enumeration. 2023 Diag(Tok, diag::err_scoped_enum_missing_identifier); 2024 IsScopedEnum = false; 2025 IsScopedUsingClassTag = false; 2026 } 2027 2028 TypeResult BaseType; 2029 2030 // Parse the fixed underlying type. 2031 if (AllowFixedUnderlyingType && Tok.is(tok::colon)) { 2032 bool PossibleBitfield = false; 2033 if (getCurScope()->getFlags() & Scope::ClassScope) { 2034 // If we're in class scope, this can either be an enum declaration with 2035 // an underlying type, or a declaration of a bitfield member. We try to 2036 // use a simple disambiguation scheme first to catch the common cases 2037 // (integer literal, sizeof); if it's still ambiguous, we then consider 2038 // anything that's a simple-type-specifier followed by '(' as an 2039 // expression. This suffices because function types are not valid 2040 // underlying types anyway. 2041 TPResult TPR = isExpressionOrTypeSpecifierSimple(NextToken().getKind()); 2042 // If the next token starts an expression, we know we're parsing a 2043 // bit-field. This is the common case. 2044 if (TPR == TPResult::True()) 2045 PossibleBitfield = true; 2046 // If the next token starts a type-specifier-seq, it may be either a 2047 // a fixed underlying type or the start of a function-style cast in C++; 2048 // lookahead one more token to see if it's obvious that we have a 2049 // fixed underlying type. 2050 else if (TPR == TPResult::False() && 2051 GetLookAheadToken(2).getKind() == tok::semi) { 2052 // Consume the ':'. 2053 ConsumeToken(); 2054 } else { 2055 // We have the start of a type-specifier-seq, so we have to perform 2056 // tentative parsing to determine whether we have an expression or a 2057 // type. 2058 TentativeParsingAction TPA(*this); 2059 2060 // Consume the ':'. 2061 ConsumeToken(); 2062 2063 if ((getLang().CPlusPlus && 2064 isCXXDeclarationSpecifier() != TPResult::True()) || 2065 (!getLang().CPlusPlus && !isDeclarationSpecifier(true))) { 2066 // We'll parse this as a bitfield later. 2067 PossibleBitfield = true; 2068 TPA.Revert(); 2069 } else { 2070 // We have a type-specifier-seq. 2071 TPA.Commit(); 2072 } 2073 } 2074 } else { 2075 // Consume the ':'. 2076 ConsumeToken(); 2077 } 2078 2079 if (!PossibleBitfield) { 2080 SourceRange Range; 2081 BaseType = ParseTypeName(&Range); 2082 2083 if (!getLang().CPlusPlus0x) 2084 Diag(StartLoc, diag::ext_ms_enum_fixed_underlying_type) 2085 << Range; 2086 } 2087 } 2088 2089 // There are three options here. If we have 'enum foo;', then this is a 2090 // forward declaration. If we have 'enum foo {...' then this is a 2091 // definition. Otherwise we have something like 'enum foo xyz', a reference. 2092 // 2093 // This is needed to handle stuff like this right (C99 6.7.2.3p11): 2094 // enum foo {..}; void bar() { enum foo; } <- new foo in bar. 2095 // enum foo {..}; void bar() { enum foo x; } <- use of old foo. 2096 // 2097 Sema::TagUseKind TUK; 2098 if (Tok.is(tok::l_brace)) 2099 TUK = Sema::TUK_Definition; 2100 else if (Tok.is(tok::semi)) 2101 TUK = Sema::TUK_Declaration; 2102 else 2103 TUK = Sema::TUK_Reference; 2104 2105 // enums cannot be templates, although they can be referenced from a 2106 // template. 2107 if (TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate && 2108 TUK != Sema::TUK_Reference) { 2109 Diag(Tok, diag::err_enum_template); 2110 2111 // Skip the rest of this declarator, up until the comma or semicolon. 2112 SkipUntil(tok::comma, true); 2113 return; 2114 } 2115 2116 if (!Name && TUK != Sema::TUK_Definition) { 2117 Diag(Tok, diag::err_enumerator_unnamed_no_def); 2118 2119 // Skip the rest of this declarator, up until the comma or semicolon. 2120 SkipUntil(tok::comma, true); 2121 return; 2122 } 2123 2124 bool Owned = false; 2125 bool IsDependent = false; 2126 SourceLocation TSTLoc = NameLoc.isValid()? NameLoc : StartLoc; 2127 const char *PrevSpec = 0; 2128 unsigned DiagID; 2129 Decl *TagDecl = Actions.ActOnTag(getCurScope(), DeclSpec::TST_enum, TUK, 2130 StartLoc, SS, Name, NameLoc, attrs.getList(), 2131 AS, 2132 MultiTemplateParamsArg(Actions), 2133 Owned, IsDependent, IsScopedEnum, 2134 IsScopedUsingClassTag, BaseType); 2135 2136 if (IsDependent) { 2137 // This enum has a dependent nested-name-specifier. Handle it as a 2138 // dependent tag. 2139 if (!Name) { 2140 DS.SetTypeSpecError(); 2141 Diag(Tok, diag::err_expected_type_name_after_typename); 2142 return; 2143 } 2144 2145 TypeResult Type = Actions.ActOnDependentTag(getCurScope(), DeclSpec::TST_enum, 2146 TUK, SS, Name, StartLoc, 2147 NameLoc); 2148 if (Type.isInvalid()) { 2149 DS.SetTypeSpecError(); 2150 return; 2151 } 2152 2153 if (DS.SetTypeSpecType(DeclSpec::TST_typename, TSTLoc, PrevSpec, DiagID, 2154 Type.get())) 2155 Diag(StartLoc, DiagID) << PrevSpec; 2156 2157 return; 2158 } 2159 2160 if (!TagDecl) { 2161 // The action failed to produce an enumeration tag. If this is a 2162 // definition, consume the entire definition. 2163 if (Tok.is(tok::l_brace)) { 2164 ConsumeBrace(); 2165 SkipUntil(tok::r_brace); 2166 } 2167 2168 DS.SetTypeSpecError(); 2169 return; 2170 } 2171 2172 if (Tok.is(tok::l_brace)) 2173 ParseEnumBody(StartLoc, TagDecl); 2174 2175 // FIXME: The DeclSpec should keep the locations of both the keyword 2176 // and the name (if there is one). 2177 if (DS.SetTypeSpecType(DeclSpec::TST_enum, TSTLoc, PrevSpec, DiagID, 2178 TagDecl, Owned)) 2179 Diag(StartLoc, DiagID) << PrevSpec; 2180} 2181 2182/// ParseEnumBody - Parse a {} enclosed enumerator-list. 2183/// enumerator-list: 2184/// enumerator 2185/// enumerator-list ',' enumerator 2186/// enumerator: 2187/// enumeration-constant 2188/// enumeration-constant '=' constant-expression 2189/// enumeration-constant: 2190/// identifier 2191/// 2192void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl) { 2193 // Enter the scope of the enum body and start the definition. 2194 ParseScope EnumScope(this, Scope::DeclScope); 2195 Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl); 2196 2197 SourceLocation LBraceLoc = ConsumeBrace(); 2198 2199 // C does not allow an empty enumerator-list, C++ does [dcl.enum]. 2200 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 2201 Diag(Tok, diag::error_empty_enum); 2202 2203 llvm::SmallVector<Decl *, 32> EnumConstantDecls; 2204 2205 Decl *LastEnumConstDecl = 0; 2206 2207 // Parse the enumerator-list. 2208 while (Tok.is(tok::identifier)) { 2209 IdentifierInfo *Ident = Tok.getIdentifierInfo(); 2210 SourceLocation IdentLoc = ConsumeToken(); 2211 2212 // If attributes exist after the enumerator, parse them. 2213 ParsedAttributes attrs; 2214 MaybeParseGNUAttributes(attrs); 2215 2216 SourceLocation EqualLoc; 2217 ExprResult AssignedVal; 2218 if (Tok.is(tok::equal)) { 2219 EqualLoc = ConsumeToken(); 2220 AssignedVal = ParseConstantExpression(); 2221 if (AssignedVal.isInvalid()) 2222 SkipUntil(tok::comma, tok::r_brace, true, true); 2223 } 2224 2225 // Install the enumerator constant into EnumDecl. 2226 Decl *EnumConstDecl = Actions.ActOnEnumConstant(getCurScope(), EnumDecl, 2227 LastEnumConstDecl, 2228 IdentLoc, Ident, 2229 attrs.getList(), EqualLoc, 2230 AssignedVal.release()); 2231 EnumConstantDecls.push_back(EnumConstDecl); 2232 LastEnumConstDecl = EnumConstDecl; 2233 2234 if (Tok.is(tok::identifier)) { 2235 // We're missing a comma between enumerators. 2236 SourceLocation Loc = PP.getLocForEndOfToken(PrevTokLocation); 2237 Diag(Loc, diag::err_enumerator_list_missing_comma) 2238 << FixItHint::CreateInsertion(Loc, ", "); 2239 continue; 2240 } 2241 2242 if (Tok.isNot(tok::comma)) 2243 break; 2244 SourceLocation CommaLoc = ConsumeToken(); 2245 2246 if (Tok.isNot(tok::identifier) && 2247 !(getLang().C99 || getLang().CPlusPlus0x)) 2248 Diag(CommaLoc, diag::ext_enumerator_list_comma) 2249 << getLang().CPlusPlus 2250 << FixItHint::CreateRemoval(CommaLoc); 2251 } 2252 2253 // Eat the }. 2254 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 2255 2256 // If attributes exist after the identifier list, parse them. 2257 ParsedAttributes attrs; 2258 MaybeParseGNUAttributes(attrs); 2259 2260 Actions.ActOnEnumBody(StartLoc, LBraceLoc, RBraceLoc, EnumDecl, 2261 EnumConstantDecls.data(), EnumConstantDecls.size(), 2262 getCurScope(), attrs.getList()); 2263 2264 EnumScope.Exit(); 2265 Actions.ActOnTagFinishDefinition(getCurScope(), EnumDecl, RBraceLoc); 2266} 2267 2268/// isTypeSpecifierQualifier - Return true if the current token could be the 2269/// start of a type-qualifier-list. 2270bool Parser::isTypeQualifier() const { 2271 switch (Tok.getKind()) { 2272 default: return false; 2273 // type-qualifier 2274 case tok::kw_const: 2275 case tok::kw_volatile: 2276 case tok::kw_restrict: 2277 return true; 2278 } 2279} 2280 2281/// isKnownToBeTypeSpecifier - Return true if we know that the specified token 2282/// is definitely a type-specifier. Return false if it isn't part of a type 2283/// specifier or if we're not sure. 2284bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const { 2285 switch (Tok.getKind()) { 2286 default: return false; 2287 // type-specifiers 2288 case tok::kw_short: 2289 case tok::kw_long: 2290 case tok::kw_signed: 2291 case tok::kw_unsigned: 2292 case tok::kw__Complex: 2293 case tok::kw__Imaginary: 2294 case tok::kw_void: 2295 case tok::kw_char: 2296 case tok::kw_wchar_t: 2297 case tok::kw_char16_t: 2298 case tok::kw_char32_t: 2299 case tok::kw_int: 2300 case tok::kw_float: 2301 case tok::kw_double: 2302 case tok::kw_bool: 2303 case tok::kw__Bool: 2304 case tok::kw__Decimal32: 2305 case tok::kw__Decimal64: 2306 case tok::kw__Decimal128: 2307 case tok::kw___vector: 2308 2309 // struct-or-union-specifier (C99) or class-specifier (C++) 2310 case tok::kw_class: 2311 case tok::kw_struct: 2312 case tok::kw_union: 2313 // enum-specifier 2314 case tok::kw_enum: 2315 2316 // typedef-name 2317 case tok::annot_typename: 2318 return true; 2319 } 2320} 2321 2322/// isTypeSpecifierQualifier - Return true if the current token could be the 2323/// start of a specifier-qualifier-list. 2324bool Parser::isTypeSpecifierQualifier() { 2325 switch (Tok.getKind()) { 2326 default: return false; 2327 2328 case tok::identifier: // foo::bar 2329 if (TryAltiVecVectorToken()) 2330 return true; 2331 // Fall through. 2332 case tok::kw_typename: // typename T::type 2333 // Annotate typenames and C++ scope specifiers. If we get one, just 2334 // recurse to handle whatever we get. 2335 if (TryAnnotateTypeOrScopeToken()) 2336 return true; 2337 if (Tok.is(tok::identifier)) 2338 return false; 2339 return isTypeSpecifierQualifier(); 2340 2341 case tok::coloncolon: // ::foo::bar 2342 if (NextToken().is(tok::kw_new) || // ::new 2343 NextToken().is(tok::kw_delete)) // ::delete 2344 return false; 2345 2346 if (TryAnnotateTypeOrScopeToken()) 2347 return true; 2348 return isTypeSpecifierQualifier(); 2349 2350 // GNU attributes support. 2351 case tok::kw___attribute: 2352 // GNU typeof support. 2353 case tok::kw_typeof: 2354 2355 // type-specifiers 2356 case tok::kw_short: 2357 case tok::kw_long: 2358 case tok::kw_signed: 2359 case tok::kw_unsigned: 2360 case tok::kw__Complex: 2361 case tok::kw__Imaginary: 2362 case tok::kw_void: 2363 case tok::kw_char: 2364 case tok::kw_wchar_t: 2365 case tok::kw_char16_t: 2366 case tok::kw_char32_t: 2367 case tok::kw_int: 2368 case tok::kw_float: 2369 case tok::kw_double: 2370 case tok::kw_bool: 2371 case tok::kw__Bool: 2372 case tok::kw__Decimal32: 2373 case tok::kw__Decimal64: 2374 case tok::kw__Decimal128: 2375 case tok::kw___vector: 2376 2377 // struct-or-union-specifier (C99) or class-specifier (C++) 2378 case tok::kw_class: 2379 case tok::kw_struct: 2380 case tok::kw_union: 2381 // enum-specifier 2382 case tok::kw_enum: 2383 2384 // type-qualifier 2385 case tok::kw_const: 2386 case tok::kw_volatile: 2387 case tok::kw_restrict: 2388 2389 // typedef-name 2390 case tok::annot_typename: 2391 return true; 2392 2393 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 2394 case tok::less: 2395 return getLang().ObjC1; 2396 2397 case tok::kw___cdecl: 2398 case tok::kw___stdcall: 2399 case tok::kw___fastcall: 2400 case tok::kw___thiscall: 2401 case tok::kw___w64: 2402 case tok::kw___ptr64: 2403 case tok::kw___pascal: 2404 return true; 2405 } 2406} 2407 2408/// isDeclarationSpecifier() - Return true if the current token is part of a 2409/// declaration specifier. 2410/// 2411/// \param DisambiguatingWithExpression True to indicate that the purpose of 2412/// this check is to disambiguate between an expression and a declaration. 2413bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) { 2414 switch (Tok.getKind()) { 2415 default: return false; 2416 2417 case tok::identifier: // foo::bar 2418 // Unfortunate hack to support "Class.factoryMethod" notation. 2419 if (getLang().ObjC1 && NextToken().is(tok::period)) 2420 return false; 2421 if (TryAltiVecVectorToken()) 2422 return true; 2423 // Fall through. 2424 case tok::kw_typename: // typename T::type 2425 // Annotate typenames and C++ scope specifiers. If we get one, just 2426 // recurse to handle whatever we get. 2427 if (TryAnnotateTypeOrScopeToken()) 2428 return true; 2429 if (Tok.is(tok::identifier)) 2430 return false; 2431 2432 // If we're in Objective-C and we have an Objective-C class type followed 2433 // by an identifier and then either ':' or ']', in a place where an 2434 // expression is permitted, then this is probably a class message send 2435 // missing the initial '['. In this case, we won't consider this to be 2436 // the start of a declaration. 2437 if (DisambiguatingWithExpression && 2438 isStartOfObjCClassMessageMissingOpenBracket()) 2439 return false; 2440 2441 return isDeclarationSpecifier(); 2442 2443 case tok::coloncolon: // ::foo::bar 2444 if (NextToken().is(tok::kw_new) || // ::new 2445 NextToken().is(tok::kw_delete)) // ::delete 2446 return false; 2447 2448 // Annotate typenames and C++ scope specifiers. If we get one, just 2449 // recurse to handle whatever we get. 2450 if (TryAnnotateTypeOrScopeToken()) 2451 return true; 2452 return isDeclarationSpecifier(); 2453 2454 // storage-class-specifier 2455 case tok::kw_typedef: 2456 case tok::kw_extern: 2457 case tok::kw___private_extern__: 2458 case tok::kw_static: 2459 case tok::kw_auto: 2460 case tok::kw_register: 2461 case tok::kw___thread: 2462 2463 // type-specifiers 2464 case tok::kw_short: 2465 case tok::kw_long: 2466 case tok::kw_signed: 2467 case tok::kw_unsigned: 2468 case tok::kw__Complex: 2469 case tok::kw__Imaginary: 2470 case tok::kw_void: 2471 case tok::kw_char: 2472 case tok::kw_wchar_t: 2473 case tok::kw_char16_t: 2474 case tok::kw_char32_t: 2475 2476 case tok::kw_int: 2477 case tok::kw_float: 2478 case tok::kw_double: 2479 case tok::kw_bool: 2480 case tok::kw__Bool: 2481 case tok::kw__Decimal32: 2482 case tok::kw__Decimal64: 2483 case tok::kw__Decimal128: 2484 case tok::kw___vector: 2485 2486 // struct-or-union-specifier (C99) or class-specifier (C++) 2487 case tok::kw_class: 2488 case tok::kw_struct: 2489 case tok::kw_union: 2490 // enum-specifier 2491 case tok::kw_enum: 2492 2493 // type-qualifier 2494 case tok::kw_const: 2495 case tok::kw_volatile: 2496 case tok::kw_restrict: 2497 2498 // function-specifier 2499 case tok::kw_inline: 2500 case tok::kw_virtual: 2501 case tok::kw_explicit: 2502 2503 // typedef-name 2504 case tok::annot_typename: 2505 2506 // GNU typeof support. 2507 case tok::kw_typeof: 2508 2509 // GNU attributes. 2510 case tok::kw___attribute: 2511 return true; 2512 2513 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 2514 case tok::less: 2515 return getLang().ObjC1; 2516 2517 case tok::kw___declspec: 2518 case tok::kw___cdecl: 2519 case tok::kw___stdcall: 2520 case tok::kw___fastcall: 2521 case tok::kw___thiscall: 2522 case tok::kw___w64: 2523 case tok::kw___ptr64: 2524 case tok::kw___forceinline: 2525 case tok::kw___pascal: 2526 return true; 2527 } 2528} 2529 2530bool Parser::isConstructorDeclarator() { 2531 TentativeParsingAction TPA(*this); 2532 2533 // Parse the C++ scope specifier. 2534 CXXScopeSpec SS; 2535 if (ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true)) { 2536 TPA.Revert(); 2537 return false; 2538 } 2539 2540 // Parse the constructor name. 2541 if (Tok.is(tok::identifier) || Tok.is(tok::annot_template_id)) { 2542 // We already know that we have a constructor name; just consume 2543 // the token. 2544 ConsumeToken(); 2545 } else { 2546 TPA.Revert(); 2547 return false; 2548 } 2549 2550 // Current class name must be followed by a left parentheses. 2551 if (Tok.isNot(tok::l_paren)) { 2552 TPA.Revert(); 2553 return false; 2554 } 2555 ConsumeParen(); 2556 2557 // A right parentheses or ellipsis signals that we have a constructor. 2558 if (Tok.is(tok::r_paren) || Tok.is(tok::ellipsis)) { 2559 TPA.Revert(); 2560 return true; 2561 } 2562 2563 // If we need to, enter the specified scope. 2564 DeclaratorScopeObj DeclScopeObj(*this, SS); 2565 if (SS.isSet() && Actions.ShouldEnterDeclaratorScope(getCurScope(), SS)) 2566 DeclScopeObj.EnterDeclaratorScope(); 2567 2568 // Optionally skip Microsoft attributes. 2569 ParsedAttributes Attrs; 2570 MaybeParseMicrosoftAttributes(Attrs); 2571 2572 // Check whether the next token(s) are part of a declaration 2573 // specifier, in which case we have the start of a parameter and, 2574 // therefore, we know that this is a constructor. 2575 bool IsConstructor = isDeclarationSpecifier(); 2576 TPA.Revert(); 2577 return IsConstructor; 2578} 2579 2580/// ParseTypeQualifierListOpt 2581/// type-qualifier-list: [C99 6.7.5] 2582/// type-qualifier 2583/// [vendor] attributes 2584/// [ only if VendorAttributesAllowed=true ] 2585/// type-qualifier-list type-qualifier 2586/// [vendor] type-qualifier-list attributes 2587/// [ only if VendorAttributesAllowed=true ] 2588/// [C++0x] attribute-specifier[opt] is allowed before cv-qualifier-seq 2589/// [ only if CXX0XAttributesAllowed=true ] 2590/// Note: vendor can be GNU, MS, etc. 2591/// 2592void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, 2593 bool VendorAttributesAllowed, 2594 bool CXX0XAttributesAllowed) { 2595 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) { 2596 SourceLocation Loc = Tok.getLocation(); 2597 ParsedAttributesWithRange attrs; 2598 ParseCXX0XAttributes(attrs); 2599 if (CXX0XAttributesAllowed) 2600 DS.takeAttributesFrom(attrs); 2601 else 2602 Diag(Loc, diag::err_attributes_not_allowed); 2603 } 2604 2605 while (1) { 2606 bool isInvalid = false; 2607 const char *PrevSpec = 0; 2608 unsigned DiagID = 0; 2609 SourceLocation Loc = Tok.getLocation(); 2610 2611 switch (Tok.getKind()) { 2612 case tok::code_completion: 2613 Actions.CodeCompleteTypeQualifiers(DS); 2614 ConsumeCodeCompletionToken(); 2615 break; 2616 2617 case tok::kw_const: 2618 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, DiagID, 2619 getLang()); 2620 break; 2621 case tok::kw_volatile: 2622 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, DiagID, 2623 getLang()); 2624 break; 2625 case tok::kw_restrict: 2626 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, DiagID, 2627 getLang()); 2628 break; 2629 case tok::kw___w64: 2630 case tok::kw___ptr64: 2631 case tok::kw___cdecl: 2632 case tok::kw___stdcall: 2633 case tok::kw___fastcall: 2634 case tok::kw___thiscall: 2635 if (VendorAttributesAllowed) { 2636 ParseMicrosoftTypeAttributes(DS.getAttributes()); 2637 continue; 2638 } 2639 goto DoneWithTypeQuals; 2640 case tok::kw___pascal: 2641 if (VendorAttributesAllowed) { 2642 ParseBorlandTypeAttributes(DS.getAttributes()); 2643 continue; 2644 } 2645 goto DoneWithTypeQuals; 2646 case tok::kw___attribute: 2647 if (VendorAttributesAllowed) { 2648 ParseGNUAttributes(DS.getAttributes()); 2649 continue; // do *not* consume the next token! 2650 } 2651 // otherwise, FALL THROUGH! 2652 default: 2653 DoneWithTypeQuals: 2654 // If this is not a type-qualifier token, we're done reading type 2655 // qualifiers. First verify that DeclSpec's are consistent. 2656 DS.Finish(Diags, PP); 2657 return; 2658 } 2659 2660 // If the specifier combination wasn't legal, issue a diagnostic. 2661 if (isInvalid) { 2662 assert(PrevSpec && "Method did not return previous specifier!"); 2663 Diag(Tok, DiagID) << PrevSpec; 2664 } 2665 ConsumeToken(); 2666 } 2667} 2668 2669 2670/// ParseDeclarator - Parse and verify a newly-initialized declarator. 2671/// 2672void Parser::ParseDeclarator(Declarator &D) { 2673 /// This implements the 'declarator' production in the C grammar, then checks 2674 /// for well-formedness and issues diagnostics. 2675 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator); 2676} 2677 2678/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator 2679/// is parsed by the function passed to it. Pass null, and the direct-declarator 2680/// isn't parsed at all, making this function effectively parse the C++ 2681/// ptr-operator production. 2682/// 2683/// declarator: [C99 6.7.5] [C++ 8p4, dcl.decl] 2684/// [C] pointer[opt] direct-declarator 2685/// [C++] direct-declarator 2686/// [C++] ptr-operator declarator 2687/// 2688/// pointer: [C99 6.7.5] 2689/// '*' type-qualifier-list[opt] 2690/// '*' type-qualifier-list[opt] pointer 2691/// 2692/// ptr-operator: 2693/// '*' cv-qualifier-seq[opt] 2694/// '&' 2695/// [C++0x] '&&' 2696/// [GNU] '&' restrict[opt] attributes[opt] 2697/// [GNU?] '&&' restrict[opt] attributes[opt] 2698/// '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt] 2699void Parser::ParseDeclaratorInternal(Declarator &D, 2700 DirectDeclParseFunction DirectDeclParser) { 2701 if (Diags.hasAllExtensionsSilenced()) 2702 D.setExtension(); 2703 2704 // C++ member pointers start with a '::' or a nested-name. 2705 // Member pointers get special handling, since there's no place for the 2706 // scope spec in the generic path below. 2707 if (getLang().CPlusPlus && 2708 (Tok.is(tok::coloncolon) || Tok.is(tok::identifier) || 2709 Tok.is(tok::annot_cxxscope))) { 2710 CXXScopeSpec SS; 2711 ParseOptionalCXXScopeSpecifier(SS, ParsedType(), true); // ignore fail 2712 2713 if (SS.isNotEmpty()) { 2714 if (Tok.isNot(tok::star)) { 2715 // The scope spec really belongs to the direct-declarator. 2716 D.getCXXScopeSpec() = SS; 2717 if (DirectDeclParser) 2718 (this->*DirectDeclParser)(D); 2719 return; 2720 } 2721 2722 SourceLocation Loc = ConsumeToken(); 2723 D.SetRangeEnd(Loc); 2724 DeclSpec DS; 2725 ParseTypeQualifierListOpt(DS); 2726 D.ExtendWithDeclSpec(DS); 2727 2728 // Recurse to parse whatever is left. 2729 ParseDeclaratorInternal(D, DirectDeclParser); 2730 2731 // Sema will have to catch (syntactically invalid) pointers into global 2732 // scope. It has to catch pointers into namespace scope anyway. 2733 D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(), 2734 Loc, DS.takeAttributes()), 2735 /* Don't replace range end. */SourceLocation()); 2736 return; 2737 } 2738 } 2739 2740 tok::TokenKind Kind = Tok.getKind(); 2741 // Not a pointer, C++ reference, or block. 2742 if (Kind != tok::star && Kind != tok::caret && 2743 (Kind != tok::amp || !getLang().CPlusPlus) && 2744 // We parse rvalue refs in C++03, because otherwise the errors are scary. 2745 (Kind != tok::ampamp || !getLang().CPlusPlus)) { 2746 if (DirectDeclParser) 2747 (this->*DirectDeclParser)(D); 2748 return; 2749 } 2750 2751 // Otherwise, '*' -> pointer, '^' -> block, '&' -> lvalue reference, 2752 // '&&' -> rvalue reference 2753 SourceLocation Loc = ConsumeToken(); // Eat the *, ^, & or &&. 2754 D.SetRangeEnd(Loc); 2755 2756 if (Kind == tok::star || Kind == tok::caret) { 2757 // Is a pointer. 2758 DeclSpec DS; 2759 2760 ParseTypeQualifierListOpt(DS); 2761 D.ExtendWithDeclSpec(DS); 2762 2763 // Recursively parse the declarator. 2764 ParseDeclaratorInternal(D, DirectDeclParser); 2765 if (Kind == tok::star) 2766 // Remember that we parsed a pointer type, and remember the type-quals. 2767 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc, 2768 DS.getConstSpecLoc(), 2769 DS.getVolatileSpecLoc(), 2770 DS.getRestrictSpecLoc(), 2771 DS.takeAttributes()), 2772 SourceLocation()); 2773 else 2774 // Remember that we parsed a Block type, and remember the type-quals. 2775 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), 2776 Loc, DS.takeAttributes()), 2777 SourceLocation()); 2778 } else { 2779 // Is a reference 2780 DeclSpec DS; 2781 2782 // Complain about rvalue references in C++03, but then go on and build 2783 // the declarator. 2784 if (Kind == tok::ampamp && !getLang().CPlusPlus0x) 2785 Diag(Loc, diag::ext_rvalue_reference); 2786 2787 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the 2788 // cv-qualifiers are introduced through the use of a typedef or of a 2789 // template type argument, in which case the cv-qualifiers are ignored. 2790 // 2791 // [GNU] Retricted references are allowed. 2792 // [GNU] Attributes on references are allowed. 2793 // [C++0x] Attributes on references are not allowed. 2794 ParseTypeQualifierListOpt(DS, true, false); 2795 D.ExtendWithDeclSpec(DS); 2796 2797 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) { 2798 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 2799 Diag(DS.getConstSpecLoc(), 2800 diag::err_invalid_reference_qualifier_application) << "const"; 2801 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 2802 Diag(DS.getVolatileSpecLoc(), 2803 diag::err_invalid_reference_qualifier_application) << "volatile"; 2804 } 2805 2806 // Recursively parse the declarator. 2807 ParseDeclaratorInternal(D, DirectDeclParser); 2808 2809 if (D.getNumTypeObjects() > 0) { 2810 // C++ [dcl.ref]p4: There shall be no references to references. 2811 DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1); 2812 if (InnerChunk.Kind == DeclaratorChunk::Reference) { 2813 if (const IdentifierInfo *II = D.getIdentifier()) 2814 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference) 2815 << II; 2816 else 2817 Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference) 2818 << "type name"; 2819 2820 // Once we've complained about the reference-to-reference, we 2821 // can go ahead and build the (technically ill-formed) 2822 // declarator: reference collapsing will take care of it. 2823 } 2824 } 2825 2826 // Remember that we parsed a reference type. It doesn't have type-quals. 2827 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc, 2828 DS.takeAttributes(), 2829 Kind == tok::amp), 2830 SourceLocation()); 2831 } 2832} 2833 2834/// ParseDirectDeclarator 2835/// direct-declarator: [C99 6.7.5] 2836/// [C99] identifier 2837/// '(' declarator ')' 2838/// [GNU] '(' attributes declarator ')' 2839/// [C90] direct-declarator '[' constant-expression[opt] ']' 2840/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 2841/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 2842/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 2843/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 2844/// direct-declarator '(' parameter-type-list ')' 2845/// direct-declarator '(' identifier-list[opt] ')' 2846/// [GNU] direct-declarator '(' parameter-forward-declarations 2847/// parameter-type-list[opt] ')' 2848/// [C++] direct-declarator '(' parameter-declaration-clause ')' 2849/// cv-qualifier-seq[opt] exception-specification[opt] 2850/// [C++] declarator-id 2851/// 2852/// declarator-id: [C++ 8] 2853/// '...'[opt] id-expression 2854/// '::'[opt] nested-name-specifier[opt] type-name 2855/// 2856/// id-expression: [C++ 5.1] 2857/// unqualified-id 2858/// qualified-id 2859/// 2860/// unqualified-id: [C++ 5.1] 2861/// identifier 2862/// operator-function-id 2863/// conversion-function-id 2864/// '~' class-name 2865/// template-id 2866/// 2867void Parser::ParseDirectDeclarator(Declarator &D) { 2868 DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec()); 2869 2870 if (getLang().CPlusPlus && D.mayHaveIdentifier()) { 2871 // ParseDeclaratorInternal might already have parsed the scope. 2872 if (D.getCXXScopeSpec().isEmpty()) { 2873 ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec(), ParsedType(), true); 2874 } 2875 2876 if (D.getCXXScopeSpec().isValid()) { 2877 if (Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec())) 2878 // Change the declaration context for name lookup, until this function 2879 // is exited (and the declarator has been parsed). 2880 DeclScopeObj.EnterDeclaratorScope(); 2881 } 2882 2883 // C++0x [dcl.fct]p14: 2884 // There is a syntactic ambiguity when an ellipsis occurs at the end 2885 // of a parameter-declaration-clause without a preceding comma. In 2886 // this case, the ellipsis is parsed as part of the 2887 // abstract-declarator if the type of the parameter names a template 2888 // parameter pack that has not been expanded; otherwise, it is parsed 2889 // as part of the parameter-declaration-clause. 2890 if (Tok.is(tok::ellipsis) && 2891 !((D.getContext() == Declarator::PrototypeContext || 2892 D.getContext() == Declarator::BlockLiteralContext) && 2893 NextToken().is(tok::r_paren) && 2894 !Actions.containsUnexpandedParameterPacks(D))) 2895 D.setEllipsisLoc(ConsumeToken()); 2896 2897 if (Tok.is(tok::identifier) || Tok.is(tok::kw_operator) || 2898 Tok.is(tok::annot_template_id) || Tok.is(tok::tilde)) { 2899 // We found something that indicates the start of an unqualified-id. 2900 // Parse that unqualified-id. 2901 bool AllowConstructorName; 2902 if (D.getDeclSpec().hasTypeSpecifier()) 2903 AllowConstructorName = false; 2904 else if (D.getCXXScopeSpec().isSet()) 2905 AllowConstructorName = 2906 (D.getContext() == Declarator::FileContext || 2907 (D.getContext() == Declarator::MemberContext && 2908 D.getDeclSpec().isFriendSpecified())); 2909 else 2910 AllowConstructorName = (D.getContext() == Declarator::MemberContext); 2911 2912 if (ParseUnqualifiedId(D.getCXXScopeSpec(), 2913 /*EnteringContext=*/true, 2914 /*AllowDestructorName=*/true, 2915 AllowConstructorName, 2916 ParsedType(), 2917 D.getName()) || 2918 // Once we're past the identifier, if the scope was bad, mark the 2919 // whole declarator bad. 2920 D.getCXXScopeSpec().isInvalid()) { 2921 D.SetIdentifier(0, Tok.getLocation()); 2922 D.setInvalidType(true); 2923 } else { 2924 // Parsed the unqualified-id; update range information and move along. 2925 if (D.getSourceRange().getBegin().isInvalid()) 2926 D.SetRangeBegin(D.getName().getSourceRange().getBegin()); 2927 D.SetRangeEnd(D.getName().getSourceRange().getEnd()); 2928 } 2929 goto PastIdentifier; 2930 } 2931 } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) { 2932 assert(!getLang().CPlusPlus && 2933 "There's a C++-specific check for tok::identifier above"); 2934 assert(Tok.getIdentifierInfo() && "Not an identifier?"); 2935 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 2936 ConsumeToken(); 2937 goto PastIdentifier; 2938 } 2939 2940 if (Tok.is(tok::l_paren)) { 2941 // direct-declarator: '(' declarator ')' 2942 // direct-declarator: '(' attributes declarator ')' 2943 // Example: 'char (*X)' or 'int (*XX)(void)' 2944 ParseParenDeclarator(D); 2945 2946 // If the declarator was parenthesized, we entered the declarator 2947 // scope when parsing the parenthesized declarator, then exited 2948 // the scope already. Re-enter the scope, if we need to. 2949 if (D.getCXXScopeSpec().isSet()) { 2950 // If there was an error parsing parenthesized declarator, declarator 2951 // scope may have been enterred before. Don't do it again. 2952 if (!D.isInvalidType() && 2953 Actions.ShouldEnterDeclaratorScope(getCurScope(), D.getCXXScopeSpec())) 2954 // Change the declaration context for name lookup, until this function 2955 // is exited (and the declarator has been parsed). 2956 DeclScopeObj.EnterDeclaratorScope(); 2957 } 2958 } else if (D.mayOmitIdentifier()) { 2959 // This could be something simple like "int" (in which case the declarator 2960 // portion is empty), if an abstract-declarator is allowed. 2961 D.SetIdentifier(0, Tok.getLocation()); 2962 } else { 2963 if (D.getContext() == Declarator::MemberContext) 2964 Diag(Tok, diag::err_expected_member_name_or_semi) 2965 << D.getDeclSpec().getSourceRange(); 2966 else if (getLang().CPlusPlus) 2967 Diag(Tok, diag::err_expected_unqualified_id) << getLang().CPlusPlus; 2968 else 2969 Diag(Tok, diag::err_expected_ident_lparen); 2970 D.SetIdentifier(0, Tok.getLocation()); 2971 D.setInvalidType(true); 2972 } 2973 2974 PastIdentifier: 2975 assert(D.isPastIdentifier() && 2976 "Haven't past the location of the identifier yet?"); 2977 2978 // Don't parse attributes unless we have an identifier. 2979 if (D.getIdentifier()) 2980 MaybeParseCXX0XAttributes(D); 2981 2982 while (1) { 2983 if (Tok.is(tok::l_paren)) { 2984 // The paren may be part of a C++ direct initializer, eg. "int x(1);". 2985 // In such a case, check if we actually have a function declarator; if it 2986 // is not, the declarator has been fully parsed. 2987 if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) { 2988 // When not in file scope, warn for ambiguous function declarators, just 2989 // in case the author intended it as a variable definition. 2990 bool warnIfAmbiguous = D.getContext() != Declarator::FileContext; 2991 if (!isCXXFunctionDeclarator(warnIfAmbiguous)) 2992 break; 2993 } 2994 ParsedAttributes attrs; 2995 ParseFunctionDeclarator(ConsumeParen(), D, attrs); 2996 } else if (Tok.is(tok::l_square)) { 2997 ParseBracketDeclarator(D); 2998 } else { 2999 break; 3000 } 3001 } 3002} 3003 3004/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is 3005/// only called before the identifier, so these are most likely just grouping 3006/// parens for precedence. If we find that these are actually function 3007/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator. 3008/// 3009/// direct-declarator: 3010/// '(' declarator ')' 3011/// [GNU] '(' attributes declarator ')' 3012/// direct-declarator '(' parameter-type-list ')' 3013/// direct-declarator '(' identifier-list[opt] ')' 3014/// [GNU] direct-declarator '(' parameter-forward-declarations 3015/// parameter-type-list[opt] ')' 3016/// 3017void Parser::ParseParenDeclarator(Declarator &D) { 3018 SourceLocation StartLoc = ConsumeParen(); 3019 assert(!D.isPastIdentifier() && "Should be called before passing identifier"); 3020 3021 // Eat any attributes before we look at whether this is a grouping or function 3022 // declarator paren. If this is a grouping paren, the attribute applies to 3023 // the type being built up, for example: 3024 // int (__attribute__(()) *x)(long y) 3025 // If this ends up not being a grouping paren, the attribute applies to the 3026 // first argument, for example: 3027 // int (__attribute__(()) int x) 3028 // In either case, we need to eat any attributes to be able to determine what 3029 // sort of paren this is. 3030 // 3031 ParsedAttributes attrs; 3032 bool RequiresArg = false; 3033 if (Tok.is(tok::kw___attribute)) { 3034 ParseGNUAttributes(attrs); 3035 3036 // We require that the argument list (if this is a non-grouping paren) be 3037 // present even if the attribute list was empty. 3038 RequiresArg = true; 3039 } 3040 // Eat any Microsoft extensions. 3041 if (Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) || 3042 Tok.is(tok::kw___thiscall) || Tok.is(tok::kw___fastcall) || 3043 Tok.is(tok::kw___w64) || Tok.is(tok::kw___ptr64)) { 3044 ParseMicrosoftTypeAttributes(attrs); 3045 } 3046 // Eat any Borland extensions. 3047 if (Tok.is(tok::kw___pascal)) 3048 ParseBorlandTypeAttributes(attrs); 3049 3050 // If we haven't past the identifier yet (or where the identifier would be 3051 // stored, if this is an abstract declarator), then this is probably just 3052 // grouping parens. However, if this could be an abstract-declarator, then 3053 // this could also be the start of function arguments (consider 'void()'). 3054 bool isGrouping; 3055 3056 if (!D.mayOmitIdentifier()) { 3057 // If this can't be an abstract-declarator, this *must* be a grouping 3058 // paren, because we haven't seen the identifier yet. 3059 isGrouping = true; 3060 } else if (Tok.is(tok::r_paren) || // 'int()' is a function. 3061 (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...) 3062 isDeclarationSpecifier()) { // 'int(int)' is a function. 3063 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is 3064 // considered to be a type, not a K&R identifier-list. 3065 isGrouping = false; 3066 } else { 3067 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'. 3068 isGrouping = true; 3069 } 3070 3071 // If this is a grouping paren, handle: 3072 // direct-declarator: '(' declarator ')' 3073 // direct-declarator: '(' attributes declarator ')' 3074 if (isGrouping) { 3075 bool hadGroupingParens = D.hasGroupingParens(); 3076 D.setGroupingParens(true); 3077 if (!attrs.empty()) 3078 D.addAttributes(attrs.getList(), SourceLocation()); 3079 3080 ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator); 3081 // Match the ')'. 3082 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_paren, StartLoc); 3083 D.AddTypeInfo(DeclaratorChunk::getParen(StartLoc, EndLoc), EndLoc); 3084 3085 D.setGroupingParens(hadGroupingParens); 3086 return; 3087 } 3088 3089 // Okay, if this wasn't a grouping paren, it must be the start of a function 3090 // argument list. Recognize that this declarator will never have an 3091 // identifier (and remember where it would have been), then call into 3092 // ParseFunctionDeclarator to handle of argument list. 3093 D.SetIdentifier(0, Tok.getLocation()); 3094 3095 ParseFunctionDeclarator(StartLoc, D, attrs, RequiresArg); 3096} 3097 3098/// ParseFunctionDeclarator - We are after the identifier and have parsed the 3099/// declarator D up to a paren, which indicates that we are parsing function 3100/// arguments. 3101/// 3102/// If AttrList is non-null, then the caller parsed those arguments immediately 3103/// after the open paren - they should be considered to be the first argument of 3104/// a parameter. If RequiresArg is true, then the first argument of the 3105/// function is required to be present and required to not be an identifier 3106/// list. 3107/// 3108/// This method also handles this portion of the grammar: 3109/// parameter-type-list: [C99 6.7.5] 3110/// parameter-list 3111/// parameter-list ',' '...' 3112/// [C++] parameter-list '...' 3113/// 3114/// parameter-list: [C99 6.7.5] 3115/// parameter-declaration 3116/// parameter-list ',' parameter-declaration 3117/// 3118/// parameter-declaration: [C99 6.7.5] 3119/// declaration-specifiers declarator 3120/// [C++] declaration-specifiers declarator '=' assignment-expression 3121/// [GNU] declaration-specifiers declarator attributes 3122/// declaration-specifiers abstract-declarator[opt] 3123/// [C++] declaration-specifiers abstract-declarator[opt] 3124/// '=' assignment-expression 3125/// [GNU] declaration-specifiers abstract-declarator[opt] attributes 3126/// 3127/// For C++, after the parameter-list, it also parses "cv-qualifier-seq[opt]", 3128/// C++0x "ref-qualifier[opt]" and "exception-specification[opt]". 3129/// 3130/// [C++0x] exception-specification: 3131/// dynamic-exception-specification 3132/// noexcept-specification 3133/// 3134void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D, 3135 ParsedAttributes &attrs, 3136 bool RequiresArg) { 3137 // lparen is already consumed! 3138 assert(D.isPastIdentifier() && "Should not call before identifier!"); 3139 3140 ParsedType TrailingReturnType; 3141 3142 // This parameter list may be empty. 3143 if (Tok.is(tok::r_paren)) { 3144 if (RequiresArg) 3145 Diag(Tok, diag::err_argument_required_after_attribute); 3146 3147 SourceLocation RParenLoc = ConsumeParen(); // Eat the closing ')'. 3148 SourceLocation EndLoc = RParenLoc; 3149 3150 // cv-qualifier-seq[opt]. 3151 DeclSpec DS; 3152 SourceLocation RefQualifierLoc; 3153 bool RefQualifierIsLValueRef = true; 3154 ExceptionSpecificationType ESpecType = EST_None; 3155 SourceRange ESpecRange; 3156 llvm::SmallVector<ParsedType, 2> DynamicExceptions; 3157 llvm::SmallVector<SourceRange, 2> DynamicExceptionRanges; 3158 ExprResult NoexceptExpr; 3159 if (getLang().CPlusPlus) { 3160 MaybeParseCXX0XAttributes(attrs); 3161 3162 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 3163 if (!DS.getSourceRange().getEnd().isInvalid()) 3164 EndLoc = DS.getSourceRange().getEnd(); 3165 3166 // Parse ref-qualifier[opt] 3167 if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) { 3168 if (!getLang().CPlusPlus0x) 3169 Diag(Tok, diag::ext_ref_qualifier); 3170 3171 RefQualifierIsLValueRef = Tok.is(tok::amp); 3172 RefQualifierLoc = ConsumeToken(); 3173 EndLoc = RefQualifierLoc; 3174 } 3175 3176 // Parse exception-specification[opt]. 3177 ESpecType = MaybeParseExceptionSpecification(ESpecRange, 3178 DynamicExceptions, 3179 DynamicExceptionRanges, 3180 NoexceptExpr); 3181 if (ESpecType != EST_None) 3182 EndLoc = ESpecRange.getEnd(); 3183 3184 // Parse trailing-return-type. 3185 if (getLang().CPlusPlus0x && Tok.is(tok::arrow)) { 3186 TrailingReturnType = ParseTrailingReturnType().get(); 3187 } 3188 } 3189 3190 // Remember that we parsed a function type, and remember the attributes. 3191 // int() -> no prototype, no '...'. 3192 D.AddTypeInfo(DeclaratorChunk::getFunction(attrs, 3193 /*prototype*/getLang().CPlusPlus, 3194 /*variadic*/ false, 3195 SourceLocation(), 3196 /*arglist*/ 0, 0, 3197 DS.getTypeQualifiers(), 3198 RefQualifierIsLValueRef, 3199 RefQualifierLoc, 3200 ESpecType, ESpecRange.getBegin(), 3201 DynamicExceptions.data(), 3202 DynamicExceptionRanges.data(), 3203 DynamicExceptions.size(), 3204 NoexceptExpr.isUsable() ? 3205 NoexceptExpr.get() : 0, 3206 LParenLoc, RParenLoc, D, 3207 TrailingReturnType), 3208 EndLoc); 3209 return; 3210 } 3211 3212 // Alternatively, this parameter list may be an identifier list form for a 3213 // K&R-style function: void foo(a,b,c) 3214 if (!getLang().CPlusPlus && Tok.is(tok::identifier) 3215 && !TryAltiVecVectorToken()) { 3216 if (TryAnnotateTypeOrScopeToken() || !Tok.is(tok::annot_typename)) { 3217 // K&R identifier lists can't have typedefs as identifiers, per 3218 // C99 6.7.5.3p11. 3219 if (RequiresArg) 3220 Diag(Tok, diag::err_argument_required_after_attribute); 3221 3222 // Identifier list. Note that '(' identifier-list ')' is only allowed for 3223 // normal declarators, not for abstract-declarators. Get the first 3224 // identifier. 3225 Token FirstTok = Tok; 3226 ConsumeToken(); // eat the first identifier. 3227 3228 // Identifier lists follow a really simple grammar: the identifiers can 3229 // be followed *only* by a ", moreidentifiers" or ")". However, K&R 3230 // identifier lists are really rare in the brave new modern world, and it 3231 // is very common for someone to typo a type in a non-k&r style list. If 3232 // we are presented with something like: "void foo(intptr x, float y)", 3233 // we don't want to start parsing the function declarator as though it is 3234 // a K&R style declarator just because intptr is an invalid type. 3235 // 3236 // To handle this, we check to see if the token after the first identifier 3237 // is a "," or ")". Only if so, do we parse it as an identifier list. 3238 if (Tok.is(tok::comma) || Tok.is(tok::r_paren)) 3239 return ParseFunctionDeclaratorIdentifierList(LParenLoc, 3240 FirstTok.getIdentifierInfo(), 3241 FirstTok.getLocation(), D); 3242 3243 // If we get here, the code is invalid. Push the first identifier back 3244 // into the token stream and parse the first argument as an (invalid) 3245 // normal argument declarator. 3246 PP.EnterToken(Tok); 3247 Tok = FirstTok; 3248 } 3249 } 3250 3251 // Finally, a normal, non-empty parameter type list. 3252 3253 // Build up an array of information about the parsed arguments. 3254 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 3255 3256 // Enter function-declaration scope, limiting any declarators to the 3257 // function prototype scope, including parameter declarators. 3258 ParseScope PrototypeScope(this, 3259 Scope::FunctionPrototypeScope|Scope::DeclScope); 3260 3261 bool IsVariadic = false; 3262 SourceLocation EllipsisLoc; 3263 while (1) { 3264 if (Tok.is(tok::ellipsis)) { 3265 IsVariadic = true; 3266 EllipsisLoc = ConsumeToken(); // Consume the ellipsis. 3267 break; 3268 } 3269 3270 // Parse the declaration-specifiers. 3271 // Just use the ParsingDeclaration "scope" of the declarator. 3272 DeclSpec DS; 3273 3274 // Skip any Microsoft attributes before a param. 3275 if (getLang().Microsoft && Tok.is(tok::l_square)) 3276 ParseMicrosoftAttributes(DS.getAttributes()); 3277 3278 SourceLocation DSStart = Tok.getLocation(); 3279 3280 // If the caller parsed attributes for the first argument, add them now. 3281 // Take them so that we only apply the attributes to the first parameter. 3282 DS.takeAttributesFrom(attrs); 3283 3284 ParseDeclarationSpecifiers(DS); 3285 3286 // Parse the declarator. This is "PrototypeContext", because we must 3287 // accept either 'declarator' or 'abstract-declarator' here. 3288 Declarator ParmDecl(DS, Declarator::PrototypeContext); 3289 ParseDeclarator(ParmDecl); 3290 3291 // Parse GNU attributes, if present. 3292 MaybeParseGNUAttributes(ParmDecl); 3293 3294 // Remember this parsed parameter in ParamInfo. 3295 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 3296 3297 // DefArgToks is used when the parsing of default arguments needs 3298 // to be delayed. 3299 CachedTokens *DefArgToks = 0; 3300 3301 // If no parameter was specified, verify that *something* was specified, 3302 // otherwise we have a missing type and identifier. 3303 if (DS.isEmpty() && ParmDecl.getIdentifier() == 0 && 3304 ParmDecl.getNumTypeObjects() == 0) { 3305 // Completely missing, emit error. 3306 Diag(DSStart, diag::err_missing_param); 3307 } else { 3308 // Otherwise, we have something. Add it and let semantic analysis try 3309 // to grok it and add the result to the ParamInfo we are building. 3310 3311 // Inform the actions module about the parameter declarator, so it gets 3312 // added to the current scope. 3313 Decl *Param = Actions.ActOnParamDeclarator(getCurScope(), ParmDecl); 3314 3315 // Parse the default argument, if any. We parse the default 3316 // arguments in all dialects; the semantic analysis in 3317 // ActOnParamDefaultArgument will reject the default argument in 3318 // C. 3319 if (Tok.is(tok::equal)) { 3320 SourceLocation EqualLoc = Tok.getLocation(); 3321 3322 // Parse the default argument 3323 if (D.getContext() == Declarator::MemberContext) { 3324 // If we're inside a class definition, cache the tokens 3325 // corresponding to the default argument. We'll actually parse 3326 // them when we see the end of the class definition. 3327 // FIXME: Templates will require something similar. 3328 // FIXME: Can we use a smart pointer for Toks? 3329 DefArgToks = new CachedTokens; 3330 3331 if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks, 3332 /*StopAtSemi=*/true, 3333 /*ConsumeFinalToken=*/false)) { 3334 delete DefArgToks; 3335 DefArgToks = 0; 3336 Actions.ActOnParamDefaultArgumentError(Param); 3337 } else { 3338 // Mark the end of the default argument so that we know when to 3339 // stop when we parse it later on. 3340 Token DefArgEnd; 3341 DefArgEnd.startToken(); 3342 DefArgEnd.setKind(tok::cxx_defaultarg_end); 3343 DefArgEnd.setLocation(Tok.getLocation()); 3344 DefArgToks->push_back(DefArgEnd); 3345 Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc, 3346 (*DefArgToks)[1].getLocation()); 3347 } 3348 } else { 3349 // Consume the '='. 3350 ConsumeToken(); 3351 3352 // The argument isn't actually potentially evaluated unless it is 3353 // used. 3354 EnterExpressionEvaluationContext Eval(Actions, 3355 Sema::PotentiallyEvaluatedIfUsed); 3356 3357 ExprResult DefArgResult(ParseAssignmentExpression()); 3358 if (DefArgResult.isInvalid()) { 3359 Actions.ActOnParamDefaultArgumentError(Param); 3360 SkipUntil(tok::comma, tok::r_paren, true, true); 3361 } else { 3362 // Inform the actions module about the default argument 3363 Actions.ActOnParamDefaultArgument(Param, EqualLoc, 3364 DefArgResult.take()); 3365 } 3366 } 3367 } 3368 3369 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 3370 ParmDecl.getIdentifierLoc(), Param, 3371 DefArgToks)); 3372 } 3373 3374 // If the next token is a comma, consume it and keep reading arguments. 3375 if (Tok.isNot(tok::comma)) { 3376 if (Tok.is(tok::ellipsis)) { 3377 IsVariadic = true; 3378 EllipsisLoc = ConsumeToken(); // Consume the ellipsis. 3379 3380 if (!getLang().CPlusPlus) { 3381 // We have ellipsis without a preceding ',', which is ill-formed 3382 // in C. Complain and provide the fix. 3383 Diag(EllipsisLoc, diag::err_missing_comma_before_ellipsis) 3384 << FixItHint::CreateInsertion(EllipsisLoc, ", "); 3385 } 3386 } 3387 3388 break; 3389 } 3390 3391 // Consume the comma. 3392 ConsumeToken(); 3393 } 3394 3395 // If we have the closing ')', eat it. 3396 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 3397 SourceLocation EndLoc = RParenLoc; 3398 3399 DeclSpec DS; 3400 SourceLocation RefQualifierLoc; 3401 bool RefQualifierIsLValueRef = true; 3402 ExceptionSpecificationType ESpecType = EST_None; 3403 SourceRange ESpecRange; 3404 llvm::SmallVector<ParsedType, 2> DynamicExceptions; 3405 llvm::SmallVector<SourceRange, 2> DynamicExceptionRanges; 3406 ExprResult NoexceptExpr; 3407 3408 if (getLang().CPlusPlus) { 3409 MaybeParseCXX0XAttributes(attrs); 3410 3411 // Parse cv-qualifier-seq[opt]. 3412 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 3413 if (!DS.getSourceRange().getEnd().isInvalid()) 3414 EndLoc = DS.getSourceRange().getEnd(); 3415 3416 // Parse ref-qualifier[opt] 3417 if (Tok.is(tok::amp) || Tok.is(tok::ampamp)) { 3418 if (!getLang().CPlusPlus0x) 3419 Diag(Tok, diag::ext_ref_qualifier); 3420 3421 RefQualifierIsLValueRef = Tok.is(tok::amp); 3422 RefQualifierLoc = ConsumeToken(); 3423 EndLoc = RefQualifierLoc; 3424 } 3425 3426 // FIXME: We should leave the prototype scope before parsing the exception 3427 // specification, and then reenter it when parsing the trailing return type. 3428 // FIXMEFIXME: Why? That wouldn't be right for the noexcept clause. 3429 3430 // Parse exception-specification[opt]. 3431 ESpecType = MaybeParseExceptionSpecification(ESpecRange, 3432 DynamicExceptions, 3433 DynamicExceptionRanges, 3434 NoexceptExpr); 3435 if (ESpecType != EST_None) 3436 EndLoc = ESpecRange.getEnd(); 3437 3438 // Parse trailing-return-type. 3439 if (getLang().CPlusPlus0x && Tok.is(tok::arrow)) { 3440 TrailingReturnType = ParseTrailingReturnType().get(); 3441 } 3442 } 3443 3444 // Leave prototype scope. 3445 PrototypeScope.Exit(); 3446 3447 // Remember that we parsed a function type, and remember the attributes. 3448 D.AddTypeInfo(DeclaratorChunk::getFunction(attrs, 3449 /*proto*/true, IsVariadic, 3450 EllipsisLoc, 3451 ParamInfo.data(), ParamInfo.size(), 3452 DS.getTypeQualifiers(), 3453 RefQualifierIsLValueRef, 3454 RefQualifierLoc, 3455 ESpecType, ESpecRange.getBegin(), 3456 DynamicExceptions.data(), 3457 DynamicExceptionRanges.data(), 3458 DynamicExceptions.size(), 3459 NoexceptExpr.isUsable() ? 3460 NoexceptExpr.get() : 0, 3461 LParenLoc, RParenLoc, D, 3462 TrailingReturnType), 3463 EndLoc); 3464} 3465 3466/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator 3467/// we found a K&R-style identifier list instead of a type argument list. The 3468/// first identifier has already been consumed, and the current token is the 3469/// token right after it. 3470/// 3471/// identifier-list: [C99 6.7.5] 3472/// identifier 3473/// identifier-list ',' identifier 3474/// 3475void Parser::ParseFunctionDeclaratorIdentifierList(SourceLocation LParenLoc, 3476 IdentifierInfo *FirstIdent, 3477 SourceLocation FirstIdentLoc, 3478 Declarator &D) { 3479 // Build up an array of information about the parsed arguments. 3480 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 3481 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar; 3482 3483 // If there was no identifier specified for the declarator, either we are in 3484 // an abstract-declarator, or we are in a parameter declarator which was found 3485 // to be abstract. In abstract-declarators, identifier lists are not valid: 3486 // diagnose this. 3487 if (!D.getIdentifier()) 3488 Diag(FirstIdentLoc, diag::ext_ident_list_in_param); 3489 3490 // The first identifier was already read, and is known to be the first 3491 // identifier in the list. Remember this identifier in ParamInfo. 3492 ParamsSoFar.insert(FirstIdent); 3493 ParamInfo.push_back(DeclaratorChunk::ParamInfo(FirstIdent, FirstIdentLoc, 0)); 3494 3495 while (Tok.is(tok::comma)) { 3496 // Eat the comma. 3497 ConsumeToken(); 3498 3499 // If this isn't an identifier, report the error and skip until ')'. 3500 if (Tok.isNot(tok::identifier)) { 3501 Diag(Tok, diag::err_expected_ident); 3502 SkipUntil(tok::r_paren); 3503 return; 3504 } 3505 3506 IdentifierInfo *ParmII = Tok.getIdentifierInfo(); 3507 3508 // Reject 'typedef int y; int test(x, y)', but continue parsing. 3509 if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope())) 3510 Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII; 3511 3512 // Verify that the argument identifier has not already been mentioned. 3513 if (!ParamsSoFar.insert(ParmII)) { 3514 Diag(Tok, diag::err_param_redefinition) << ParmII; 3515 } else { 3516 // Remember this identifier in ParamInfo. 3517 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 3518 Tok.getLocation(), 3519 0)); 3520 } 3521 3522 // Eat the identifier. 3523 ConsumeToken(); 3524 } 3525 3526 // If we have the closing ')', eat it and we're done. 3527 SourceLocation RLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 3528 3529 // Remember that we parsed a function type, and remember the attributes. This 3530 // function type is always a K&R style function type, which is not varargs and 3531 // has no prototype. 3532 D.AddTypeInfo(DeclaratorChunk::getFunction(ParsedAttributes(), 3533 /*proto*/false, /*varargs*/false, 3534 SourceLocation(), 3535 &ParamInfo[0], ParamInfo.size(), 3536 /*TypeQuals*/0, 3537 true, SourceLocation(), 3538 EST_None, SourceLocation(), 0, 0, 3539 0, 0, LParenLoc, RLoc, D), 3540 RLoc); 3541} 3542 3543/// [C90] direct-declarator '[' constant-expression[opt] ']' 3544/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 3545/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 3546/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 3547/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 3548void Parser::ParseBracketDeclarator(Declarator &D) { 3549 SourceLocation StartLoc = ConsumeBracket(); 3550 3551 // C array syntax has many features, but by-far the most common is [] and [4]. 3552 // This code does a fast path to handle some of the most obvious cases. 3553 if (Tok.getKind() == tok::r_square) { 3554 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 3555 ParsedAttributes attrs; 3556 MaybeParseCXX0XAttributes(attrs); 3557 3558 // Remember that we parsed the empty array type. 3559 ExprResult NumElements; 3560 D.AddTypeInfo(DeclaratorChunk::getArray(0, attrs, false, false, 0, 3561 StartLoc, EndLoc), 3562 EndLoc); 3563 return; 3564 } else if (Tok.getKind() == tok::numeric_constant && 3565 GetLookAheadToken(1).is(tok::r_square)) { 3566 // [4] is very common. Parse the numeric constant expression. 3567 ExprResult ExprRes(Actions.ActOnNumericConstant(Tok)); 3568 ConsumeToken(); 3569 3570 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 3571 ParsedAttributes attrs; 3572 MaybeParseCXX0XAttributes(attrs); 3573 3574 // Remember that we parsed a array type, and remember its features. 3575 D.AddTypeInfo(DeclaratorChunk::getArray(0, attrs, false, 0, 3576 ExprRes.release(), 3577 StartLoc, EndLoc), 3578 EndLoc); 3579 return; 3580 } 3581 3582 // If valid, this location is the position where we read the 'static' keyword. 3583 SourceLocation StaticLoc; 3584 if (Tok.is(tok::kw_static)) 3585 StaticLoc = ConsumeToken(); 3586 3587 // If there is a type-qualifier-list, read it now. 3588 // Type qualifiers in an array subscript are a C99 feature. 3589 DeclSpec DS; 3590 ParseTypeQualifierListOpt(DS, false /*no attributes*/); 3591 3592 // If we haven't already read 'static', check to see if there is one after the 3593 // type-qualifier-list. 3594 if (!StaticLoc.isValid() && Tok.is(tok::kw_static)) 3595 StaticLoc = ConsumeToken(); 3596 3597 // Handle "direct-declarator [ type-qual-list[opt] * ]". 3598 bool isStar = false; 3599 ExprResult NumElements; 3600 3601 // Handle the case where we have '[*]' as the array size. However, a leading 3602 // star could be the start of an expression, for example 'X[*p + 4]'. Verify 3603 // the the token after the star is a ']'. Since stars in arrays are 3604 // infrequent, use of lookahead is not costly here. 3605 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) { 3606 ConsumeToken(); // Eat the '*'. 3607 3608 if (StaticLoc.isValid()) { 3609 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static); 3610 StaticLoc = SourceLocation(); // Drop the static. 3611 } 3612 isStar = true; 3613 } else if (Tok.isNot(tok::r_square)) { 3614 // Note, in C89, this production uses the constant-expr production instead 3615 // of assignment-expr. The only difference is that assignment-expr allows 3616 // things like '=' and '*='. Sema rejects these in C89 mode because they 3617 // are not i-c-e's, so we don't need to distinguish between the two here. 3618 3619 // Parse the constant-expression or assignment-expression now (depending 3620 // on dialect). 3621 if (getLang().CPlusPlus) 3622 NumElements = ParseConstantExpression(); 3623 else 3624 NumElements = ParseAssignmentExpression(); 3625 } 3626 3627 // If there was an error parsing the assignment-expression, recover. 3628 if (NumElements.isInvalid()) { 3629 D.setInvalidType(true); 3630 // If the expression was invalid, skip it. 3631 SkipUntil(tok::r_square); 3632 return; 3633 } 3634 3635 SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc); 3636 3637 ParsedAttributes attrs; 3638 MaybeParseCXX0XAttributes(attrs); 3639 3640 // Remember that we parsed a array type, and remember its features. 3641 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(), attrs, 3642 StaticLoc.isValid(), isStar, 3643 NumElements.release(), 3644 StartLoc, EndLoc), 3645 EndLoc); 3646} 3647 3648/// [GNU] typeof-specifier: 3649/// typeof ( expressions ) 3650/// typeof ( type-name ) 3651/// [GNU/C++] typeof unary-expression 3652/// 3653void Parser::ParseTypeofSpecifier(DeclSpec &DS) { 3654 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier"); 3655 Token OpTok = Tok; 3656 SourceLocation StartLoc = ConsumeToken(); 3657 3658 const bool hasParens = Tok.is(tok::l_paren); 3659 3660 bool isCastExpr; 3661 ParsedType CastTy; 3662 SourceRange CastRange; 3663 ExprResult Operand = ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, 3664 CastTy, CastRange); 3665 if (hasParens) 3666 DS.setTypeofParensRange(CastRange); 3667 3668 if (CastRange.getEnd().isInvalid()) 3669 // FIXME: Not accurate, the range gets one token more than it should. 3670 DS.SetRangeEnd(Tok.getLocation()); 3671 else 3672 DS.SetRangeEnd(CastRange.getEnd()); 3673 3674 if (isCastExpr) { 3675 if (!CastTy) { 3676 DS.SetTypeSpecError(); 3677 return; 3678 } 3679 3680 const char *PrevSpec = 0; 3681 unsigned DiagID; 3682 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 3683 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, 3684 DiagID, CastTy)) 3685 Diag(StartLoc, DiagID) << PrevSpec; 3686 return; 3687 } 3688 3689 // If we get here, the operand to the typeof was an expresion. 3690 if (Operand.isInvalid()) { 3691 DS.SetTypeSpecError(); 3692 return; 3693 } 3694 3695 const char *PrevSpec = 0; 3696 unsigned DiagID; 3697 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 3698 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 3699 DiagID, Operand.get())) 3700 Diag(StartLoc, DiagID) << PrevSpec; 3701} 3702 3703 3704/// TryAltiVecVectorTokenOutOfLine - Out of line body that should only be called 3705/// from TryAltiVecVectorToken. 3706bool Parser::TryAltiVecVectorTokenOutOfLine() { 3707 Token Next = NextToken(); 3708 switch (Next.getKind()) { 3709 default: return false; 3710 case tok::kw_short: 3711 case tok::kw_long: 3712 case tok::kw_signed: 3713 case tok::kw_unsigned: 3714 case tok::kw_void: 3715 case tok::kw_char: 3716 case tok::kw_int: 3717 case tok::kw_float: 3718 case tok::kw_double: 3719 case tok::kw_bool: 3720 case tok::kw___pixel: 3721 Tok.setKind(tok::kw___vector); 3722 return true; 3723 case tok::identifier: 3724 if (Next.getIdentifierInfo() == Ident_pixel) { 3725 Tok.setKind(tok::kw___vector); 3726 return true; 3727 } 3728 return false; 3729 } 3730} 3731 3732bool Parser::TryAltiVecTokenOutOfLine(DeclSpec &DS, SourceLocation Loc, 3733 const char *&PrevSpec, unsigned &DiagID, 3734 bool &isInvalid) { 3735 if (Tok.getIdentifierInfo() == Ident_vector) { 3736 Token Next = NextToken(); 3737 switch (Next.getKind()) { 3738 case tok::kw_short: 3739 case tok::kw_long: 3740 case tok::kw_signed: 3741 case tok::kw_unsigned: 3742 case tok::kw_void: 3743 case tok::kw_char: 3744 case tok::kw_int: 3745 case tok::kw_float: 3746 case tok::kw_double: 3747 case tok::kw_bool: 3748 case tok::kw___pixel: 3749 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 3750 return true; 3751 case tok::identifier: 3752 if (Next.getIdentifierInfo() == Ident_pixel) { 3753 isInvalid = DS.SetTypeAltiVecVector(true, Loc, PrevSpec, DiagID); 3754 return true; 3755 } 3756 break; 3757 default: 3758 break; 3759 } 3760 } else if ((Tok.getIdentifierInfo() == Ident_pixel) && 3761 DS.isTypeAltiVecVector()) { 3762 isInvalid = DS.SetTypeAltiVecPixel(true, Loc, PrevSpec, DiagID); 3763 return true; 3764 } 3765 return false; 3766} 3767