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