Parser.cpp revision 51a75d0cc7651753399efdc3176feaee6214c3ca 
1//===--- Parser.cpp - C Language Family Parser ----------------------------===//
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 Parser interfaces.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Parse/Parser.h"
15#include "clang/Parse/ParseDiagnostic.h"
16#include "clang/Parse/DeclSpec.h"
17#include "clang/Parse/Scope.h"
18#include "ExtensionRAIIObject.h"
19#include "ParsePragma.h"
20using namespace clang;
21
22Parser::Parser(Preprocessor &pp, Action &actions)
23  : PP(pp), Actions(actions), Diags(PP.getDiagnostics()),
24    GreaterThanIsOperator(true) {
25  Tok.setKind(tok::eof);
26  CurScope = 0;
27  NumCachedScopes = 0;
28  ParenCount = BracketCount = BraceCount = 0;
29  ObjCImpDecl = 0;
30
31  // Add #pragma handlers. These are removed and destroyed in the
32  // destructor.
33  PackHandler =
34    new PragmaPackHandler(&PP.getIdentifierTable().get("pack"), actions);
35  PP.AddPragmaHandler(0, PackHandler);
36
37  // Instantiate a LexedMethodsForTopClass for all the non-nested classes.
38  PushTopClassStack();
39}
40
41///  Out-of-line virtual destructor to provide home for Action class.
42ActionBase::~ActionBase() {}
43
44///  Out-of-line virtual destructor to provide home for Action class.
45Action::~Action() {}
46
47// Defined out-of-line here because of dependecy on AttributeList
48Action::DeclTy *Action::ActOnUsingDirective(Scope *CurScope,
49                                            SourceLocation UsingLoc,
50                                            SourceLocation NamespcLoc,
51                                            const CXXScopeSpec &SS,
52                                            SourceLocation IdentLoc,
53                                            IdentifierInfo *NamespcName,
54                                            AttributeList *AttrList) {
55
56  // FIXME: Parser seems to assume that Action::ActOn* takes ownership over
57  // passed AttributeList, however other actions don't free it, is it
58  // temporary state or bug?
59  delete AttrList;
60  return 0;
61}
62
63DiagnosticBuilder Parser::Diag(SourceLocation Loc, unsigned DiagID) {
64  return Diags.Report(FullSourceLoc(Loc,PP.getSourceManager()), DiagID);
65}
66
67DiagnosticBuilder Parser::Diag(const Token &Tok, unsigned DiagID) {
68  return Diag(Tok.getLocation(), DiagID);
69}
70
71/// \brief Emits a diagnostic suggesting parentheses surrounding a
72/// given range.
73///
74/// \param Loc The location where we'll emit the diagnostic.
75/// \param Loc The kind of diagnostic to emit.
76/// \param ParenRange Source range enclosing code that should be parenthesized.
77void Parser::SuggestParentheses(SourceLocation Loc, unsigned DK,
78                                SourceRange ParenRange) {
79  if (!ParenRange.getEnd().isFileID()) {
80    // We can't display the parentheses, so just dig the
81    // warning/error and return.
82    Diag(Loc, DK);
83    return;
84  }
85
86  unsigned Len = Lexer::MeasureTokenLength(ParenRange.getEnd(),
87                                           PP.getSourceManager());
88  Diag(Loc, DK)
89    << CodeInsertionHint(ParenRange.getBegin(), "(")
90    << CodeInsertionHint(ParenRange.getEnd().getFileLocWithOffset(Len), ")");
91}
92
93/// MatchRHSPunctuation - For punctuation with a LHS and RHS (e.g. '['/']'),
94/// this helper function matches and consumes the specified RHS token if
95/// present.  If not present, it emits the specified diagnostic indicating
96/// that the parser failed to match the RHS of the token at LHSLoc.  LHSName
97/// should be the name of the unmatched LHS token.
98SourceLocation Parser::MatchRHSPunctuation(tok::TokenKind RHSTok,
99                                           SourceLocation LHSLoc) {
100
101  if (Tok.is(RHSTok))
102    return ConsumeAnyToken();
103
104  SourceLocation R = Tok.getLocation();
105  const char *LHSName = "unknown";
106  diag::kind DID = diag::err_parse_error;
107  switch (RHSTok) {
108  default: break;
109  case tok::r_paren : LHSName = "("; DID = diag::err_expected_rparen; break;
110  case tok::r_brace : LHSName = "{"; DID = diag::err_expected_rbrace; break;
111  case tok::r_square: LHSName = "["; DID = diag::err_expected_rsquare; break;
112  case tok::greater:  LHSName = "<"; DID = diag::err_expected_greater; break;
113  }
114  Diag(Tok, DID);
115  Diag(LHSLoc, diag::note_matching) << LHSName;
116  SkipUntil(RHSTok);
117  return R;
118}
119
120/// ExpectAndConsume - The parser expects that 'ExpectedTok' is next in the
121/// input.  If so, it is consumed and false is returned.
122///
123/// If the input is malformed, this emits the specified diagnostic.  Next, if
124/// SkipToTok is specified, it calls SkipUntil(SkipToTok).  Finally, true is
125/// returned.
126bool Parser::ExpectAndConsume(tok::TokenKind ExpectedTok, unsigned DiagID,
127                              const char *Msg, tok::TokenKind SkipToTok) {
128  if (Tok.is(ExpectedTok)) {
129    ConsumeAnyToken();
130    return false;
131  }
132
133  const char *Spelling = 0;
134  if (PrevTokLocation.isValid() && PrevTokLocation.isFileID() &&
135      (Spelling = tok::getTokenSpelling(ExpectedTok))) {
136    // Show what code to insert to fix this problem.
137    SourceLocation DiagLoc
138      = PrevTokLocation.getFileLocWithOffset(strlen(Spelling));
139    Diag(DiagLoc, DiagID)
140      << Msg
141      << CodeInsertionHint(DiagLoc, Spelling);
142  } else
143    Diag(Tok, DiagID) << Msg;
144
145  if (SkipToTok != tok::unknown)
146    SkipUntil(SkipToTok);
147  return true;
148}
149
150//===----------------------------------------------------------------------===//
151// Error recovery.
152//===----------------------------------------------------------------------===//
153
154/// SkipUntil - Read tokens until we get to the specified token, then consume
155/// it (unless DontConsume is true).  Because we cannot guarantee that the
156/// token will ever occur, this skips to the next token, or to some likely
157/// good stopping point.  If StopAtSemi is true, skipping will stop at a ';'
158/// character.
159///
160/// If SkipUntil finds the specified token, it returns true, otherwise it
161/// returns false.
162bool Parser::SkipUntil(const tok::TokenKind *Toks, unsigned NumToks,
163                       bool StopAtSemi, bool DontConsume) {
164  // We always want this function to skip at least one token if the first token
165  // isn't T and if not at EOF.
166  bool isFirstTokenSkipped = true;
167  while (1) {
168    // If we found one of the tokens, stop and return true.
169    for (unsigned i = 0; i != NumToks; ++i) {
170      if (Tok.is(Toks[i])) {
171        if (DontConsume) {
172          // Noop, don't consume the token.
173        } else {
174          ConsumeAnyToken();
175        }
176        return true;
177      }
178    }
179
180    switch (Tok.getKind()) {
181    case tok::eof:
182      // Ran out of tokens.
183      return false;
184
185    case tok::l_paren:
186      // Recursively skip properly-nested parens.
187      ConsumeParen();
188      SkipUntil(tok::r_paren, false);
189      break;
190    case tok::l_square:
191      // Recursively skip properly-nested square brackets.
192      ConsumeBracket();
193      SkipUntil(tok::r_square, false);
194      break;
195    case tok::l_brace:
196      // Recursively skip properly-nested braces.
197      ConsumeBrace();
198      SkipUntil(tok::r_brace, false);
199      break;
200
201    // Okay, we found a ']' or '}' or ')', which we think should be balanced.
202    // Since the user wasn't looking for this token (if they were, it would
203    // already be handled), this isn't balanced.  If there is a LHS token at a
204    // higher level, we will assume that this matches the unbalanced token
205    // and return it.  Otherwise, this is a spurious RHS token, which we skip.
206    case tok::r_paren:
207      if (ParenCount && !isFirstTokenSkipped)
208        return false;  // Matches something.
209      ConsumeParen();
210      break;
211    case tok::r_square:
212      if (BracketCount && !isFirstTokenSkipped)
213        return false;  // Matches something.
214      ConsumeBracket();
215      break;
216    case tok::r_brace:
217      if (BraceCount && !isFirstTokenSkipped)
218        return false;  // Matches something.
219      ConsumeBrace();
220      break;
221
222    case tok::string_literal:
223    case tok::wide_string_literal:
224      ConsumeStringToken();
225      break;
226    case tok::semi:
227      if (StopAtSemi)
228        return false;
229      // FALL THROUGH.
230    default:
231      // Skip this token.
232      ConsumeToken();
233      break;
234    }
235    isFirstTokenSkipped = false;
236  }
237}
238
239//===----------------------------------------------------------------------===//
240// Scope manipulation
241//===----------------------------------------------------------------------===//
242
243/// EnterScope - Start a new scope.
244void Parser::EnterScope(unsigned ScopeFlags) {
245  if (NumCachedScopes) {
246    Scope *N = ScopeCache[--NumCachedScopes];
247    N->Init(CurScope, ScopeFlags);
248    CurScope = N;
249  } else {
250    CurScope = new Scope(CurScope, ScopeFlags);
251  }
252}
253
254/// ExitScope - Pop a scope off the scope stack.
255void Parser::ExitScope() {
256  assert(CurScope && "Scope imbalance!");
257
258  // Inform the actions module that this scope is going away if there are any
259  // decls in it.
260  if (!CurScope->decl_empty())
261    Actions.ActOnPopScope(Tok.getLocation(), CurScope);
262
263  Scope *OldScope = CurScope;
264  CurScope = OldScope->getParent();
265
266  if (NumCachedScopes == ScopeCacheSize)
267    delete OldScope;
268  else
269    ScopeCache[NumCachedScopes++] = OldScope;
270}
271
272
273
274
275//===----------------------------------------------------------------------===//
276// C99 6.9: External Definitions.
277//===----------------------------------------------------------------------===//
278
279Parser::~Parser() {
280  // If we still have scopes active, delete the scope tree.
281  delete CurScope;
282
283  // Free the scope cache.
284  for (unsigned i = 0, e = NumCachedScopes; i != e; ++i)
285    delete ScopeCache[i];
286
287  // Remove the pragma handlers we installed.
288  PP.RemovePragmaHandler(0, PackHandler);
289  delete PackHandler;
290}
291
292/// Initialize - Warm up the parser.
293///
294void Parser::Initialize() {
295  // Prime the lexer look-ahead.
296  ConsumeToken();
297
298  // Create the translation unit scope.  Install it as the current scope.
299  assert(CurScope == 0 && "A scope is already active?");
300  EnterScope(Scope::DeclScope);
301  Actions.ActOnTranslationUnitScope(Tok.getLocation(), CurScope);
302
303  if (Tok.is(tok::eof) &&
304      !getLang().CPlusPlus)  // Empty source file is an extension in C
305    Diag(Tok, diag::ext_empty_source_file);
306
307  // Initialization for Objective-C context sensitive keywords recognition.
308  // Referenced in Parser::ParseObjCTypeQualifierList.
309  if (getLang().ObjC1) {
310    ObjCTypeQuals[objc_in] = &PP.getIdentifierTable().get("in");
311    ObjCTypeQuals[objc_out] = &PP.getIdentifierTable().get("out");
312    ObjCTypeQuals[objc_inout] = &PP.getIdentifierTable().get("inout");
313    ObjCTypeQuals[objc_oneway] = &PP.getIdentifierTable().get("oneway");
314    ObjCTypeQuals[objc_bycopy] = &PP.getIdentifierTable().get("bycopy");
315    ObjCTypeQuals[objc_byref] = &PP.getIdentifierTable().get("byref");
316  }
317
318  Ident_super = &PP.getIdentifierTable().get("super");
319}
320
321/// ParseTopLevelDecl - Parse one top-level declaration, return whatever the
322/// action tells us to.  This returns true if the EOF was encountered.
323bool Parser::ParseTopLevelDecl(DeclTy*& Result) {
324  Result = 0;
325  if (Tok.is(tok::eof)) {
326    Actions.ActOnEndOfTranslationUnit();
327    return true;
328  }
329
330  Result = ParseExternalDeclaration();
331  return false;
332}
333
334/// ParseTranslationUnit:
335///       translation-unit: [C99 6.9]
336///         external-declaration
337///         translation-unit external-declaration
338void Parser::ParseTranslationUnit() {
339  Initialize();
340
341  DeclTy *Res;
342  while (!ParseTopLevelDecl(Res))
343    /*parse them all*/;
344
345  ExitScope();
346  assert(CurScope == 0 && "Scope imbalance!");
347}
348
349/// ParseExternalDeclaration:
350///
351///       external-declaration: [C99 6.9], declaration: [C++ dcl.dcl]
352///         function-definition
353///         declaration
354/// [EXT]   ';'
355/// [GNU]   asm-definition
356/// [GNU]   __extension__ external-declaration
357/// [OBJC]  objc-class-definition
358/// [OBJC]  objc-class-declaration
359/// [OBJC]  objc-alias-declaration
360/// [OBJC]  objc-protocol-definition
361/// [OBJC]  objc-method-definition
362/// [OBJC]  @end
363/// [C++]   linkage-specification
364/// [GNU] asm-definition:
365///         simple-asm-expr ';'
366///
367Parser::DeclTy *Parser::ParseExternalDeclaration() {
368  switch (Tok.getKind()) {
369  case tok::semi:
370    Diag(Tok, diag::ext_top_level_semi);
371    ConsumeToken();
372    // TODO: Invoke action for top-level semicolon.
373    return 0;
374  case tok::r_brace:
375    Diag(Tok, diag::err_expected_external_declaration);
376    ConsumeBrace();
377    return 0;
378  case tok::eof:
379    Diag(Tok, diag::err_expected_external_declaration);
380    return 0;
381  case tok::kw___extension__: {
382    // __extension__ silences extension warnings in the subexpression.
383    ExtensionRAIIObject O(Diags);  // Use RAII to do this.
384    ConsumeToken();
385    return ParseExternalDeclaration();
386  }
387  case tok::kw_asm: {
388    OwningExprResult Result(ParseSimpleAsm());
389
390    ExpectAndConsume(tok::semi, diag::err_expected_semi_after,
391                     "top-level asm block");
392
393    if (!Result.isInvalid())
394      return Actions.ActOnFileScopeAsmDecl(Tok.getLocation(), move(Result));
395    return 0;
396  }
397  case tok::at:
398    // @ is not a legal token unless objc is enabled, no need to check.
399    return ParseObjCAtDirectives();
400  case tok::minus:
401  case tok::plus:
402    if (getLang().ObjC1)
403      return ParseObjCMethodDefinition();
404    else {
405      Diag(Tok, diag::err_expected_external_declaration);
406      ConsumeToken();
407    }
408    return 0;
409  case tok::kw_using:
410  case tok::kw_namespace:
411  case tok::kw_typedef:
412  case tok::kw_template:
413  case tok::kw_export:    // As in 'export template'
414    // A function definition cannot start with a these keywords.
415    return ParseDeclaration(Declarator::FileContext);
416  default:
417    // We can't tell whether this is a function-definition or declaration yet.
418    return ParseDeclarationOrFunctionDefinition();
419  }
420}
421
422/// ParseDeclarationOrFunctionDefinition - Parse either a function-definition or
423/// a declaration.  We can't tell which we have until we read up to the
424/// compound-statement in function-definition. TemplateParams, if
425/// non-NULL, provides the template parameters when we're parsing a
426/// C++ template-declaration.
427///
428///       function-definition: [C99 6.9.1]
429///         decl-specs      declarator declaration-list[opt] compound-statement
430/// [C90] function-definition: [C99 6.7.1] - implicit int result
431/// [C90]   decl-specs[opt] declarator declaration-list[opt] compound-statement
432///
433///       declaration: [C99 6.7]
434///         declaration-specifiers init-declarator-list[opt] ';'
435/// [!C99]  init-declarator-list ';'                   [TODO: warn in c99 mode]
436/// [OMP]   threadprivate-directive                              [TODO]
437///
438Parser::DeclTy *
439Parser::ParseDeclarationOrFunctionDefinition(
440                                  TemplateParameterLists *TemplateParams) {
441  // Parse the common declaration-specifiers piece.
442  DeclSpec DS;
443  ParseDeclarationSpecifiers(DS, TemplateParams);
444
445  // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
446  // declaration-specifiers init-declarator-list[opt] ';'
447  if (Tok.is(tok::semi)) {
448    ConsumeToken();
449    return Actions.ParsedFreeStandingDeclSpec(CurScope, DS);
450  }
451
452  // ObjC2 allows prefix attributes on class interfaces and protocols.
453  // FIXME: This still needs better diagnostics. We should only accept
454  // attributes here, no types, etc.
455  if (getLang().ObjC2 && Tok.is(tok::at)) {
456    SourceLocation AtLoc = ConsumeToken(); // the "@"
457    if (!Tok.isObjCAtKeyword(tok::objc_interface) &&
458        !Tok.isObjCAtKeyword(tok::objc_protocol)) {
459      Diag(Tok, diag::err_objc_unexpected_attr);
460      SkipUntil(tok::semi); // FIXME: better skip?
461      return 0;
462    }
463    const char *PrevSpec = 0;
464    if (DS.SetTypeSpecType(DeclSpec::TST_unspecified, AtLoc, PrevSpec))
465      Diag(AtLoc, diag::err_invalid_decl_spec_combination) << PrevSpec;
466    if (Tok.isObjCAtKeyword(tok::objc_protocol))
467      return ParseObjCAtProtocolDeclaration(AtLoc, DS.getAttributes());
468    return ParseObjCAtInterfaceDeclaration(AtLoc, DS.getAttributes());
469  }
470
471  // If the declspec consisted only of 'extern' and we have a string
472  // literal following it, this must be a C++ linkage specifier like
473  // 'extern "C"'.
474  if (Tok.is(tok::string_literal) && getLang().CPlusPlus &&
475      DS.getStorageClassSpec() == DeclSpec::SCS_extern &&
476      DS.getParsedSpecifiers() == DeclSpec::PQ_StorageClassSpecifier)
477    return ParseLinkage(Declarator::FileContext);
478
479  // Parse the first declarator.
480  Declarator DeclaratorInfo(DS, Declarator::FileContext);
481  ParseDeclarator(DeclaratorInfo);
482  // Error parsing the declarator?
483  if (!DeclaratorInfo.hasName()) {
484    // If so, skip until the semi-colon or a }.
485    SkipUntil(tok::r_brace, true, true);
486    if (Tok.is(tok::semi))
487      ConsumeToken();
488    return 0;
489  }
490
491  // If the declarator is the start of a function definition, handle it.
492  if (Tok.is(tok::equal) ||           // int X()=  -> not a function def
493      Tok.is(tok::comma) ||           // int X(),  -> not a function def
494      Tok.is(tok::semi)  ||           // int X();  -> not a function def
495      Tok.is(tok::kw_asm) ||          // int X() __asm__ -> not a function def
496      Tok.is(tok::kw___attribute) ||  // int X() __attr__ -> not a function def
497      (getLang().CPlusPlus &&
498       Tok.is(tok::l_paren)) ) {      // int X(0) -> not a function def [C++]
499    // FALL THROUGH.
500  } else if (DeclaratorInfo.isFunctionDeclarator() &&
501             (Tok.is(tok::l_brace) ||             // int X() {}
502              (!getLang().CPlusPlus &&
503               isDeclarationSpecifier()))) {    // int X(f) int f; {}
504    if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {
505      Diag(Tok, diag::err_function_declared_typedef);
506
507      if (Tok.is(tok::l_brace)) {
508        // This recovery skips the entire function body. It would be nice
509        // to simply call ParseFunctionDefinition() below, however Sema
510        // assumes the declarator represents a function, not a typedef.
511        ConsumeBrace();
512        SkipUntil(tok::r_brace, true);
513      } else {
514        SkipUntil(tok::semi);
515      }
516      return 0;
517    }
518    return ParseFunctionDefinition(DeclaratorInfo);
519  } else {
520    if (DeclaratorInfo.isFunctionDeclarator())
521      Diag(Tok, diag::err_expected_fn_body);
522    else
523      Diag(Tok, diag::err_invalid_token_after_toplevel_declarator);
524    SkipUntil(tok::semi);
525    return 0;
526  }
527
528  // Parse the init-declarator-list for a normal declaration.
529  return ParseInitDeclaratorListAfterFirstDeclarator(DeclaratorInfo);
530}
531
532/// ParseFunctionDefinition - We parsed and verified that the specified
533/// Declarator is well formed.  If this is a K&R-style function, read the
534/// parameters declaration-list, then start the compound-statement.
535///
536///       function-definition: [C99 6.9.1]
537///         decl-specs      declarator declaration-list[opt] compound-statement
538/// [C90] function-definition: [C99 6.7.1] - implicit int result
539/// [C90]   decl-specs[opt] declarator declaration-list[opt] compound-statement
540/// [C++] function-definition: [C++ 8.4]
541///         decl-specifier-seq[opt] declarator ctor-initializer[opt] function-body
542/// [C++] function-definition: [C++ 8.4]
543///         decl-specifier-seq[opt] declarator function-try-block [TODO]
544///
545Parser::DeclTy *Parser::ParseFunctionDefinition(Declarator &D) {
546  const DeclaratorChunk &FnTypeInfo = D.getTypeObject(0);
547  assert(FnTypeInfo.Kind == DeclaratorChunk::Function &&
548         "This isn't a function declarator!");
549  const DeclaratorChunk::FunctionTypeInfo &FTI = FnTypeInfo.Fun;
550
551  // If this is C90 and the declspecs were completely missing, fudge in an
552  // implicit int.  We do this here because this is the only place where
553  // declaration-specifiers are completely optional in the grammar.
554  if (getLang().ImplicitInt && D.getDeclSpec().getParsedSpecifiers() == 0) {
555    const char *PrevSpec;
556    D.getMutableDeclSpec().SetTypeSpecType(DeclSpec::TST_int,
557                                           D.getIdentifierLoc(),
558                                           PrevSpec);
559    D.SetRangeBegin(D.getDeclSpec().getSourceRange().getBegin());
560  }
561
562  // If this declaration was formed with a K&R-style identifier list for the
563  // arguments, parse declarations for all of the args next.
564  // int foo(a,b) int a; float b; {}
565  if (!FTI.hasPrototype && FTI.NumArgs != 0)
566    ParseKNRParamDeclarations(D);
567
568  // We should have either an opening brace or, in a C++ constructor,
569  // we may have a colon.
570  // FIXME: In C++, we might also find the 'try' keyword.
571  if (Tok.isNot(tok::l_brace) && Tok.isNot(tok::colon)) {
572    Diag(Tok, diag::err_expected_fn_body);
573
574    // Skip over garbage, until we get to '{'.  Don't eat the '{'.
575    SkipUntil(tok::l_brace, true, true);
576
577    // If we didn't find the '{', bail out.
578    if (Tok.isNot(tok::l_brace))
579      return 0;
580  }
581
582  // Enter a scope for the function body.
583  ParseScope BodyScope(this, Scope::FnScope|Scope::DeclScope);
584
585  // Tell the actions module that we have entered a function definition with the
586  // specified Declarator for the function.
587  DeclTy *Res = Actions.ActOnStartOfFunctionDef(CurScope, D);
588
589  // If we have a colon, then we're probably parsing a C++
590  // ctor-initializer.
591  if (Tok.is(tok::colon))
592    ParseConstructorInitializer(Res);
593
594  SourceLocation BraceLoc = Tok.getLocation();
595  return ParseFunctionStatementBody(Res, BraceLoc, BraceLoc);
596}
597
598/// ParseKNRParamDeclarations - Parse 'declaration-list[opt]' which provides
599/// types for a function with a K&R-style identifier list for arguments.
600void Parser::ParseKNRParamDeclarations(Declarator &D) {
601  // We know that the top-level of this declarator is a function.
602  DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
603
604  // Enter function-declaration scope, limiting any declarators to the
605  // function prototype scope, including parameter declarators.
606  ParseScope PrototypeScope(this, Scope::FunctionPrototypeScope|Scope::DeclScope);
607
608  // Read all the argument declarations.
609  while (isDeclarationSpecifier()) {
610    SourceLocation DSStart = Tok.getLocation();
611
612    // Parse the common declaration-specifiers piece.
613    DeclSpec DS;
614    ParseDeclarationSpecifiers(DS);
615
616    // C99 6.9.1p6: 'each declaration in the declaration list shall have at
617    // least one declarator'.
618    // NOTE: GCC just makes this an ext-warn.  It's not clear what it does with
619    // the declarations though.  It's trivial to ignore them, really hard to do
620    // anything else with them.
621    if (Tok.is(tok::semi)) {
622      Diag(DSStart, diag::err_declaration_does_not_declare_param);
623      ConsumeToken();
624      continue;
625    }
626
627    // C99 6.9.1p6: Declarations shall contain no storage-class specifiers other
628    // than register.
629    if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
630        DS.getStorageClassSpec() != DeclSpec::SCS_register) {
631      Diag(DS.getStorageClassSpecLoc(),
632           diag::err_invalid_storage_class_in_func_decl);
633      DS.ClearStorageClassSpecs();
634    }
635    if (DS.isThreadSpecified()) {
636      Diag(DS.getThreadSpecLoc(),
637           diag::err_invalid_storage_class_in_func_decl);
638      DS.ClearStorageClassSpecs();
639    }
640
641    // Parse the first declarator attached to this declspec.
642    Declarator ParmDeclarator(DS, Declarator::KNRTypeListContext);
643    ParseDeclarator(ParmDeclarator);
644
645    // Handle the full declarator list.
646    while (1) {
647      DeclTy *AttrList;
648      // If attributes are present, parse them.
649      if (Tok.is(tok::kw___attribute))
650        // FIXME: attach attributes too.
651        AttrList = ParseAttributes();
652
653      // Ask the actions module to compute the type for this declarator.
654      Action::DeclTy *Param =
655        Actions.ActOnParamDeclarator(CurScope, ParmDeclarator);
656
657      if (Param &&
658          // A missing identifier has already been diagnosed.
659          ParmDeclarator.getIdentifier()) {
660
661        // Scan the argument list looking for the correct param to apply this
662        // type.
663        for (unsigned i = 0; ; ++i) {
664          // C99 6.9.1p6: those declarators shall declare only identifiers from
665          // the identifier list.
666          if (i == FTI.NumArgs) {
667            Diag(ParmDeclarator.getIdentifierLoc(), diag::err_no_matching_param)
668              << ParmDeclarator.getIdentifier();
669            break;
670          }
671
672          if (FTI.ArgInfo[i].Ident == ParmDeclarator.getIdentifier()) {
673            // Reject redefinitions of parameters.
674            if (FTI.ArgInfo[i].Param) {
675              Diag(ParmDeclarator.getIdentifierLoc(),
676                   diag::err_param_redefinition)
677                 << ParmDeclarator.getIdentifier();
678            } else {
679              FTI.ArgInfo[i].Param = Param;
680            }
681            break;
682          }
683        }
684      }
685
686      // If we don't have a comma, it is either the end of the list (a ';') or
687      // an error, bail out.
688      if (Tok.isNot(tok::comma))
689        break;
690
691      // Consume the comma.
692      ConsumeToken();
693
694      // Parse the next declarator.
695      ParmDeclarator.clear();
696      ParseDeclarator(ParmDeclarator);
697    }
698
699    if (Tok.is(tok::semi)) {
700      ConsumeToken();
701    } else {
702      Diag(Tok, diag::err_parse_error);
703      // Skip to end of block or statement
704      SkipUntil(tok::semi, true);
705      if (Tok.is(tok::semi))
706        ConsumeToken();
707    }
708  }
709
710  // The actions module must verify that all arguments were declared.
711  Actions.ActOnFinishKNRParamDeclarations(CurScope, D);
712}
713
714
715/// ParseAsmStringLiteral - This is just a normal string-literal, but is not
716/// allowed to be a wide string, and is not subject to character translation.
717///
718/// [GNU] asm-string-literal:
719///         string-literal
720///
721Parser::OwningExprResult Parser::ParseAsmStringLiteral() {
722  if (!isTokenStringLiteral()) {
723    Diag(Tok, diag::err_expected_string_literal);
724    return ExprError();
725  }
726
727  OwningExprResult Res(ParseStringLiteralExpression());
728  if (Res.isInvalid()) return move(Res);
729
730  // TODO: Diagnose: wide string literal in 'asm'
731
732  return move(Res);
733}
734
735/// ParseSimpleAsm
736///
737/// [GNU] simple-asm-expr:
738///         'asm' '(' asm-string-literal ')'
739///
740Parser::OwningExprResult Parser::ParseSimpleAsm(SourceLocation *EndLoc) {
741  assert(Tok.is(tok::kw_asm) && "Not an asm!");
742  SourceLocation Loc = ConsumeToken();
743
744  if (Tok.isNot(tok::l_paren)) {
745    Diag(Tok, diag::err_expected_lparen_after) << "asm";
746    return ExprError();
747  }
748
749  Loc = ConsumeParen();
750
751  OwningExprResult Result(ParseAsmStringLiteral());
752
753  if (Result.isInvalid()) {
754    SkipUntil(tok::r_paren, true, true);
755    if (EndLoc)
756      *EndLoc = Tok.getLocation();
757    ConsumeAnyToken();
758  } else {
759    Loc = MatchRHSPunctuation(tok::r_paren, Loc);
760    if (EndLoc)
761      *EndLoc = Loc;
762  }
763
764  return move(Result);
765}
766
767/// TryAnnotateTypeOrScopeToken - If the current token position is on a
768/// typename (possibly qualified in C++) or a C++ scope specifier not followed
769/// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens
770/// with a single annotation token representing the typename or C++ scope
771/// respectively.
772/// This simplifies handling of C++ scope specifiers and allows efficient
773/// backtracking without the need to re-parse and resolve nested-names and
774/// typenames.
775/// It will mainly be called when we expect to treat identifiers as typenames
776/// (if they are typenames). For example, in C we do not expect identifiers
777/// inside expressions to be treated as typenames so it will not be called
778/// for expressions in C.
779/// The benefit for C/ObjC is that a typename will be annotated and
780/// Actions.getTypeName will not be needed to be called again (e.g. getTypeName
781/// will not be called twice, once to check whether we have a declaration
782/// specifier, and another one to get the actual type inside
783/// ParseDeclarationSpecifiers).
784///
785/// This returns true if the token was annotated.
786///
787/// Note that this routine emits an error if you call it with ::new or ::delete
788/// as the current tokens, so only call it in contexts where these are invalid.
789bool Parser::TryAnnotateTypeOrScopeToken() {
790  assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) &&
791         "Cannot be a type or scope token!");
792
793  // FIXME: Implement template-ids
794  CXXScopeSpec SS;
795  if (getLang().CPlusPlus)
796    ParseOptionalCXXScopeSpecifier(SS);
797
798  if (Tok.is(tok::identifier)) {
799    // Determine whether the identifier is a type name.
800    if (TypeTy *Ty = Actions.getTypeName(*Tok.getIdentifierInfo(),
801                                         Tok.getLocation(), CurScope, &SS)) {
802      // This is a typename. Replace the current token in-place with an
803      // annotation type token.
804      Tok.setKind(tok::annot_typename);
805      Tok.setAnnotationValue(Ty);
806      Tok.setAnnotationEndLoc(Tok.getLocation());
807      if (SS.isNotEmpty()) // it was a C++ qualified type name.
808        Tok.setLocation(SS.getBeginLoc());
809
810      // In case the tokens were cached, have Preprocessor replace
811      // them with the annotation token.
812      PP.AnnotateCachedTokens(Tok);
813      return true;
814    }
815
816    if (!getLang().CPlusPlus) {
817      // If we're in C, we can't have :: tokens at all (the lexer won't return
818      // them).  If the identifier is not a type, then it can't be scope either,
819      // just early exit.
820      return false;
821    }
822
823    // If this is a template-id, annotate with a template-id or type token.
824    if (NextToken().is(tok::less)) {
825      DeclTy *Template;
826      if (TemplateNameKind TNK
827            = Actions.isTemplateName(*Tok.getIdentifierInfo(),
828                                     CurScope, Template, &SS))
829        AnnotateTemplateIdToken(Template, TNK, &SS);
830    }
831
832    // The current token, which is either an identifier or a
833    // template-id, is not part of the annotation. Fall through to
834    // push that token back into the stream and complete the C++ scope
835    // specifier annotation.
836  }
837
838  if (Tok.is(tok::annot_template_id)) {
839    TemplateIdAnnotation *TemplateId
840      = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue());
841    if (TemplateId->Kind == TNK_Class_template) {
842      // A template-id that refers to a type was parsed into a
843      // template-id annotation in a context where we weren't allowed
844      // to produce a type annotation token. Update the template-id
845      // annotation token to a type annotation token now.
846      return !AnnotateTemplateIdTokenAsType(&SS);
847    }
848  }
849
850  if (SS.isEmpty())
851    return false;
852
853  // A C++ scope specifier that isn't followed by a typename.
854  // Push the current token back into the token stream (or revert it if it is
855  // cached) and use an annotation scope token for current token.
856  if (PP.isBacktrackEnabled())
857    PP.RevertCachedTokens(1);
858  else
859    PP.EnterToken(Tok);
860  Tok.setKind(tok::annot_cxxscope);
861  Tok.setAnnotationValue(SS.getScopeRep());
862  Tok.setAnnotationRange(SS.getRange());
863
864  // In case the tokens were cached, have Preprocessor replace them with the
865  // annotation token.
866  PP.AnnotateCachedTokens(Tok);
867  return true;
868}
869
870/// TryAnnotateScopeToken - Like TryAnnotateTypeOrScopeToken but only
871/// annotates C++ scope specifiers and template-ids.  This returns
872/// true if the token was annotated.
873///
874/// Note that this routine emits an error if you call it with ::new or ::delete
875/// as the current tokens, so only call it in contexts where these are invalid.
876bool Parser::TryAnnotateCXXScopeToken() {
877  assert(getLang().CPlusPlus &&
878         "Call sites of this function should be guarded by checking for C++");
879  assert((Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) &&
880         "Cannot be a type or scope token!");
881
882  CXXScopeSpec SS;
883  if (!ParseOptionalCXXScopeSpecifier(SS))
884    return Tok.is(tok::annot_template_id);
885
886  // Push the current token back into the token stream (or revert it if it is
887  // cached) and use an annotation scope token for current token.
888  if (PP.isBacktrackEnabled())
889    PP.RevertCachedTokens(1);
890  else
891    PP.EnterToken(Tok);
892  Tok.setKind(tok::annot_cxxscope);
893  Tok.setAnnotationValue(SS.getScopeRep());
894  Tok.setAnnotationRange(SS.getRange());
895
896  // In case the tokens were cached, have Preprocessor replace them with the
897  // annotation token.
898  PP.AnnotateCachedTokens(Tok);
899  return true;
900}
901