ParseObjc.cpp revision 7b4192c558268fd9007c671e72b4aa59d4f75daa
1//===--- ParseObjC.cpp - Objective C 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 Objective-C portions of the Parser interface. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/Parser.h" 15#include "clang/Parse/DeclSpec.h" 16#include "clang/Parse/Scope.h" 17#include "AstGuard.h" 18#include "clang/Parse/ParseDiagnostic.h" 19#include "llvm/ADT/SmallVector.h" 20using namespace clang; 21 22 23/// ParseObjCAtDirectives - Handle parts of the external-declaration production: 24/// external-declaration: [C99 6.9] 25/// [OBJC] objc-class-definition 26/// [OBJC] objc-class-declaration 27/// [OBJC] objc-alias-declaration 28/// [OBJC] objc-protocol-definition 29/// [OBJC] objc-method-definition 30/// [OBJC] '@' 'end' 31Parser::DeclTy *Parser::ParseObjCAtDirectives() { 32 SourceLocation AtLoc = ConsumeToken(); // the "@" 33 34 switch (Tok.getObjCKeywordID()) { 35 case tok::objc_class: 36 return ParseObjCAtClassDeclaration(AtLoc); 37 case tok::objc_interface: 38 return ParseObjCAtInterfaceDeclaration(AtLoc); 39 case tok::objc_protocol: 40 return ParseObjCAtProtocolDeclaration(AtLoc); 41 case tok::objc_implementation: 42 return ParseObjCAtImplementationDeclaration(AtLoc); 43 case tok::objc_end: 44 return ParseObjCAtEndDeclaration(AtLoc); 45 case tok::objc_compatibility_alias: 46 return ParseObjCAtAliasDeclaration(AtLoc); 47 case tok::objc_synthesize: 48 return ParseObjCPropertySynthesize(AtLoc); 49 case tok::objc_dynamic: 50 return ParseObjCPropertyDynamic(AtLoc); 51 default: 52 Diag(AtLoc, diag::err_unexpected_at); 53 SkipUntil(tok::semi); 54 return 0; 55 } 56} 57 58/// 59/// objc-class-declaration: 60/// '@' 'class' identifier-list ';' 61/// 62Parser::DeclTy *Parser::ParseObjCAtClassDeclaration(SourceLocation atLoc) { 63 ConsumeToken(); // the identifier "class" 64 llvm::SmallVector<IdentifierInfo *, 8> ClassNames; 65 66 while (1) { 67 if (Tok.isNot(tok::identifier)) { 68 Diag(Tok, diag::err_expected_ident); 69 SkipUntil(tok::semi); 70 return 0; 71 } 72 ClassNames.push_back(Tok.getIdentifierInfo()); 73 ConsumeToken(); 74 75 if (Tok.isNot(tok::comma)) 76 break; 77 78 ConsumeToken(); 79 } 80 81 // Consume the ';'. 82 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@class")) 83 return 0; 84 85 return Actions.ActOnForwardClassDeclaration(atLoc, 86 &ClassNames[0], ClassNames.size()); 87} 88 89/// 90/// objc-interface: 91/// objc-class-interface-attributes[opt] objc-class-interface 92/// objc-category-interface 93/// 94/// objc-class-interface: 95/// '@' 'interface' identifier objc-superclass[opt] 96/// objc-protocol-refs[opt] 97/// objc-class-instance-variables[opt] 98/// objc-interface-decl-list 99/// @end 100/// 101/// objc-category-interface: 102/// '@' 'interface' identifier '(' identifier[opt] ')' 103/// objc-protocol-refs[opt] 104/// objc-interface-decl-list 105/// @end 106/// 107/// objc-superclass: 108/// ':' identifier 109/// 110/// objc-class-interface-attributes: 111/// __attribute__((visibility("default"))) 112/// __attribute__((visibility("hidden"))) 113/// __attribute__((deprecated)) 114/// __attribute__((unavailable)) 115/// __attribute__((objc_exception)) - used by NSException on 64-bit 116/// 117Parser::DeclTy *Parser::ParseObjCAtInterfaceDeclaration( 118 SourceLocation atLoc, AttributeList *attrList) { 119 assert(Tok.isObjCAtKeyword(tok::objc_interface) && 120 "ParseObjCAtInterfaceDeclaration(): Expected @interface"); 121 ConsumeToken(); // the "interface" identifier 122 123 if (Tok.isNot(tok::identifier)) { 124 Diag(Tok, diag::err_expected_ident); // missing class or category name. 125 return 0; 126 } 127 // We have a class or category name - consume it. 128 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 129 SourceLocation nameLoc = ConsumeToken(); 130 131 if (Tok.is(tok::l_paren)) { // we have a category. 132 SourceLocation lparenLoc = ConsumeParen(); 133 SourceLocation categoryLoc, rparenLoc; 134 IdentifierInfo *categoryId = 0; 135 136 // For ObjC2, the category name is optional (not an error). 137 if (Tok.is(tok::identifier)) { 138 categoryId = Tok.getIdentifierInfo(); 139 categoryLoc = ConsumeToken(); 140 } else if (!getLang().ObjC2) { 141 Diag(Tok, diag::err_expected_ident); // missing category name. 142 return 0; 143 } 144 if (Tok.isNot(tok::r_paren)) { 145 Diag(Tok, diag::err_expected_rparen); 146 SkipUntil(tok::r_paren, false); // don't stop at ';' 147 return 0; 148 } 149 rparenLoc = ConsumeParen(); 150 151 // Next, we need to check for any protocol references. 152 SourceLocation EndProtoLoc; 153 llvm::SmallVector<DeclTy *, 8> ProtocolRefs; 154 if (Tok.is(tok::less) && 155 ParseObjCProtocolReferences(ProtocolRefs, true, EndProtoLoc)) 156 return 0; 157 158 if (attrList) // categories don't support attributes. 159 Diag(Tok, diag::err_objc_no_attributes_on_category); 160 161 DeclTy *CategoryType = Actions.ActOnStartCategoryInterface(atLoc, 162 nameId, nameLoc, categoryId, categoryLoc, 163 &ProtocolRefs[0], ProtocolRefs.size(), 164 EndProtoLoc); 165 166 ParseObjCInterfaceDeclList(CategoryType, tok::objc_not_keyword); 167 return CategoryType; 168 } 169 // Parse a class interface. 170 IdentifierInfo *superClassId = 0; 171 SourceLocation superClassLoc; 172 173 if (Tok.is(tok::colon)) { // a super class is specified. 174 ConsumeToken(); 175 if (Tok.isNot(tok::identifier)) { 176 Diag(Tok, diag::err_expected_ident); // missing super class name. 177 return 0; 178 } 179 superClassId = Tok.getIdentifierInfo(); 180 superClassLoc = ConsumeToken(); 181 } 182 // Next, we need to check for any protocol references. 183 llvm::SmallVector<Action::DeclTy*, 8> ProtocolRefs; 184 SourceLocation EndProtoLoc; 185 if (Tok.is(tok::less) && 186 ParseObjCProtocolReferences(ProtocolRefs, true, EndProtoLoc)) 187 return 0; 188 189 DeclTy *ClsType = 190 Actions.ActOnStartClassInterface(atLoc, nameId, nameLoc, 191 superClassId, superClassLoc, 192 &ProtocolRefs[0], ProtocolRefs.size(), 193 EndProtoLoc, attrList); 194 195 if (Tok.is(tok::l_brace)) 196 ParseObjCClassInstanceVariables(ClsType, atLoc); 197 198 ParseObjCInterfaceDeclList(ClsType, tok::objc_interface); 199 return ClsType; 200} 201 202/// constructSetterName - Return the setter name for the given 203/// identifier, i.e. "set" + Name where the initial character of Name 204/// has been capitalized. 205static IdentifierInfo *constructSetterName(IdentifierTable &Idents, 206 const IdentifierInfo *Name) { 207 llvm::SmallString<100> SelectorName; 208 SelectorName = "set"; 209 SelectorName.append(Name->getName(), Name->getName()+Name->getLength()); 210 SelectorName[3] = toupper(SelectorName[3]); 211 return &Idents.get(&SelectorName[0], &SelectorName[SelectorName.size()]); 212} 213 214/// objc-interface-decl-list: 215/// empty 216/// objc-interface-decl-list objc-property-decl [OBJC2] 217/// objc-interface-decl-list objc-method-requirement [OBJC2] 218/// objc-interface-decl-list objc-method-proto ';' 219/// objc-interface-decl-list declaration 220/// objc-interface-decl-list ';' 221/// 222/// objc-method-requirement: [OBJC2] 223/// @required 224/// @optional 225/// 226void Parser::ParseObjCInterfaceDeclList(DeclTy *interfaceDecl, 227 tok::ObjCKeywordKind contextKey) { 228 llvm::SmallVector<DeclTy*, 32> allMethods; 229 llvm::SmallVector<DeclTy*, 16> allProperties; 230 tok::ObjCKeywordKind MethodImplKind = tok::objc_not_keyword; 231 232 SourceLocation AtEndLoc; 233 234 while (1) { 235 // If this is a method prototype, parse it. 236 if (Tok.is(tok::minus) || Tok.is(tok::plus)) { 237 DeclTy *methodPrototype = 238 ParseObjCMethodPrototype(interfaceDecl, MethodImplKind); 239 allMethods.push_back(methodPrototype); 240 // Consume the ';' here, since ParseObjCMethodPrototype() is re-used for 241 // method definitions. 242 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_method_proto); 243 continue; 244 } 245 246 // Ignore excess semicolons. 247 if (Tok.is(tok::semi)) { 248 ConsumeToken(); 249 continue; 250 } 251 252 // If we got to the end of the file, exit the loop. 253 if (Tok.is(tok::eof)) 254 break; 255 256 // If we don't have an @ directive, parse it as a function definition. 257 if (Tok.isNot(tok::at)) { 258 // The code below does not consume '}'s because it is afraid of eating the 259 // end of a namespace. Because of the way this code is structured, an 260 // erroneous r_brace would cause an infinite loop if not handled here. 261 if (Tok.is(tok::r_brace)) 262 break; 263 264 // FIXME: as the name implies, this rule allows function definitions. 265 // We could pass a flag or check for functions during semantic analysis. 266 ParseDeclarationOrFunctionDefinition(); 267 continue; 268 } 269 270 // Otherwise, we have an @ directive, eat the @. 271 SourceLocation AtLoc = ConsumeToken(); // the "@" 272 tok::ObjCKeywordKind DirectiveKind = Tok.getObjCKeywordID(); 273 274 if (DirectiveKind == tok::objc_end) { // @end -> terminate list 275 AtEndLoc = AtLoc; 276 break; 277 } 278 279 // Eat the identifier. 280 ConsumeToken(); 281 282 switch (DirectiveKind) { 283 default: 284 // FIXME: If someone forgets an @end on a protocol, this loop will 285 // continue to eat up tons of stuff and spew lots of nonsense errors. It 286 // would probably be better to bail out if we saw an @class or @interface 287 // or something like that. 288 Diag(AtLoc, diag::err_objc_illegal_interface_qual); 289 // Skip until we see an '@' or '}' or ';'. 290 SkipUntil(tok::r_brace, tok::at); 291 break; 292 293 case tok::objc_required: 294 case tok::objc_optional: 295 // This is only valid on protocols. 296 // FIXME: Should this check for ObjC2 being enabled? 297 if (contextKey != tok::objc_protocol) 298 Diag(AtLoc, diag::err_objc_directive_only_in_protocol); 299 else 300 MethodImplKind = DirectiveKind; 301 break; 302 303 case tok::objc_property: 304 if (!getLang().ObjC2) 305 Diag(AtLoc, diag::err_objc_propertoes_require_objc2); 306 307 ObjCDeclSpec OCDS; 308 // Parse property attribute list, if any. 309 if (Tok.is(tok::l_paren)) 310 ParseObjCPropertyAttribute(OCDS); 311 312 // Parse all the comma separated declarators. 313 DeclSpec DS; 314 llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators; 315 ParseStructDeclaration(DS, FieldDeclarators); 316 317 ExpectAndConsume(tok::semi, diag::err_expected_semi_decl_list, "", 318 tok::at); 319 320 // Convert them all to property declarations. 321 for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) { 322 FieldDeclarator &FD = FieldDeclarators[i]; 323 if (FD.D.getIdentifier() == 0) { 324 Diag(AtLoc, diag::err_objc_property_requires_field_name) 325 << FD.D.getSourceRange(); 326 continue; 327 } 328 if (FD.BitfieldSize) { 329 Diag(AtLoc, diag::err_objc_property_bitfield) 330 << FD.D.getSourceRange(); 331 continue; 332 } 333 334 // Install the property declarator into interfaceDecl. 335 IdentifierInfo *SelName = 336 OCDS.getGetterName() ? OCDS.getGetterName() : FD.D.getIdentifier(); 337 338 Selector GetterSel = 339 PP.getSelectorTable().getNullarySelector(SelName); 340 IdentifierInfo *SetterName = OCDS.getSetterName(); 341 if (!SetterName) 342 SetterName = constructSetterName(PP.getIdentifierTable(), 343 FD.D.getIdentifier()); 344 Selector SetterSel = 345 PP.getSelectorTable().getUnarySelector(SetterName); 346 bool isOverridingProperty = false; 347 DeclTy *Property = Actions.ActOnProperty(CurScope, AtLoc, FD, OCDS, 348 GetterSel, SetterSel, 349 interfaceDecl, 350 &isOverridingProperty, 351 MethodImplKind); 352 if (!isOverridingProperty) 353 allProperties.push_back(Property); 354 } 355 break; 356 } 357 } 358 359 // We break out of the big loop in two cases: when we see @end or when we see 360 // EOF. In the former case, eat the @end. In the later case, emit an error. 361 if (Tok.isObjCAtKeyword(tok::objc_end)) 362 ConsumeToken(); // the "end" identifier 363 else 364 Diag(Tok, diag::err_objc_missing_end); 365 366 // Insert collected methods declarations into the @interface object. 367 // This passes in an invalid SourceLocation for AtEndLoc when EOF is hit. 368 Actions.ActOnAtEnd(AtEndLoc, interfaceDecl, 369 allMethods.empty() ? 0 : &allMethods[0], 370 allMethods.size(), 371 allProperties.empty() ? 0 : &allProperties[0], 372 allProperties.size()); 373} 374 375/// Parse property attribute declarations. 376/// 377/// property-attr-decl: '(' property-attrlist ')' 378/// property-attrlist: 379/// property-attribute 380/// property-attrlist ',' property-attribute 381/// property-attribute: 382/// getter '=' identifier 383/// setter '=' identifier ':' 384/// readonly 385/// readwrite 386/// assign 387/// retain 388/// copy 389/// nonatomic 390/// 391void Parser::ParseObjCPropertyAttribute(ObjCDeclSpec &DS) { 392 assert(Tok.getKind() == tok::l_paren); 393 SourceLocation LHSLoc = ConsumeParen(); // consume '(' 394 395 while (1) { 396 const IdentifierInfo *II = Tok.getIdentifierInfo(); 397 398 // If this is not an identifier at all, bail out early. 399 if (II == 0) { 400 MatchRHSPunctuation(tok::r_paren, LHSLoc); 401 return; 402 } 403 404 SourceLocation AttrName = ConsumeToken(); // consume last attribute name 405 406 if (II->isStr("readonly")) 407 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readonly); 408 else if (II->isStr("assign")) 409 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_assign); 410 else if (II->isStr("readwrite")) 411 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_readwrite); 412 else if (II->isStr("retain")) 413 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_retain); 414 else if (II->isStr("copy")) 415 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_copy); 416 else if (II->isStr("nonatomic")) 417 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_nonatomic); 418 else if (II->isStr("getter") || II->isStr("setter")) { 419 // getter/setter require extra treatment. 420 if (ExpectAndConsume(tok::equal, diag::err_objc_expected_equal, "", 421 tok::r_paren)) 422 return; 423 424 if (Tok.isNot(tok::identifier)) { 425 Diag(Tok, diag::err_expected_ident); 426 SkipUntil(tok::r_paren); 427 return; 428 } 429 430 if (II->getName()[0] == 's') { 431 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_setter); 432 DS.setSetterName(Tok.getIdentifierInfo()); 433 ConsumeToken(); // consume method name 434 435 if (ExpectAndConsume(tok::colon, diag::err_expected_colon, "", 436 tok::r_paren)) 437 return; 438 } else { 439 DS.setPropertyAttributes(ObjCDeclSpec::DQ_PR_getter); 440 DS.setGetterName(Tok.getIdentifierInfo()); 441 ConsumeToken(); // consume method name 442 } 443 } else { 444 Diag(AttrName, diag::err_objc_expected_property_attr) << II; 445 SkipUntil(tok::r_paren); 446 return; 447 } 448 449 if (Tok.isNot(tok::comma)) 450 break; 451 452 ConsumeToken(); 453 } 454 455 MatchRHSPunctuation(tok::r_paren, LHSLoc); 456} 457 458/// objc-method-proto: 459/// objc-instance-method objc-method-decl objc-method-attributes[opt] 460/// objc-class-method objc-method-decl objc-method-attributes[opt] 461/// 462/// objc-instance-method: '-' 463/// objc-class-method: '+' 464/// 465/// objc-method-attributes: [OBJC2] 466/// __attribute__((deprecated)) 467/// 468Parser::DeclTy *Parser::ParseObjCMethodPrototype(DeclTy *IDecl, 469 tok::ObjCKeywordKind MethodImplKind) { 470 assert((Tok.is(tok::minus) || Tok.is(tok::plus)) && "expected +/-"); 471 472 tok::TokenKind methodType = Tok.getKind(); 473 SourceLocation mLoc = ConsumeToken(); 474 475 DeclTy *MDecl = ParseObjCMethodDecl(mLoc, methodType, IDecl, MethodImplKind); 476 // Since this rule is used for both method declarations and definitions, 477 // the caller is (optionally) responsible for consuming the ';'. 478 return MDecl; 479} 480 481/// objc-selector: 482/// identifier 483/// one of 484/// enum struct union if else while do for switch case default 485/// break continue return goto asm sizeof typeof __alignof 486/// unsigned long const short volatile signed restrict _Complex 487/// in out inout bycopy byref oneway int char float double void _Bool 488/// 489IdentifierInfo *Parser::ParseObjCSelector(SourceLocation &SelectorLoc) { 490 switch (Tok.getKind()) { 491 default: 492 return 0; 493 case tok::identifier: 494 case tok::kw_asm: 495 case tok::kw_auto: 496 case tok::kw_bool: 497 case tok::kw_break: 498 case tok::kw_case: 499 case tok::kw_catch: 500 case tok::kw_char: 501 case tok::kw_class: 502 case tok::kw_const: 503 case tok::kw_const_cast: 504 case tok::kw_continue: 505 case tok::kw_default: 506 case tok::kw_delete: 507 case tok::kw_do: 508 case tok::kw_double: 509 case tok::kw_dynamic_cast: 510 case tok::kw_else: 511 case tok::kw_enum: 512 case tok::kw_explicit: 513 case tok::kw_export: 514 case tok::kw_extern: 515 case tok::kw_false: 516 case tok::kw_float: 517 case tok::kw_for: 518 case tok::kw_friend: 519 case tok::kw_goto: 520 case tok::kw_if: 521 case tok::kw_inline: 522 case tok::kw_int: 523 case tok::kw_long: 524 case tok::kw_mutable: 525 case tok::kw_namespace: 526 case tok::kw_new: 527 case tok::kw_operator: 528 case tok::kw_private: 529 case tok::kw_protected: 530 case tok::kw_public: 531 case tok::kw_register: 532 case tok::kw_reinterpret_cast: 533 case tok::kw_restrict: 534 case tok::kw_return: 535 case tok::kw_short: 536 case tok::kw_signed: 537 case tok::kw_sizeof: 538 case tok::kw_static: 539 case tok::kw_static_cast: 540 case tok::kw_struct: 541 case tok::kw_switch: 542 case tok::kw_template: 543 case tok::kw_this: 544 case tok::kw_throw: 545 case tok::kw_true: 546 case tok::kw_try: 547 case tok::kw_typedef: 548 case tok::kw_typeid: 549 case tok::kw_typename: 550 case tok::kw_typeof: 551 case tok::kw_union: 552 case tok::kw_unsigned: 553 case tok::kw_using: 554 case tok::kw_virtual: 555 case tok::kw_void: 556 case tok::kw_volatile: 557 case tok::kw_wchar_t: 558 case tok::kw_while: 559 case tok::kw__Bool: 560 case tok::kw__Complex: 561 case tok::kw___alignof: 562 IdentifierInfo *II = Tok.getIdentifierInfo(); 563 SelectorLoc = ConsumeToken(); 564 return II; 565 } 566} 567 568/// objc-for-collection-in: 'in' 569/// 570bool Parser::isTokIdentifier_in() const { 571 // FIXME: May have to do additional look-ahead to only allow for 572 // valid tokens following an 'in'; such as an identifier, unary operators, 573 // '[' etc. 574 return (getLang().ObjC2 && Tok.is(tok::identifier) && 575 Tok.getIdentifierInfo() == ObjCTypeQuals[objc_in]); 576} 577 578/// ParseObjCTypeQualifierList - This routine parses the objective-c's type 579/// qualifier list and builds their bitmask representation in the input 580/// argument. 581/// 582/// objc-type-qualifiers: 583/// objc-type-qualifier 584/// objc-type-qualifiers objc-type-qualifier 585/// 586void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS) { 587 while (1) { 588 if (Tok.isNot(tok::identifier)) 589 return; 590 591 const IdentifierInfo *II = Tok.getIdentifierInfo(); 592 for (unsigned i = 0; i != objc_NumQuals; ++i) { 593 if (II != ObjCTypeQuals[i]) 594 continue; 595 596 ObjCDeclSpec::ObjCDeclQualifier Qual; 597 switch (i) { 598 default: assert(0 && "Unknown decl qualifier"); 599 case objc_in: Qual = ObjCDeclSpec::DQ_In; break; 600 case objc_out: Qual = ObjCDeclSpec::DQ_Out; break; 601 case objc_inout: Qual = ObjCDeclSpec::DQ_Inout; break; 602 case objc_oneway: Qual = ObjCDeclSpec::DQ_Oneway; break; 603 case objc_bycopy: Qual = ObjCDeclSpec::DQ_Bycopy; break; 604 case objc_byref: Qual = ObjCDeclSpec::DQ_Byref; break; 605 } 606 DS.setObjCDeclQualifier(Qual); 607 ConsumeToken(); 608 II = 0; 609 break; 610 } 611 612 // If this wasn't a recognized qualifier, bail out. 613 if (II) return; 614 } 615} 616 617/// objc-type-name: 618/// '(' objc-type-qualifiers[opt] type-name ')' 619/// '(' objc-type-qualifiers[opt] ')' 620/// 621Parser::TypeTy *Parser::ParseObjCTypeName(ObjCDeclSpec &DS) { 622 assert(Tok.is(tok::l_paren) && "expected ("); 623 624 SourceLocation LParenLoc = ConsumeParen(); 625 SourceLocation TypeStartLoc = Tok.getLocation(); 626 627 // Parse type qualifiers, in, inout, etc. 628 ParseObjCTypeQualifierList(DS); 629 630 TypeTy *Ty = 0; 631 if (isTypeSpecifierQualifier()) 632 Ty = ParseTypeName(); 633 634 if (Tok.is(tok::r_paren)) 635 ConsumeParen(); 636 else if (Tok.getLocation() == TypeStartLoc) { 637 // If we didn't eat any tokens, then this isn't a type. 638 Diag(Tok, diag::err_expected_type); 639 SkipUntil(tok::r_paren); 640 } else { 641 // Otherwise, we found *something*, but didn't get a ')' in the right 642 // place. Emit an error then return what we have as the type. 643 MatchRHSPunctuation(tok::r_paren, LParenLoc); 644 } 645 return Ty; 646} 647 648/// objc-method-decl: 649/// objc-selector 650/// objc-keyword-selector objc-parmlist[opt] 651/// objc-type-name objc-selector 652/// objc-type-name objc-keyword-selector objc-parmlist[opt] 653/// 654/// objc-keyword-selector: 655/// objc-keyword-decl 656/// objc-keyword-selector objc-keyword-decl 657/// 658/// objc-keyword-decl: 659/// objc-selector ':' objc-type-name objc-keyword-attributes[opt] identifier 660/// objc-selector ':' objc-keyword-attributes[opt] identifier 661/// ':' objc-type-name objc-keyword-attributes[opt] identifier 662/// ':' objc-keyword-attributes[opt] identifier 663/// 664/// objc-parmlist: 665/// objc-parms objc-ellipsis[opt] 666/// 667/// objc-parms: 668/// objc-parms , parameter-declaration 669/// 670/// objc-ellipsis: 671/// , ... 672/// 673/// objc-keyword-attributes: [OBJC2] 674/// __attribute__((unused)) 675/// 676Parser::DeclTy *Parser::ParseObjCMethodDecl(SourceLocation mLoc, 677 tok::TokenKind mType, 678 DeclTy *IDecl, 679 tok::ObjCKeywordKind MethodImplKind) 680{ 681 // Parse the return type if present. 682 TypeTy *ReturnType = 0; 683 ObjCDeclSpec DSRet; 684 if (Tok.is(tok::l_paren)) 685 ReturnType = ParseObjCTypeName(DSRet); 686 687 SourceLocation selLoc; 688 IdentifierInfo *SelIdent = ParseObjCSelector(selLoc); 689 690 // An unnamed colon is valid. 691 if (!SelIdent && Tok.isNot(tok::colon)) { // missing selector name. 692 Diag(Tok, diag::err_expected_selector_for_method) 693 << SourceRange(mLoc, Tok.getLocation()); 694 // Skip until we get a ; or {}. 695 SkipUntil(tok::r_brace); 696 return 0; 697 } 698 699 llvm::SmallVector<Declarator, 8> CargNames; 700 if (Tok.isNot(tok::colon)) { 701 // If attributes exist after the method, parse them. 702 AttributeList *MethodAttrs = 0; 703 if (getLang().ObjC2 && Tok.is(tok::kw___attribute)) 704 MethodAttrs = ParseAttributes(); 705 706 Selector Sel = PP.getSelectorTable().getNullarySelector(SelIdent); 707 return Actions.ActOnMethodDeclaration(mLoc, Tok.getLocation(), 708 mType, IDecl, DSRet, ReturnType, Sel, 709 0, 0, 0, CargNames, 710 MethodAttrs, MethodImplKind); 711 } 712 713 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents; 714 llvm::SmallVector<Action::TypeTy *, 12> KeyTypes; 715 llvm::SmallVector<ObjCDeclSpec, 12> ArgTypeQuals; 716 llvm::SmallVector<IdentifierInfo *, 12> ArgNames; 717 718 Action::TypeTy *TypeInfo; 719 while (1) { 720 KeyIdents.push_back(SelIdent); 721 722 // Each iteration parses a single keyword argument. 723 if (Tok.isNot(tok::colon)) { 724 Diag(Tok, diag::err_expected_colon); 725 break; 726 } 727 ConsumeToken(); // Eat the ':'. 728 ObjCDeclSpec DSType; 729 if (Tok.is(tok::l_paren)) // Parse the argument type. 730 TypeInfo = ParseObjCTypeName(DSType); 731 else 732 TypeInfo = 0; 733 KeyTypes.push_back(TypeInfo); 734 ArgTypeQuals.push_back(DSType); 735 736 // If attributes exist before the argument name, parse them. 737 if (getLang().ObjC2 && Tok.is(tok::kw___attribute)) 738 ParseAttributes(); // FIXME: pass attributes through. 739 740 if (Tok.isNot(tok::identifier)) { 741 Diag(Tok, diag::err_expected_ident); // missing argument name. 742 break; 743 } 744 ArgNames.push_back(Tok.getIdentifierInfo()); 745 ConsumeToken(); // Eat the identifier. 746 747 // Check for another keyword selector. 748 SourceLocation Loc; 749 SelIdent = ParseObjCSelector(Loc); 750 if (!SelIdent && Tok.isNot(tok::colon)) 751 break; 752 // We have a selector or a colon, continue parsing. 753 } 754 755 bool isVariadic = false; 756 757 // Parse the (optional) parameter list. 758 while (Tok.is(tok::comma)) { 759 ConsumeToken(); 760 if (Tok.is(tok::ellipsis)) { 761 isVariadic = true; 762 ConsumeToken(); 763 break; 764 } 765 DeclSpec DS; 766 ParseDeclarationSpecifiers(DS); 767 // Parse the declarator. 768 Declarator ParmDecl(DS, Declarator::PrototypeContext); 769 ParseDeclarator(ParmDecl); 770 CargNames.push_back(ParmDecl); 771 } 772 773 // FIXME: Add support for optional parmameter list... 774 // If attributes exist after the method, parse them. 775 AttributeList *MethodAttrs = 0; 776 if (getLang().ObjC2 && Tok.is(tok::kw___attribute)) 777 MethodAttrs = ParseAttributes(); 778 779 Selector Sel = PP.getSelectorTable().getSelector(KeyIdents.size(), 780 &KeyIdents[0]); 781 return Actions.ActOnMethodDeclaration(mLoc, Tok.getLocation(), 782 mType, IDecl, DSRet, ReturnType, Sel, 783 &ArgTypeQuals[0], &KeyTypes[0], 784 &ArgNames[0], CargNames, 785 MethodAttrs, 786 MethodImplKind, isVariadic); 787} 788 789/// objc-protocol-refs: 790/// '<' identifier-list '>' 791/// 792bool Parser:: 793ParseObjCProtocolReferences(llvm::SmallVectorImpl<Action::DeclTy*> &Protocols, 794 bool WarnOnDeclarations, SourceLocation &EndLoc) { 795 assert(Tok.is(tok::less) && "expected <"); 796 797 ConsumeToken(); // the "<" 798 799 llvm::SmallVector<IdentifierLocPair, 8> ProtocolIdents; 800 801 while (1) { 802 if (Tok.isNot(tok::identifier)) { 803 Diag(Tok, diag::err_expected_ident); 804 SkipUntil(tok::greater); 805 return true; 806 } 807 ProtocolIdents.push_back(std::make_pair(Tok.getIdentifierInfo(), 808 Tok.getLocation())); 809 ConsumeToken(); 810 811 if (Tok.isNot(tok::comma)) 812 break; 813 ConsumeToken(); 814 } 815 816 // Consume the '>'. 817 if (Tok.isNot(tok::greater)) { 818 Diag(Tok, diag::err_expected_greater); 819 return true; 820 } 821 822 EndLoc = ConsumeAnyToken(); 823 824 // Convert the list of protocols identifiers into a list of protocol decls. 825 Actions.FindProtocolDeclaration(WarnOnDeclarations, 826 &ProtocolIdents[0], ProtocolIdents.size(), 827 Protocols); 828 return false; 829} 830 831/// objc-class-instance-variables: 832/// '{' objc-instance-variable-decl-list[opt] '}' 833/// 834/// objc-instance-variable-decl-list: 835/// objc-visibility-spec 836/// objc-instance-variable-decl ';' 837/// ';' 838/// objc-instance-variable-decl-list objc-visibility-spec 839/// objc-instance-variable-decl-list objc-instance-variable-decl ';' 840/// objc-instance-variable-decl-list ';' 841/// 842/// objc-visibility-spec: 843/// @private 844/// @protected 845/// @public 846/// @package [OBJC2] 847/// 848/// objc-instance-variable-decl: 849/// struct-declaration 850/// 851void Parser::ParseObjCClassInstanceVariables(DeclTy *interfaceDecl, 852 SourceLocation atLoc) { 853 assert(Tok.is(tok::l_brace) && "expected {"); 854 llvm::SmallVector<DeclTy*, 32> AllIvarDecls; 855 llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators; 856 857 ParseScope ClassScope(this, Scope::DeclScope|Scope::ClassScope); 858 859 SourceLocation LBraceLoc = ConsumeBrace(); // the "{" 860 861 tok::ObjCKeywordKind visibility = tok::objc_protected; 862 // While we still have something to read, read the instance variables. 863 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 864 // Each iteration of this loop reads one objc-instance-variable-decl. 865 866 // Check for extraneous top-level semicolon. 867 if (Tok.is(tok::semi)) { 868 Diag(Tok, diag::ext_extra_struct_semi); 869 ConsumeToken(); 870 continue; 871 } 872 873 // Set the default visibility to private. 874 if (Tok.is(tok::at)) { // parse objc-visibility-spec 875 ConsumeToken(); // eat the @ sign 876 switch (Tok.getObjCKeywordID()) { 877 case tok::objc_private: 878 case tok::objc_public: 879 case tok::objc_protected: 880 case tok::objc_package: 881 visibility = Tok.getObjCKeywordID(); 882 ConsumeToken(); 883 continue; 884 default: 885 Diag(Tok, diag::err_objc_illegal_visibility_spec); 886 continue; 887 } 888 } 889 890 // Parse all the comma separated declarators. 891 DeclSpec DS; 892 FieldDeclarators.clear(); 893 ParseStructDeclaration(DS, FieldDeclarators); 894 895 // Convert them all to fields. 896 for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) { 897 FieldDeclarator &FD = FieldDeclarators[i]; 898 // Install the declarator into interfaceDecl. 899 DeclTy *Field = Actions.ActOnIvar(CurScope, 900 DS.getSourceRange().getBegin(), 901 FD.D, FD.BitfieldSize, visibility); 902 AllIvarDecls.push_back(Field); 903 } 904 905 if (Tok.is(tok::semi)) { 906 ConsumeToken(); 907 } else { 908 Diag(Tok, diag::err_expected_semi_decl_list); 909 // Skip to end of block or statement 910 SkipUntil(tok::r_brace, true, true); 911 } 912 } 913 SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc); 914 // Call ActOnFields() even if we don't have any decls. This is useful 915 // for code rewriting tools that need to be aware of the empty list. 916 Actions.ActOnFields(CurScope, atLoc, interfaceDecl, 917 &AllIvarDecls[0], AllIvarDecls.size(), 918 LBraceLoc, RBraceLoc, 0); 919 return; 920} 921 922/// objc-protocol-declaration: 923/// objc-protocol-definition 924/// objc-protocol-forward-reference 925/// 926/// objc-protocol-definition: 927/// @protocol identifier 928/// objc-protocol-refs[opt] 929/// objc-interface-decl-list 930/// @end 931/// 932/// objc-protocol-forward-reference: 933/// @protocol identifier-list ';' 934/// 935/// "@protocol identifier ;" should be resolved as "@protocol 936/// identifier-list ;": objc-interface-decl-list may not start with a 937/// semicolon in the first alternative if objc-protocol-refs are omitted. 938Parser::DeclTy *Parser::ParseObjCAtProtocolDeclaration(SourceLocation AtLoc, 939 AttributeList *attrList) { 940 assert(Tok.isObjCAtKeyword(tok::objc_protocol) && 941 "ParseObjCAtProtocolDeclaration(): Expected @protocol"); 942 ConsumeToken(); // the "protocol" identifier 943 944 if (Tok.isNot(tok::identifier)) { 945 Diag(Tok, diag::err_expected_ident); // missing protocol name. 946 return 0; 947 } 948 // Save the protocol name, then consume it. 949 IdentifierInfo *protocolName = Tok.getIdentifierInfo(); 950 SourceLocation nameLoc = ConsumeToken(); 951 952 if (Tok.is(tok::semi)) { // forward declaration of one protocol. 953 IdentifierLocPair ProtoInfo(protocolName, nameLoc); 954 ConsumeToken(); 955 return Actions.ActOnForwardProtocolDeclaration(AtLoc, &ProtoInfo, 1, 956 attrList); 957 } 958 959 if (Tok.is(tok::comma)) { // list of forward declarations. 960 llvm::SmallVector<IdentifierLocPair, 8> ProtocolRefs; 961 ProtocolRefs.push_back(std::make_pair(protocolName, nameLoc)); 962 963 // Parse the list of forward declarations. 964 while (1) { 965 ConsumeToken(); // the ',' 966 if (Tok.isNot(tok::identifier)) { 967 Diag(Tok, diag::err_expected_ident); 968 SkipUntil(tok::semi); 969 return 0; 970 } 971 ProtocolRefs.push_back(IdentifierLocPair(Tok.getIdentifierInfo(), 972 Tok.getLocation())); 973 ConsumeToken(); // the identifier 974 975 if (Tok.isNot(tok::comma)) 976 break; 977 } 978 // Consume the ';'. 979 if (ExpectAndConsume(tok::semi, diag::err_expected_semi_after, "@protocol")) 980 return 0; 981 982 return Actions.ActOnForwardProtocolDeclaration(AtLoc, 983 &ProtocolRefs[0], 984 ProtocolRefs.size(), 985 attrList); 986 } 987 988 // Last, and definitely not least, parse a protocol declaration. 989 SourceLocation EndProtoLoc; 990 991 llvm::SmallVector<DeclTy *, 8> ProtocolRefs; 992 if (Tok.is(tok::less) && 993 ParseObjCProtocolReferences(ProtocolRefs, true, EndProtoLoc)) 994 return 0; 995 996 DeclTy *ProtoType = 997 Actions.ActOnStartProtocolInterface(AtLoc, protocolName, nameLoc, 998 &ProtocolRefs[0], ProtocolRefs.size(), 999 EndProtoLoc, attrList); 1000 ParseObjCInterfaceDeclList(ProtoType, tok::objc_protocol); 1001 return ProtoType; 1002} 1003 1004/// objc-implementation: 1005/// objc-class-implementation-prologue 1006/// objc-category-implementation-prologue 1007/// 1008/// objc-class-implementation-prologue: 1009/// @implementation identifier objc-superclass[opt] 1010/// objc-class-instance-variables[opt] 1011/// 1012/// objc-category-implementation-prologue: 1013/// @implementation identifier ( identifier ) 1014 1015Parser::DeclTy *Parser::ParseObjCAtImplementationDeclaration( 1016 SourceLocation atLoc) { 1017 assert(Tok.isObjCAtKeyword(tok::objc_implementation) && 1018 "ParseObjCAtImplementationDeclaration(): Expected @implementation"); 1019 ConsumeToken(); // the "implementation" identifier 1020 1021 if (Tok.isNot(tok::identifier)) { 1022 Diag(Tok, diag::err_expected_ident); // missing class or category name. 1023 return 0; 1024 } 1025 // We have a class or category name - consume it. 1026 IdentifierInfo *nameId = Tok.getIdentifierInfo(); 1027 SourceLocation nameLoc = ConsumeToken(); // consume class or category name 1028 1029 if (Tok.is(tok::l_paren)) { 1030 // we have a category implementation. 1031 SourceLocation lparenLoc = ConsumeParen(); 1032 SourceLocation categoryLoc, rparenLoc; 1033 IdentifierInfo *categoryId = 0; 1034 1035 if (Tok.is(tok::identifier)) { 1036 categoryId = Tok.getIdentifierInfo(); 1037 categoryLoc = ConsumeToken(); 1038 } else { 1039 Diag(Tok, diag::err_expected_ident); // missing category name. 1040 return 0; 1041 } 1042 if (Tok.isNot(tok::r_paren)) { 1043 Diag(Tok, diag::err_expected_rparen); 1044 SkipUntil(tok::r_paren, false); // don't stop at ';' 1045 return 0; 1046 } 1047 rparenLoc = ConsumeParen(); 1048 DeclTy *ImplCatType = Actions.ActOnStartCategoryImplementation( 1049 atLoc, nameId, nameLoc, categoryId, 1050 categoryLoc); 1051 ObjCImpDecl = ImplCatType; 1052 return 0; 1053 } 1054 // We have a class implementation 1055 SourceLocation superClassLoc; 1056 IdentifierInfo *superClassId = 0; 1057 if (Tok.is(tok::colon)) { 1058 // We have a super class 1059 ConsumeToken(); 1060 if (Tok.isNot(tok::identifier)) { 1061 Diag(Tok, diag::err_expected_ident); // missing super class name. 1062 return 0; 1063 } 1064 superClassId = Tok.getIdentifierInfo(); 1065 superClassLoc = ConsumeToken(); // Consume super class name 1066 } 1067 DeclTy *ImplClsType = Actions.ActOnStartClassImplementation( 1068 atLoc, nameId, nameLoc, 1069 superClassId, superClassLoc); 1070 1071 if (Tok.is(tok::l_brace)) // we have ivars 1072 ParseObjCClassInstanceVariables(ImplClsType/*FIXME*/, atLoc); 1073 ObjCImpDecl = ImplClsType; 1074 1075 return 0; 1076} 1077 1078Parser::DeclTy *Parser::ParseObjCAtEndDeclaration(SourceLocation atLoc) { 1079 assert(Tok.isObjCAtKeyword(tok::objc_end) && 1080 "ParseObjCAtEndDeclaration(): Expected @end"); 1081 ConsumeToken(); // the "end" identifier 1082 if (ObjCImpDecl) 1083 Actions.ActOnAtEnd(atLoc, ObjCImpDecl); 1084 else 1085 Diag(atLoc, diag::warn_expected_implementation); // missing @implementation 1086 return ObjCImpDecl; 1087} 1088 1089/// compatibility-alias-decl: 1090/// @compatibility_alias alias-name class-name ';' 1091/// 1092Parser::DeclTy *Parser::ParseObjCAtAliasDeclaration(SourceLocation atLoc) { 1093 assert(Tok.isObjCAtKeyword(tok::objc_compatibility_alias) && 1094 "ParseObjCAtAliasDeclaration(): Expected @compatibility_alias"); 1095 ConsumeToken(); // consume compatibility_alias 1096 if (Tok.isNot(tok::identifier)) { 1097 Diag(Tok, diag::err_expected_ident); 1098 return 0; 1099 } 1100 IdentifierInfo *aliasId = Tok.getIdentifierInfo(); 1101 SourceLocation aliasLoc = ConsumeToken(); // consume alias-name 1102 if (Tok.isNot(tok::identifier)) { 1103 Diag(Tok, diag::err_expected_ident); 1104 return 0; 1105 } 1106 IdentifierInfo *classId = Tok.getIdentifierInfo(); 1107 SourceLocation classLoc = ConsumeToken(); // consume class-name; 1108 if (Tok.isNot(tok::semi)) { 1109 Diag(Tok, diag::err_expected_semi_after) << "@compatibility_alias"; 1110 return 0; 1111 } 1112 DeclTy *ClsType = Actions.ActOnCompatiblityAlias(atLoc, 1113 aliasId, aliasLoc, 1114 classId, classLoc); 1115 return ClsType; 1116} 1117 1118/// property-synthesis: 1119/// @synthesize property-ivar-list ';' 1120/// 1121/// property-ivar-list: 1122/// property-ivar 1123/// property-ivar-list ',' property-ivar 1124/// 1125/// property-ivar: 1126/// identifier 1127/// identifier '=' identifier 1128/// 1129Parser::DeclTy *Parser::ParseObjCPropertySynthesize(SourceLocation atLoc) { 1130 assert(Tok.isObjCAtKeyword(tok::objc_synthesize) && 1131 "ParseObjCPropertyDynamic(): Expected '@synthesize'"); 1132 SourceLocation loc = ConsumeToken(); // consume synthesize 1133 if (Tok.isNot(tok::identifier)) { 1134 Diag(Tok, diag::err_expected_ident); 1135 return 0; 1136 } 1137 while (Tok.is(tok::identifier)) { 1138 IdentifierInfo *propertyIvar = 0; 1139 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 1140 SourceLocation propertyLoc = ConsumeToken(); // consume property name 1141 if (Tok.is(tok::equal)) { 1142 // property '=' ivar-name 1143 ConsumeToken(); // consume '=' 1144 if (Tok.isNot(tok::identifier)) { 1145 Diag(Tok, diag::err_expected_ident); 1146 break; 1147 } 1148 propertyIvar = Tok.getIdentifierInfo(); 1149 ConsumeToken(); // consume ivar-name 1150 } 1151 Actions.ActOnPropertyImplDecl(atLoc, propertyLoc, true, ObjCImpDecl, 1152 propertyId, propertyIvar); 1153 if (Tok.isNot(tok::comma)) 1154 break; 1155 ConsumeToken(); // consume ',' 1156 } 1157 if (Tok.isNot(tok::semi)) 1158 Diag(Tok, diag::err_expected_semi_after) << "@synthesize"; 1159 return 0; 1160} 1161 1162/// property-dynamic: 1163/// @dynamic property-list 1164/// 1165/// property-list: 1166/// identifier 1167/// property-list ',' identifier 1168/// 1169Parser::DeclTy *Parser::ParseObjCPropertyDynamic(SourceLocation atLoc) { 1170 assert(Tok.isObjCAtKeyword(tok::objc_dynamic) && 1171 "ParseObjCPropertyDynamic(): Expected '@dynamic'"); 1172 SourceLocation loc = ConsumeToken(); // consume dynamic 1173 if (Tok.isNot(tok::identifier)) { 1174 Diag(Tok, diag::err_expected_ident); 1175 return 0; 1176 } 1177 while (Tok.is(tok::identifier)) { 1178 IdentifierInfo *propertyId = Tok.getIdentifierInfo(); 1179 SourceLocation propertyLoc = ConsumeToken(); // consume property name 1180 Actions.ActOnPropertyImplDecl(atLoc, propertyLoc, false, ObjCImpDecl, 1181 propertyId, 0); 1182 1183 if (Tok.isNot(tok::comma)) 1184 break; 1185 ConsumeToken(); // consume ',' 1186 } 1187 if (Tok.isNot(tok::semi)) 1188 Diag(Tok, diag::err_expected_semi_after) << "@dynamic"; 1189 return 0; 1190} 1191 1192/// objc-throw-statement: 1193/// throw expression[opt]; 1194/// 1195Parser::OwningStmtResult Parser::ParseObjCThrowStmt(SourceLocation atLoc) { 1196 OwningExprResult Res(Actions); 1197 ConsumeToken(); // consume throw 1198 if (Tok.isNot(tok::semi)) { 1199 Res = ParseExpression(); 1200 if (Res.isInvalid()) { 1201 SkipUntil(tok::semi); 1202 return StmtError(); 1203 } 1204 } 1205 ConsumeToken(); // consume ';' 1206 return Actions.ActOnObjCAtThrowStmt(atLoc, move(Res), CurScope); 1207} 1208 1209/// objc-synchronized-statement: 1210/// @synchronized '(' expression ')' compound-statement 1211/// 1212Parser::OwningStmtResult 1213Parser::ParseObjCSynchronizedStmt(SourceLocation atLoc) { 1214 ConsumeToken(); // consume synchronized 1215 if (Tok.isNot(tok::l_paren)) { 1216 Diag(Tok, diag::err_expected_lparen_after) << "@synchronized"; 1217 return StmtError(); 1218 } 1219 ConsumeParen(); // '(' 1220 OwningExprResult Res(ParseExpression()); 1221 if (Res.isInvalid()) { 1222 SkipUntil(tok::semi); 1223 return StmtError(); 1224 } 1225 if (Tok.isNot(tok::r_paren)) { 1226 Diag(Tok, diag::err_expected_lbrace); 1227 return StmtError(); 1228 } 1229 ConsumeParen(); // ')' 1230 if (Tok.isNot(tok::l_brace)) { 1231 Diag(Tok, diag::err_expected_lbrace); 1232 return StmtError(); 1233 } 1234 // Enter a scope to hold everything within the compound stmt. Compound 1235 // statements can always hold declarations. 1236 ParseScope BodyScope(this, Scope::DeclScope); 1237 1238 OwningStmtResult SynchBody(ParseCompoundStatementBody()); 1239 1240 BodyScope.Exit(); 1241 if (SynchBody.isInvalid()) 1242 SynchBody = Actions.ActOnNullStmt(Tok.getLocation()); 1243 return Actions.ActOnObjCAtSynchronizedStmt(atLoc, move(Res), move(SynchBody)); 1244} 1245 1246/// objc-try-catch-statement: 1247/// @try compound-statement objc-catch-list[opt] 1248/// @try compound-statement objc-catch-list[opt] @finally compound-statement 1249/// 1250/// objc-catch-list: 1251/// @catch ( parameter-declaration ) compound-statement 1252/// objc-catch-list @catch ( catch-parameter-declaration ) compound-statement 1253/// catch-parameter-declaration: 1254/// parameter-declaration 1255/// '...' [OBJC2] 1256/// 1257Parser::OwningStmtResult Parser::ParseObjCTryStmt(SourceLocation atLoc) { 1258 bool catch_or_finally_seen = false; 1259 1260 ConsumeToken(); // consume try 1261 if (Tok.isNot(tok::l_brace)) { 1262 Diag(Tok, diag::err_expected_lbrace); 1263 return StmtError(); 1264 } 1265 OwningStmtResult CatchStmts(Actions); 1266 OwningStmtResult FinallyStmt(Actions); 1267 ParseScope TryScope(this, Scope::DeclScope); 1268 OwningStmtResult TryBody(ParseCompoundStatementBody()); 1269 TryScope.Exit(); 1270 if (TryBody.isInvalid()) 1271 TryBody = Actions.ActOnNullStmt(Tok.getLocation()); 1272 1273 while (Tok.is(tok::at)) { 1274 // At this point, we need to lookahead to determine if this @ is the start 1275 // of an @catch or @finally. We don't want to consume the @ token if this 1276 // is an @try or @encode or something else. 1277 Token AfterAt = GetLookAheadToken(1); 1278 if (!AfterAt.isObjCAtKeyword(tok::objc_catch) && 1279 !AfterAt.isObjCAtKeyword(tok::objc_finally)) 1280 break; 1281 1282 SourceLocation AtCatchFinallyLoc = ConsumeToken(); 1283 if (Tok.isObjCAtKeyword(tok::objc_catch)) { 1284 OwningStmtResult FirstPart(Actions); 1285 ConsumeToken(); // consume catch 1286 if (Tok.is(tok::l_paren)) { 1287 ConsumeParen(); 1288 ParseScope CatchScope(this, Scope::DeclScope|Scope::AtCatchScope); 1289 if (Tok.isNot(tok::ellipsis)) { 1290 DeclSpec DS; 1291 ParseDeclarationSpecifiers(DS); 1292 // For some odd reason, the name of the exception variable is 1293 // optional. As a result, we need to use PrototypeContext. 1294 Declarator DeclaratorInfo(DS, Declarator::PrototypeContext); 1295 ParseDeclarator(DeclaratorInfo); 1296 if (DeclaratorInfo.getIdentifier()) { 1297 DeclTy *aBlockVarDecl = Actions.ActOnDeclarator(CurScope, 1298 DeclaratorInfo, 0); 1299 FirstPart = 1300 Actions.ActOnDeclStmt(aBlockVarDecl, 1301 DS.getSourceRange().getBegin(), 1302 DeclaratorInfo.getSourceRange().getEnd()); 1303 } 1304 } else 1305 ConsumeToken(); // consume '...' 1306 SourceLocation RParenLoc = ConsumeParen(); 1307 1308 OwningStmtResult CatchBody(Actions, true); 1309 if (Tok.is(tok::l_brace)) 1310 CatchBody = ParseCompoundStatementBody(); 1311 else 1312 Diag(Tok, diag::err_expected_lbrace); 1313 if (CatchBody.isInvalid()) 1314 CatchBody = Actions.ActOnNullStmt(Tok.getLocation()); 1315 CatchStmts = Actions.ActOnObjCAtCatchStmt(AtCatchFinallyLoc, 1316 RParenLoc, move(FirstPart), move(CatchBody), 1317 move(CatchStmts)); 1318 } else { 1319 Diag(AtCatchFinallyLoc, diag::err_expected_lparen_after) 1320 << "@catch clause"; 1321 return StmtError(); 1322 } 1323 catch_or_finally_seen = true; 1324 } else { 1325 assert(Tok.isObjCAtKeyword(tok::objc_finally) && "Lookahead confused?"); 1326 ConsumeToken(); // consume finally 1327 ParseScope FinallyScope(this, Scope::DeclScope); 1328 1329 OwningStmtResult FinallyBody(Actions, true); 1330 if (Tok.is(tok::l_brace)) 1331 FinallyBody = ParseCompoundStatementBody(); 1332 else 1333 Diag(Tok, diag::err_expected_lbrace); 1334 if (FinallyBody.isInvalid()) 1335 FinallyBody = Actions.ActOnNullStmt(Tok.getLocation()); 1336 FinallyStmt = Actions.ActOnObjCAtFinallyStmt(AtCatchFinallyLoc, 1337 move(FinallyBody)); 1338 catch_or_finally_seen = true; 1339 break; 1340 } 1341 } 1342 if (!catch_or_finally_seen) { 1343 Diag(atLoc, diag::err_missing_catch_finally); 1344 return StmtError(); 1345 } 1346 return Actions.ActOnObjCAtTryStmt(atLoc, move(TryBody), move(CatchStmts), 1347 move(FinallyStmt)); 1348} 1349 1350/// objc-method-def: objc-method-proto ';'[opt] '{' body '}' 1351/// 1352Parser::DeclTy *Parser::ParseObjCMethodDefinition() { 1353 DeclTy *MDecl = ParseObjCMethodPrototype(ObjCImpDecl); 1354 // parse optional ';' 1355 if (Tok.is(tok::semi)) 1356 ConsumeToken(); 1357 1358 // We should have an opening brace now. 1359 if (Tok.isNot(tok::l_brace)) { 1360 Diag(Tok, diag::err_expected_method_body); 1361 1362 // Skip over garbage, until we get to '{'. Don't eat the '{'. 1363 SkipUntil(tok::l_brace, true, true); 1364 1365 // If we didn't find the '{', bail out. 1366 if (Tok.isNot(tok::l_brace)) 1367 return 0; 1368 } 1369 SourceLocation BraceLoc = Tok.getLocation(); 1370 1371 // Enter a scope for the method body. 1372 ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope); 1373 1374 // Tell the actions module that we have entered a method definition with the 1375 // specified Declarator for the method. 1376 Actions.ObjCActOnStartOfMethodDef(CurScope, MDecl); 1377 1378 OwningStmtResult FnBody(ParseCompoundStatementBody()); 1379 1380 // If the function body could not be parsed, make a bogus compoundstmt. 1381 if (FnBody.isInvalid()) 1382 FnBody = Actions.ActOnCompoundStmt(BraceLoc, BraceLoc, 1383 MultiStmtArg(Actions), false); 1384 1385 // Leave the function body scope. 1386 BodyScope.Exit(); 1387 1388 // TODO: Pass argument information. 1389 Actions.ActOnFinishFunctionBody(MDecl, move(FnBody)); 1390 return MDecl; 1391} 1392 1393Parser::OwningStmtResult Parser::ParseObjCAtStatement(SourceLocation AtLoc) { 1394 if (Tok.isObjCAtKeyword(tok::objc_try)) { 1395 return ParseObjCTryStmt(AtLoc); 1396 } else if (Tok.isObjCAtKeyword(tok::objc_throw)) 1397 return ParseObjCThrowStmt(AtLoc); 1398 else if (Tok.isObjCAtKeyword(tok::objc_synchronized)) 1399 return ParseObjCSynchronizedStmt(AtLoc); 1400 OwningExprResult Res(ParseExpressionWithLeadingAt(AtLoc)); 1401 if (Res.isInvalid()) { 1402 // If the expression is invalid, skip ahead to the next semicolon. Not 1403 // doing this opens us up to the possibility of infinite loops if 1404 // ParseExpression does not consume any tokens. 1405 SkipUntil(tok::semi); 1406 return StmtError(); 1407 } 1408 // Otherwise, eat the semicolon. 1409 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr); 1410 return Actions.ActOnExprStmt(move(Res)); 1411} 1412 1413Parser::OwningExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) { 1414 switch (Tok.getKind()) { 1415 case tok::string_literal: // primary-expression: string-literal 1416 case tok::wide_string_literal: 1417 return ParsePostfixExpressionSuffix(ParseObjCStringLiteral(AtLoc)); 1418 default: 1419 if (Tok.getIdentifierInfo() == 0) 1420 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 1421 1422 switch (Tok.getIdentifierInfo()->getObjCKeywordID()) { 1423 case tok::objc_encode: 1424 return ParsePostfixExpressionSuffix(ParseObjCEncodeExpression(AtLoc)); 1425 case tok::objc_protocol: 1426 return ParsePostfixExpressionSuffix(ParseObjCProtocolExpression(AtLoc)); 1427 case tok::objc_selector: 1428 return ParsePostfixExpressionSuffix(ParseObjCSelectorExpression(AtLoc)); 1429 default: 1430 return ExprError(Diag(AtLoc, diag::err_unexpected_at)); 1431 } 1432 } 1433} 1434 1435/// objc-message-expr: 1436/// '[' objc-receiver objc-message-args ']' 1437/// 1438/// objc-receiver: 1439/// expression 1440/// class-name 1441/// type-name 1442Parser::OwningExprResult Parser::ParseObjCMessageExpression() { 1443 assert(Tok.is(tok::l_square) && "'[' expected"); 1444 SourceLocation LBracLoc = ConsumeBracket(); // consume '[' 1445 1446 // Parse receiver 1447 if (isTokObjCMessageIdentifierReceiver()) { 1448 IdentifierInfo *ReceiverName = Tok.getIdentifierInfo(); 1449 SourceLocation NameLoc = ConsumeToken(); 1450 return ParseObjCMessageExpressionBody(LBracLoc, NameLoc, ReceiverName, 1451 ExprArg(Actions)); 1452 } 1453 1454 OwningExprResult Res(ParseExpression()); 1455 if (Res.isInvalid()) { 1456 SkipUntil(tok::r_square); 1457 return move(Res); 1458 } 1459 1460 return ParseObjCMessageExpressionBody(LBracLoc, SourceLocation(), 1461 0, move(Res)); 1462} 1463 1464/// ParseObjCMessageExpressionBody - Having parsed "'[' objc-receiver", parse 1465/// the rest of a message expression. 1466/// 1467/// objc-message-args: 1468/// objc-selector 1469/// objc-keywordarg-list 1470/// 1471/// objc-keywordarg-list: 1472/// objc-keywordarg 1473/// objc-keywordarg-list objc-keywordarg 1474/// 1475/// objc-keywordarg: 1476/// selector-name[opt] ':' objc-keywordexpr 1477/// 1478/// objc-keywordexpr: 1479/// nonempty-expr-list 1480/// 1481/// nonempty-expr-list: 1482/// assignment-expression 1483/// nonempty-expr-list , assignment-expression 1484/// 1485Parser::OwningExprResult 1486Parser::ParseObjCMessageExpressionBody(SourceLocation LBracLoc, 1487 SourceLocation NameLoc, 1488 IdentifierInfo *ReceiverName, 1489 ExprArg ReceiverExpr) { 1490 // Parse objc-selector 1491 SourceLocation Loc; 1492 IdentifierInfo *selIdent = ParseObjCSelector(Loc); 1493 1494 SourceLocation SelectorLoc = Loc; 1495 1496 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents; 1497 ExprVector KeyExprs(Actions); 1498 1499 if (Tok.is(tok::colon)) { 1500 while (1) { 1501 // Each iteration parses a single keyword argument. 1502 KeyIdents.push_back(selIdent); 1503 1504 if (Tok.isNot(tok::colon)) { 1505 Diag(Tok, diag::err_expected_colon); 1506 // We must manually skip to a ']', otherwise the expression skipper will 1507 // stop at the ']' when it skips to the ';'. We want it to skip beyond 1508 // the enclosing expression. 1509 SkipUntil(tok::r_square); 1510 return ExprError(); 1511 } 1512 1513 ConsumeToken(); // Eat the ':'. 1514 /// Parse the expression after ':' 1515 OwningExprResult Res(ParseAssignmentExpression()); 1516 if (Res.isInvalid()) { 1517 // We must manually skip to a ']', otherwise the expression skipper will 1518 // stop at the ']' when it skips to the ';'. We want it to skip beyond 1519 // the enclosing expression. 1520 SkipUntil(tok::r_square); 1521 return move(Res); 1522 } 1523 1524 // We have a valid expression. 1525 KeyExprs.push_back(Res.release()); 1526 1527 // Check for another keyword selector. 1528 selIdent = ParseObjCSelector(Loc); 1529 if (!selIdent && Tok.isNot(tok::colon)) 1530 break; 1531 // We have a selector or a colon, continue parsing. 1532 } 1533 // Parse the, optional, argument list, comma separated. 1534 while (Tok.is(tok::comma)) { 1535 ConsumeToken(); // Eat the ','. 1536 /// Parse the expression after ',' 1537 OwningExprResult Res(ParseAssignmentExpression()); 1538 if (Res.isInvalid()) { 1539 // We must manually skip to a ']', otherwise the expression skipper will 1540 // stop at the ']' when it skips to the ';'. We want it to skip beyond 1541 // the enclosing expression. 1542 SkipUntil(tok::r_square); 1543 return move(Res); 1544 } 1545 1546 // We have a valid expression. 1547 KeyExprs.push_back(Res.release()); 1548 } 1549 } else if (!selIdent) { 1550 Diag(Tok, diag::err_expected_ident); // missing selector name. 1551 1552 // We must manually skip to a ']', otherwise the expression skipper will 1553 // stop at the ']' when it skips to the ';'. We want it to skip beyond 1554 // the enclosing expression. 1555 SkipUntil(tok::r_square); 1556 return ExprError(); 1557 } 1558 1559 if (Tok.isNot(tok::r_square)) { 1560 Diag(Tok, diag::err_expected_rsquare); 1561 // We must manually skip to a ']', otherwise the expression skipper will 1562 // stop at the ']' when it skips to the ';'. We want it to skip beyond 1563 // the enclosing expression. 1564 SkipUntil(tok::r_square); 1565 return ExprError(); 1566 } 1567 1568 SourceLocation RBracLoc = ConsumeBracket(); // consume ']' 1569 1570 unsigned nKeys = KeyIdents.size(); 1571 if (nKeys == 0) 1572 KeyIdents.push_back(selIdent); 1573 Selector Sel = PP.getSelectorTable().getSelector(nKeys, &KeyIdents[0]); 1574 1575 // We've just parsed a keyword message. 1576 if (ReceiverName) 1577 return Owned(Actions.ActOnClassMessage(CurScope, ReceiverName, Sel, 1578 LBracLoc, NameLoc, SelectorLoc, 1579 RBracLoc, 1580 KeyExprs.take(), KeyExprs.size())); 1581 return Owned(Actions.ActOnInstanceMessage(ReceiverExpr.release(), Sel, 1582 LBracLoc, SelectorLoc, RBracLoc, 1583 KeyExprs.take(), KeyExprs.size())); 1584} 1585 1586Parser::OwningExprResult Parser::ParseObjCStringLiteral(SourceLocation AtLoc) { 1587 OwningExprResult Res(ParseStringLiteralExpression()); 1588 if (Res.isInvalid()) return move(Res); 1589 1590 // @"foo" @"bar" is a valid concatenated string. Eat any subsequent string 1591 // expressions. At this point, we know that the only valid thing that starts 1592 // with '@' is an @"". 1593 llvm::SmallVector<SourceLocation, 4> AtLocs; 1594 ExprVector AtStrings(Actions); 1595 AtLocs.push_back(AtLoc); 1596 AtStrings.push_back(Res.release()); 1597 1598 while (Tok.is(tok::at)) { 1599 AtLocs.push_back(ConsumeToken()); // eat the @. 1600 1601 // Invalid unless there is a string literal. 1602 OwningExprResult Lit(Actions, true); 1603 if (isTokenStringLiteral()) 1604 Lit = ParseStringLiteralExpression(); 1605 else 1606 Diag(Tok, diag::err_objc_concat_string); 1607 1608 if (Lit.isInvalid()) 1609 return move(Lit); 1610 1611 AtStrings.push_back(Lit.release()); 1612 } 1613 1614 return Owned(Actions.ParseObjCStringLiteral(&AtLocs[0], AtStrings.take(), 1615 AtStrings.size())); 1616} 1617 1618/// objc-encode-expression: 1619/// @encode ( type-name ) 1620Parser::OwningExprResult 1621Parser::ParseObjCEncodeExpression(SourceLocation AtLoc) { 1622 assert(Tok.isObjCAtKeyword(tok::objc_encode) && "Not an @encode expression!"); 1623 1624 SourceLocation EncLoc = ConsumeToken(); 1625 1626 if (Tok.isNot(tok::l_paren)) 1627 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@encode"); 1628 1629 SourceLocation LParenLoc = ConsumeParen(); 1630 1631 TypeTy *Ty = ParseTypeName(); 1632 1633 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1634 1635 return Owned(Actions.ParseObjCEncodeExpression(AtLoc, EncLoc, LParenLoc, Ty, 1636 RParenLoc)); 1637} 1638 1639/// objc-protocol-expression 1640/// @protocol ( protocol-name ) 1641Parser::OwningExprResult 1642Parser::ParseObjCProtocolExpression(SourceLocation AtLoc) { 1643 SourceLocation ProtoLoc = ConsumeToken(); 1644 1645 if (Tok.isNot(tok::l_paren)) 1646 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@protocol"); 1647 1648 SourceLocation LParenLoc = ConsumeParen(); 1649 1650 if (Tok.isNot(tok::identifier)) 1651 return ExprError(Diag(Tok, diag::err_expected_ident)); 1652 1653 IdentifierInfo *protocolId = Tok.getIdentifierInfo(); 1654 ConsumeToken(); 1655 1656 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1657 1658 return Owned(Actions.ParseObjCProtocolExpression(protocolId, AtLoc, ProtoLoc, 1659 LParenLoc, RParenLoc)); 1660} 1661 1662/// objc-selector-expression 1663/// @selector '(' objc-keyword-selector ')' 1664Parser::OwningExprResult 1665Parser::ParseObjCSelectorExpression(SourceLocation AtLoc) { 1666 SourceLocation SelectorLoc = ConsumeToken(); 1667 1668 if (Tok.isNot(tok::l_paren)) 1669 return ExprError(Diag(Tok, diag::err_expected_lparen_after) << "@selector"); 1670 1671 llvm::SmallVector<IdentifierInfo *, 12> KeyIdents; 1672 SourceLocation LParenLoc = ConsumeParen(); 1673 SourceLocation sLoc; 1674 IdentifierInfo *SelIdent = ParseObjCSelector(sLoc); 1675 if (!SelIdent && Tok.isNot(tok::colon)) // missing selector name. 1676 return ExprError(Diag(Tok, diag::err_expected_ident)); 1677 1678 KeyIdents.push_back(SelIdent); 1679 unsigned nColons = 0; 1680 if (Tok.isNot(tok::r_paren)) { 1681 while (1) { 1682 if (Tok.isNot(tok::colon)) 1683 return ExprError(Diag(Tok, diag::err_expected_colon)); 1684 1685 nColons++; 1686 ConsumeToken(); // Eat the ':'. 1687 if (Tok.is(tok::r_paren)) 1688 break; 1689 // Check for another keyword selector. 1690 SourceLocation Loc; 1691 SelIdent = ParseObjCSelector(Loc); 1692 KeyIdents.push_back(SelIdent); 1693 if (!SelIdent && Tok.isNot(tok::colon)) 1694 break; 1695 } 1696 } 1697 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1698 Selector Sel = PP.getSelectorTable().getSelector(nColons, &KeyIdents[0]); 1699 return Owned(Actions.ParseObjCSelectorExpression(Sel, AtLoc, SelectorLoc, 1700 LParenLoc, RParenLoc)); 1701 } 1702