ParseDecl.cpp revision 55f6b14230c94272efbbcdd89a92224c8db9f225 
1//===--- ParseDecl.cpp - Declaration Parsing ------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file implements the Declaration portions of the Parser interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/Parser.h"
15#include "clang/Parse/ParseDiagnostic.h"
16#include "clang/Parse/Scope.h"
17#include "ExtensionRAIIObject.h"
18#include "AstGuard.h"
19#include "llvm/ADT/SmallSet.h"
20using namespace clang;
21
22//===----------------------------------------------------------------------===//
23// C99 6.7: Declarations.
24//===----------------------------------------------------------------------===//
25
26/// ParseTypeName
27///       type-name: [C99 6.7.6]
28///         specifier-qualifier-list abstract-declarator[opt]
29///
30/// Called type-id in C++.
31Parser::TypeTy *Parser::ParseTypeName() {
32  // Parse the common declaration-specifiers piece.
33  DeclSpec DS;
34  ParseSpecifierQualifierList(DS);
35
36  // Parse the abstract-declarator, if present.
37  Declarator DeclaratorInfo(DS, Declarator::TypeNameContext);
38  ParseDeclarator(DeclaratorInfo);
39
40  return Actions.ActOnTypeName(CurScope, DeclaratorInfo).get();
41}
42
43/// ParseAttributes - Parse a non-empty attributes list.
44///
45/// [GNU] attributes:
46///         attribute
47///         attributes attribute
48///
49/// [GNU]  attribute:
50///          '__attribute__' '(' '(' attribute-list ')' ')'
51///
52/// [GNU]  attribute-list:
53///          attrib
54///          attribute_list ',' attrib
55///
56/// [GNU]  attrib:
57///          empty
58///          attrib-name
59///          attrib-name '(' identifier ')'
60///          attrib-name '(' identifier ',' nonempty-expr-list ')'
61///          attrib-name '(' argument-expression-list [C99 6.5.2] ')'
62///
63/// [GNU]  attrib-name:
64///          identifier
65///          typespec
66///          typequal
67///          storageclass
68///
69/// FIXME: The GCC grammar/code for this construct implies we need two
70/// token lookahead. Comment from gcc: "If they start with an identifier
71/// which is followed by a comma or close parenthesis, then the arguments
72/// start with that identifier; otherwise they are an expression list."
73///
74/// At the moment, I am not doing 2 token lookahead. I am also unaware of
75/// any attributes that don't work (based on my limited testing). Most
76/// attributes are very simple in practice. Until we find a bug, I don't see
77/// a pressing need to implement the 2 token lookahead.
78
79AttributeList *Parser::ParseAttributes(SourceLocation *EndLoc) {
80  assert(Tok.is(tok::kw___attribute) && "Not an attribute list!");
81
82  AttributeList *CurrAttr = 0;
83
84  while (Tok.is(tok::kw___attribute)) {
85    ConsumeToken();
86    if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
87                         "attribute")) {
88      SkipUntil(tok::r_paren, true); // skip until ) or ;
89      return CurrAttr;
90    }
91    if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) {
92      SkipUntil(tok::r_paren, true); // skip until ) or ;
93      return CurrAttr;
94    }
95    // Parse the attribute-list. e.g. __attribute__(( weak, alias("__f") ))
96    while (Tok.is(tok::identifier) || isDeclarationSpecifier() ||
97           Tok.is(tok::comma)) {
98
99      if (Tok.is(tok::comma)) {
100        // allows for empty/non-empty attributes. ((__vector_size__(16),,,,))
101        ConsumeToken();
102        continue;
103      }
104      // we have an identifier or declaration specifier (const, int, etc.)
105      IdentifierInfo *AttrName = Tok.getIdentifierInfo();
106      SourceLocation AttrNameLoc = ConsumeToken();
107
108      // check if we have a "paramterized" attribute
109      if (Tok.is(tok::l_paren)) {
110        ConsumeParen(); // ignore the left paren loc for now
111
112        if (Tok.is(tok::identifier)) {
113          IdentifierInfo *ParmName = Tok.getIdentifierInfo();
114          SourceLocation ParmLoc = ConsumeToken();
115
116          if (Tok.is(tok::r_paren)) {
117            // __attribute__(( mode(byte) ))
118            ConsumeParen(); // ignore the right paren loc for now
119            CurrAttr = new AttributeList(AttrName, AttrNameLoc,
120                                         ParmName, ParmLoc, 0, 0, CurrAttr);
121          } else if (Tok.is(tok::comma)) {
122            ConsumeToken();
123            // __attribute__(( format(printf, 1, 2) ))
124            ExprVector ArgExprs(Actions);
125            bool ArgExprsOk = true;
126
127            // now parse the non-empty comma separated list of expressions
128            while (1) {
129              OwningExprResult ArgExpr(ParseAssignmentExpression());
130              if (ArgExpr.isInvalid()) {
131                ArgExprsOk = false;
132                SkipUntil(tok::r_paren);
133                break;
134              } else {
135                ArgExprs.push_back(ArgExpr.release());
136              }
137              if (Tok.isNot(tok::comma))
138                break;
139              ConsumeToken(); // Eat the comma, move to the next argument
140            }
141            if (ArgExprsOk && Tok.is(tok::r_paren)) {
142              ConsumeParen(); // ignore the right paren loc for now
143              CurrAttr = new AttributeList(AttrName, AttrNameLoc, ParmName,
144                           ParmLoc, ArgExprs.take(), ArgExprs.size(), CurrAttr);
145            }
146          }
147        } else { // not an identifier
148          // parse a possibly empty comma separated list of expressions
149          if (Tok.is(tok::r_paren)) {
150            // __attribute__(( nonnull() ))
151            ConsumeParen(); // ignore the right paren loc for now
152            CurrAttr = new AttributeList(AttrName, AttrNameLoc,
153                                         0, SourceLocation(), 0, 0, CurrAttr);
154          } else {
155            // __attribute__(( aligned(16) ))
156            ExprVector ArgExprs(Actions);
157            bool ArgExprsOk = true;
158
159            // now parse the list of expressions
160            while (1) {
161              OwningExprResult ArgExpr(ParseAssignmentExpression());
162              if (ArgExpr.isInvalid()) {
163                ArgExprsOk = false;
164                SkipUntil(tok::r_paren);
165                break;
166              } else {
167                ArgExprs.push_back(ArgExpr.release());
168              }
169              if (Tok.isNot(tok::comma))
170                break;
171              ConsumeToken(); // Eat the comma, move to the next argument
172            }
173            // Match the ')'.
174            if (ArgExprsOk && Tok.is(tok::r_paren)) {
175              ConsumeParen(); // ignore the right paren loc for now
176              CurrAttr = new AttributeList(AttrName, AttrNameLoc, 0,
177                           SourceLocation(), ArgExprs.take(), ArgExprs.size(),
178                           CurrAttr);
179            }
180          }
181        }
182      } else {
183        CurrAttr = new AttributeList(AttrName, AttrNameLoc,
184                                     0, SourceLocation(), 0, 0, CurrAttr);
185      }
186    }
187    if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen))
188      SkipUntil(tok::r_paren, false);
189    SourceLocation Loc = Tok.getLocation();;
190    if (ExpectAndConsume(tok::r_paren, diag::err_expected_rparen)) {
191      SkipUntil(tok::r_paren, false);
192    }
193    if (EndLoc)
194      *EndLoc = Loc;
195  }
196  return CurrAttr;
197}
198
199/// FuzzyParseMicrosoftDeclSpec. When -fms-extensions is enabled, this
200/// routine is called to skip/ignore tokens that comprise the MS declspec.
201void Parser::FuzzyParseMicrosoftDeclSpec() {
202  assert(Tok.is(tok::kw___declspec) && "Not a declspec!");
203  ConsumeToken();
204  if (Tok.is(tok::l_paren)) {
205    unsigned short savedParenCount = ParenCount;
206    do {
207      ConsumeAnyToken();
208    } while (ParenCount > savedParenCount && Tok.isNot(tok::eof));
209  }
210  return;
211}
212
213/// ParseDeclaration - Parse a full 'declaration', which consists of
214/// declaration-specifiers, some number of declarators, and a semicolon.
215/// 'Context' should be a Declarator::TheContext value.
216///
217///       declaration: [C99 6.7]
218///         block-declaration ->
219///           simple-declaration
220///           others                   [FIXME]
221/// [C++]   template-declaration
222/// [C++]   namespace-definition
223/// [C++]   using-directive
224/// [C++]   using-declaration [TODO]
225///         others... [FIXME]
226///
227Parser::DeclTy *Parser::ParseDeclaration(unsigned Context) {
228  switch (Tok.getKind()) {
229  case tok::kw_export:
230  case tok::kw_template:
231    return ParseTemplateDeclaration(Context);
232  case tok::kw_namespace:
233    return ParseNamespace(Context);
234  case tok::kw_using:
235    return ParseUsingDirectiveOrDeclaration(Context);
236  default:
237    return ParseSimpleDeclaration(Context);
238  }
239}
240
241///       simple-declaration: [C99 6.7: declaration] [C++ 7p1: dcl.dcl]
242///         declaration-specifiers init-declarator-list[opt] ';'
243///[C90/C++]init-declarator-list ';'                             [TODO]
244/// [OMP]   threadprivate-directive                              [TODO]
245Parser::DeclTy *Parser::ParseSimpleDeclaration(unsigned Context) {
246  // Parse the common declaration-specifiers piece.
247  DeclSpec DS;
248  ParseDeclarationSpecifiers(DS);
249
250  // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
251  // declaration-specifiers init-declarator-list[opt] ';'
252  if (Tok.is(tok::semi)) {
253    ConsumeToken();
254    return Actions.ParsedFreeStandingDeclSpec(CurScope, DS);
255  }
256
257  Declarator DeclaratorInfo(DS, (Declarator::TheContext)Context);
258  ParseDeclarator(DeclaratorInfo);
259
260  return ParseInitDeclaratorListAfterFirstDeclarator(DeclaratorInfo);
261}
262
263
264/// ParseInitDeclaratorListAfterFirstDeclarator - Parse 'declaration' after
265/// parsing 'declaration-specifiers declarator'.  This method is split out this
266/// way to handle the ambiguity between top-level function-definitions and
267/// declarations.
268///
269///       init-declarator-list: [C99 6.7]
270///         init-declarator
271///         init-declarator-list ',' init-declarator
272///       init-declarator: [C99 6.7]
273///         declarator
274///         declarator '=' initializer
275/// [GNU]   declarator simple-asm-expr[opt] attributes[opt]
276/// [GNU]   declarator simple-asm-expr[opt] attributes[opt] '=' initializer
277/// [C++]   declarator initializer[opt]
278///
279/// [C++] initializer:
280/// [C++]   '=' initializer-clause
281/// [C++]   '(' expression-list ')'
282///
283Parser::DeclTy *Parser::
284ParseInitDeclaratorListAfterFirstDeclarator(Declarator &D) {
285
286  // Declarators may be grouped together ("int X, *Y, Z();").  Provide info so
287  // that they can be chained properly if the actions want this.
288  Parser::DeclTy *LastDeclInGroup = 0;
289
290  // At this point, we know that it is not a function definition.  Parse the
291  // rest of the init-declarator-list.
292  while (1) {
293    // If a simple-asm-expr is present, parse it.
294    if (Tok.is(tok::kw_asm)) {
295      SourceLocation Loc;
296      OwningExprResult AsmLabel(ParseSimpleAsm(&Loc));
297      if (AsmLabel.isInvalid()) {
298        SkipUntil(tok::semi);
299        return 0;
300      }
301
302      D.setAsmLabel(AsmLabel.release());
303      D.SetRangeEnd(Loc);
304    }
305
306    // If attributes are present, parse them.
307    if (Tok.is(tok::kw___attribute)) {
308      SourceLocation Loc;
309      AttributeList *AttrList = ParseAttributes(&Loc);
310      D.AddAttributes(AttrList, Loc);
311    }
312
313    // Inform the current actions module that we just parsed this declarator.
314    LastDeclInGroup = Actions.ActOnDeclarator(CurScope, D, LastDeclInGroup);
315
316    // Parse declarator '=' initializer.
317    if (Tok.is(tok::equal)) {
318      ConsumeToken();
319      OwningExprResult Init(ParseInitializer());
320      if (Init.isInvalid()) {
321        SkipUntil(tok::semi);
322        return 0;
323      }
324      Actions.AddInitializerToDecl(LastDeclInGroup, move(Init));
325    } else if (Tok.is(tok::l_paren)) {
326      // Parse C++ direct initializer: '(' expression-list ')'
327      SourceLocation LParenLoc = ConsumeParen();
328      ExprVector Exprs(Actions);
329      CommaLocsTy CommaLocs;
330
331      bool InvalidExpr = false;
332      if (ParseExpressionList(Exprs, CommaLocs)) {
333        SkipUntil(tok::r_paren);
334        InvalidExpr = true;
335      }
336      // Match the ')'.
337      SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
338
339      if (!InvalidExpr) {
340        assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
341               "Unexpected number of commas!");
342        Actions.AddCXXDirectInitializerToDecl(LastDeclInGroup, LParenLoc,
343                                              Exprs.take(), Exprs.size(),
344                                              &CommaLocs[0], RParenLoc);
345      }
346    } else {
347      Actions.ActOnUninitializedDecl(LastDeclInGroup);
348    }
349
350    // If we don't have a comma, it is either the end of the list (a ';') or an
351    // error, bail out.
352    if (Tok.isNot(tok::comma))
353      break;
354
355    // Consume the comma.
356    ConsumeToken();
357
358    // Parse the next declarator.
359    D.clear();
360
361    // Accept attributes in an init-declarator.  In the first declarator in a
362    // declaration, these would be part of the declspec.  In subsequent
363    // declarators, they become part of the declarator itself, so that they
364    // don't apply to declarators after *this* one.  Examples:
365    //    short __attribute__((common)) var;    -> declspec
366    //    short var __attribute__((common));    -> declarator
367    //    short x, __attribute__((common)) var;    -> declarator
368    if (Tok.is(tok::kw___attribute)) {
369      SourceLocation Loc;
370      AttributeList *AttrList = ParseAttributes(&Loc);
371      D.AddAttributes(AttrList, Loc);
372    }
373
374    ParseDeclarator(D);
375  }
376
377  if (Tok.is(tok::semi)) {
378    ConsumeToken();
379    // for(is key; in keys) is error.
380    if (D.getContext()  == Declarator::ForContext && isTokIdentifier_in()) {
381      Diag(Tok, diag::err_parse_error);
382      return 0;
383    }
384    return Actions.FinalizeDeclaratorGroup(CurScope, LastDeclInGroup);
385  }
386  // If this is an ObjC2 for-each loop, this is a successful declarator
387  // parse.  The syntax for these looks like:
388  // 'for' '(' declaration 'in' expr ')' statement
389  if (D.getContext()  == Declarator::ForContext && isTokIdentifier_in()) {
390    return Actions.FinalizeDeclaratorGroup(CurScope, LastDeclInGroup);
391  }
392  Diag(Tok, diag::err_parse_error);
393  // Skip to end of block or statement
394  SkipUntil(tok::r_brace, true, true);
395  if (Tok.is(tok::semi))
396    ConsumeToken();
397  return 0;
398}
399
400/// ParseSpecifierQualifierList
401///        specifier-qualifier-list:
402///          type-specifier specifier-qualifier-list[opt]
403///          type-qualifier specifier-qualifier-list[opt]
404/// [GNU]    attributes     specifier-qualifier-list[opt]
405///
406void Parser::ParseSpecifierQualifierList(DeclSpec &DS) {
407  /// specifier-qualifier-list is a subset of declaration-specifiers.  Just
408  /// parse declaration-specifiers and complain about extra stuff.
409  ParseDeclarationSpecifiers(DS);
410
411  // Validate declspec for type-name.
412  unsigned Specs = DS.getParsedSpecifiers();
413  if (Specs == DeclSpec::PQ_None && !DS.getNumProtocolQualifiers())
414    Diag(Tok, diag::err_typename_requires_specqual);
415
416  // Issue diagnostic and remove storage class if present.
417  if (Specs & DeclSpec::PQ_StorageClassSpecifier) {
418    if (DS.getStorageClassSpecLoc().isValid())
419      Diag(DS.getStorageClassSpecLoc(),diag::err_typename_invalid_storageclass);
420    else
421      Diag(DS.getThreadSpecLoc(), diag::err_typename_invalid_storageclass);
422    DS.ClearStorageClassSpecs();
423  }
424
425  // Issue diagnostic and remove function specfier if present.
426  if (Specs & DeclSpec::PQ_FunctionSpecifier) {
427    if (DS.isInlineSpecified())
428      Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
429    if (DS.isVirtualSpecified())
430      Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
431    if (DS.isExplicitSpecified())
432      Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
433    DS.ClearFunctionSpecs();
434  }
435}
436
437/// ParseDeclarationSpecifiers
438///       declaration-specifiers: [C99 6.7]
439///         storage-class-specifier declaration-specifiers[opt]
440///         type-specifier declaration-specifiers[opt]
441/// [C99]   function-specifier declaration-specifiers[opt]
442/// [GNU]   attributes declaration-specifiers[opt]
443///
444///       storage-class-specifier: [C99 6.7.1]
445///         'typedef'
446///         'extern'
447///         'static'
448///         'auto'
449///         'register'
450/// [C++]   'mutable'
451/// [GNU]   '__thread'
452///       function-specifier: [C99 6.7.4]
453/// [C99]   'inline'
454/// [C++]   'virtual'
455/// [C++]   'explicit'
456///
457void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
458                                        TemplateParameterLists *TemplateParams){
459  DS.SetRangeStart(Tok.getLocation());
460  while (1) {
461    int isInvalid = false;
462    const char *PrevSpec = 0;
463    SourceLocation Loc = Tok.getLocation();
464
465    switch (Tok.getKind()) {
466    default:
467    DoneWithDeclSpec:
468      // If this is not a declaration specifier token, we're done reading decl
469      // specifiers.  First verify that DeclSpec's are consistent.
470      DS.Finish(Diags, PP.getSourceManager(), getLang());
471      return;
472
473    case tok::coloncolon: // ::foo::bar
474      // Annotate C++ scope specifiers.  If we get one, loop.
475      if (TryAnnotateCXXScopeToken())
476        continue;
477      goto DoneWithDeclSpec;
478
479    case tok::annot_cxxscope: {
480      if (DS.hasTypeSpecifier())
481        goto DoneWithDeclSpec;
482
483      // We are looking for a qualified typename.
484      if (NextToken().isNot(tok::identifier))
485        goto DoneWithDeclSpec;
486
487      CXXScopeSpec SS;
488      SS.setScopeRep(Tok.getAnnotationValue());
489      SS.setRange(Tok.getAnnotationRange());
490
491      // If the next token is the name of the class type that the C++ scope
492      // denotes, followed by a '(', then this is a constructor declaration.
493      // We're done with the decl-specifiers.
494      if (Actions.isCurrentClassName(*NextToken().getIdentifierInfo(),
495                                     CurScope, &SS) &&
496          GetLookAheadToken(2).is(tok::l_paren))
497        goto DoneWithDeclSpec;
498
499      Token Next = NextToken();
500      TypeTy *TypeRep = Actions.getTypeName(*Next.getIdentifierInfo(),
501                                            Next.getLocation(), CurScope, &SS);
502
503      if (TypeRep == 0)
504        goto DoneWithDeclSpec;
505
506      ConsumeToken(); // The C++ scope.
507
508      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
509                                     TypeRep);
510      if (isInvalid)
511        break;
512
513      DS.SetRangeEnd(Tok.getLocation());
514      ConsumeToken(); // The typename.
515
516      continue;
517    }
518
519    case tok::annot_typename: {
520      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
521                                     Tok.getAnnotationValue());
522      DS.SetRangeEnd(Tok.getAnnotationEndLoc());
523      ConsumeToken(); // The typename
524
525      // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
526      // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
527      // Objective-C interface.  If we don't have Objective-C or a '<', this is
528      // just a normal reference to a typedef name.
529      if (!Tok.is(tok::less) || !getLang().ObjC1)
530        continue;
531
532      SourceLocation EndProtoLoc;
533      llvm::SmallVector<DeclTy *, 8> ProtocolDecl;
534      ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
535      DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
536
537      DS.SetRangeEnd(EndProtoLoc);
538      continue;
539    }
540
541      // typedef-name
542    case tok::identifier: {
543      // In C++, check to see if this is a scope specifier like foo::bar::, if
544      // so handle it as such.  This is important for ctor parsing.
545      if (getLang().CPlusPlus && TryAnnotateCXXScopeToken())
546        continue;
547
548      // This identifier can only be a typedef name if we haven't already seen
549      // a type-specifier.  Without this check we misparse:
550      //  typedef int X; struct Y { short X; };  as 'short int'.
551      if (DS.hasTypeSpecifier())
552        goto DoneWithDeclSpec;
553
554      // It has to be available as a typedef too!
555      TypeTy *TypeRep = Actions.getTypeName(*Tok.getIdentifierInfo(),
556                                            Tok.getLocation(), CurScope);
557
558      if (TypeRep == 0 && getLang().CPlusPlus && NextToken().is(tok::less)) {
559        // If we have a template name, annotate the token and try again.
560        DeclTy *Template = 0;
561        if (TemplateNameKind TNK =
562              Actions.isTemplateName(*Tok.getIdentifierInfo(), CurScope,
563                                     Template)) {
564          AnnotateTemplateIdToken(Template, TNK, 0);
565          continue;
566        }
567      }
568
569      if (TypeRep == 0)
570        goto DoneWithDeclSpec;
571
572
573
574      // C++: If the identifier is actually the name of the class type
575      // being defined and the next token is a '(', then this is a
576      // constructor declaration. We're done with the decl-specifiers
577      // and will treat this token as an identifier.
578      if (getLang().CPlusPlus &&
579          CurScope->isClassScope() &&
580          Actions.isCurrentClassName(*Tok.getIdentifierInfo(), CurScope) &&
581          NextToken().getKind() == tok::l_paren)
582        goto DoneWithDeclSpec;
583
584      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
585                                     TypeRep);
586      if (isInvalid)
587        break;
588
589      DS.SetRangeEnd(Tok.getLocation());
590      ConsumeToken(); // The identifier
591
592      // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
593      // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
594      // Objective-C interface.  If we don't have Objective-C or a '<', this is
595      // just a normal reference to a typedef name.
596      if (!Tok.is(tok::less) || !getLang().ObjC1)
597        continue;
598
599      SourceLocation EndProtoLoc;
600      llvm::SmallVector<DeclTy *, 8> ProtocolDecl;
601      ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
602      DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
603
604      DS.SetRangeEnd(EndProtoLoc);
605
606      // Need to support trailing type qualifiers (e.g. "id<p> const").
607      // If a type specifier follows, it will be diagnosed elsewhere.
608      continue;
609    }
610    // GNU attributes support.
611    case tok::kw___attribute:
612      DS.AddAttributes(ParseAttributes());
613      continue;
614
615    // Microsoft declspec support.
616    case tok::kw___declspec:
617      if (!PP.getLangOptions().Microsoft)
618        goto DoneWithDeclSpec;
619      FuzzyParseMicrosoftDeclSpec();
620      continue;
621
622    // Microsoft single token adornments.
623    case tok::kw___forceinline:
624    case tok::kw___w64:
625    case tok::kw___cdecl:
626    case tok::kw___stdcall:
627    case tok::kw___fastcall:
628      if (!PP.getLangOptions().Microsoft)
629        goto DoneWithDeclSpec;
630      // Just ignore it.
631      break;
632
633    // storage-class-specifier
634    case tok::kw_typedef:
635      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_typedef, Loc, PrevSpec);
636      break;
637    case tok::kw_extern:
638      if (DS.isThreadSpecified())
639        Diag(Tok, diag::ext_thread_before) << "extern";
640      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_extern, Loc, PrevSpec);
641      break;
642    case tok::kw___private_extern__:
643      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_private_extern, Loc,
644                                         PrevSpec);
645      break;
646    case tok::kw_static:
647      if (DS.isThreadSpecified())
648        Diag(Tok, diag::ext_thread_before) << "static";
649      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_static, Loc, PrevSpec);
650      break;
651    case tok::kw_auto:
652      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_auto, Loc, PrevSpec);
653      break;
654    case tok::kw_register:
655      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_register, Loc, PrevSpec);
656      break;
657    case tok::kw_mutable:
658      isInvalid = DS.SetStorageClassSpec(DeclSpec::SCS_mutable, Loc, PrevSpec);
659      break;
660    case tok::kw___thread:
661      isInvalid = DS.SetStorageClassSpecThread(Loc, PrevSpec)*2;
662      break;
663
664      continue;
665
666    // function-specifier
667    case tok::kw_inline:
668      isInvalid = DS.SetFunctionSpecInline(Loc, PrevSpec);
669      break;
670    case tok::kw_virtual:
671      isInvalid = DS.SetFunctionSpecVirtual(Loc, PrevSpec);
672      break;
673    case tok::kw_explicit:
674      isInvalid = DS.SetFunctionSpecExplicit(Loc, PrevSpec);
675      break;
676
677    // type-specifier
678    case tok::kw_short:
679      isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec);
680      break;
681    case tok::kw_long:
682      if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
683        isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec);
684      else
685        isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec);
686      break;
687    case tok::kw_signed:
688      isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec);
689      break;
690    case tok::kw_unsigned:
691      isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec);
692      break;
693    case tok::kw__Complex:
694      isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec);
695      break;
696    case tok::kw__Imaginary:
697      isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec);
698      break;
699    case tok::kw_void:
700      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec);
701      break;
702    case tok::kw_char:
703      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec);
704      break;
705    case tok::kw_int:
706      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec);
707      break;
708    case tok::kw_float:
709      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec);
710      break;
711    case tok::kw_double:
712      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec);
713      break;
714    case tok::kw_wchar_t:
715      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec);
716      break;
717    case tok::kw_bool:
718    case tok::kw__Bool:
719      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec);
720      break;
721    case tok::kw__Decimal32:
722      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec);
723      break;
724    case tok::kw__Decimal64:
725      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec);
726      break;
727    case tok::kw__Decimal128:
728      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec);
729      break;
730
731    // class-specifier:
732    case tok::kw_class:
733    case tok::kw_struct:
734    case tok::kw_union:
735      ParseClassSpecifier(DS, TemplateParams);
736      continue;
737
738    // enum-specifier:
739    case tok::kw_enum:
740      ParseEnumSpecifier(DS);
741      continue;
742
743    // cv-qualifier:
744    case tok::kw_const:
745      isInvalid = DS.SetTypeQual(DeclSpec::TQ_const, Loc, PrevSpec,getLang())*2;
746      break;
747    case tok::kw_volatile:
748      isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
749                                 getLang())*2;
750      break;
751    case tok::kw_restrict:
752      isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
753                                 getLang())*2;
754      break;
755
756    // GNU typeof support.
757    case tok::kw_typeof:
758      ParseTypeofSpecifier(DS);
759      continue;
760
761    case tok::less:
762      // GCC ObjC supports types like "<SomeProtocol>" as a synonym for
763      // "id<SomeProtocol>".  This is hopelessly old fashioned and dangerous,
764      // but we support it.
765      if (DS.hasTypeSpecifier() || !getLang().ObjC1)
766        goto DoneWithDeclSpec;
767
768      {
769        SourceLocation EndProtoLoc;
770        llvm::SmallVector<DeclTy *, 8> ProtocolDecl;
771        ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
772        DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
773        DS.SetRangeEnd(EndProtoLoc);
774
775        Diag(Loc, diag::warn_objc_protocol_qualifier_missing_id)
776          << SourceRange(Loc, EndProtoLoc);
777        // Need to support trailing type qualifiers (e.g. "id<p> const").
778        // If a type specifier follows, it will be diagnosed elsewhere.
779        continue;
780      }
781    }
782    // If the specifier combination wasn't legal, issue a diagnostic.
783    if (isInvalid) {
784      assert(PrevSpec && "Method did not return previous specifier!");
785      // Pick between error or extwarn.
786      unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination
787                                       : diag::ext_duplicate_declspec;
788      Diag(Tok, DiagID) << PrevSpec;
789    }
790    DS.SetRangeEnd(Tok.getLocation());
791    ConsumeToken();
792  }
793}
794
795/// ParseOptionalTypeSpecifier - Try to parse a single type-specifier. We
796/// primarily follow the C++ grammar with additions for C99 and GNU,
797/// which together subsume the C grammar. Note that the C++
798/// type-specifier also includes the C type-qualifier (for const,
799/// volatile, and C99 restrict). Returns true if a type-specifier was
800/// found (and parsed), false otherwise.
801///
802///       type-specifier: [C++ 7.1.5]
803///         simple-type-specifier
804///         class-specifier
805///         enum-specifier
806///         elaborated-type-specifier  [TODO]
807///         cv-qualifier
808///
809///       cv-qualifier: [C++ 7.1.5.1]
810///         'const'
811///         'volatile'
812/// [C99]   'restrict'
813///
814///       simple-type-specifier: [ C++ 7.1.5.2]
815///         '::'[opt] nested-name-specifier[opt] type-name [TODO]
816///         '::'[opt] nested-name-specifier 'template' template-id [TODO]
817///         'char'
818///         'wchar_t'
819///         'bool'
820///         'short'
821///         'int'
822///         'long'
823///         'signed'
824///         'unsigned'
825///         'float'
826///         'double'
827///         'void'
828/// [C99]   '_Bool'
829/// [C99]   '_Complex'
830/// [C99]   '_Imaginary'  // Removed in TC2?
831/// [GNU]   '_Decimal32'
832/// [GNU]   '_Decimal64'
833/// [GNU]   '_Decimal128'
834/// [GNU]   typeof-specifier
835/// [OBJC]  class-name objc-protocol-refs[opt]    [TODO]
836/// [OBJC]  typedef-name objc-protocol-refs[opt]  [TODO]
837bool Parser::ParseOptionalTypeSpecifier(DeclSpec &DS, int& isInvalid,
838                                        const char *&PrevSpec,
839                                        TemplateParameterLists *TemplateParams){
840  SourceLocation Loc = Tok.getLocation();
841
842  switch (Tok.getKind()) {
843  case tok::identifier:   // foo::bar
844    // Annotate typenames and C++ scope specifiers.  If we get one, just
845    // recurse to handle whatever we get.
846    if (TryAnnotateTypeOrScopeToken())
847      return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec,TemplateParams);
848    // Otherwise, not a type specifier.
849    return false;
850  case tok::coloncolon:   // ::foo::bar
851    if (NextToken().is(tok::kw_new) ||    // ::new
852        NextToken().is(tok::kw_delete))   // ::delete
853      return false;
854
855    // Annotate typenames and C++ scope specifiers.  If we get one, just
856    // recurse to handle whatever we get.
857    if (TryAnnotateTypeOrScopeToken())
858      return ParseOptionalTypeSpecifier(DS, isInvalid, PrevSpec,TemplateParams);
859    // Otherwise, not a type specifier.
860    return false;
861
862  // simple-type-specifier:
863  case tok::annot_typename: {
864    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typename, Loc, PrevSpec,
865                                   Tok.getAnnotationValue());
866    DS.SetRangeEnd(Tok.getAnnotationEndLoc());
867    ConsumeToken(); // The typename
868
869    // Objective-C supports syntax of the form 'id<proto1,proto2>' where 'id'
870    // is a specific typedef and 'itf<proto1,proto2>' where 'itf' is an
871    // Objective-C interface.  If we don't have Objective-C or a '<', this is
872    // just a normal reference to a typedef name.
873    if (!Tok.is(tok::less) || !getLang().ObjC1)
874      return true;
875
876    SourceLocation EndProtoLoc;
877    llvm::SmallVector<DeclTy *, 8> ProtocolDecl;
878    ParseObjCProtocolReferences(ProtocolDecl, false, EndProtoLoc);
879    DS.setProtocolQualifiers(&ProtocolDecl[0], ProtocolDecl.size());
880
881    DS.SetRangeEnd(EndProtoLoc);
882    return true;
883  }
884
885  case tok::kw_short:
886    isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec);
887    break;
888  case tok::kw_long:
889    if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
890      isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec);
891    else
892      isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_longlong, Loc, PrevSpec);
893    break;
894  case tok::kw_signed:
895    isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_signed, Loc, PrevSpec);
896    break;
897  case tok::kw_unsigned:
898    isInvalid = DS.SetTypeSpecSign(DeclSpec::TSS_unsigned, Loc, PrevSpec);
899    break;
900  case tok::kw__Complex:
901    isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_complex, Loc, PrevSpec);
902    break;
903  case tok::kw__Imaginary:
904    isInvalid = DS.SetTypeSpecComplex(DeclSpec::TSC_imaginary, Loc, PrevSpec);
905    break;
906  case tok::kw_void:
907    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_void, Loc, PrevSpec);
908    break;
909  case tok::kw_char:
910    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char, Loc, PrevSpec);
911    break;
912  case tok::kw_int:
913    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec);
914    break;
915  case tok::kw_float:
916    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec);
917    break;
918  case tok::kw_double:
919    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec);
920    break;
921  case tok::kw_wchar_t:
922    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec);
923    break;
924  case tok::kw_bool:
925  case tok::kw__Bool:
926    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_bool, Loc, PrevSpec);
927    break;
928  case tok::kw__Decimal32:
929    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal32, Loc, PrevSpec);
930    break;
931  case tok::kw__Decimal64:
932    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal64, Loc, PrevSpec);
933    break;
934  case tok::kw__Decimal128:
935    isInvalid = DS.SetTypeSpecType(DeclSpec::TST_decimal128, Loc, PrevSpec);
936    break;
937
938  // class-specifier:
939  case tok::kw_class:
940  case tok::kw_struct:
941  case tok::kw_union:
942    ParseClassSpecifier(DS, TemplateParams);
943    return true;
944
945  // enum-specifier:
946  case tok::kw_enum:
947    ParseEnumSpecifier(DS);
948    return true;
949
950  // cv-qualifier:
951  case tok::kw_const:
952    isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec,
953                               getLang())*2;
954    break;
955  case tok::kw_volatile:
956    isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
957                               getLang())*2;
958    break;
959  case tok::kw_restrict:
960    isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
961                               getLang())*2;
962    break;
963
964  // GNU typeof support.
965  case tok::kw_typeof:
966    ParseTypeofSpecifier(DS);
967    return true;
968
969  case tok::kw___cdecl:
970  case tok::kw___stdcall:
971  case tok::kw___fastcall:
972    if (!PP.getLangOptions().Microsoft) return false;
973    ConsumeToken();
974    return true;
975
976  default:
977    // Not a type-specifier; do nothing.
978    return false;
979  }
980
981  // If the specifier combination wasn't legal, issue a diagnostic.
982  if (isInvalid) {
983    assert(PrevSpec && "Method did not return previous specifier!");
984    // Pick between error or extwarn.
985    unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination
986                                     : diag::ext_duplicate_declspec;
987    Diag(Tok, DiagID) << PrevSpec;
988  }
989  DS.SetRangeEnd(Tok.getLocation());
990  ConsumeToken(); // whatever we parsed above.
991  return true;
992}
993
994/// ParseStructDeclaration - Parse a struct declaration without the terminating
995/// semicolon.
996///
997///       struct-declaration:
998///         specifier-qualifier-list struct-declarator-list
999/// [GNU]   __extension__ struct-declaration
1000/// [GNU]   specifier-qualifier-list
1001///       struct-declarator-list:
1002///         struct-declarator
1003///         struct-declarator-list ',' struct-declarator
1004/// [GNU]   struct-declarator-list ',' attributes[opt] struct-declarator
1005///       struct-declarator:
1006///         declarator
1007/// [GNU]   declarator attributes[opt]
1008///         declarator[opt] ':' constant-expression
1009/// [GNU]   declarator[opt] ':' constant-expression attributes[opt]
1010///
1011void Parser::
1012ParseStructDeclaration(DeclSpec &DS,
1013                       llvm::SmallVectorImpl<FieldDeclarator> &Fields) {
1014  if (Tok.is(tok::kw___extension__)) {
1015    // __extension__ silences extension warnings in the subexpression.
1016    ExtensionRAIIObject O(Diags);  // Use RAII to do this.
1017    ConsumeToken();
1018    return ParseStructDeclaration(DS, Fields);
1019  }
1020
1021  // Parse the common specifier-qualifiers-list piece.
1022  SourceLocation DSStart = Tok.getLocation();
1023  ParseSpecifierQualifierList(DS);
1024
1025  // If there are no declarators, this is a free-standing declaration
1026  // specifier. Let the actions module cope with it.
1027  if (Tok.is(tok::semi)) {
1028    Actions.ParsedFreeStandingDeclSpec(CurScope, DS);
1029    return;
1030  }
1031
1032  // Read struct-declarators until we find the semicolon.
1033  Fields.push_back(FieldDeclarator(DS));
1034  while (1) {
1035    FieldDeclarator &DeclaratorInfo = Fields.back();
1036
1037    /// struct-declarator: declarator
1038    /// struct-declarator: declarator[opt] ':' constant-expression
1039    if (Tok.isNot(tok::colon))
1040      ParseDeclarator(DeclaratorInfo.D);
1041
1042    if (Tok.is(tok::colon)) {
1043      ConsumeToken();
1044      OwningExprResult Res(ParseConstantExpression());
1045      if (Res.isInvalid())
1046        SkipUntil(tok::semi, true, true);
1047      else
1048        DeclaratorInfo.BitfieldSize = Res.release();
1049    }
1050
1051    // If attributes exist after the declarator, parse them.
1052    if (Tok.is(tok::kw___attribute)) {
1053      SourceLocation Loc;
1054      AttributeList *AttrList = ParseAttributes(&Loc);
1055      DeclaratorInfo.D.AddAttributes(AttrList, Loc);
1056    }
1057
1058    // If we don't have a comma, it is either the end of the list (a ';')
1059    // or an error, bail out.
1060    if (Tok.isNot(tok::comma))
1061      return;
1062
1063    // Consume the comma.
1064    ConsumeToken();
1065
1066    // Parse the next declarator.
1067    Fields.push_back(FieldDeclarator(DS));
1068
1069    // Attributes are only allowed on the second declarator.
1070    if (Tok.is(tok::kw___attribute)) {
1071      SourceLocation Loc;
1072      AttributeList *AttrList = ParseAttributes(&Loc);
1073      Fields.back().D.AddAttributes(AttrList, Loc);
1074    }
1075  }
1076}
1077
1078/// ParseStructUnionBody
1079///       struct-contents:
1080///         struct-declaration-list
1081/// [EXT]   empty
1082/// [GNU]   "struct-declaration-list" without terminatoring ';'
1083///       struct-declaration-list:
1084///         struct-declaration
1085///         struct-declaration-list struct-declaration
1086/// [OBC]   '@' 'defs' '(' class-name ')'
1087///
1088void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
1089                                  unsigned TagType, DeclTy *TagDecl) {
1090  SourceLocation LBraceLoc = ConsumeBrace();
1091
1092  ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
1093  Actions.ActOnTagStartDefinition(CurScope, TagDecl);
1094
1095  // Empty structs are an extension in C (C99 6.7.2.1p7), but are allowed in
1096  // C++.
1097  if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
1098    Diag(Tok, diag::ext_empty_struct_union_enum)
1099      << DeclSpec::getSpecifierName((DeclSpec::TST)TagType);
1100
1101  llvm::SmallVector<DeclTy*, 32> FieldDecls;
1102  llvm::SmallVector<FieldDeclarator, 8> FieldDeclarators;
1103
1104  // While we still have something to read, read the declarations in the struct.
1105  while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
1106    // Each iteration of this loop reads one struct-declaration.
1107
1108    // Check for extraneous top-level semicolon.
1109    if (Tok.is(tok::semi)) {
1110      Diag(Tok, diag::ext_extra_struct_semi);
1111      ConsumeToken();
1112      continue;
1113    }
1114
1115    // Parse all the comma separated declarators.
1116    DeclSpec DS;
1117    FieldDeclarators.clear();
1118    if (!Tok.is(tok::at)) {
1119      ParseStructDeclaration(DS, FieldDeclarators);
1120
1121      // Convert them all to fields.
1122      for (unsigned i = 0, e = FieldDeclarators.size(); i != e; ++i) {
1123        FieldDeclarator &FD = FieldDeclarators[i];
1124        // Install the declarator into the current TagDecl.
1125        DeclTy *Field = Actions.ActOnField(CurScope, TagDecl,
1126                                           DS.getSourceRange().getBegin(),
1127                                           FD.D, FD.BitfieldSize);
1128        FieldDecls.push_back(Field);
1129      }
1130    } else { // Handle @defs
1131      ConsumeToken();
1132      if (!Tok.isObjCAtKeyword(tok::objc_defs)) {
1133        Diag(Tok, diag::err_unexpected_at);
1134        SkipUntil(tok::semi, true, true);
1135        continue;
1136      }
1137      ConsumeToken();
1138      ExpectAndConsume(tok::l_paren, diag::err_expected_lparen);
1139      if (!Tok.is(tok::identifier)) {
1140        Diag(Tok, diag::err_expected_ident);
1141        SkipUntil(tok::semi, true, true);
1142        continue;
1143      }
1144      llvm::SmallVector<DeclTy*, 16> Fields;
1145      Actions.ActOnDefs(CurScope, TagDecl, Tok.getLocation(),
1146                        Tok.getIdentifierInfo(), Fields);
1147      FieldDecls.insert(FieldDecls.end(), Fields.begin(), Fields.end());
1148      ConsumeToken();
1149      ExpectAndConsume(tok::r_paren, diag::err_expected_rparen);
1150    }
1151
1152    if (Tok.is(tok::semi)) {
1153      ConsumeToken();
1154    } else if (Tok.is(tok::r_brace)) {
1155      Diag(Tok, diag::ext_expected_semi_decl_list);
1156      break;
1157    } else {
1158      Diag(Tok, diag::err_expected_semi_decl_list);
1159      // Skip to end of block or statement
1160      SkipUntil(tok::r_brace, true, true);
1161    }
1162  }
1163
1164  SourceLocation RBraceLoc = MatchRHSPunctuation(tok::r_brace, LBraceLoc);
1165
1166  AttributeList *AttrList = 0;
1167  // If attributes exist after struct contents, parse them.
1168  if (Tok.is(tok::kw___attribute))
1169    AttrList = ParseAttributes();
1170
1171  Actions.ActOnFields(CurScope,
1172                      RecordLoc,TagDecl,&FieldDecls[0],FieldDecls.size(),
1173                      LBraceLoc, RBraceLoc,
1174                      AttrList);
1175  StructScope.Exit();
1176  Actions.ActOnTagFinishDefinition(CurScope, TagDecl);
1177}
1178
1179
1180/// ParseEnumSpecifier
1181///       enum-specifier: [C99 6.7.2.2]
1182///         'enum' identifier[opt] '{' enumerator-list '}'
1183///[C99/C++]'enum' identifier[opt] '{' enumerator-list ',' '}'
1184/// [GNU]   'enum' attributes[opt] identifier[opt] '{' enumerator-list ',' [opt]
1185///                                                 '}' attributes[opt]
1186///         'enum' identifier
1187/// [GNU]   'enum' attributes[opt] identifier
1188///
1189/// [C++] elaborated-type-specifier:
1190/// [C++]   'enum' '::'[opt] nested-name-specifier[opt] identifier
1191///
1192void Parser::ParseEnumSpecifier(DeclSpec &DS) {
1193  assert(Tok.is(tok::kw_enum) && "Not an enum specifier");
1194  SourceLocation StartLoc = ConsumeToken();
1195
1196  // Parse the tag portion of this.
1197
1198  AttributeList *Attr = 0;
1199  // If attributes exist after tag, parse them.
1200  if (Tok.is(tok::kw___attribute))
1201    Attr = ParseAttributes();
1202
1203  CXXScopeSpec SS;
1204  if (getLang().CPlusPlus && ParseOptionalCXXScopeSpecifier(SS)) {
1205    if (Tok.isNot(tok::identifier)) {
1206      Diag(Tok, diag::err_expected_ident);
1207      if (Tok.isNot(tok::l_brace)) {
1208        // Has no name and is not a definition.
1209        // Skip the rest of this declarator, up until the comma or semicolon.
1210        SkipUntil(tok::comma, true);
1211        return;
1212      }
1213    }
1214  }
1215
1216  // Must have either 'enum name' or 'enum {...}'.
1217  if (Tok.isNot(tok::identifier) && Tok.isNot(tok::l_brace)) {
1218    Diag(Tok, diag::err_expected_ident_lbrace);
1219
1220    // Skip the rest of this declarator, up until the comma or semicolon.
1221    SkipUntil(tok::comma, true);
1222    return;
1223  }
1224
1225  // If an identifier is present, consume and remember it.
1226  IdentifierInfo *Name = 0;
1227  SourceLocation NameLoc;
1228  if (Tok.is(tok::identifier)) {
1229    Name = Tok.getIdentifierInfo();
1230    NameLoc = ConsumeToken();
1231  }
1232
1233  // There are three options here.  If we have 'enum foo;', then this is a
1234  // forward declaration.  If we have 'enum foo {...' then this is a
1235  // definition. Otherwise we have something like 'enum foo xyz', a reference.
1236  //
1237  // This is needed to handle stuff like this right (C99 6.7.2.3p11):
1238  // enum foo {..};  void bar() { enum foo; }    <- new foo in bar.
1239  // enum foo {..};  void bar() { enum foo x; }  <- use of old foo.
1240  //
1241  Action::TagKind TK;
1242  if (Tok.is(tok::l_brace))
1243    TK = Action::TK_Definition;
1244  else if (Tok.is(tok::semi))
1245    TK = Action::TK_Declaration;
1246  else
1247    TK = Action::TK_Reference;
1248  DeclTy *TagDecl = Actions.ActOnTag(CurScope, DeclSpec::TST_enum, TK, StartLoc,
1249                                     SS, Name, NameLoc, Attr);
1250
1251  if (Tok.is(tok::l_brace))
1252    ParseEnumBody(StartLoc, TagDecl);
1253
1254  // TODO: semantic analysis on the declspec for enums.
1255  const char *PrevSpec = 0;
1256  if (DS.SetTypeSpecType(DeclSpec::TST_enum, StartLoc, PrevSpec, TagDecl))
1257    Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
1258}
1259
1260/// ParseEnumBody - Parse a {} enclosed enumerator-list.
1261///       enumerator-list:
1262///         enumerator
1263///         enumerator-list ',' enumerator
1264///       enumerator:
1265///         enumeration-constant
1266///         enumeration-constant '=' constant-expression
1267///       enumeration-constant:
1268///         identifier
1269///
1270void Parser::ParseEnumBody(SourceLocation StartLoc, DeclTy *EnumDecl) {
1271  // Enter the scope of the enum body and start the definition.
1272  ParseScope EnumScope(this, Scope::DeclScope);
1273  Actions.ActOnTagStartDefinition(CurScope, EnumDecl);
1274
1275  SourceLocation LBraceLoc = ConsumeBrace();
1276
1277  // C does not allow an empty enumerator-list, C++ does [dcl.enum].
1278  if (Tok.is(tok::r_brace) && !getLang().CPlusPlus)
1279    Diag(Tok, diag::ext_empty_struct_union_enum) << "enum";
1280
1281  llvm::SmallVector<DeclTy*, 32> EnumConstantDecls;
1282
1283  DeclTy *LastEnumConstDecl = 0;
1284
1285  // Parse the enumerator-list.
1286  while (Tok.is(tok::identifier)) {
1287    IdentifierInfo *Ident = Tok.getIdentifierInfo();
1288    SourceLocation IdentLoc = ConsumeToken();
1289
1290    SourceLocation EqualLoc;
1291    OwningExprResult AssignedVal(Actions);
1292    if (Tok.is(tok::equal)) {
1293      EqualLoc = ConsumeToken();
1294      AssignedVal = ParseConstantExpression();
1295      if (AssignedVal.isInvalid())
1296        SkipUntil(tok::comma, tok::r_brace, true, true);
1297    }
1298
1299    // Install the enumerator constant into EnumDecl.
1300    DeclTy *EnumConstDecl = Actions.ActOnEnumConstant(CurScope, EnumDecl,
1301                                                      LastEnumConstDecl,
1302                                                      IdentLoc, Ident,
1303                                                      EqualLoc,
1304                                                      AssignedVal.release());
1305    EnumConstantDecls.push_back(EnumConstDecl);
1306    LastEnumConstDecl = EnumConstDecl;
1307
1308    if (Tok.isNot(tok::comma))
1309      break;
1310    SourceLocation CommaLoc = ConsumeToken();
1311
1312    if (Tok.isNot(tok::identifier) && !getLang().C99)
1313      Diag(CommaLoc, diag::ext_c99_enumerator_list_comma);
1314  }
1315
1316  // Eat the }.
1317  MatchRHSPunctuation(tok::r_brace, LBraceLoc);
1318
1319  Actions.ActOnEnumBody(StartLoc, EnumDecl, &EnumConstantDecls[0],
1320                        EnumConstantDecls.size());
1321
1322  DeclTy *AttrList = 0;
1323  // If attributes exist after the identifier list, parse them.
1324  if (Tok.is(tok::kw___attribute))
1325    AttrList = ParseAttributes(); // FIXME: where do they do?
1326
1327  EnumScope.Exit();
1328  Actions.ActOnTagFinishDefinition(CurScope, EnumDecl);
1329}
1330
1331/// isTypeSpecifierQualifier - Return true if the current token could be the
1332/// start of a type-qualifier-list.
1333bool Parser::isTypeQualifier() const {
1334  switch (Tok.getKind()) {
1335  default: return false;
1336    // type-qualifier
1337  case tok::kw_const:
1338  case tok::kw_volatile:
1339  case tok::kw_restrict:
1340    return true;
1341  }
1342}
1343
1344/// isTypeSpecifierQualifier - Return true if the current token could be the
1345/// start of a specifier-qualifier-list.
1346bool Parser::isTypeSpecifierQualifier() {
1347  switch (Tok.getKind()) {
1348  default: return false;
1349
1350  case tok::identifier:   // foo::bar
1351    // Annotate typenames and C++ scope specifiers.  If we get one, just
1352    // recurse to handle whatever we get.
1353    if (TryAnnotateTypeOrScopeToken())
1354      return isTypeSpecifierQualifier();
1355    // Otherwise, not a type specifier.
1356    return false;
1357  case tok::coloncolon:   // ::foo::bar
1358    if (NextToken().is(tok::kw_new) ||    // ::new
1359        NextToken().is(tok::kw_delete))   // ::delete
1360      return false;
1361
1362    // Annotate typenames and C++ scope specifiers.  If we get one, just
1363    // recurse to handle whatever we get.
1364    if (TryAnnotateTypeOrScopeToken())
1365      return isTypeSpecifierQualifier();
1366    // Otherwise, not a type specifier.
1367    return false;
1368
1369    // GNU attributes support.
1370  case tok::kw___attribute:
1371    // GNU typeof support.
1372  case tok::kw_typeof:
1373
1374    // type-specifiers
1375  case tok::kw_short:
1376  case tok::kw_long:
1377  case tok::kw_signed:
1378  case tok::kw_unsigned:
1379  case tok::kw__Complex:
1380  case tok::kw__Imaginary:
1381  case tok::kw_void:
1382  case tok::kw_char:
1383  case tok::kw_wchar_t:
1384  case tok::kw_int:
1385  case tok::kw_float:
1386  case tok::kw_double:
1387  case tok::kw_bool:
1388  case tok::kw__Bool:
1389  case tok::kw__Decimal32:
1390  case tok::kw__Decimal64:
1391  case tok::kw__Decimal128:
1392
1393    // struct-or-union-specifier (C99) or class-specifier (C++)
1394  case tok::kw_class:
1395  case tok::kw_struct:
1396  case tok::kw_union:
1397    // enum-specifier
1398  case tok::kw_enum:
1399
1400    // type-qualifier
1401  case tok::kw_const:
1402  case tok::kw_volatile:
1403  case tok::kw_restrict:
1404
1405    // typedef-name
1406  case tok::annot_typename:
1407    return true;
1408
1409    // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
1410  case tok::less:
1411    return getLang().ObjC1;
1412
1413  case tok::kw___cdecl:
1414  case tok::kw___stdcall:
1415  case tok::kw___fastcall:
1416    return PP.getLangOptions().Microsoft;
1417  }
1418}
1419
1420/// isDeclarationSpecifier() - Return true if the current token is part of a
1421/// declaration specifier.
1422bool Parser::isDeclarationSpecifier() {
1423  switch (Tok.getKind()) {
1424  default: return false;
1425
1426  case tok::identifier:   // foo::bar
1427    // Annotate typenames and C++ scope specifiers.  If we get one, just
1428    // recurse to handle whatever we get.
1429    if (TryAnnotateTypeOrScopeToken())
1430      return isDeclarationSpecifier();
1431    // Otherwise, not a declaration specifier.
1432    return false;
1433  case tok::coloncolon:   // ::foo::bar
1434    if (NextToken().is(tok::kw_new) ||    // ::new
1435        NextToken().is(tok::kw_delete))   // ::delete
1436      return false;
1437
1438    // Annotate typenames and C++ scope specifiers.  If we get one, just
1439    // recurse to handle whatever we get.
1440    if (TryAnnotateTypeOrScopeToken())
1441      return isDeclarationSpecifier();
1442    // Otherwise, not a declaration specifier.
1443    return false;
1444
1445    // storage-class-specifier
1446  case tok::kw_typedef:
1447  case tok::kw_extern:
1448  case tok::kw___private_extern__:
1449  case tok::kw_static:
1450  case tok::kw_auto:
1451  case tok::kw_register:
1452  case tok::kw___thread:
1453
1454    // type-specifiers
1455  case tok::kw_short:
1456  case tok::kw_long:
1457  case tok::kw_signed:
1458  case tok::kw_unsigned:
1459  case tok::kw__Complex:
1460  case tok::kw__Imaginary:
1461  case tok::kw_void:
1462  case tok::kw_char:
1463  case tok::kw_wchar_t:
1464  case tok::kw_int:
1465  case tok::kw_float:
1466  case tok::kw_double:
1467  case tok::kw_bool:
1468  case tok::kw__Bool:
1469  case tok::kw__Decimal32:
1470  case tok::kw__Decimal64:
1471  case tok::kw__Decimal128:
1472
1473    // struct-or-union-specifier (C99) or class-specifier (C++)
1474  case tok::kw_class:
1475  case tok::kw_struct:
1476  case tok::kw_union:
1477    // enum-specifier
1478  case tok::kw_enum:
1479
1480    // type-qualifier
1481  case tok::kw_const:
1482  case tok::kw_volatile:
1483  case tok::kw_restrict:
1484
1485    // function-specifier
1486  case tok::kw_inline:
1487  case tok::kw_virtual:
1488  case tok::kw_explicit:
1489
1490    // typedef-name
1491  case tok::annot_typename:
1492
1493    // GNU typeof support.
1494  case tok::kw_typeof:
1495
1496    // GNU attributes.
1497  case tok::kw___attribute:
1498    return true;
1499
1500    // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
1501  case tok::less:
1502    return getLang().ObjC1;
1503
1504  case tok::kw___declspec:
1505  case tok::kw___cdecl:
1506  case tok::kw___stdcall:
1507  case tok::kw___fastcall:
1508    return PP.getLangOptions().Microsoft;
1509  }
1510}
1511
1512
1513/// ParseTypeQualifierListOpt
1514///       type-qualifier-list: [C99 6.7.5]
1515///         type-qualifier
1516/// [GNU]   attributes                        [ only if AttributesAllowed=true ]
1517///         type-qualifier-list type-qualifier
1518/// [GNU]   type-qualifier-list attributes    [ only if AttributesAllowed=true ]
1519///
1520void Parser::ParseTypeQualifierListOpt(DeclSpec &DS, bool AttributesAllowed) {
1521  while (1) {
1522    int isInvalid = false;
1523    const char *PrevSpec = 0;
1524    SourceLocation Loc = Tok.getLocation();
1525
1526    switch (Tok.getKind()) {
1527    case tok::kw_const:
1528      isInvalid = DS.SetTypeQual(DeclSpec::TQ_const   , Loc, PrevSpec,
1529                                 getLang())*2;
1530      break;
1531    case tok::kw_volatile:
1532      isInvalid = DS.SetTypeQual(DeclSpec::TQ_volatile, Loc, PrevSpec,
1533                                 getLang())*2;
1534      break;
1535    case tok::kw_restrict:
1536      isInvalid = DS.SetTypeQual(DeclSpec::TQ_restrict, Loc, PrevSpec,
1537                                 getLang())*2;
1538      break;
1539    case tok::kw___ptr64:
1540    case tok::kw___cdecl:
1541    case tok::kw___stdcall:
1542    case tok::kw___fastcall:
1543      if (!PP.getLangOptions().Microsoft)
1544        goto DoneWithTypeQuals;
1545      // Just ignore it.
1546      break;
1547    case tok::kw___attribute:
1548      if (AttributesAllowed) {
1549        DS.AddAttributes(ParseAttributes());
1550        continue; // do *not* consume the next token!
1551      }
1552      // otherwise, FALL THROUGH!
1553    default:
1554      DoneWithTypeQuals:
1555      // If this is not a type-qualifier token, we're done reading type
1556      // qualifiers.  First verify that DeclSpec's are consistent.
1557      DS.Finish(Diags, PP.getSourceManager(), getLang());
1558      return;
1559    }
1560
1561    // If the specifier combination wasn't legal, issue a diagnostic.
1562    if (isInvalid) {
1563      assert(PrevSpec && "Method did not return previous specifier!");
1564      // Pick between error or extwarn.
1565      unsigned DiagID = isInvalid == 1 ? diag::err_invalid_decl_spec_combination
1566                                      : diag::ext_duplicate_declspec;
1567      Diag(Tok, DiagID) << PrevSpec;
1568    }
1569    ConsumeToken();
1570  }
1571}
1572
1573
1574/// ParseDeclarator - Parse and verify a newly-initialized declarator.
1575///
1576void Parser::ParseDeclarator(Declarator &D) {
1577  /// This implements the 'declarator' production in the C grammar, then checks
1578  /// for well-formedness and issues diagnostics.
1579  ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
1580}
1581
1582/// ParseDeclaratorInternal - Parse a C or C++ declarator. The direct-declarator
1583/// is parsed by the function passed to it. Pass null, and the direct-declarator
1584/// isn't parsed at all, making this function effectively parse the C++
1585/// ptr-operator production.
1586///
1587///       declarator: [C99 6.7.5] [C++ 8p4, dcl.decl]
1588/// [C]     pointer[opt] direct-declarator
1589/// [C++]   direct-declarator
1590/// [C++]   ptr-operator declarator
1591///
1592///       pointer: [C99 6.7.5]
1593///         '*' type-qualifier-list[opt]
1594///         '*' type-qualifier-list[opt] pointer
1595///
1596///       ptr-operator:
1597///         '*' cv-qualifier-seq[opt]
1598///         '&'
1599/// [GNU]   '&' restrict[opt] attributes[opt]
1600///         '::'[opt] nested-name-specifier '*' cv-qualifier-seq[opt]
1601void Parser::ParseDeclaratorInternal(Declarator &D,
1602                                     DirectDeclParseFunction DirectDeclParser) {
1603
1604  // C++ member pointers start with a '::' or a nested-name.
1605  // Member pointers get special handling, since there's no place for the
1606  // scope spec in the generic path below.
1607  if ((Tok.is(tok::coloncolon) || Tok.is(tok::identifier) ||
1608       Tok.is(tok::annot_cxxscope)) && getLang().CPlusPlus) {
1609    CXXScopeSpec SS;
1610    if (ParseOptionalCXXScopeSpecifier(SS)) {
1611      if(Tok.isNot(tok::star)) {
1612        // The scope spec really belongs to the direct-declarator.
1613        D.getCXXScopeSpec() = SS;
1614        if (DirectDeclParser)
1615          (this->*DirectDeclParser)(D);
1616        return;
1617      }
1618
1619      SourceLocation Loc = ConsumeToken();
1620      D.SetRangeEnd(Loc);
1621      DeclSpec DS;
1622      ParseTypeQualifierListOpt(DS);
1623      D.ExtendWithDeclSpec(DS);
1624
1625      // Recurse to parse whatever is left.
1626      ParseDeclaratorInternal(D, DirectDeclParser);
1627
1628      // Sema will have to catch (syntactically invalid) pointers into global
1629      // scope. It has to catch pointers into namespace scope anyway.
1630      D.AddTypeInfo(DeclaratorChunk::getMemberPointer(SS,DS.getTypeQualifiers(),
1631                                                      Loc, DS.TakeAttributes()),
1632                    /* Don't replace range end. */SourceLocation());
1633      return;
1634    }
1635  }
1636
1637  tok::TokenKind Kind = Tok.getKind();
1638  // Not a pointer, C++ reference, or block.
1639  if (Kind != tok::star && (Kind != tok::amp || !getLang().CPlusPlus) &&
1640      (Kind != tok::caret || !getLang().Blocks)) {
1641    if (DirectDeclParser)
1642      (this->*DirectDeclParser)(D);
1643    return;
1644  }
1645
1646  // Otherwise, '*' -> pointer, '^' -> block, '&' -> reference.
1647  SourceLocation Loc = ConsumeToken();  // Eat the *, ^ or &.
1648  D.SetRangeEnd(Loc);
1649
1650  if (Kind == tok::star || (Kind == tok::caret && getLang().Blocks)) {
1651    // Is a pointer.
1652    DeclSpec DS;
1653
1654    ParseTypeQualifierListOpt(DS);
1655    D.ExtendWithDeclSpec(DS);
1656
1657    // Recursively parse the declarator.
1658    ParseDeclaratorInternal(D, DirectDeclParser);
1659    if (Kind == tok::star)
1660      // Remember that we parsed a pointer type, and remember the type-quals.
1661      D.AddTypeInfo(DeclaratorChunk::getPointer(DS.getTypeQualifiers(), Loc,
1662                                                DS.TakeAttributes()),
1663                    SourceLocation());
1664    else
1665      // Remember that we parsed a Block type, and remember the type-quals.
1666      D.AddTypeInfo(DeclaratorChunk::getBlockPointer(DS.getTypeQualifiers(),
1667                                                     Loc),
1668                    SourceLocation());
1669  } else {
1670    // Is a reference
1671    DeclSpec DS;
1672
1673    // C++ 8.3.2p1: cv-qualified references are ill-formed except when the
1674    // cv-qualifiers are introduced through the use of a typedef or of a
1675    // template type argument, in which case the cv-qualifiers are ignored.
1676    //
1677    // [GNU] Retricted references are allowed.
1678    // [GNU] Attributes on references are allowed.
1679    ParseTypeQualifierListOpt(DS);
1680    D.ExtendWithDeclSpec(DS);
1681
1682    if (DS.getTypeQualifiers() != DeclSpec::TQ_unspecified) {
1683      if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
1684        Diag(DS.getConstSpecLoc(),
1685             diag::err_invalid_reference_qualifier_application) << "const";
1686      if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
1687        Diag(DS.getVolatileSpecLoc(),
1688             diag::err_invalid_reference_qualifier_application) << "volatile";
1689    }
1690
1691    // Recursively parse the declarator.
1692    ParseDeclaratorInternal(D, DirectDeclParser);
1693
1694    if (D.getNumTypeObjects() > 0) {
1695      // C++ [dcl.ref]p4: There shall be no references to references.
1696      DeclaratorChunk& InnerChunk = D.getTypeObject(D.getNumTypeObjects() - 1);
1697      if (InnerChunk.Kind == DeclaratorChunk::Reference) {
1698        if (const IdentifierInfo *II = D.getIdentifier())
1699          Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
1700           << II;
1701        else
1702          Diag(InnerChunk.Loc, diag::err_illegal_decl_reference_to_reference)
1703            << "type name";
1704
1705        // Once we've complained about the reference-to-reference, we
1706        // can go ahead and build the (technically ill-formed)
1707        // declarator: reference collapsing will take care of it.
1708      }
1709    }
1710
1711    // Remember that we parsed a reference type. It doesn't have type-quals.
1712    D.AddTypeInfo(DeclaratorChunk::getReference(DS.getTypeQualifiers(), Loc,
1713                                                DS.TakeAttributes()),
1714                  SourceLocation());
1715  }
1716}
1717
1718/// ParseDirectDeclarator
1719///       direct-declarator: [C99 6.7.5]
1720/// [C99]   identifier
1721///         '(' declarator ')'
1722/// [GNU]   '(' attributes declarator ')'
1723/// [C90]   direct-declarator '[' constant-expression[opt] ']'
1724/// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
1725/// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
1726/// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
1727/// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
1728///         direct-declarator '(' parameter-type-list ')'
1729///         direct-declarator '(' identifier-list[opt] ')'
1730/// [GNU]   direct-declarator '(' parameter-forward-declarations
1731///                    parameter-type-list[opt] ')'
1732/// [C++]   direct-declarator '(' parameter-declaration-clause ')'
1733///                    cv-qualifier-seq[opt] exception-specification[opt]
1734/// [C++]   declarator-id
1735///
1736///       declarator-id: [C++ 8]
1737///         id-expression
1738///         '::'[opt] nested-name-specifier[opt] type-name
1739///
1740///       id-expression: [C++ 5.1]
1741///         unqualified-id
1742///         qualified-id            [TODO]
1743///
1744///       unqualified-id: [C++ 5.1]
1745///         identifier
1746///         operator-function-id
1747///         conversion-function-id  [TODO]
1748///          '~' class-name
1749///         template-id             [TODO]
1750///
1751void Parser::ParseDirectDeclarator(Declarator &D) {
1752  DeclaratorScopeObj DeclScopeObj(*this, D.getCXXScopeSpec());
1753
1754  if (getLang().CPlusPlus) {
1755    if (D.mayHaveIdentifier()) {
1756      // ParseDeclaratorInternal might already have parsed the scope.
1757      bool afterCXXScope = D.getCXXScopeSpec().isSet() ||
1758        ParseOptionalCXXScopeSpecifier(D.getCXXScopeSpec());
1759      if (afterCXXScope) {
1760        // Change the declaration context for name lookup, until this function
1761        // is exited (and the declarator has been parsed).
1762        DeclScopeObj.EnterDeclaratorScope();
1763      }
1764
1765      if (Tok.is(tok::identifier)) {
1766        assert(Tok.getIdentifierInfo() && "Not an identifier?");
1767
1768        // If this identifier is followed by a '<', we may have a template-id.
1769        DeclTy *Template;
1770        Action::TemplateNameKind TNK;
1771        if (getLang().CPlusPlus && NextToken().is(tok::less) &&
1772            (TNK = Actions.isTemplateName(*Tok.getIdentifierInfo(),
1773                                          CurScope, Template))) {
1774          IdentifierInfo *II = Tok.getIdentifierInfo();
1775          AnnotateTemplateIdToken(Template, TNK, 0);
1776          // FIXME: Set the declarator to a template-id. How? I don't
1777          // know... for now, just use the identifier.
1778          D.SetIdentifier(II, Tok.getLocation());
1779        }
1780        // If this identifier is the name of the current class, it's a
1781        // constructor name.
1782        else if (Actions.isCurrentClassName(*Tok.getIdentifierInfo(),CurScope)){
1783          D.setConstructor(Actions.getTypeName(*Tok.getIdentifierInfo(),
1784                                               Tok.getLocation(), CurScope),
1785                           Tok.getLocation());
1786        // This is a normal identifier.
1787        } else
1788          D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1789        ConsumeToken();
1790        goto PastIdentifier;
1791      } else if (Tok.is(tok::kw_operator)) {
1792        SourceLocation OperatorLoc = Tok.getLocation();
1793        SourceLocation EndLoc;
1794
1795        // First try the name of an overloaded operator
1796        if (OverloadedOperatorKind Op = TryParseOperatorFunctionId(&EndLoc)) {
1797          D.setOverloadedOperator(Op, OperatorLoc, EndLoc);
1798        } else {
1799          // This must be a conversion function (C++ [class.conv.fct]).
1800          if (TypeTy *ConvType = ParseConversionFunctionId(&EndLoc))
1801            D.setConversionFunction(ConvType, OperatorLoc, EndLoc);
1802          else {
1803            D.SetIdentifier(0, Tok.getLocation());
1804          }
1805        }
1806        goto PastIdentifier;
1807      } else if (Tok.is(tok::tilde)) {
1808        // This should be a C++ destructor.
1809        SourceLocation TildeLoc = ConsumeToken();
1810        if (Tok.is(tok::identifier)) {
1811          // FIXME: Inaccurate.
1812          SourceLocation NameLoc = Tok.getLocation();
1813          if (TypeTy *Type = ParseClassName()) {
1814            D.setDestructor(Type, TildeLoc, NameLoc);
1815          } else {
1816            D.SetIdentifier(0, TildeLoc);
1817          }
1818        } else {
1819          Diag(Tok, diag::err_expected_class_name);
1820          D.SetIdentifier(0, TildeLoc);
1821        }
1822        goto PastIdentifier;
1823      }
1824
1825      // If we reached this point, token is not identifier and not '~'.
1826
1827      if (afterCXXScope) {
1828        Diag(Tok, diag::err_expected_unqualified_id);
1829        D.SetIdentifier(0, Tok.getLocation());
1830        D.setInvalidType(true);
1831        goto PastIdentifier;
1832      }
1833    }
1834  }
1835
1836  // If we reached this point, we are either in C/ObjC or the token didn't
1837  // satisfy any of the C++-specific checks.
1838
1839  if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {
1840    assert(!getLang().CPlusPlus &&
1841           "There's a C++-specific check for tok::identifier above");
1842    assert(Tok.getIdentifierInfo() && "Not an identifier?");
1843    D.SetIdentifier(Tok.getIdentifierInfo(), Tok.getLocation());
1844    ConsumeToken();
1845  } else if (Tok.is(tok::l_paren)) {
1846    // direct-declarator: '(' declarator ')'
1847    // direct-declarator: '(' attributes declarator ')'
1848    // Example: 'char (*X)'   or 'int (*XX)(void)'
1849    ParseParenDeclarator(D);
1850  } else if (D.mayOmitIdentifier()) {
1851    // This could be something simple like "int" (in which case the declarator
1852    // portion is empty), if an abstract-declarator is allowed.
1853    D.SetIdentifier(0, Tok.getLocation());
1854  } else {
1855    if (getLang().CPlusPlus)
1856      Diag(Tok, diag::err_expected_unqualified_id);
1857    else
1858      Diag(Tok, diag::err_expected_ident_lparen);
1859    D.SetIdentifier(0, Tok.getLocation());
1860    D.setInvalidType(true);
1861  }
1862
1863 PastIdentifier:
1864  assert(D.isPastIdentifier() &&
1865         "Haven't past the location of the identifier yet?");
1866
1867  while (1) {
1868    if (Tok.is(tok::l_paren)) {
1869      // The paren may be part of a C++ direct initializer, eg. "int x(1);".
1870      // In such a case, check if we actually have a function declarator; if it
1871      // is not, the declarator has been fully parsed.
1872      if (getLang().CPlusPlus && D.mayBeFollowedByCXXDirectInit()) {
1873        // When not in file scope, warn for ambiguous function declarators, just
1874        // in case the author intended it as a variable definition.
1875        bool warnIfAmbiguous = D.getContext() != Declarator::FileContext;
1876        if (!isCXXFunctionDeclarator(warnIfAmbiguous))
1877          break;
1878      }
1879      ParseFunctionDeclarator(ConsumeParen(), D);
1880    } else if (Tok.is(tok::l_square)) {
1881      ParseBracketDeclarator(D);
1882    } else {
1883      break;
1884    }
1885  }
1886}
1887
1888/// ParseParenDeclarator - We parsed the declarator D up to a paren.  This is
1889/// only called before the identifier, so these are most likely just grouping
1890/// parens for precedence.  If we find that these are actually function
1891/// parameter parens in an abstract-declarator, we call ParseFunctionDeclarator.
1892///
1893///       direct-declarator:
1894///         '(' declarator ')'
1895/// [GNU]   '(' attributes declarator ')'
1896///         direct-declarator '(' parameter-type-list ')'
1897///         direct-declarator '(' identifier-list[opt] ')'
1898/// [GNU]   direct-declarator '(' parameter-forward-declarations
1899///                    parameter-type-list[opt] ')'
1900///
1901void Parser::ParseParenDeclarator(Declarator &D) {
1902  SourceLocation StartLoc = ConsumeParen();
1903  assert(!D.isPastIdentifier() && "Should be called before passing identifier");
1904
1905  // Eat any attributes before we look at whether this is a grouping or function
1906  // declarator paren.  If this is a grouping paren, the attribute applies to
1907  // the type being built up, for example:
1908  //     int (__attribute__(()) *x)(long y)
1909  // If this ends up not being a grouping paren, the attribute applies to the
1910  // first argument, for example:
1911  //     int (__attribute__(()) int x)
1912  // In either case, we need to eat any attributes to be able to determine what
1913  // sort of paren this is.
1914  //
1915  AttributeList *AttrList = 0;
1916  bool RequiresArg = false;
1917  if (Tok.is(tok::kw___attribute)) {
1918    AttrList = ParseAttributes();
1919
1920    // We require that the argument list (if this is a non-grouping paren) be
1921    // present even if the attribute list was empty.
1922    RequiresArg = true;
1923  }
1924  // Eat any Microsoft extensions.
1925  while ((Tok.is(tok::kw___cdecl) || Tok.is(tok::kw___stdcall) ||
1926          (Tok.is(tok::kw___fastcall))) && PP.getLangOptions().Microsoft)
1927    ConsumeToken();
1928
1929  // If we haven't past the identifier yet (or where the identifier would be
1930  // stored, if this is an abstract declarator), then this is probably just
1931  // grouping parens. However, if this could be an abstract-declarator, then
1932  // this could also be the start of function arguments (consider 'void()').
1933  bool isGrouping;
1934
1935  if (!D.mayOmitIdentifier()) {
1936    // If this can't be an abstract-declarator, this *must* be a grouping
1937    // paren, because we haven't seen the identifier yet.
1938    isGrouping = true;
1939  } else if (Tok.is(tok::r_paren) ||           // 'int()' is a function.
1940             (getLang().CPlusPlus && Tok.is(tok::ellipsis)) || // C++ int(...)
1941             isDeclarationSpecifier()) {       // 'int(int)' is a function.
1942    // This handles C99 6.7.5.3p11: in "typedef int X; void foo(X)", X is
1943    // considered to be a type, not a K&R identifier-list.
1944    isGrouping = false;
1945  } else {
1946    // Otherwise, this is a grouping paren, e.g. 'int (*X)' or 'int(X)'.
1947    isGrouping = true;
1948  }
1949
1950  // If this is a grouping paren, handle:
1951  // direct-declarator: '(' declarator ')'
1952  // direct-declarator: '(' attributes declarator ')'
1953  if (isGrouping) {
1954    bool hadGroupingParens = D.hasGroupingParens();
1955    D.setGroupingParens(true);
1956    if (AttrList)
1957      D.AddAttributes(AttrList, SourceLocation());
1958
1959    ParseDeclaratorInternal(D, &Parser::ParseDirectDeclarator);
1960    // Match the ')'.
1961    SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, StartLoc);
1962
1963    D.setGroupingParens(hadGroupingParens);
1964    D.SetRangeEnd(Loc);
1965    return;
1966  }
1967
1968  // Okay, if this wasn't a grouping paren, it must be the start of a function
1969  // argument list.  Recognize that this declarator will never have an
1970  // identifier (and remember where it would have been), then call into
1971  // ParseFunctionDeclarator to handle of argument list.
1972  D.SetIdentifier(0, Tok.getLocation());
1973
1974  ParseFunctionDeclarator(StartLoc, D, AttrList, RequiresArg);
1975}
1976
1977/// ParseFunctionDeclarator - We are after the identifier and have parsed the
1978/// declarator D up to a paren, which indicates that we are parsing function
1979/// arguments.
1980///
1981/// If AttrList is non-null, then the caller parsed those arguments immediately
1982/// after the open paren - they should be considered to be the first argument of
1983/// a parameter.  If RequiresArg is true, then the first argument of the
1984/// function is required to be present and required to not be an identifier
1985/// list.
1986///
1987/// This method also handles this portion of the grammar:
1988///       parameter-type-list: [C99 6.7.5]
1989///         parameter-list
1990///         parameter-list ',' '...'
1991///
1992///       parameter-list: [C99 6.7.5]
1993///         parameter-declaration
1994///         parameter-list ',' parameter-declaration
1995///
1996///       parameter-declaration: [C99 6.7.5]
1997///         declaration-specifiers declarator
1998/// [C++]   declaration-specifiers declarator '=' assignment-expression
1999/// [GNU]   declaration-specifiers declarator attributes
2000///         declaration-specifiers abstract-declarator[opt]
2001/// [C++]   declaration-specifiers abstract-declarator[opt]
2002///           '=' assignment-expression
2003/// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
2004///
2005/// For C++, after the parameter-list, it also parses "cv-qualifier-seq[opt]"
2006/// and "exception-specification[opt]"(TODO).
2007///
2008void Parser::ParseFunctionDeclarator(SourceLocation LParenLoc, Declarator &D,
2009                                     AttributeList *AttrList,
2010                                     bool RequiresArg) {
2011  // lparen is already consumed!
2012  assert(D.isPastIdentifier() && "Should not call before identifier!");
2013
2014  // This parameter list may be empty.
2015  if (Tok.is(tok::r_paren)) {
2016    if (RequiresArg) {
2017      Diag(Tok, diag::err_argument_required_after_attribute);
2018      delete AttrList;
2019    }
2020
2021    SourceLocation Loc = ConsumeParen();  // Eat the closing ')'.
2022
2023    // cv-qualifier-seq[opt].
2024    DeclSpec DS;
2025    if (getLang().CPlusPlus) {
2026      ParseTypeQualifierListOpt(DS, false /*no attributes*/);
2027      if (!DS.getSourceRange().getEnd().isInvalid())
2028        Loc = DS.getSourceRange().getEnd();
2029
2030      // Parse exception-specification[opt].
2031      if (Tok.is(tok::kw_throw))
2032        ParseExceptionSpecification(Loc);
2033    }
2034
2035    // Remember that we parsed a function type, and remember the attributes.
2036    // int() -> no prototype, no '...'.
2037    D.AddTypeInfo(DeclaratorChunk::getFunction(/*prototype*/getLang().CPlusPlus,
2038                                               /*variadic*/ false,
2039                                               /*arglist*/ 0, 0,
2040                                               DS.getTypeQualifiers(),
2041                                               LParenLoc, D),
2042                  Loc);
2043    return;
2044  }
2045
2046  // Alternatively, this parameter list may be an identifier list form for a
2047  // K&R-style function:  void foo(a,b,c)
2048  if (!getLang().CPlusPlus && Tok.is(tok::identifier)) {
2049    if (!TryAnnotateTypeOrScopeToken()) {
2050      // K&R identifier lists can't have typedefs as identifiers, per
2051      // C99 6.7.5.3p11.
2052      if (RequiresArg) {
2053        Diag(Tok, diag::err_argument_required_after_attribute);
2054        delete AttrList;
2055      }
2056      // Identifier list.  Note that '(' identifier-list ')' is only allowed for
2057      // normal declarators, not for abstract-declarators.
2058      return ParseFunctionDeclaratorIdentifierList(LParenLoc, D);
2059    }
2060  }
2061
2062  // Finally, a normal, non-empty parameter type list.
2063
2064  // Build up an array of information about the parsed arguments.
2065  llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
2066
2067  // Enter function-declaration scope, limiting any declarators to the
2068  // function prototype scope, including parameter declarators.
2069  ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope|Scope::DeclScope);
2070
2071  bool IsVariadic = false;
2072  while (1) {
2073    if (Tok.is(tok::ellipsis)) {
2074      IsVariadic = true;
2075
2076      // Check to see if this is "void(...)" which is not allowed.
2077      if (!getLang().CPlusPlus && ParamInfo.empty()) {
2078        // Otherwise, parse parameter type list.  If it starts with an
2079        // ellipsis,  diagnose the malformed function.
2080        Diag(Tok, diag::err_ellipsis_first_arg);
2081        IsVariadic = false;       // Treat this like 'void()'.
2082      }
2083
2084      ConsumeToken();     // Consume the ellipsis.
2085      break;
2086    }
2087
2088    SourceLocation DSStart = Tok.getLocation();
2089
2090    // Parse the declaration-specifiers.
2091    DeclSpec DS;
2092
2093    // If the caller parsed attributes for the first argument, add them now.
2094    if (AttrList) {
2095      DS.AddAttributes(AttrList);
2096      AttrList = 0;  // Only apply the attributes to the first parameter.
2097    }
2098    ParseDeclarationSpecifiers(DS);
2099
2100    // Parse the declarator.  This is "PrototypeContext", because we must
2101    // accept either 'declarator' or 'abstract-declarator' here.
2102    Declarator ParmDecl(DS, Declarator::PrototypeContext);
2103    ParseDeclarator(ParmDecl);
2104
2105    // Parse GNU attributes, if present.
2106    if (Tok.is(tok::kw___attribute)) {
2107      SourceLocation Loc;
2108      AttributeList *AttrList = ParseAttributes(&Loc);
2109      ParmDecl.AddAttributes(AttrList, Loc);
2110    }
2111
2112    // Remember this parsed parameter in ParamInfo.
2113    IdentifierInfo *ParmII = ParmDecl.getIdentifier();
2114
2115    // DefArgToks is used when the parsing of default arguments needs
2116    // to be delayed.
2117    CachedTokens *DefArgToks = 0;
2118
2119    // If no parameter was specified, verify that *something* was specified,
2120    // otherwise we have a missing type and identifier.
2121    if (DS.getParsedSpecifiers() == DeclSpec::PQ_None &&
2122        ParmDecl.getIdentifier() == 0 && ParmDecl.getNumTypeObjects() == 0) {
2123      // Completely missing, emit error.
2124      Diag(DSStart, diag::err_missing_param);
2125    } else {
2126      // Otherwise, we have something.  Add it and let semantic analysis try
2127      // to grok it and add the result to the ParamInfo we are building.
2128
2129      // Inform the actions module about the parameter declarator, so it gets
2130      // added to the current scope.
2131      DeclTy *Param = Actions.ActOnParamDeclarator(CurScope, ParmDecl);
2132
2133      // Parse the default argument, if any. We parse the default
2134      // arguments in all dialects; the semantic analysis in
2135      // ActOnParamDefaultArgument will reject the default argument in
2136      // C.
2137      if (Tok.is(tok::equal)) {
2138        SourceLocation EqualLoc = Tok.getLocation();
2139
2140        // Parse the default argument
2141        if (D.getContext() == Declarator::MemberContext) {
2142          // If we're inside a class definition, cache the tokens
2143          // corresponding to the default argument. We'll actually parse
2144          // them when we see the end of the class definition.
2145          // FIXME: Templates will require something similar.
2146          // FIXME: Can we use a smart pointer for Toks?
2147          DefArgToks = new CachedTokens;
2148
2149          if (!ConsumeAndStoreUntil(tok::comma, tok::r_paren, *DefArgToks,
2150                                    tok::semi, false)) {
2151            delete DefArgToks;
2152            DefArgToks = 0;
2153            Actions.ActOnParamDefaultArgumentError(Param);
2154          } else
2155            Actions.ActOnParamUnparsedDefaultArgument(Param, EqualLoc);
2156        } else {
2157          // Consume the '='.
2158          ConsumeToken();
2159
2160          OwningExprResult DefArgResult(ParseAssignmentExpression());
2161          if (DefArgResult.isInvalid()) {
2162            Actions.ActOnParamDefaultArgumentError(Param);
2163            SkipUntil(tok::comma, tok::r_paren, true, true);
2164          } else {
2165            // Inform the actions module about the default argument
2166            Actions.ActOnParamDefaultArgument(Param, EqualLoc,
2167                                              DefArgResult.release());
2168          }
2169        }
2170      }
2171
2172      ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
2173                                          ParmDecl.getIdentifierLoc(), Param,
2174                                          DefArgToks));
2175    }
2176
2177    // If the next token is a comma, consume it and keep reading arguments.
2178    if (Tok.isNot(tok::comma)) break;
2179
2180    // Consume the comma.
2181    ConsumeToken();
2182  }
2183
2184  // Leave prototype scope.
2185  PrototypeScope.Exit();
2186
2187  // If we have the closing ')', eat it.
2188  SourceLocation Loc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2189
2190  DeclSpec DS;
2191  if (getLang().CPlusPlus) {
2192    // Parse cv-qualifier-seq[opt].
2193    ParseTypeQualifierListOpt(DS, false /*no attributes*/);
2194      if (!DS.getSourceRange().getEnd().isInvalid())
2195        Loc = DS.getSourceRange().getEnd();
2196
2197    // Parse exception-specification[opt].
2198    if (Tok.is(tok::kw_throw))
2199      ParseExceptionSpecification(Loc);
2200  }
2201
2202  // Remember that we parsed a function type, and remember the attributes.
2203  D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/true, IsVariadic,
2204                                             &ParamInfo[0], ParamInfo.size(),
2205                                             DS.getTypeQualifiers(),
2206                                             LParenLoc, D),
2207                Loc);
2208}
2209
2210/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator
2211/// we found a K&R-style identifier list instead of a type argument list.  The
2212/// current token is known to be the first identifier in the list.
2213///
2214///       identifier-list: [C99 6.7.5]
2215///         identifier
2216///         identifier-list ',' identifier
2217///
2218void Parser::ParseFunctionDeclaratorIdentifierList(SourceLocation LParenLoc,
2219                                                   Declarator &D) {
2220  // Build up an array of information about the parsed arguments.
2221  llvm::SmallVector<DeclaratorChunk::ParamInfo, 16> ParamInfo;
2222  llvm::SmallSet<const IdentifierInfo*, 16> ParamsSoFar;
2223
2224  // If there was no identifier specified for the declarator, either we are in
2225  // an abstract-declarator, or we are in a parameter declarator which was found
2226  // to be abstract.  In abstract-declarators, identifier lists are not valid:
2227  // diagnose this.
2228  if (!D.getIdentifier())
2229    Diag(Tok, diag::ext_ident_list_in_param);
2230
2231  // Tok is known to be the first identifier in the list.  Remember this
2232  // identifier in ParamInfo.
2233  ParamsSoFar.insert(Tok.getIdentifierInfo());
2234  ParamInfo.push_back(DeclaratorChunk::ParamInfo(Tok.getIdentifierInfo(),
2235                                                 Tok.getLocation(), 0));
2236
2237  ConsumeToken();  // eat the first identifier.
2238
2239  while (Tok.is(tok::comma)) {
2240    // Eat the comma.
2241    ConsumeToken();
2242
2243    // If this isn't an identifier, report the error and skip until ')'.
2244    if (Tok.isNot(tok::identifier)) {
2245      Diag(Tok, diag::err_expected_ident);
2246      SkipUntil(tok::r_paren);
2247      return;
2248    }
2249
2250    IdentifierInfo *ParmII = Tok.getIdentifierInfo();
2251
2252    // Reject 'typedef int y; int test(x, y)', but continue parsing.
2253    if (Actions.getTypeName(*ParmII, Tok.getLocation(), CurScope))
2254      Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;
2255
2256    // Verify that the argument identifier has not already been mentioned.
2257    if (!ParamsSoFar.insert(ParmII)) {
2258      Diag(Tok, diag::err_param_redefinition) << ParmII;
2259    } else {
2260      // Remember this identifier in ParamInfo.
2261      ParamInfo.push_back(DeclaratorChunk::ParamInfo(ParmII,
2262                                                     Tok.getLocation(), 0));
2263    }
2264
2265    // Eat the identifier.
2266    ConsumeToken();
2267  }
2268
2269  // If we have the closing ')', eat it and we're done.
2270  SourceLocation RLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
2271
2272  // Remember that we parsed a function type, and remember the attributes.  This
2273  // function type is always a K&R style function type, which is not varargs and
2274  // has no prototype.
2275  D.AddTypeInfo(DeclaratorChunk::getFunction(/*proto*/false, /*varargs*/false,
2276                                             &ParamInfo[0], ParamInfo.size(),
2277                                             /*TypeQuals*/0, LParenLoc, D),
2278                RLoc);
2279}
2280
2281/// [C90]   direct-declarator '[' constant-expression[opt] ']'
2282/// [C99]   direct-declarator '[' type-qual-list[opt] assignment-expr[opt] ']'
2283/// [C99]   direct-declarator '[' 'static' type-qual-list[opt] assign-expr ']'
2284/// [C99]   direct-declarator '[' type-qual-list 'static' assignment-expr ']'
2285/// [C99]   direct-declarator '[' type-qual-list[opt] '*' ']'
2286void Parser::ParseBracketDeclarator(Declarator &D) {
2287  SourceLocation StartLoc = ConsumeBracket();
2288
2289  // C array syntax has many features, but by-far the most common is [] and [4].
2290  // This code does a fast path to handle some of the most obvious cases.
2291  if (Tok.getKind() == tok::r_square) {
2292    SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
2293    // Remember that we parsed the empty array type.
2294    OwningExprResult NumElements(Actions);
2295    D.AddTypeInfo(DeclaratorChunk::getArray(0, false, false, 0, StartLoc),
2296                  EndLoc);
2297    return;
2298  } else if (Tok.getKind() == tok::numeric_constant &&
2299             GetLookAheadToken(1).is(tok::r_square)) {
2300    // [4] is very common.  Parse the numeric constant expression.
2301    OwningExprResult ExprRes(Actions.ActOnNumericConstant(Tok));
2302    ConsumeToken();
2303
2304    SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
2305
2306    // If there was an error parsing the assignment-expression, recover.
2307    if (ExprRes.isInvalid())
2308      ExprRes.release();  // Deallocate expr, just use [].
2309
2310    // Remember that we parsed a array type, and remember its features.
2311    D.AddTypeInfo(DeclaratorChunk::getArray(0, false, 0,
2312                                            ExprRes.release(), StartLoc),
2313                  EndLoc);
2314    return;
2315  }
2316
2317  // If valid, this location is the position where we read the 'static' keyword.
2318  SourceLocation StaticLoc;
2319  if (Tok.is(tok::kw_static))
2320    StaticLoc = ConsumeToken();
2321
2322  // If there is a type-qualifier-list, read it now.
2323  // Type qualifiers in an array subscript are a C99 feature.
2324  DeclSpec DS;
2325  ParseTypeQualifierListOpt(DS, false /*no attributes*/);
2326
2327  // If we haven't already read 'static', check to see if there is one after the
2328  // type-qualifier-list.
2329  if (!StaticLoc.isValid() && Tok.is(tok::kw_static))
2330    StaticLoc = ConsumeToken();
2331
2332  // Handle "direct-declarator [ type-qual-list[opt] * ]".
2333  bool isStar = false;
2334  OwningExprResult NumElements(Actions);
2335
2336  // Handle the case where we have '[*]' as the array size.  However, a leading
2337  // star could be the start of an expression, for example 'X[*p + 4]'.  Verify
2338  // the the token after the star is a ']'.  Since stars in arrays are
2339  // infrequent, use of lookahead is not costly here.
2340  if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {
2341    ConsumeToken();  // Eat the '*'.
2342
2343    if (StaticLoc.isValid()) {
2344      Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);
2345      StaticLoc = SourceLocation();  // Drop the static.
2346    }
2347    isStar = true;
2348  } else if (Tok.isNot(tok::r_square)) {
2349    // Note, in C89, this production uses the constant-expr production instead
2350    // of assignment-expr.  The only difference is that assignment-expr allows
2351    // things like '=' and '*='.  Sema rejects these in C89 mode because they
2352    // are not i-c-e's, so we don't need to distinguish between the two here.
2353
2354    // Parse the assignment-expression now.
2355    NumElements = ParseAssignmentExpression();
2356  }
2357
2358  // If there was an error parsing the assignment-expression, recover.
2359  if (NumElements.isInvalid()) {
2360    // If the expression was invalid, skip it.
2361    SkipUntil(tok::r_square);
2362    return;
2363  }
2364
2365  SourceLocation EndLoc = MatchRHSPunctuation(tok::r_square, StartLoc);
2366
2367  // Remember that we parsed a array type, and remember its features.
2368  D.AddTypeInfo(DeclaratorChunk::getArray(DS.getTypeQualifiers(),
2369                                          StaticLoc.isValid(), isStar,
2370                                          NumElements.release(), StartLoc),
2371                EndLoc);
2372}
2373
2374/// [GNU]   typeof-specifier:
2375///           typeof ( expressions )
2376///           typeof ( type-name )
2377/// [GNU/C++] typeof unary-expression
2378///
2379void Parser::ParseTypeofSpecifier(DeclSpec &DS) {
2380  assert(Tok.is(tok::kw_typeof) && "Not a typeof specifier");
2381  const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo();
2382  SourceLocation StartLoc = ConsumeToken();
2383
2384  if (Tok.isNot(tok::l_paren)) {
2385    if (!getLang().CPlusPlus) {
2386      Diag(Tok, diag::err_expected_lparen_after_id) << BuiltinII;
2387      return;
2388    }
2389
2390    OwningExprResult Result(ParseCastExpression(true/*isUnaryExpression*/));
2391    if (Result.isInvalid())
2392      return;
2393
2394    const char *PrevSpec = 0;
2395    // Check for duplicate type specifiers.
2396    if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
2397                           Result.release()))
2398      Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
2399
2400    // FIXME: Not accurate, the range gets one token more than it should.
2401    DS.SetRangeEnd(Tok.getLocation());
2402    return;
2403  }
2404
2405  SourceLocation LParenLoc = ConsumeParen(), RParenLoc;
2406
2407  if (isTypeIdInParens()) {
2408    TypeTy *Ty = ParseTypeName();
2409
2410    assert(Ty && "Parser::ParseTypeofSpecifier(): missing type");
2411
2412    if (Tok.isNot(tok::r_paren)) {
2413      MatchRHSPunctuation(tok::r_paren, LParenLoc);
2414      return;
2415    }
2416    RParenLoc = ConsumeParen();
2417    const char *PrevSpec = 0;
2418    // Check for duplicate type specifiers (e.g. "int typeof(int)").
2419    if (DS.SetTypeSpecType(DeclSpec::TST_typeofType, StartLoc, PrevSpec, Ty))
2420      Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
2421  } else { // we have an expression.
2422    OwningExprResult Result(ParseExpression());
2423
2424    if (Result.isInvalid() || Tok.isNot(tok::r_paren)) {
2425      MatchRHSPunctuation(tok::r_paren, LParenLoc);
2426      return;
2427    }
2428    RParenLoc = ConsumeParen();
2429    const char *PrevSpec = 0;
2430    // Check for duplicate type specifiers (e.g. "int typeof(int)").
2431    if (DS.SetTypeSpecType(DeclSpec::TST_typeofExpr, StartLoc, PrevSpec,
2432                           Result.release()))
2433      Diag(StartLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
2434  }
2435  DS.SetRangeEnd(RParenLoc);
2436}
2437
2438
2439