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