lib/Parse/Parser.cpp

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