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