ParseDecl.cpp revision 1bfe1c2129771c06fb58ae5e8c079ae30e138309
1//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Declaration portions of the Parser interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "clang/Basic/Diagnostic.h" 16#include "clang/Parse/DeclSpec.h" 17#include "clang/Parse/Scope.h" 18#include "llvm/ADT/SmallSet.h" 19using namespace clang; 20 21//===----------------------------------------------------------------------===// 22// C99 6.7: Declarations. 23//===----------------------------------------------------------------------===// 24 25/// ParseTypeName 26/// type-name: [C99 6.7.6] 27/// specifier-qualifier-list abstract-declarator[opt] 28Parser::TypeTy *Parser::ParseTypeName() { 29 // Parse the common declaration-specifiers piece. 30 DeclSpec DS; 31 ParseSpecifierQualifierList(DS); 32 33 // Parse the abstract-declarator, if present. 34 Declarator DeclaratorInfo(DS, Declarator::TypeNameContext); 35 ParseDeclarator(DeclaratorInfo); 36 37 return Actions.ActOnTypeName(CurScope, DeclaratorInfo).Val; 38} 39 40/// ParseAttributes - Parse a non-empty attributes list. 41/// 42/// [GNU] attributes: 43/// attribute 44/// attributes attribute 45/// 46/// [GNU] attribute: 47/// '__attribute__' '(' '(' attribute-list ')' ')' 48/// 49/// [GNU] attribute-list: 50/// attrib 51/// attribute_list ',' attrib 52/// 53/// [GNU] attrib: 54/// empty 55/// attrib-name 56/// attrib-name '(' identifier ')' 57/// attrib-name '(' identifier ',' nonempty-expr-list ')' 58/// attrib-name '(' argument-expression-list [C99 6.5.2] ')' 59/// 60/// [GNU] attrib-name: 61/// identifier 62/// typespec 63/// typequal 64/// storageclass 65/// 66/// FIXME: The GCC grammar/code for this construct implies we need two 67/// token lookahead. Comment from gcc: "If they start with an identifier 68/// which is followed by a comma or close parenthesis, then the arguments 69/// start with that identifier; otherwise they are an expression list." 70/// 71/// At the moment, I am not doing 2 token lookahead. I am also unaware of 72/// any attributes that don't work (based on my limited testing). Most 73/// attributes are very simple in practice. Until we find a bug, I don't see 74/// a pressing need to implement the 2 token lookahead. 75 76AttributeList *Parser::ParseAttributes() { 77 assert(Tok.is(tok::kw___attribute) && "Not an attribute list!"); 78 79 AttributeList *CurrAttr = 0; 80 81 while (Tok.is(tok::kw___attribute)) { 82 ConsumeToken(); 83 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, 84 "attribute")) { 85 SkipUntil(tok::r_paren, true); // skip until ) or ; 86 return CurrAttr; 87 } 88 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) { 89 SkipUntil(tok::r_paren, true); // skip until ) or ; 90 return CurrAttr; 91 } 92 // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") )) 93 while (Tok.is(tok::identifier) || isDeclarationSpecifier() || 94 Tok.is(tok::comma)) { 95 96 if (Tok.is(tok::comma)) { 97 // allows for empty/non-empty attributes. ((__vector_size__(16),,,,)) 98 ConsumeToken(); 99 continue; 100 } 101 // we have an identifier or declaration specifier (const, int, etc.) 102 IdentifierInfo *AttrName = Tok.getIdentifierInfo(); 103 SourceLocation AttrNameLoc = ConsumeToken(); 104 105 // check if we have a "paramterized" attribute 106 if (Tok.is(tok::l_paren)) { 107 ConsumeParen(); // ignore the left paren loc for now 108 109 if (Tok.is(tok::identifier)) { 110 IdentifierInfo *ParmName = Tok.getIdentifierInfo(); 111 SourceLocation ParmLoc = ConsumeToken(); 112 113 if (Tok.is(tok::r_paren)) { 114 // __attribute__(( mode(byte) )) 115 ConsumeParen(); // ignore the right paren loc for now 116 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 117 ParmName, ParmLoc, 0, 0, CurrAttr); 118 } else if (Tok.is(tok::comma)) { 119 ConsumeToken(); 120 // __attribute__(( format(printf, 1, 2) )) 121 llvm::SmallVector<ExprTy*, 8> ArgExprs; 122 bool ArgExprsOk = true; 123 124 // now parse the non-empty comma separated list of expressions 125 while (1) { 126 ExprResult ArgExpr = ParseAssignmentExpression(); 127 if (ArgExpr.isInvalid) { 128 ArgExprsOk = false; 129 SkipUntil(tok::r_paren); 130 break; 131 } else { 132 ArgExprs.push_back(ArgExpr.Val); 133 } 134 if (Tok.isNot(tok::comma)) 135 break; 136 ConsumeToken(); // Eat the comma, move to the next argument 137 } 138 if (ArgExprsOk && Tok.is(tok::r_paren)) { 139 ConsumeParen(); // ignore the right paren loc for now 140 CurrAttr = new AttributeList(AttrName, AttrNameLoc, ParmName, 141 ParmLoc, &ArgExprs[0], ArgExprs.size(), CurrAttr); 142 } 143 } 144 } else { // not an identifier 145 // parse a possibly empty comma separated list of expressions 146 if (Tok.is(tok::r_paren)) { 147 // __attribute__(( nonnull() )) 148 ConsumeParen(); // ignore the right paren loc for now 149 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 150 0, SourceLocation(), 0, 0, CurrAttr); 151 } else { 152 // __attribute__(( aligned(16) )) 153 llvm::SmallVector<ExprTy*, 8> ArgExprs; 154 bool ArgExprsOk = true; 155 156 // now parse the list of expressions 157 while (1) { 158 ExprResult ArgExpr = ParseAssignmentExpression(); 159 if (ArgExpr.isInvalid) { 160 ArgExprsOk = false; 161 SkipUntil(tok::r_paren); 162 break; 163 } else { 164 ArgExprs.push_back(ArgExpr.Val); 165 } 166 if (Tok.isNot(tok::comma)) 167 break; 168 ConsumeToken(); // Eat the comma, move to the next argument 169 } 170 // Match the ')'. 171 if (ArgExprsOk && Tok.is(tok::r_paren)) { 172 ConsumeParen(); // ignore the right paren loc for now 173 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0, 174 SourceLocation(), &ArgExprs[0], ArgExprs.size(), 175 CurrAttr); 176 } 177 } 178 } 179 } else { 180 CurrAttr = new AttributeList(AttrName, AttrNameLoc, 181 0, SourceLocation(), 0, 0, CurrAttr); 182 } 183 } 184 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 185 SkipUntil(tok::r_paren, false); 186 if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) 187 SkipUntil(tok::r_paren, false); 188 } 189 return CurrAttr; 190} 191 192/// ParseDeclaration - Parse a full 'declaration', which consists of 193/// declaration-specifiers, some number of declarators, and a semicolon. 194/// 'Context' should be a Declarator::TheContext value. 195/// 196/// declaration: [C99 6.7] 197/// block-declaration -> 198/// simple-declaration 199/// others [FIXME] 200/// [C++] namespace-definition 201/// others... [FIXME] 202/// 203Parser::DeclTy *Parser::ParseDeclaration(unsigned Context) { 204 switch (Tok.getKind()) { 205 case tok::kw_namespace: 206 return ParseNamespace(Context); 207 default: 208 return ParseSimpleDeclaration(Context); 209 } 210} 211 212/// simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl] 213/// declaration-specifiers init-declarator-list[opt] ';' 214///[C90/C++]init-declarator-list ';' [TODO] 215/// [OMP] threadprivate-directive [TODO] 216Parser::DeclTy *Parser::ParseSimpleDeclaration(unsigned Context) { 217 // Parse the common declaration-specifiers piece. 218 DeclSpec DS; 219 ParseDeclarationSpecifiers(DS); 220 221 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };" 222 // declaration-specifiers init-declarator-list[opt] ';' 223 if (Tok.is(tok::semi)) { 224 ConsumeToken(); 225 return Actions.ParsedFreeStandingDeclSpec(CurScope, DS); 226 } 227 228 Declarator DeclaratorInfo(DS, (Declarator::TheContext)Context); 229 ParseDeclarator(DeclaratorInfo); 230 231 return ParseInitDeclaratorListAfterFirstDeclarator(DeclaratorInfo); 232} 233 234 235/// ParseInitDeclaratorListAfterFirstDeclarator - Parse 'declaration' after 236/// parsing 'declaration-specifiers declarator'. This method is split out this 237/// way to handle the ambiguity between top-level function-definitions and 238/// declarations. 239/// 240/// init-declarator-list: [C99 6.7] 241/// init-declarator 242/// init-declarator-list ',' init-declarator 243/// init-declarator: [C99 6.7] 244/// declarator 245/// declarator '=' initializer 246/// [GNU] declarator simple-asm-expr[opt] attributes[opt] 247/// [GNU] declarator simple-asm-expr[opt] attributes[opt] '=' initializer 248/// 249Parser::DeclTy *Parser:: 250ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) { 251 252 // Declarators may be grouped together ("int X, *Y, Z();"). Provide info so 253 // that they can be chained properly if the actions want this. 254 Parser::DeclTy *LastDeclInGroup = 0; 255 256 // At this point, we know that it is not a function definition. Parse the 257 // rest of the init-declarator-list. 258 while (1) { 259 // If a simple-asm-expr is present, parse it. 260 if (Tok.is(tok::kw_asm)) { 261 ExprResult AsmLabel = ParseSimpleAsm(); 262 if (AsmLabel.isInvalid) { 263 SkipUntil(tok::semi); 264 return 0; 265 } 266 267 D.setAsmLabel(AsmLabel.Val); 268 } 269 270 // If attributes are present, parse them. 271 if (Tok.is(tok::kw___attribute)) 272 D.AddAttributes(ParseAttributes()); 273 274 // Inform the current actions module that we just parsed this declarator. 275 // FIXME: pass asm & attributes. 276 LastDeclInGroup = Actions.ActOnDeclarator(CurScope, D, LastDeclInGroup); 277 278 // Parse declarator '=' initializer. 279 if (Tok.is(tok::equal)) { 280 ConsumeToken(); 281 ExprResult Init = ParseInitializer(); 282 if (Init.isInvalid) { 283 SkipUntil(tok::semi); 284 return 0; 285 } 286 Actions.AddInitializerToDecl(LastDeclInGroup, Init.Val); 287 } 288 289 // If we don't have a comma, it is either the end of the list (a ';') or an 290 // error, bail out. 291 if (Tok.isNot(tok::comma)) 292 break; 293 294 // Consume the comma. 295 ConsumeToken(); 296 297 // Parse the next declarator. 298 D.clear(); 299 ParseDeclarator(D); 300 } 301 302 if (Tok.is(tok::semi)) { 303 ConsumeToken(); 304 return Actions.FinalizeDeclaratorGroup(CurScope, LastDeclInGroup); 305 } 306 // If this is an ObjC2 for-each loop, this is a successful declarator 307 // parse. The syntax for these looks like: 308 // 'for' '(' declaration 'in' expr ')' statement 309 if (D.getContext() == Declarator::ForContext && isTokIdentifier_in()) { 310 return Actions.FinalizeDeclaratorGroup(CurScope, LastDeclInGroup); 311 } 312 Diag(Tok, diag::err_parse_error); 313 // Skip to end of block or statement 314 SkipUntil(tok::r_brace, true, true); 315 if (Tok.is(tok::semi)) 316 ConsumeToken(); 317 return 0; 318} 319 320/// ParseSpecifierQualifierList 321/// specifier-qualifier-list: 322/// type-specifier specifier-qualifier-list[opt] 323/// type-qualifier specifier-qualifier-list[opt] 324/// [GNU] attributes specifier-qualifier-list[opt] 325/// 326void Parser::ParseSpecifierQualifierList(DeclSpec &DS) { 327 /// specifier-qualifier-list is a subset of declaration-specifiers. Just 328 /// parse declaration-specifiers and complain about extra stuff. 329 ParseDeclarationSpecifiers(DS); 330 331 // Validate declspec for type-name. 332 unsigned Specs = DS.getParsedSpecifiers(); 333 if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers()) 334 Diag(Tok, diag::err_typename_requires_specqual); 335 336 // Issue diagnostic and remove storage class if present. 337 if (Specs & DeclSpec::PQ_StorageClassSpecifier) { 338 if (DS.getStorageClassSpecLoc().isValid()) 339 Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass); 340 else 341 Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass); 342 DS.ClearStorageClassSpecs(); 343 } 344 345 // Issue diagnostic and remove function specfier if present. 346 if (Specs & DeclSpec::PQ_FunctionSpecifier) { 347 Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec); 348 DS.ClearFunctionSpecs(); 349 } 350} 351 352/// ParseDeclarationSpecifiers 353/// declaration-specifiers: [C99 6.7] 354/// storage-class-specifier declaration-specifiers[opt] 355/// type-specifier declaration-specifiers[opt] 356/// type-qualifier declaration-specifiers[opt] 357/// [C99] function-specifier declaration-specifiers[opt] 358/// [GNU] attributes declaration-specifiers[opt] 359/// 360/// storage-class-specifier: [C99 6.7.1] 361/// 'typedef' 362/// 'extern' 363/// 'static' 364/// 'auto' 365/// 'register' 366/// [GNU] '__thread' 367/// type-specifier: [C99 6.7.2] 368/// 'void' 369/// 'char' 370/// 'short' 371/// 'int' 372/// 'long' 373/// 'float' 374/// 'double' 375/// 'signed' 376/// 'unsigned' 377/// struct-or-union-specifier 378/// enum-specifier 379/// typedef-name 380/// [C++] 'wchar_t' 381/// [C++] 'bool' 382/// [C99] '_Bool' 383/// [C99] '_Complex' 384/// [C99] '_Imaginary' // Removed in TC2? 385/// [GNU] '_Decimal32' 386/// [GNU] '_Decimal64' 387/// [GNU] '_Decimal128' 388/// [GNU] typeof-specifier 389/// [OBJC] class-name objc-protocol-refs[opt] [TODO] 390/// [OBJC] typedef-name objc-protocol-refs[opt] [TODO] 391/// type-qualifier: 392/// 'const' 393/// 'volatile' 394/// [C99] 'restrict' 395/// function-specifier: [C99 6.7.4] 396/// [C99] 'inline' 397/// 398void Parser::ParseDeclarationSpecifiers(DeclSpec &DS) { 399 DS.SetRangeStart(Tok.getLocation()); 400 while (1) { 401 int isInvalid = false; 402 const char *PrevSpec = 0; 403 SourceLocation Loc = Tok.getLocation(); 404 405 switch (Tok.getKind()) { 406 default: 407 DoneWithDeclSpec: 408 // If this is not a declaration specifier token, we're done reading decl 409 // specifiers. First verify that DeclSpec's are consistent. 410 DS.Finish(Diags, PP.getSourceManager(), getLang()); 411 return; 412 413 // typedef-name 414 case tok::identifier: { 415 // This identifier can only be a typedef name if we haven't already seen 416 // a type-specifier. Without this check we misparse: 417 // typedef int X; struct Y { short X; }; as 'short int'. 418 if (DS.hasTypeSpecifier()) 419 goto DoneWithDeclSpec; 420 421 // It has to be available as a typedef too! 422 TypeTy *TypeRep = Actions.isTypeName(*Tok.getIdentifierInfo(), CurScope); 423 if (TypeRep == 0) 424 goto DoneWithDeclSpec; 425 426 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typedef, Loc, PrevSpec, 427 TypeRep); 428 if (isInvalid) 429 break; 430 431 DS.SetRangeEnd(Tok.getLocation()); 432 ConsumeToken(); // The identifier 433 434 // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id' 435 // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an 436 // Objective-C interface. If we don't have Objective-C or a '<', this is 437 // just a normal reference to a typedef name. 438 if (!Tok.is(tok::less) || !getLang().ObjC1) 439 continue; 440 441 SourceLocation EndProtoLoc; 442 llvm::SmallVector<DeclTy *, 8> ProtocolDecl; 443 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc); 444 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size()); 445 446 DS.SetRangeEnd(EndProtoLoc); 447 448 // Need to support trailing type qualifiers (e.g. "id<p> const"). 449 // If a type specifier follows, it will be diagnosed elsewhere. 450 continue; 451 } 452 // GNU attributes support. 453 case tok::kw___attribute: 454 DS.AddAttributes(ParseAttributes()); 455 continue; 456 457 // storage-class-specifier 458 case tok::kw_typedef: 459 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec); 460 break; 461 case tok::kw_extern: 462 if (DS.isThreadSpecified()) 463 Diag(Tok, diag::ext_thread_before, "extern"); 464 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_extern, Loc, PrevSpec); 465 break; 466 case tok::kw___private_extern__: 467 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_private_extern, Loc, 468 PrevSpec); 469 break; 470 case tok::kw_static: 471 if (DS.isThreadSpecified()) 472 Diag(Tok, diag::ext_thread_before, "static"); 473 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_static, Loc, PrevSpec); 474 break; 475 case tok::kw_auto: 476 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec); 477 break; 478 case tok::kw_register: 479 isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_register, Loc, PrevSpec); 480 break; 481 case tok::kw___thread: 482 isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec)*2; 483 break; 484 485 // type-specifiers 486 case tok::kw_short: 487 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec); 488 break; 489 case tok::kw_long: 490 if (DS.getTypeSpecWidth() != DeclSpec::TSW_long) 491 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec); 492 else 493 isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec); 494 break; 495 case tok::kw_signed: 496 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec); 497 break; 498 case tok::kw_unsigned: 499 isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec); 500 break; 501 case tok::kw__Complex: 502 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec); 503 break; 504 case tok::kw__Imaginary: 505 isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec); 506 break; 507 case tok::kw_void: 508 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec); 509 break; 510 case tok::kw_char: 511 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec); 512 break; 513 case tok::kw_int: 514 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec); 515 break; 516 case tok::kw_float: 517 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec); 518 break; 519 case tok::kw_double: 520 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec); 521 break; 522 case tok::kw_wchar_t: // [C++ 2.11p1] 523 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec); 524 break; 525 case tok::kw_bool: // [C++ 2.11p1] 526 case tok::kw__Bool: 527 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec); 528 break; 529 case tok::kw__Decimal32: 530 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec); 531 break; 532 case tok::kw__Decimal64: 533 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec); 534 break; 535 case tok::kw__Decimal128: 536 isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec); 537 break; 538 539 case tok::kw_class: 540 case tok::kw_struct: 541 case tok::kw_union: 542 ParseClassSpecifier(DS); 543 continue; 544 case tok::kw_enum: 545 ParseEnumSpecifier(DS); 546 continue; 547 548 // GNU typeof support. 549 case tok::kw_typeof: 550 ParseTypeofSpecifier(DS); 551 continue; 552 553 // type-qualifier 554 case tok::kw_const: 555 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, 556 getLang())*2; 557 break; 558 case tok::kw_volatile: 559 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 560 getLang())*2; 561 break; 562 case tok::kw_restrict: 563 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 564 getLang())*2; 565 break; 566 567 // function-specifier 568 case tok::kw_inline: 569 isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec); 570 break; 571 572 case tok::less: 573 // GCC ObjC supports types like "<SomeProtocol>" as a synonym for 574 // "id<SomeProtocol>". This is hopelessly old fashioned and dangerous, 575 // but we support it. 576 if (DS.hasTypeSpecifier() || !getLang().ObjC1) 577 goto DoneWithDeclSpec; 578 579 { 580 SourceLocation EndProtoLoc; 581 llvm::SmallVector<DeclTy *, 8> ProtocolDecl; 582 ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc); 583 DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size()); 584 DS.SetRangeEnd(EndProtoLoc); 585 586 Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id, 587 SourceRange(Loc, EndProtoLoc)); 588 // Need to support trailing type qualifiers (e.g. "id<p> const"). 589 // If a type specifier follows, it will be diagnosed elsewhere. 590 continue; 591 } 592 } 593 // If the specifier combination wasn't legal, issue a diagnostic. 594 if (isInvalid) { 595 assert(PrevSpec && "Method did not return previous specifier!"); 596 if (isInvalid == 1) // Error. 597 Diag(Tok, diag::err_invalid_decl_spec_combination, PrevSpec); 598 else // extwarn. 599 Diag(Tok, diag::ext_duplicate_declspec, PrevSpec); 600 } 601 DS.SetRangeEnd(Tok.getLocation()); 602 ConsumeToken(); 603 } 604} 605 606/// ParseStructDeclaration - Parse a struct declaration without the terminating 607/// semicolon. 608/// 609/// struct-declaration: 610/// specifier-qualifier-list struct-declarator-list 611/// [GNU] __extension__ struct-declaration 612/// [GNU] specifier-qualifier-list 613/// struct-declarator-list: 614/// struct-declarator 615/// struct-declarator-list ',' struct-declarator 616/// [GNU] struct-declarator-list ',' attributes[opt] struct-declarator 617/// struct-declarator: 618/// declarator 619/// [GNU] declarator attributes[opt] 620/// declarator[opt] ':' constant-expression 621/// [GNU] declarator[opt] ':' constant-expression attributes[opt] 622/// 623void Parser:: 624ParseStructDeclaration(DeclSpec &DS, 625 llvm::SmallVectorImpl<FieldDeclarator> &Fields) { 626 // FIXME: When __extension__ is specified, disable extension diagnostics. 627 while (Tok.is(tok::kw___extension__)) 628 ConsumeToken(); 629 630 // Parse the common specifier-qualifiers-list piece. 631 SourceLocation DSStart = Tok.getLocation(); 632 ParseSpecifierQualifierList(DS); 633 // TODO: Does specifier-qualifier list correctly check that *something* is 634 // specified? 635 636 // If there are no declarators, issue a warning. 637 if (Tok.is(tok::semi)) { 638 Diag(DSStart, diag::w_no_declarators); 639 return; 640 } 641 642 // Read struct-declarators until we find the semicolon. 643 Fields.push_back(FieldDeclarator(DS)); 644 while (1) { 645 FieldDeclarator &DeclaratorInfo = Fields.back(); 646 647 /// struct-declarator: declarator 648 /// struct-declarator: declarator[opt] ':' constant-expression 649 if (Tok.isNot(tok::colon)) 650 ParseDeclarator(DeclaratorInfo.D); 651 652 if (Tok.is(tok::colon)) { 653 ConsumeToken(); 654 ExprResult Res = ParseConstantExpression(); 655 if (Res.isInvalid) 656 SkipUntil(tok::semi, true, true); 657 else 658 DeclaratorInfo.BitfieldSize = Res.Val; 659 } 660 661 // If attributes exist after the declarator, parse them. 662 if (Tok.is(tok::kw___attribute)) 663 DeclaratorInfo.D.AddAttributes(ParseAttributes()); 664 665 // If we don't have a comma, it is either the end of the list (a ';') 666 // or an error, bail out. 667 if (Tok.isNot(tok::comma)) 668 return; 669 670 // Consume the comma. 671 ConsumeToken(); 672 673 // Parse the next declarator. 674 Fields.push_back(FieldDeclarator(DS)); 675 676 // Attributes are only allowed on the second declarator. 677 if (Tok.is(tok::kw___attribute)) 678 Fields.back().D.AddAttributes(ParseAttributes()); 679 } 680} 681 682/// ParseStructUnionBody 683/// struct-contents: 684/// struct-declaration-list 685/// [EXT] empty 686/// [GNU] "struct-declaration-list" without terminatoring ';' 687/// struct-declaration-list: 688/// struct-declaration 689/// struct-declaration-list struct-declaration 690/// [OBC] '@' 'defs' '(' class-name ')' 691/// 692void Parser::ParseStructUnionBody(SourceLocation RecordLoc, 693 unsigned TagType, DeclTy *TagDecl) { 694 SourceLocation LBraceLoc = ConsumeBrace(); 695 696 // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in 697 // C++. 698 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 699 Diag(Tok, diag::ext_empty_struct_union_enum, 700 DeclSpec::getSpecifierName((DeclSpec::TST)TagType)); 701 702 llvm::SmallVector<DeclTy*, 32> FieldDecls; 703 llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators; 704 705 // While we still have something to read, read the declarations in the struct. 706 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 707 // Each iteration of this loop reads one struct-declaration. 708 709 // Check for extraneous top-level semicolon. 710 if (Tok.is(tok::semi)) { 711 Diag(Tok, diag::ext_extra_struct_semi); 712 ConsumeToken(); 713 continue; 714 } 715 716 // Parse all the comma separated declarators. 717 DeclSpec DS; 718 FieldDeclarators.clear(); 719 if (!Tok.is(tok::at)) { 720 ParseStructDeclaration(DS, FieldDeclarators); 721 722 // Convert them all to fields. 723 for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) { 724 FieldDeclarator &FD = FieldDeclarators[i]; 725 // Install the declarator into the current TagDecl. 726 DeclTy *Field = Actions.ActOnField(CurScope, 727 DS.getSourceRange().getBegin(), 728 FD.D, FD.BitfieldSize); 729 FieldDecls.push_back(Field); 730 } 731 } else { // Handle @defs 732 ConsumeToken(); 733 if (!Tok.isObjCAtKeyword(tok::objc_defs)) { 734 Diag(Tok, diag::err_unexpected_at); 735 SkipUntil(tok::semi, true, true); 736 continue; 737 } 738 ConsumeToken(); 739 ExpectAndConsume(tok::l_paren, diag::err_expected_lparen); 740 if (!Tok.is(tok::identifier)) { 741 Diag(Tok, diag::err_expected_ident); 742 SkipUntil(tok::semi, true, true); 743 continue; 744 } 745 llvm::SmallVector<DeclTy*, 16> Fields; 746 Actions.ActOnDefs(CurScope, Tok.getLocation(), Tok.getIdentifierInfo(), 747 Fields); 748 FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end()); 749 ConsumeToken(); 750 ExpectAndConsume(tok::r_paren, diag::err_expected_rparen); 751 } 752 753 if (Tok.is(tok::semi)) { 754 ConsumeToken(); 755 } else if (Tok.is(tok::r_brace)) { 756 Diag(Tok.getLocation(), diag::ext_expected_semi_decl_list); 757 break; 758 } else { 759 Diag(Tok, diag::err_expected_semi_decl_list); 760 // Skip to end of block or statement 761 SkipUntil(tok::r_brace, true, true); 762 } 763 } 764 765 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 766 767 AttributeList *AttrList = 0; 768 // If attributes exist after struct contents, parse them. 769 if (Tok.is(tok::kw___attribute)) 770 AttrList = ParseAttributes(); // FIXME: where should I put them? 771 772 Actions.ActOnFields(CurScope, 773 RecordLoc,TagDecl,&FieldDecls[0],FieldDecls.size(), 774 LBraceLoc, RBraceLoc, 775 AttrList); 776} 777 778 779/// ParseEnumSpecifier 780/// enum-specifier: [C99 6.7.2.2] 781/// 'enum' identifier[opt] '{' enumerator-list '}' 782/// [C99] 'enum' identifier[opt] '{' enumerator-list ',' '}' 783/// [GNU] 'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt] 784/// '}' attributes[opt] 785/// 'enum' identifier 786/// [GNU] 'enum' attributes[opt] identifier 787void Parser::ParseEnumSpecifier(DeclSpec &DS) { 788 assert(Tok.is(tok::kw_enum) && "Not an enum specifier"); 789 SourceLocation StartLoc = ConsumeToken(); 790 791 // Parse the tag portion of this. 792 793 AttributeList *Attr = 0; 794 // If attributes exist after tag, parse them. 795 if (Tok.is(tok::kw___attribute)) 796 Attr = ParseAttributes(); 797 798 // Must have either 'enum name' or 'enum {...}'. 799 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace)) { 800 Diag(Tok, diag::err_expected_ident_lbrace); 801 802 // Skip the rest of this declarator, up until the comma or semicolon. 803 SkipUntil(tok::comma, true); 804 return; 805 } 806 807 // If an identifier is present, consume and remember it. 808 IdentifierInfo *Name = 0; 809 SourceLocation NameLoc; 810 if (Tok.is(tok::identifier)) { 811 Name = Tok.getIdentifierInfo(); 812 NameLoc = ConsumeToken(); 813 } 814 815 // There are three options here. If we have 'enum foo;', then this is a 816 // forward declaration. If we have 'enum foo {...' then this is a 817 // definition. Otherwise we have something like 'enum foo xyz', a reference. 818 // 819 // This is needed to handle stuff like this right (C99 6.7.2.3p11): 820 // enum foo {..}; void bar() { enum foo; } <- new foo in bar. 821 // enum foo {..}; void bar() { enum foo x; } <- use of old foo. 822 // 823 Action::TagKind TK; 824 if (Tok.is(tok::l_brace)) 825 TK = Action::TK_Definition; 826 else if (Tok.is(tok::semi)) 827 TK = Action::TK_Declaration; 828 else 829 TK = Action::TK_Reference; 830 DeclTy *TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TK, StartLoc, 831 Name, NameLoc, Attr); 832 833 if (Tok.is(tok::l_brace)) 834 ParseEnumBody(StartLoc, TagDecl); 835 836 // TODO: semantic analysis on the declspec for enums. 837 const char *PrevSpec = 0; 838 if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, PrevSpec, TagDecl)) 839 Diag(StartLoc, diag::err_invalid_decl_spec_combination, PrevSpec); 840} 841 842/// ParseEnumBody - Parse a {} enclosed enumerator-list. 843/// enumerator-list: 844/// enumerator 845/// enumerator-list ',' enumerator 846/// enumerator: 847/// enumeration-constant 848/// enumeration-constant '=' constant-expression 849/// enumeration-constant: 850/// identifier 851/// 852void Parser::ParseEnumBody(SourceLocation StartLoc, DeclTy *EnumDecl) { 853 SourceLocation LBraceLoc = ConsumeBrace(); 854 855 // C does not allow an empty enumerator-list, C++ does [dcl.enum]. 856 if (Tok.is(tok::r_brace) && !getLang().CPlusPlus) 857 Diag(Tok, diag::ext_empty_struct_union_enum, "enum"); 858 859 llvm::SmallVector<DeclTy*, 32> EnumConstantDecls; 860 861 DeclTy *LastEnumConstDecl = 0; 862 863 // Parse the enumerator-list. 864 while (Tok.is(tok::identifier)) { 865 IdentifierInfo *Ident = Tok.getIdentifierInfo(); 866 SourceLocation IdentLoc = ConsumeToken(); 867 868 SourceLocation EqualLoc; 869 ExprTy *AssignedVal = 0; 870 if (Tok.is(tok::equal)) { 871 EqualLoc = ConsumeToken(); 872 ExprResult Res = ParseConstantExpression(); 873 if (Res.isInvalid) 874 SkipUntil(tok::comma, tok::r_brace, true, true); 875 else 876 AssignedVal = Res.Val; 877 } 878 879 // Install the enumerator constant into EnumDecl. 880 DeclTy *EnumConstDecl = Actions.ActOnEnumConstant(CurScope, EnumDecl, 881 LastEnumConstDecl, 882 IdentLoc, Ident, 883 EqualLoc, AssignedVal); 884 EnumConstantDecls.push_back(EnumConstDecl); 885 LastEnumConstDecl = EnumConstDecl; 886 887 if (Tok.isNot(tok::comma)) 888 break; 889 SourceLocation CommaLoc = ConsumeToken(); 890 891 if (Tok.isNot(tok::identifier) && !getLang().C99) 892 Diag(CommaLoc, diag::ext_c99_enumerator_list_comma); 893 } 894 895 // Eat the }. 896 MatchRHSPunctuation(tok::r_brace, LBraceLoc); 897 898 Actions.ActOnEnumBody(StartLoc, EnumDecl, &EnumConstantDecls[0], 899 EnumConstantDecls.size()); 900 901 DeclTy *AttrList = 0; 902 // If attributes exist after the identifier list, parse them. 903 if (Tok.is(tok::kw___attribute)) 904 AttrList = ParseAttributes(); // FIXME: where do they do? 905} 906 907/// isTypeSpecifierQualifier - Return true if the current token could be the 908/// start of a type-qualifier-list. 909bool Parser::isTypeQualifier() const { 910 switch (Tok.getKind()) { 911 default: return false; 912 // type-qualifier 913 case tok::kw_const: 914 case tok::kw_volatile: 915 case tok::kw_restrict: 916 return true; 917 } 918} 919 920/// isTypeSpecifierQualifier - Return true if the current token could be the 921/// start of a specifier-qualifier-list. 922bool Parser::isTypeSpecifierQualifier() const { 923 switch (Tok.getKind()) { 924 default: return false; 925 // GNU attributes support. 926 case tok::kw___attribute: 927 // GNU typeof support. 928 case tok::kw_typeof: 929 // GNU bizarre protocol extension. FIXME: make an extension? 930 case tok::less: 931 932 // type-specifiers 933 case tok::kw_short: 934 case tok::kw_long: 935 case tok::kw_signed: 936 case tok::kw_unsigned: 937 case tok::kw__Complex: 938 case tok::kw__Imaginary: 939 case tok::kw_void: 940 case tok::kw_char: 941 case tok::kw_wchar_t: 942 case tok::kw_int: 943 case tok::kw_float: 944 case tok::kw_double: 945 case tok::kw_bool: 946 case tok::kw__Bool: 947 case tok::kw__Decimal32: 948 case tok::kw__Decimal64: 949 case tok::kw__Decimal128: 950 951 // struct-or-union-specifier (C99) or class-specifier (C++) 952 case tok::kw_class: 953 case tok::kw_struct: 954 case tok::kw_union: 955 // enum-specifier 956 case tok::kw_enum: 957 958 // type-qualifier 959 case tok::kw_const: 960 case tok::kw_volatile: 961 case tok::kw_restrict: 962 return true; 963 964 // typedef-name 965 case tok::identifier: 966 return Actions.isTypeName(*Tok.getIdentifierInfo(), CurScope) != 0; 967 } 968} 969 970/// isDeclarationSpecifier() - Return true if the current token is part of a 971/// declaration specifier. 972bool Parser::isDeclarationSpecifier() const { 973 switch (Tok.getKind()) { 974 default: return false; 975 // storage-class-specifier 976 case tok::kw_typedef: 977 case tok::kw_extern: 978 case tok::kw___private_extern__: 979 case tok::kw_static: 980 case tok::kw_auto: 981 case tok::kw_register: 982 case tok::kw___thread: 983 984 // type-specifiers 985 case tok::kw_short: 986 case tok::kw_long: 987 case tok::kw_signed: 988 case tok::kw_unsigned: 989 case tok::kw__Complex: 990 case tok::kw__Imaginary: 991 case tok::kw_void: 992 case tok::kw_char: 993 case tok::kw_wchar_t: 994 case tok::kw_int: 995 case tok::kw_float: 996 case tok::kw_double: 997 case tok::kw_bool: 998 case tok::kw__Bool: 999 case tok::kw__Decimal32: 1000 case tok::kw__Decimal64: 1001 case tok::kw__Decimal128: 1002 1003 // struct-or-union-specifier (C99) or class-specifier (C++) 1004 case tok::kw_class: 1005 case tok::kw_struct: 1006 case tok::kw_union: 1007 // enum-specifier 1008 case tok::kw_enum: 1009 1010 // type-qualifier 1011 case tok::kw_const: 1012 case tok::kw_volatile: 1013 case tok::kw_restrict: 1014 1015 // function-specifier 1016 case tok::kw_inline: 1017 1018 // GNU typeof support. 1019 case tok::kw_typeof: 1020 1021 // GNU attributes. 1022 case tok::kw___attribute: 1023 return true; 1024 1025 // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'. 1026 case tok::less: 1027 return getLang().ObjC1; 1028 1029 // typedef-name 1030 case tok::identifier: 1031 return Actions.isTypeName(*Tok.getIdentifierInfo(), CurScope) != 0; 1032 } 1033} 1034 1035 1036/// ParseTypeQualifierListOpt 1037/// type-qualifier-list: [C99 6.7.5] 1038/// type-qualifier 1039/// [GNU] attributes 1040/// type-qualifier-list type-qualifier 1041/// [GNU] type-qualifier-list attributes 1042/// 1043void Parser::ParseTypeQualifierListOpt(DeclSpec &DS) { 1044 while (1) { 1045 int isInvalid = false; 1046 const char *PrevSpec = 0; 1047 SourceLocation Loc = Tok.getLocation(); 1048 1049 switch (Tok.getKind()) { 1050 default: 1051 // If this is not a type-qualifier token, we're done reading type 1052 // qualifiers. First verify that DeclSpec's are consistent. 1053 DS.Finish(Diags, PP.getSourceManager(), getLang()); 1054 return; 1055 case tok::kw_const: 1056 isInvalid = DS.SetTypeQual(DeclSpec::TQ_const , Loc, PrevSpec, 1057 getLang())*2; 1058 break; 1059 case tok::kw_volatile: 1060 isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec, 1061 getLang())*2; 1062 break; 1063 case tok::kw_restrict: 1064 isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec, 1065 getLang())*2; 1066 break; 1067 case tok::kw___attribute: 1068 DS.AddAttributes(ParseAttributes()); 1069 continue; // do *not* consume the next token! 1070 } 1071 1072 // If the specifier combination wasn't legal, issue a diagnostic. 1073 if (isInvalid) { 1074 assert(PrevSpec && "Method did not return previous specifier!"); 1075 if (isInvalid == 1) // Error. 1076 Diag(Tok, diag::err_invalid_decl_spec_combination, PrevSpec); 1077 else // extwarn. 1078 Diag(Tok, diag::ext_duplicate_declspec, PrevSpec); 1079 } 1080 ConsumeToken(); 1081 } 1082} 1083 1084 1085/// ParseDeclarator - Parse and verify a newly-initialized declarator. 1086/// 1087void Parser::ParseDeclarator(Declarator &D) { 1088 /// This implements the 'declarator' production in the C grammar, then checks 1089 /// for well-formedness and issues diagnostics. 1090 ParseDeclaratorInternal(D); 1091} 1092 1093/// ParseDeclaratorInternal 1094/// declarator: [C99 6.7.5] 1095/// pointer[opt] direct-declarator 1096/// [C++] '&' declarator [C++ 8p4, dcl.decl] 1097/// [GNU] '&' restrict[opt] attributes[opt] declarator 1098/// 1099/// pointer: [C99 6.7.5] 1100/// '*' type-qualifier-list[opt] 1101/// '*' type-qualifier-list[opt] pointer 1102/// 1103void Parser::ParseDeclaratorInternal(Declarator &D) { 1104 tok::TokenKind Kind = Tok.getKind(); 1105 1106 // Not a pointer, C++ reference, or block. 1107 if (Kind != tok::star && (Kind != tok::amp || !getLang().CPlusPlus) && 1108 (Kind != tok::caret || !getLang().Blocks)) 1109 return ParseDirectDeclarator(D); 1110 1111 // Otherwise, '*' -> pointer, '^' -> block, '&' -> reference. 1112 SourceLocation Loc = ConsumeToken(); // Eat the * or &. 1113 1114 if (Kind == tok::star || (Kind == tok::caret && getLang().Blocks)) { 1115 // Is a pointer. 1116 DeclSpec DS; 1117 1118 ParseTypeQualifierListOpt(DS); 1119 1120 // Recursively parse the declarator. 1121 ParseDeclaratorInternal(D); 1122 if (Kind == tok::star) 1123 // Remember that we parsed a pointer type, and remember the type-quals. 1124 D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc, 1125 DS.TakeAttributes())); 1126 else 1127 // Remember that we parsed a Block type, and remember the type-quals. 1128 D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(), 1129 Loc)); 1130 } else { 1131 // Is a reference 1132 DeclSpec DS; 1133 1134 // C++ 8.3.2p1: cv-qualified references are ill-formed except when the 1135 // cv-qualifiers are introduced through the use of a typedef or of a 1136 // template type argument, in which case the cv-qualifiers are ignored. 1137 // 1138 // [GNU] Retricted references are allowed. 1139 // [GNU] Attributes on references are allowed. 1140 ParseTypeQualifierListOpt(DS); 1141 1142 if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) { 1143 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 1144 Diag(DS.getConstSpecLoc(), 1145 diag::err_invalid_reference_qualifier_application, 1146 "const"); 1147 if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile) 1148 Diag(DS.getVolatileSpecLoc(), 1149 diag::err_invalid_reference_qualifier_application, 1150 "volatile"); 1151 } 1152 1153 // Recursively parse the declarator. 1154 ParseDeclaratorInternal(D); 1155 1156 // Remember that we parsed a reference type. It doesn't have type-quals. 1157 D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc, 1158 DS.TakeAttributes())); 1159 } 1160} 1161 1162/// ParseDirectDeclarator 1163/// direct-declarator: [C99 6.7.5] 1164/// identifier 1165/// '(' declarator ')' 1166/// [GNU] '(' attributes declarator ')' 1167/// [C90] direct-declarator '[' constant-expression[opt] ']' 1168/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 1169/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 1170/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 1171/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 1172/// direct-declarator '(' parameter-type-list ')' 1173/// direct-declarator '(' identifier-list[opt] ')' 1174/// [GNU] direct-declarator '(' parameter-forward-declarations 1175/// parameter-type-list[opt] ')' 1176/// 1177void Parser::ParseDirectDeclarator(Declarator &D) { 1178 // Parse the first direct-declarator seen. 1179 if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) { 1180 assert(Tok.getIdentifierInfo() && "Not an identifier?"); 1181 D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation()); 1182 ConsumeToken(); 1183 } else if (Tok.is(tok::l_paren)) { 1184 // direct-declarator: '(' declarator ')' 1185 // direct-declarator: '(' attributes declarator ')' 1186 // Example: 'char (*X)' or 'int (*XX)(void)' 1187 ParseParenDeclarator(D); 1188 } else if (D.mayOmitIdentifier()) { 1189 // This could be something simple like "int" (in which case the declarator 1190 // portion is empty), if an abstract-declarator is allowed. 1191 D.SetIdentifier(0, Tok.getLocation()); 1192 } else { 1193 // Expected identifier or '('. 1194 Diag(Tok, diag::err_expected_ident_lparen); 1195 D.SetIdentifier(0, Tok.getLocation()); 1196 } 1197 1198 assert(D.isPastIdentifier() && 1199 "Haven't past the location of the identifier yet?"); 1200 1201 while (1) { 1202 if (Tok.is(tok::l_paren)) { 1203 ParseFunctionDeclarator(ConsumeParen(), D); 1204 } else if (Tok.is(tok::l_square)) { 1205 ParseBracketDeclarator(D); 1206 } else { 1207 break; 1208 } 1209 } 1210} 1211 1212/// ParseParenDeclarator - We parsed the declarator D up to a paren. This is 1213/// only called before the identifier, so these are most likely just grouping 1214/// parens for precedence. If we find that these are actually function 1215/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator. 1216/// 1217/// direct-declarator: 1218/// '(' declarator ')' 1219/// [GNU] '(' attributes declarator ')' 1220/// 1221void Parser::ParseParenDeclarator(Declarator &D) { 1222 SourceLocation StartLoc = ConsumeParen(); 1223 assert(!D.isPastIdentifier() && "Should be called before passing identifier"); 1224 1225 // If we haven't past the identifier yet (or where the identifier would be 1226 // stored, if this is an abstract declarator), then this is probably just 1227 // grouping parens. However, if this could be an abstract-declarator, then 1228 // this could also be the start of function arguments (consider 'void()'). 1229 bool isGrouping; 1230 1231 if (!D.mayOmitIdentifier()) { 1232 // If this can't be an abstract-declarator, this *must* be a grouping 1233 // paren, because we haven't seen the identifier yet. 1234 isGrouping = true; 1235 } else if (Tok.is(tok::r_paren) || // 'int()' is a function. 1236 isDeclarationSpecifier()) { // 'int(int)' is a function. 1237 // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is 1238 // considered to be a type, not a K&R identifier-list. 1239 isGrouping = false; 1240 } else { 1241 // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'. 1242 isGrouping = true; 1243 } 1244 1245 // If this is a grouping paren, handle: 1246 // direct-declarator: '(' declarator ')' 1247 // direct-declarator: '(' attributes declarator ')' 1248 if (isGrouping) { 1249 if (Tok.is(tok::kw___attribute)) 1250 D.AddAttributes(ParseAttributes()); 1251 1252 ParseDeclaratorInternal(D); 1253 // Match the ')'. 1254 MatchRHSPunctuation(tok::r_paren, StartLoc); 1255 return; 1256 } 1257 1258 // Okay, if this wasn't a grouping paren, it must be the start of a function 1259 // argument list. Recognize that this declarator will never have an 1260 // identifier (and remember where it would have been), then fall through to 1261 // the handling of argument lists. 1262 D.SetIdentifier(0, Tok.getLocation()); 1263 1264 ParseFunctionDeclarator(StartLoc, D); 1265} 1266 1267/// ParseFunctionDeclarator - We are after the identifier and have parsed the 1268/// declarator D up to a paren, which indicates that we are parsing function 1269/// arguments. 1270/// 1271/// This method also handles this portion of the grammar: 1272/// parameter-type-list: [C99 6.7.5] 1273/// parameter-list 1274/// parameter-list ',' '...' 1275/// 1276/// parameter-list: [C99 6.7.5] 1277/// parameter-declaration 1278/// parameter-list ',' parameter-declaration 1279/// 1280/// parameter-declaration: [C99 6.7.5] 1281/// declaration-specifiers declarator 1282/// [C++] declaration-specifiers declarator '=' assignment-expression 1283/// [GNU] declaration-specifiers declarator attributes 1284/// declaration-specifiers abstract-declarator[opt] 1285/// [C++] declaration-specifiers abstract-declarator[opt] 1286/// '=' assignment-expression 1287/// [GNU] declaration-specifiers abstract-declarator[opt] attributes 1288/// 1289void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D) { 1290 // lparen is already consumed! 1291 assert(D.isPastIdentifier() && "Should not call before identifier!"); 1292 1293 // Okay, this is the parameter list of a function definition, or it is an 1294 // identifier list of a K&R-style function. 1295 1296 if (Tok.is(tok::r_paren)) { 1297 // Remember that we parsed a function type, and remember the attributes. 1298 // int() -> no prototype, no '...'. 1299 D.AddTypeInfo(DeclaratorChunk::getFunction(/*prototype*/ false, 1300 /*variadic*/ false, 1301 /*arglist*/ 0, 0, LParenLoc)); 1302 1303 ConsumeParen(); // Eat the closing ')'. 1304 return; 1305 } else if (Tok.is(tok::identifier) && 1306 // K&R identifier lists can't have typedefs as identifiers, per 1307 // C99 6.7.5.3p11. 1308 !Actions.isTypeName(*Tok.getIdentifierInfo(), CurScope)) { 1309 // Identifier list. Note that '(' identifier-list ')' is only allowed for 1310 // normal declarators, not for abstract-declarators. 1311 return ParseFunctionDeclaratorIdentifierList(LParenLoc, D); 1312 } 1313 1314 // Finally, a normal, non-empty parameter type list. 1315 1316 // Build up an array of information about the parsed arguments. 1317 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 1318 1319 // Enter function-declaration scope, limiting any declarators to the 1320 // function prototype scope, including parameter declarators. 1321 EnterScope(Scope::FnScope|Scope::DeclScope); 1322 1323 bool IsVariadic = false; 1324 while (1) { 1325 if (Tok.is(tok::ellipsis)) { 1326 IsVariadic = true; 1327 1328 // Check to see if this is "void(...)" which is not allowed. 1329 if (ParamInfo.empty()) { 1330 // Otherwise, parse parameter type list. If it starts with an 1331 // ellipsis, diagnose the malformed function. 1332 Diag(Tok, diag::err_ellipsis_first_arg); 1333 IsVariadic = false; // Treat this like 'void()'. 1334 } 1335 1336 ConsumeToken(); // Consume the ellipsis. 1337 break; 1338 } 1339 1340 SourceLocation DSStart = Tok.getLocation(); 1341 1342 // Parse the declaration-specifiers. 1343 DeclSpec DS; 1344 ParseDeclarationSpecifiers(DS); 1345 1346 // Parse the declarator. This is "PrototypeContext", because we must 1347 // accept either 'declarator' or 'abstract-declarator' here. 1348 Declarator ParmDecl(DS, Declarator::PrototypeContext); 1349 ParseDeclarator(ParmDecl); 1350 1351 // Parse GNU attributes, if present. 1352 if (Tok.is(tok::kw___attribute)) 1353 ParmDecl.AddAttributes(ParseAttributes()); 1354 1355 // Remember this parsed parameter in ParamInfo. 1356 IdentifierInfo *ParmII = ParmDecl.getIdentifier(); 1357 1358 // If no parameter was specified, verify that *something* was specified, 1359 // otherwise we have a missing type and identifier. 1360 if (DS.getParsedSpecifiers() == DeclSpec::PQ_None && 1361 ParmDecl.getIdentifier() == 0 && ParmDecl.getNumTypeObjects() == 0) { 1362 // Completely missing, emit error. 1363 Diag(DSStart, diag::err_missing_param); 1364 } else { 1365 // Otherwise, we have something. Add it and let semantic analysis try 1366 // to grok it and add the result to the ParamInfo we are building. 1367 1368 // Inform the actions module about the parameter declarator, so it gets 1369 // added to the current scope. 1370 DeclTy *Param = Actions.ActOnParamDeclarator(CurScope, ParmDecl); 1371 1372 // Parse the default argument, if any. We parse the default 1373 // arguments in all dialects; the semantic analysis in 1374 // ActOnParamDefaultArgument will reject the default argument in 1375 // C. 1376 if (Tok.is(tok::equal)) { 1377 SourceLocation EqualLoc = Tok.getLocation(); 1378 1379 // Consume the '='. 1380 ConsumeToken(); 1381 1382 // Parse the default argument 1383 ExprResult DefArgResult = ParseAssignmentExpression(); 1384 if (DefArgResult.isInvalid) { 1385 SkipUntil(tok::comma, tok::r_paren, true, true); 1386 } else { 1387 // Inform the actions module about the default argument 1388 Actions.ActOnParamDefaultArgument(Param, EqualLoc, DefArgResult.Val); 1389 } 1390 } 1391 1392 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 1393 ParmDecl.getIdentifierLoc(), Param)); 1394 } 1395 1396 // If the next token is a comma, consume it and keep reading arguments. 1397 if (Tok.isNot(tok::comma)) break; 1398 1399 // Consume the comma. 1400 ConsumeToken(); 1401 } 1402 1403 // Leave prototype scope. 1404 ExitScope(); 1405 1406 // Remember that we parsed a function type, and remember the attributes. 1407 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/true, IsVariadic, 1408 &ParamInfo[0], ParamInfo.size(), 1409 LParenLoc)); 1410 1411 // If we have the closing ')', eat it and we're done. 1412 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1413} 1414 1415/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator 1416/// we found a K&R-style identifier list instead of a type argument list. The 1417/// current token is known to be the first identifier in the list. 1418/// 1419/// identifier-list: [C99 6.7.5] 1420/// identifier 1421/// identifier-list ',' identifier 1422/// 1423void Parser::ParseFunctionDeclaratorIdentifierList(SourceLocation LParenLoc, 1424 Declarator &D) { 1425 // Build up an array of information about the parsed arguments. 1426 llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo; 1427 llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar; 1428 1429 // If there was no identifier specified for the declarator, either we are in 1430 // an abstract-declarator, or we are in a parameter declarator which was found 1431 // to be abstract. In abstract-declarators, identifier lists are not valid: 1432 // diagnose this. 1433 if (!D.getIdentifier()) 1434 Diag(Tok, diag::ext_ident_list_in_param); 1435 1436 // Tok is known to be the first identifier in the list. Remember this 1437 // identifier in ParamInfo. 1438 ParamsSoFar.insert(Tok.getIdentifierInfo()); 1439 ParamInfo.push_back(DeclaratorChunk::ParamInfo(Tok.getIdentifierInfo(), 1440 Tok.getLocation(), 0)); 1441 1442 ConsumeToken(); // eat the first identifier. 1443 1444 while (Tok.is(tok::comma)) { 1445 // Eat the comma. 1446 ConsumeToken(); 1447 1448 // If this isn't an identifier, report the error and skip until ')'. 1449 if (Tok.isNot(tok::identifier)) { 1450 Diag(Tok, diag::err_expected_ident); 1451 SkipUntil(tok::r_paren); 1452 return; 1453 } 1454 1455 IdentifierInfo *ParmII = Tok.getIdentifierInfo(); 1456 1457 // Reject 'typedef int y; int test(x, y)', but continue parsing. 1458 if (Actions.isTypeName(*ParmII, CurScope)) 1459 Diag(Tok, diag::err_unexpected_typedef_ident, ParmII->getName()); 1460 1461 // Verify that the argument identifier has not already been mentioned. 1462 if (!ParamsSoFar.insert(ParmII)) { 1463 Diag(Tok.getLocation(), diag::err_param_redefinition, ParmII->getName()); 1464 } else { 1465 // Remember this identifier in ParamInfo. 1466 ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII, 1467 Tok.getLocation(), 0)); 1468 } 1469 1470 // Eat the identifier. 1471 ConsumeToken(); 1472 } 1473 1474 // Remember that we parsed a function type, and remember the attributes. This 1475 // function type is always a K&R style function type, which is not varargs and 1476 // has no prototype. 1477 D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/false, /*varargs*/false, 1478 &ParamInfo[0], ParamInfo.size(), 1479 LParenLoc)); 1480 1481 // If we have the closing ')', eat it and we're done. 1482 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1483} 1484 1485/// [C90] direct-declarator '[' constant-expression[opt] ']' 1486/// [C99] direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']' 1487/// [C99] direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']' 1488/// [C99] direct-declarator '[' type-qual-list 'static' assignment-expr ']' 1489/// [C99] direct-declarator '[' type-qual-list[opt] '*' ']' 1490void Parser::ParseBracketDeclarator(Declarator &D) { 1491 SourceLocation StartLoc = ConsumeBracket(); 1492 1493 // If valid, this location is the position where we read the 'static' keyword. 1494 SourceLocation StaticLoc; 1495 if (Tok.is(tok::kw_static)) 1496 StaticLoc = ConsumeToken(); 1497 1498 // If there is a type-qualifier-list, read it now. 1499 DeclSpec DS; 1500 ParseTypeQualifierListOpt(DS); 1501 1502 // If we haven't already read 'static', check to see if there is one after the 1503 // type-qualifier-list. 1504 if (!StaticLoc.isValid() && Tok.is(tok::kw_static)) 1505 StaticLoc = ConsumeToken(); 1506 1507 // Handle "direct-declarator [ type-qual-list[opt] * ]". 1508 bool isStar = false; 1509 ExprResult NumElements(false); 1510 1511 // Handle the case where we have '[*]' as the array size. However, a leading 1512 // star could be the start of an expression, for example 'X[*p + 4]'. Verify 1513 // the the token after the star is a ']'. Since stars in arrays are 1514 // infrequent, use of lookahead is not costly here. 1515 if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) { 1516 ConsumeToken(); // Eat the '*'. 1517 1518 if (StaticLoc.isValid()) 1519 Diag(StaticLoc, diag::err_unspecified_vla_size_with_static); 1520 StaticLoc = SourceLocation(); // Drop the static. 1521 isStar = true; 1522 } else if (Tok.isNot(tok::r_square)) { 1523 // Parse the assignment-expression now. 1524 NumElements = ParseAssignmentExpression(); 1525 } 1526 1527 // If there was an error parsing the assignment-expression, recover. 1528 if (NumElements.isInvalid) { 1529 // If the expression was invalid, skip it. 1530 SkipUntil(tok::r_square); 1531 return; 1532 } 1533 1534 MatchRHSPunctuation(tok::r_square, StartLoc); 1535 1536 // If C99 isn't enabled, emit an ext-warn if the arg list wasn't empty and if 1537 // it was not a constant expression. 1538 if (!getLang().C99) { 1539 // TODO: check C90 array constant exprness. 1540 if (isStar || StaticLoc.isValid() || 1541 0/*TODO: NumElts is not a C90 constantexpr */) 1542 Diag(StartLoc, diag::ext_c99_array_usage); 1543 } 1544 1545 // Remember that we parsed a pointer type, and remember the type-quals. 1546 D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(), 1547 StaticLoc.isValid(), isStar, 1548 NumElements.Val, StartLoc)); 1549} 1550 1551/// [GNU] typeof-specifier: 1552/// typeof ( expressions ) 1553/// typeof ( type-name ) 1554/// [GNU/C++] typeof unary-expression 1555/// 1556void Parser::ParseTypeofSpecifier(DeclSpec &DS) { 1557 assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier"); 1558 const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo(); 1559 SourceLocation StartLoc = ConsumeToken(); 1560 1561 if (Tok.isNot(tok::l_paren)) { 1562 if (!getLang().CPlusPlus) { 1563 Diag(Tok, diag::err_expected_lparen_after, BuiltinII->getName()); 1564 return; 1565 } 1566 1567 ExprResult Result = ParseCastExpression(true/*isUnaryExpression*/); 1568 if (Result.isInvalid) 1569 return; 1570 1571 const char *PrevSpec = 0; 1572 // Check for duplicate type specifiers. 1573 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 1574 Result.Val)) 1575 Diag(StartLoc, diag::err_invalid_decl_spec_combination, PrevSpec); 1576 1577 // FIXME: Not accurate, the range gets one token more than it should. 1578 DS.SetRangeEnd(Tok.getLocation()); 1579 return; 1580 } 1581 1582 SourceLocation LParenLoc = ConsumeParen(), RParenLoc; 1583 1584 if (isTypeSpecifierQualifier()) { 1585 TypeTy *Ty = ParseTypeName(); 1586 1587 assert(Ty && "Parser::ParseTypeofSpecifier(): missing type"); 1588 1589 if (Tok.isNot(tok::r_paren)) { 1590 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1591 return; 1592 } 1593 RParenLoc = ConsumeParen(); 1594 const char *PrevSpec = 0; 1595 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 1596 if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, Ty)) 1597 Diag(StartLoc, diag::err_invalid_decl_spec_combination, PrevSpec); 1598 } else { // we have an expression. 1599 ExprResult Result = ParseExpression(); 1600 1601 if (Result.isInvalid || Tok.isNot(tok::r_paren)) { 1602 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1603 return; 1604 } 1605 RParenLoc = ConsumeParen(); 1606 const char *PrevSpec = 0; 1607 // Check for duplicate type specifiers (e.g. "int typeof(int)"). 1608 if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec, 1609 Result.Val)) 1610 Diag(StartLoc, diag::err_invalid_decl_spec_combination, PrevSpec); 1611 } 1612 DS.SetRangeEnd(RParenLoc); 1613} 1614 1615 1616