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