contrib/llvm/tools/clang/lib/Parse/ParseStmt.cpp

   1 //===--- ParseStmt.cpp - Statement and Block 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 Statement and Block portions of the Parser
  11 // interface.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Parse/Parser.h"
  16 #include "RAIIObjectsForParser.h"
  17 #include "clang/Sema/DeclSpec.h"
  18 #include "clang/Sema/PrettyDeclStackTrace.h"
  19 #include "clang/Sema/Scope.h"
  20 #include "clang/Sema/TypoCorrection.h"
  21 #include "clang/Basic/Diagnostic.h"
  22 #include "clang/Basic/PrettyStackTrace.h"
  23 #include "clang/Basic/SourceManager.h"
  24 #include "llvm/ADT/SmallString.h"
  25 using namespace clang;
  26
  27 //===----------------------------------------------------------------------===//
  28 // C99 6.8: Statements and Blocks.
  29 //===----------------------------------------------------------------------===//
  30
  31 /// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
  32 ///       StatementOrDeclaration:
  33 ///         statement
  34 ///         declaration
  35 ///
  36 ///       statement:
  37 ///         labeled-statement
  38 ///         compound-statement
  39 ///         expression-statement
  40 ///         selection-statement
  41 ///         iteration-statement
  42 ///         jump-statement
  43 /// [C++]   declaration-statement
  44 /// [C++]   try-block
  45 /// [MS]    seh-try-block
  46 /// [OBC]   objc-throw-statement
  47 /// [OBC]   objc-try-catch-statement
  48 /// [OBC]   objc-synchronized-statement
  49 /// [GNU]   asm-statement
  50 /// [OMP]   openmp-construct             [TODO]
  51 ///
  52 ///       labeled-statement:
  53 ///         identifier ':' statement
  54 ///         'case' constant-expression ':' statement
  55 ///         'default' ':' statement
  56 ///
  57 ///       selection-statement:
  58 ///         if-statement
  59 ///         switch-statement
  60 ///
  61 ///       iteration-statement:
  62 ///         while-statement
  63 ///         do-statement
  64 ///         for-statement
  65 ///
  66 ///       expression-statement:
  67 ///         expression[opt] ';'
  68 ///
  69 ///       jump-statement:
  70 ///         'goto' identifier ';'
  71 ///         'continue' ';'
  72 ///         'break' ';'
  73 ///         'return' expression[opt] ';'
  74 /// [GNU]   'goto' '*' expression ';'
  75 ///
  76 /// [OBC] objc-throw-statement:
  77 /// [OBC]   '@' 'throw' expression ';'
  78 /// [OBC]   '@' 'throw' ';'
  79 ///
  80 StmtResult
  81 Parser::ParseStatementOrDeclaration(StmtVector &Stmts, bool OnlyStatement,
  82                                     SourceLocation *TrailingElseLoc) {
  83
  84   ParenBraceBracketBalancer BalancerRAIIObj(*this);
  85
  86   ParsedAttributesWithRange Attrs(AttrFactory);
  87   MaybeParseCXX0XAttributes(Attrs, 0, /*MightBeObjCMessageSend*/ true);
  88
  89   StmtResult Res = ParseStatementOrDeclarationAfterAttributes(Stmts,
  90                                  OnlyStatement, TrailingElseLoc, Attrs);
  91
  92   assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
  93          "attributes on empty statement");
  94
  95   if (Attrs.empty() || Res.isInvalid())
  96     return Res;
  97
  98   return Actions.ProcessStmtAttributes(Res.get(), Attrs.getList(), Attrs.Range);
  99 }
 100
 101 StmtResult
 102 Parser::ParseStatementOrDeclarationAfterAttributes(StmtVector &Stmts,
 103           bool OnlyStatement, SourceLocation *TrailingElseLoc,
 104           ParsedAttributesWithRange &Attrs) {
 105   const char *SemiError = 0;
 106   StmtResult Res;
 107
 108   // Cases in this switch statement should fall through if the parser expects
 109   // the token to end in a semicolon (in which case SemiError should be set),
 110   // or they directly 'return;' if not.
 111 Retry:
 112   tok::TokenKind Kind  = Tok.getKind();
 113   SourceLocation AtLoc;
 114   switch (Kind) {
 115   case tok::at: // May be a @try or @throw statement
 116     {
 117       ProhibitAttributes(Attrs); // TODO: is it correct?
 118       AtLoc = ConsumeToken();  // consume @
 119       return ParseObjCAtStatement(AtLoc);
 120     }
 121
 122   case tok::code_completion:
 123     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement);
 124     cutOffParsing();
 125     return StmtError();
 126
 127   case tok::identifier: {
 128     Token Next = NextToken();
 129     if (Next.is(tok::colon)) { // C99 6.8.1: labeled-statement
 130       // identifier ':' statement
 131       return ParseLabeledStatement(Attrs);
 132     }
 133
 134     // Look up the identifier, and typo-correct it to a keyword if it's not
 135     // found.
 136     if (Next.isNot(tok::coloncolon)) {
 137       // Try to limit which sets of keywords should be included in typo
 138       // correction based on what the next token is.
 139       // FIXME: Pass the next token into the CorrectionCandidateCallback and
 140       //        do this filtering in a more fine-grained manner.
 141       CorrectionCandidateCallback DefaultValidator;
 142       DefaultValidator.WantTypeSpecifiers =
 143           Next.is(tok::l_paren) || Next.is(tok::less) ||
 144           Next.is(tok::identifier) || Next.is(tok::star) ||
 145           Next.is(tok::amp) || Next.is(tok::l_square);
 146       DefaultValidator.WantExpressionKeywords =
 147           Next.is(tok::l_paren) || Next.is(tok::identifier) ||
 148           Next.is(tok::arrow) || Next.is(tok::period);
 149       DefaultValidator.WantRemainingKeywords =
 150           Next.is(tok::l_paren) || Next.is(tok::semi) ||
 151           Next.is(tok::identifier) || Next.is(tok::l_brace);
 152       DefaultValidator.WantCXXNamedCasts = false;
 153       if (TryAnnotateName(/*IsAddressOfOperand*/false, &DefaultValidator)
 154             == ANK_Error) {
 155         // Handle errors here by skipping up to the next semicolon or '}', and
 156         // eat the semicolon if that's what stopped us.
 157         SkipUntil(tok::r_brace, /*StopAtSemi=*/true, /*DontConsume=*/true);
 158         if (Tok.is(tok::semi))
 159           ConsumeToken();
 160         return StmtError();
 161       }
 162
 163       // If the identifier was typo-corrected, try again.
 164       if (Tok.isNot(tok::identifier))
 165         goto Retry;
 166     }
 167
 168     // Fall through
 169   }
 170
 171   default: {
 172     if ((getLangOpts().CPlusPlus || !OnlyStatement) && isDeclarationStatement()) {
 173       SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
 174       DeclGroupPtrTy Decl = ParseDeclaration(Stmts, Declarator::BlockContext,
 175                                              DeclEnd, Attrs);
 176       return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd);
 177     }
 178
 179     if (Tok.is(tok::r_brace)) {
 180       Diag(Tok, diag::err_expected_statement);
 181       return StmtError();
 182     }
 183
 184     return ParseExprStatement();
 185   }
 186
 187   case tok::kw_case:                // C99 6.8.1: labeled-statement
 188     return ParseCaseStatement();
 189   case tok::kw_default:             // C99 6.8.1: labeled-statement
 190     return ParseDefaultStatement();
 191
 192   case tok::l_brace:                // C99 6.8.2: compound-statement
 193     return ParseCompoundStatement();
 194   case tok::semi: {                 // C99 6.8.3p3: expression[opt] ';'
 195     bool HasLeadingEmptyMacro = Tok.hasLeadingEmptyMacro();
 196     return Actions.ActOnNullStmt(ConsumeToken(), HasLeadingEmptyMacro);
 197   }
 198
 199   case tok::kw_if:                  // C99 6.8.4.1: if-statement
 200     return ParseIfStatement(TrailingElseLoc);
 201   case tok::kw_switch:              // C99 6.8.4.2: switch-statement
 202     return ParseSwitchStatement(TrailingElseLoc);
 203
 204   case tok::kw_while:               // C99 6.8.5.1: while-statement
 205     return ParseWhileStatement(TrailingElseLoc);
 206   case tok::kw_do:                  // C99 6.8.5.2: do-statement
 207     Res = ParseDoStatement();
 208     SemiError = "do/while";
 209     break;
 210   case tok::kw_for:                 // C99 6.8.5.3: for-statement
 211     return ParseForStatement(TrailingElseLoc);
 212
 213   case tok::kw_goto:                // C99 6.8.6.1: goto-statement
 214     Res = ParseGotoStatement();
 215     SemiError = "goto";
 216     break;
 217   case tok::kw_continue:            // C99 6.8.6.2: continue-statement
 218     Res = ParseContinueStatement();
 219     SemiError = "continue";
 220     break;
 221   case tok::kw_break:               // C99 6.8.6.3: break-statement
 222     Res = ParseBreakStatement();
 223     SemiError = "break";
 224     break;
 225   case tok::kw_return:              // C99 6.8.6.4: return-statement
 226     Res = ParseReturnStatement();
 227     SemiError = "return";
 228     break;
 229
 230   case tok::kw_asm: {
 231     ProhibitAttributes(Attrs);
 232     bool msAsm = false;
 233     Res = ParseAsmStatement(msAsm);
 234     Res = Actions.ActOnFinishFullStmt(Res.get());
 235     if (msAsm) return Res;
 236     SemiError = "asm";
 237     break;
 238   }
 239
 240   case tok::kw_try:                 // C++ 15: try-block
 241     return ParseCXXTryBlock();
 242
 243   case tok::kw___try:
 244     ProhibitAttributes(Attrs); // TODO: is it correct?
 245     return ParseSEHTryBlock();
 246
 247   case tok::annot_pragma_vis:
 248     ProhibitAttributes(Attrs);
 249     HandlePragmaVisibility();
 250     return StmtEmpty();
 251
 252   case tok::annot_pragma_pack:
 253     ProhibitAttributes(Attrs);
 254     HandlePragmaPack();
 255     return StmtEmpty();
 256
 257   case tok::annot_pragma_msstruct:
 258     ProhibitAttributes(Attrs);
 259     HandlePragmaMSStruct();
 260     return StmtEmpty();
 261
 262   case tok::annot_pragma_align:
 263     ProhibitAttributes(Attrs);
 264     HandlePragmaAlign();
 265     return StmtEmpty();
 266
 267   case tok::annot_pragma_weak:
 268     ProhibitAttributes(Attrs);
 269     HandlePragmaWeak();
 270     return StmtEmpty();
 271
 272   case tok::annot_pragma_weakalias:
 273     ProhibitAttributes(Attrs);
 274     HandlePragmaWeakAlias();
 275     return StmtEmpty();
 276
 277   case tok::annot_pragma_redefine_extname:
 278     ProhibitAttributes(Attrs);
 279     HandlePragmaRedefineExtname();
 280     return StmtEmpty();
 281
 282   case tok::annot_pragma_fp_contract:
 283     Diag(Tok, diag::err_pragma_fp_contract_scope);
 284     ConsumeToken();
 285     return StmtError();
 286
 287   case tok::annot_pragma_opencl_extension:
 288     ProhibitAttributes(Attrs);
 289     HandlePragmaOpenCLExtension();
 290     return StmtEmpty();
 291   }
 292
 293   // If we reached this code, the statement must end in a semicolon.
 294   if (Tok.is(tok::semi)) {
 295     ConsumeToken();
 296   } else if (!Res.isInvalid()) {
 297     // If the result was valid, then we do want to diagnose this.  Use
 298     // ExpectAndConsume to emit the diagnostic, even though we know it won't
 299     // succeed.
 300     ExpectAndConsume(tok::semi, diag::err_expected_semi_after_stmt, SemiError);
 301     // Skip until we see a } or ;, but don't eat it.
 302     SkipUntil(tok::r_brace, true, true);
 303   }
 304
 305   return Res;
 306 }
 307
 308 /// \brief Parse an expression statement.
 309 StmtResult Parser::ParseExprStatement() {
 310   // If a case keyword is missing, this is where it should be inserted.
 311   Token OldToken = Tok;
 312
 313   // expression[opt] ';'
 314   ExprResult Expr(ParseExpression());
 315   if (Expr.isInvalid()) {
 316     // If the expression is invalid, skip ahead to the next semicolon or '}'.
 317     // Not doing this opens us up to the possibility of infinite loops if
 318     // ParseExpression does not consume any tokens.
 319     SkipUntil(tok::r_brace, /*StopAtSemi=*/true, /*DontConsume=*/true);
 320     if (Tok.is(tok::semi))
 321       ConsumeToken();
 322     return StmtError();
 323   }
 324
 325   if (Tok.is(tok::colon) && getCurScope()->isSwitchScope() &&
 326       Actions.CheckCaseExpression(Expr.get())) {
 327     // If a constant expression is followed by a colon inside a switch block,
 328     // suggest a missing case keyword.
 329     Diag(OldToken, diag::err_expected_case_before_expression)
 330       << FixItHint::CreateInsertion(OldToken.getLocation(), "case ");
 331
 332     // Recover parsing as a case statement.
 333     return ParseCaseStatement(/*MissingCase=*/true, Expr);
 334   }
 335
 336   // Otherwise, eat the semicolon.
 337   ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
 338   return Actions.ActOnExprStmt(Actions.MakeFullExpr(Expr.get()));
 339 }
 340
 341 StmtResult Parser::ParseSEHTryBlock() {
 342   assert(Tok.is(tok::kw___try) && "Expected '__try'");
 343   SourceLocation Loc = ConsumeToken();
 344   return ParseSEHTryBlockCommon(Loc);
 345 }
 346
 347 /// ParseSEHTryBlockCommon
 348 ///
 349 /// seh-try-block:
 350 ///   '__try' compound-statement seh-handler
 351 ///
 352 /// seh-handler:
 353 ///   seh-except-block
 354 ///   seh-finally-block
 355 ///
 356 StmtResult Parser::ParseSEHTryBlockCommon(SourceLocation TryLoc) {
 357   if(Tok.isNot(tok::l_brace))
 358     return StmtError(Diag(Tok,diag::err_expected_lbrace));
 359
 360   StmtResult TryBlock(ParseCompoundStatement());
 361   if(TryBlock.isInvalid())
 362     return TryBlock;
 363
 364   StmtResult Handler;
 365   if (Tok.is(tok::identifier) &&
 366       Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
 367     SourceLocation Loc = ConsumeToken();
 368     Handler = ParseSEHExceptBlock(Loc);
 369   } else if (Tok.is(tok::kw___finally)) {
 370     SourceLocation Loc = ConsumeToken();
 371     Handler = ParseSEHFinallyBlock(Loc);
 372   } else {
 373     return StmtError(Diag(Tok,diag::err_seh_expected_handler));
 374   }
 375
 376   if(Handler.isInvalid())
 377     return Handler;
 378
 379   return Actions.ActOnSEHTryBlock(false /* IsCXXTry */,
 380                                   TryLoc,
 381                                   TryBlock.take(),
 382                                   Handler.take());
 383 }
 384
 385 /// ParseSEHExceptBlock - Handle __except
 386 ///
 387 /// seh-except-block:
 388 ///   '__except' '(' seh-filter-expression ')' compound-statement
 389 ///
 390 StmtResult Parser::ParseSEHExceptBlock(SourceLocation ExceptLoc) {
 391   PoisonIdentifierRAIIObject raii(Ident__exception_code, false),
 392     raii2(Ident___exception_code, false),
 393     raii3(Ident_GetExceptionCode, false);
 394
 395   if(ExpectAndConsume(tok::l_paren,diag::err_expected_lparen))
 396     return StmtError();
 397
 398   ParseScope ExpectScope(this, Scope::DeclScope | Scope::ControlScope);
 399
 400   if (getLangOpts().Borland) {
 401     Ident__exception_info->setIsPoisoned(false);
 402     Ident___exception_info->setIsPoisoned(false);
 403     Ident_GetExceptionInfo->setIsPoisoned(false);
 404   }
 405   ExprResult FilterExpr(ParseExpression());
 406
 407   if (getLangOpts().Borland) {
 408     Ident__exception_info->setIsPoisoned(true);
 409     Ident___exception_info->setIsPoisoned(true);
 410     Ident_GetExceptionInfo->setIsPoisoned(true);
 411   }
 412
 413   if(FilterExpr.isInvalid())
 414     return StmtError();
 415
 416   if(ExpectAndConsume(tok::r_paren,diag::err_expected_rparen))
 417     return StmtError();
 418
 419   StmtResult Block(ParseCompoundStatement());
 420
 421   if(Block.isInvalid())
 422     return Block;
 423
 424   return Actions.ActOnSEHExceptBlock(ExceptLoc, FilterExpr.take(), Block.take());
 425 }
 426
 427 /// ParseSEHFinallyBlock - Handle __finally
 428 ///
 429 /// seh-finally-block:
 430 ///   '__finally' compound-statement
 431 ///
 432 StmtResult Parser::ParseSEHFinallyBlock(SourceLocation FinallyBlock) {
 433   PoisonIdentifierRAIIObject raii(Ident__abnormal_termination, false),
 434     raii2(Ident___abnormal_termination, false),
 435     raii3(Ident_AbnormalTermination, false);
 436
 437   StmtResult Block(ParseCompoundStatement());
 438   if(Block.isInvalid())
 439     return Block;
 440
 441   return Actions.ActOnSEHFinallyBlock(FinallyBlock,Block.take());
 442 }
 443
 444 /// ParseLabeledStatement - We have an identifier and a ':' after it.
 445 ///
 446 ///       labeled-statement:
 447 ///         identifier ':' statement
 448 /// [GNU]   identifier ':' attributes[opt] statement
 449 ///
 450 StmtResult Parser::ParseLabeledStatement(ParsedAttributesWithRange &attrs) {
 451   assert(Tok.is(tok::identifier) && Tok.getIdentifierInfo() &&
 452          "Not an identifier!");
 453
 454   Token IdentTok = Tok;  // Save the whole token.
 455   ConsumeToken();  // eat the identifier.
 456
 457   assert(Tok.is(tok::colon) && "Not a label!");
 458
 459   // identifier ':' statement
 460   SourceLocation ColonLoc = ConsumeToken();
 461
 462   // Read label attributes, if present. attrs will contain both C++11 and GNU
 463   // attributes (if present) after this point.
 464   MaybeParseGNUAttributes(attrs);
 465
 466   StmtResult SubStmt(ParseStatement());
 467
 468   // Broken substmt shouldn't prevent the label from being added to the AST.
 469   if (SubStmt.isInvalid())
 470     SubStmt = Actions.ActOnNullStmt(ColonLoc);
 471
 472   LabelDecl *LD = Actions.LookupOrCreateLabel(IdentTok.getIdentifierInfo(),
 473                                               IdentTok.getLocation());
 474   if (AttributeList *Attrs = attrs.getList()) {
 475     Actions.ProcessDeclAttributeList(Actions.CurScope, LD, Attrs);
 476     attrs.clear();
 477   }
 478
 479   return Actions.ActOnLabelStmt(IdentTok.getLocation(), LD, ColonLoc,
 480                                 SubStmt.get());
 481 }
 482
 483 /// ParseCaseStatement
 484 ///       labeled-statement:
 485 ///         'case' constant-expression ':' statement
 486 /// [GNU]   'case' constant-expression '...' constant-expression ':' statement
 487 ///
 488 StmtResult Parser::ParseCaseStatement(bool MissingCase, ExprResult Expr) {
 489   assert((MissingCase || Tok.is(tok::kw_case)) && "Not a case stmt!");
 490
 491   // It is very very common for code to contain many case statements recursively
 492   // nested, as in (but usually without indentation):
 493   //  case 1:
 494   //    case 2:
 495   //      case 3:
 496   //         case 4:
 497   //           case 5: etc.
 498   //
 499   // Parsing this naively works, but is both inefficient and can cause us to run
 500   // out of stack space in our recursive descent parser.  As a special case,
 501   // flatten this recursion into an iterative loop.  This is complex and gross,
 502   // but all the grossness is constrained to ParseCaseStatement (and some
 503   // wierdness in the actions), so this is just local grossness :).
 504
 505   // TopLevelCase - This is the highest level we have parsed.  'case 1' in the
 506   // example above.
 507   StmtResult TopLevelCase(true);
 508
 509   // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which
 510   // gets updated each time a new case is parsed, and whose body is unset so
 511   // far.  When parsing 'case 4', this is the 'case 3' node.
 512   Stmt *DeepestParsedCaseStmt = 0;
 513
 514   // While we have case statements, eat and stack them.
 515   SourceLocation ColonLoc;
 516   do {
 517     SourceLocation CaseLoc = MissingCase ? Expr.get()->getExprLoc() :
 518                                            ConsumeToken();  // eat the 'case'.
 519
 520     if (Tok.is(tok::code_completion)) {
 521       Actions.CodeCompleteCase(getCurScope());
 522       cutOffParsing();
 523       return StmtError();
 524     }
 525
 526     /// We don't want to treat 'case x : y' as a potential typo for 'case x::y'.
 527     /// Disable this form of error recovery while we're parsing the case
 528     /// expression.
 529     ColonProtectionRAIIObject ColonProtection(*this);
 530
 531     ExprResult LHS(MissingCase ? Expr : ParseConstantExpression());
 532     MissingCase = false;
 533     if (LHS.isInvalid()) {
 534       SkipUntil(tok::colon);
 535       return StmtError();
 536     }
 537
 538     // GNU case range extension.
 539     SourceLocation DotDotDotLoc;
 540     ExprResult RHS;
 541     if (Tok.is(tok::ellipsis)) {
 542       Diag(Tok, diag::ext_gnu_case_range);
 543       DotDotDotLoc = ConsumeToken();
 544
 545       RHS = ParseConstantExpression();
 546       if (RHS.isInvalid()) {
 547         SkipUntil(tok::colon);
 548         return StmtError();
 549       }
 550     }
 551
 552     ColonProtection.restore();
 553
 554     if (Tok.is(tok::colon)) {
 555       ColonLoc = ConsumeToken();
 556
 557     // Treat "case blah;" as a typo for "case blah:".
 558     } else if (Tok.is(tok::semi)) {
 559       ColonLoc = ConsumeToken();
 560       Diag(ColonLoc, diag::err_expected_colon_after) << "'case'"
 561         << FixItHint::CreateReplacement(ColonLoc, ":");
 562     } else {
 563       SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
 564       Diag(ExpectedLoc, diag::err_expected_colon_after) << "'case'"
 565         << FixItHint::CreateInsertion(ExpectedLoc, ":");
 566       ColonLoc = ExpectedLoc;
 567     }
 568
 569     StmtResult Case =
 570       Actions.ActOnCaseStmt(CaseLoc, LHS.get(), DotDotDotLoc,
 571                             RHS.get(), ColonLoc);
 572
 573     // If we had a sema error parsing this case, then just ignore it and
 574     // continue parsing the sub-stmt.
 575     if (Case.isInvalid()) {
 576       if (TopLevelCase.isInvalid())  // No parsed case stmts.
 577         return ParseStatement();
 578       // Otherwise, just don't add it as a nested case.
 579     } else {
 580       // If this is the first case statement we parsed, it becomes TopLevelCase.
 581       // Otherwise we link it into the current chain.
 582       Stmt *NextDeepest = Case.get();
 583       if (TopLevelCase.isInvalid())
 584         TopLevelCase = Case;
 585       else
 586         Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, Case.get());
 587       DeepestParsedCaseStmt = NextDeepest;
 588     }
 589
 590     // Handle all case statements.
 591   } while (Tok.is(tok::kw_case));
 592
 593   assert(!TopLevelCase.isInvalid() && "Should have parsed at least one case!");
 594
 595   // If we found a non-case statement, start by parsing it.
 596   StmtResult SubStmt;
 597
 598   if (Tok.isNot(tok::r_brace)) {
 599     SubStmt = ParseStatement();
 600   } else {
 601     // Nicely diagnose the common error "switch (X) { case 4: }", which is
 602     // not valid.
 603     SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
 604     Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
 605       << FixItHint::CreateInsertion(AfterColonLoc, " ;");
 606     SubStmt = true;
 607   }
 608
 609   // Broken sub-stmt shouldn't prevent forming the case statement properly.
 610   if (SubStmt.isInvalid())
 611     SubStmt = Actions.ActOnNullStmt(SourceLocation());
 612
 613   // Install the body into the most deeply-nested case.
 614   Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, SubStmt.get());
 615
 616   // Return the top level parsed statement tree.
 617   return TopLevelCase;
 618 }
 619
 620 /// ParseDefaultStatement
 621 ///       labeled-statement:
 622 ///         'default' ':' statement
 623 /// Note that this does not parse the 'statement' at the end.
 624 ///
 625 StmtResult Parser::ParseDefaultStatement() {
 626   assert(Tok.is(tok::kw_default) && "Not a default stmt!");
 627   SourceLocation DefaultLoc = ConsumeToken();  // eat the 'default'.
 628
 629   SourceLocation ColonLoc;
 630   if (Tok.is(tok::colon)) {
 631     ColonLoc = ConsumeToken();
 632
 633   // Treat "default;" as a typo for "default:".
 634   } else if (Tok.is(tok::semi)) {
 635     ColonLoc = ConsumeToken();
 636     Diag(ColonLoc, diag::err_expected_colon_after) << "'default'"
 637       << FixItHint::CreateReplacement(ColonLoc, ":");
 638   } else {
 639     SourceLocation ExpectedLoc = PP.getLocForEndOfToken(PrevTokLocation);
 640     Diag(ExpectedLoc, diag::err_expected_colon_after) << "'default'"
 641       << FixItHint::CreateInsertion(ExpectedLoc, ":");
 642     ColonLoc = ExpectedLoc;
 643   }
 644
 645   StmtResult SubStmt;
 646
 647   if (Tok.isNot(tok::r_brace)) {
 648     SubStmt = ParseStatement();
 649   } else {
 650     // Diagnose the common error "switch (X) {... default: }", which is
 651     // not valid.
 652     SourceLocation AfterColonLoc = PP.getLocForEndOfToken(ColonLoc);
 653     Diag(AfterColonLoc, diag::err_label_end_of_compound_statement)
 654       << FixItHint::CreateInsertion(AfterColonLoc, " ;");
 655     SubStmt = true;
 656   }
 657
 658   // Broken sub-stmt shouldn't prevent forming the case statement properly.
 659   if (SubStmt.isInvalid())
 660     SubStmt = Actions.ActOnNullStmt(ColonLoc);
 661
 662   return Actions.ActOnDefaultStmt(DefaultLoc, ColonLoc,
 663                                   SubStmt.get(), getCurScope());
 664 }
 665
 666 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr) {
 667   return ParseCompoundStatement(isStmtExpr, Scope::DeclScope);
 668 }
 669
 670 /// ParseCompoundStatement - Parse a "{}" block.
 671 ///
 672 ///       compound-statement: [C99 6.8.2]
 673 ///         { block-item-list[opt] }
 674 /// [GNU]   { label-declarations block-item-list } [TODO]
 675 ///
 676 ///       block-item-list:
 677 ///         block-item
 678 ///         block-item-list block-item
 679 ///
 680 ///       block-item:
 681 ///         declaration
 682 /// [GNU]   '__extension__' declaration
 683 ///         statement
 684 /// [OMP]   openmp-directive            [TODO]
 685 ///
 686 /// [GNU] label-declarations:
 687 /// [GNU]   label-declaration
 688 /// [GNU]   label-declarations label-declaration
 689 ///
 690 /// [GNU] label-declaration:
 691 /// [GNU]   '__label__' identifier-list ';'
 692 ///
 693 /// [OMP] openmp-directive:             [TODO]
 694 /// [OMP]   barrier-directive
 695 /// [OMP]   flush-directive
 696 ///
 697 StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
 698                                           unsigned ScopeFlags) {
 699   assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
 700
 701   // Enter a scope to hold everything within the compound stmt.  Compound
 702   // statements can always hold declarations.
 703   ParseScope CompoundScope(this, ScopeFlags);
 704
 705   // Parse the statements in the body.
 706   return ParseCompoundStatementBody(isStmtExpr);
 707 }
 708
 709 /// Parse any pragmas at the start of the compound expression. We handle these
 710 /// separately since some pragmas (FP_CONTRACT) must appear before any C
 711 /// statement in the compound, but may be intermingled with other pragmas.
 712 void Parser::ParseCompoundStatementLeadingPragmas() {
 713   bool checkForPragmas = true;
 714   while (checkForPragmas) {
 715     switch (Tok.getKind()) {
 716     case tok::annot_pragma_vis:
 717       HandlePragmaVisibility();
 718       break;
 719     case tok::annot_pragma_pack:
 720       HandlePragmaPack();
 721       break;
 722     case tok::annot_pragma_msstruct:
 723       HandlePragmaMSStruct();
 724       break;
 725     case tok::annot_pragma_align:
 726       HandlePragmaAlign();
 727       break;
 728     case tok::annot_pragma_weak:
 729       HandlePragmaWeak();
 730       break;
 731     case tok::annot_pragma_weakalias:
 732       HandlePragmaWeakAlias();
 733       break;
 734     case tok::annot_pragma_redefine_extname:
 735       HandlePragmaRedefineExtname();
 736       break;
 737     case tok::annot_pragma_opencl_extension:
 738       HandlePragmaOpenCLExtension();
 739       break;
 740     case tok::annot_pragma_fp_contract:
 741       HandlePragmaFPContract();
 742       break;
 743     default:
 744       checkForPragmas = false;
 745       break;
 746     }
 747   }
 748
 749 }
 750
 751 /// ParseCompoundStatementBody - Parse a sequence of statements and invoke the
 752 /// ActOnCompoundStmt action.  This expects the '{' to be the current token, and
 753 /// consume the '}' at the end of the block.  It does not manipulate the scope
 754 /// stack.
 755 StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) {
 756   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(),
 757                                 Tok.getLocation(),
 758                                 "in compound statement ('{}')");
 759
 760   // Record the state of the FP_CONTRACT pragma, restore on leaving the
 761   // compound statement.
 762   Sema::FPContractStateRAII SaveFPContractState(Actions);
 763
 764   InMessageExpressionRAIIObject InMessage(*this, false);
 765   BalancedDelimiterTracker T(*this, tok::l_brace);
 766   if (T.consumeOpen())
 767     return StmtError();
 768
 769   Sema::CompoundScopeRAII CompoundScope(Actions);
 770
 771   // Parse any pragmas at the beginning of the compound statement.
 772   ParseCompoundStatementLeadingPragmas();
 773
 774   StmtVector Stmts;
 775
 776   // "__label__ X, Y, Z;" is the GNU "Local Label" extension.  These are
 777   // only allowed at the start of a compound stmt regardless of the language.
 778   while (Tok.is(tok::kw___label__)) {
 779     SourceLocation LabelLoc = ConsumeToken();
 780     Diag(LabelLoc, diag::ext_gnu_local_label);
 781
 782     SmallVector<Decl *, 8> DeclsInGroup;
 783     while (1) {
 784       if (Tok.isNot(tok::identifier)) {
 785         Diag(Tok, diag::err_expected_ident);
 786         break;
 787       }
 788
 789       IdentifierInfo *II = Tok.getIdentifierInfo();
 790       SourceLocation IdLoc = ConsumeToken();
 791       DeclsInGroup.push_back(Actions.LookupOrCreateLabel(II, IdLoc, LabelLoc));
 792
 793       if (!Tok.is(tok::comma))
 794         break;
 795       ConsumeToken();
 796     }
 797
 798     DeclSpec DS(AttrFactory);
 799     DeclGroupPtrTy Res = Actions.FinalizeDeclaratorGroup(getCurScope(), DS,
 800                                       DeclsInGroup.data(), DeclsInGroup.size());
 801     StmtResult R = Actions.ActOnDeclStmt(Res, LabelLoc, Tok.getLocation());
 802
 803     ExpectAndConsumeSemi(diag::err_expected_semi_declaration);
 804     if (R.isUsable())
 805       Stmts.push_back(R.release());
 806   }
 807
 808   while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {
 809     if (Tok.is(tok::annot_pragma_unused)) {
 810       HandlePragmaUnused();
 811       continue;
 812     }
 813
 814     if (getLangOpts().MicrosoftExt && (Tok.is(tok::kw___if_exists) ||
 815         Tok.is(tok::kw___if_not_exists))) {
 816       ParseMicrosoftIfExistsStatement(Stmts);
 817       continue;
 818     }
 819
 820     StmtResult R;
 821     if (Tok.isNot(tok::kw___extension__)) {
 822       R = ParseStatementOrDeclaration(Stmts, false);
 823     } else {
 824       // __extension__ can start declarations and it can also be a unary
 825       // operator for expressions.  Consume multiple __extension__ markers here
 826       // until we can determine which is which.
 827       // FIXME: This loses extension expressions in the AST!
 828       SourceLocation ExtLoc = ConsumeToken();
 829       while (Tok.is(tok::kw___extension__))
 830         ConsumeToken();
 831
 832       ParsedAttributesWithRange attrs(AttrFactory);
 833       MaybeParseCXX0XAttributes(attrs, 0, /*MightBeObjCMessageSend*/ true);
 834
 835       // If this is the start of a declaration, parse it as such.
 836       if (isDeclarationStatement()) {
 837         // __extension__ silences extension warnings in the subdeclaration.
 838         // FIXME: Save the __extension__ on the decl as a node somehow?
 839         ExtensionRAIIObject O(Diags);
 840
 841         SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
 842         DeclGroupPtrTy Res = ParseDeclaration(Stmts,
 843                                               Declarator::BlockContext, DeclEnd,
 844                                               attrs);
 845         R = Actions.ActOnDeclStmt(Res, DeclStart, DeclEnd);
 846       } else {
 847         // Otherwise this was a unary __extension__ marker.
 848         ExprResult Res(ParseExpressionWithLeadingExtension(ExtLoc));
 849
 850         if (Res.isInvalid()) {
 851           SkipUntil(tok::semi);
 852           continue;
 853         }
 854
 855         // FIXME: Use attributes?
 856         // Eat the semicolon at the end of stmt and convert the expr into a
 857         // statement.
 858         ExpectAndConsumeSemi(diag::err_expected_semi_after_expr);
 859         R = Actions.ActOnExprStmt(Actions.MakeFullExpr(Res.get()));
 860       }
 861     }
 862
 863     if (R.isUsable())
 864       Stmts.push_back(R.release());
 865   }
 866
 867   SourceLocation CloseLoc = Tok.getLocation();
 868
 869   // We broke out of the while loop because we found a '}' or EOF.
 870   if (Tok.isNot(tok::r_brace)) {
 871     Diag(Tok, diag::err_expected_rbrace);
 872     Diag(T.getOpenLocation(), diag::note_matching) << "{";
 873     // Recover by creating a compound statement with what we parsed so far,
 874     // instead of dropping everything and returning StmtError();
 875   } else {
 876     if (!T.consumeClose())
 877       CloseLoc = T.getCloseLocation();
 878   }
 879
 880   return Actions.ActOnCompoundStmt(T.getOpenLocation(), CloseLoc,
 881                                    Stmts, isStmtExpr);
 882 }
 883
 884 /// ParseParenExprOrCondition:
 885 /// [C  ]     '(' expression ')'
 886 /// [C++]     '(' condition ')'       [not allowed if OnlyAllowCondition=true]
 887 ///
 888 /// This function parses and performs error recovery on the specified condition
 889 /// or expression (depending on whether we're in C++ or C mode).  This function
 890 /// goes out of its way to recover well.  It returns true if there was a parser
 891 /// error (the right paren couldn't be found), which indicates that the caller
 892 /// should try to recover harder.  It returns false if the condition is
 893 /// successfully parsed.  Note that a successful parse can still have semantic
 894 /// errors in the condition.
 895 bool Parser::ParseParenExprOrCondition(ExprResult &ExprResult,
 896                                        Decl *&DeclResult,
 897                                        SourceLocation Loc,
 898                                        bool ConvertToBoolean) {
 899   BalancedDelimiterTracker T(*this, tok::l_paren);
 900   T.consumeOpen();
 901
 902   if (getLangOpts().CPlusPlus)
 903     ParseCXXCondition(ExprResult, DeclResult, Loc, ConvertToBoolean);
 904   else {
 905     ExprResult = ParseExpression();
 906     DeclResult = 0;
 907
 908     // If required, convert to a boolean value.
 909     if (!ExprResult.isInvalid() && ConvertToBoolean)
 910       ExprResult
 911         = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprResult.get());
 912   }
 913
 914   // If the parser was confused by the condition and we don't have a ')', try to
 915   // recover by skipping ahead to a semi and bailing out.  If condexp is
 916   // semantically invalid but we have well formed code, keep going.
 917   if (ExprResult.isInvalid() && !DeclResult && Tok.isNot(tok::r_paren)) {
 918     SkipUntil(tok::semi);
 919     // Skipping may have stopped if it found the containing ')'.  If so, we can
 920     // continue parsing the if statement.
 921     if (Tok.isNot(tok::r_paren))
 922       return true;
 923   }
 924
 925   // Otherwise the condition is valid or the rparen is present.
 926   T.consumeClose();
 927
 928   // Check for extraneous ')'s to catch things like "if (foo())) {".  We know
 929   // that all callers are looking for a statement after the condition, so ")"
 930   // isn't valid.
 931   while (Tok.is(tok::r_paren)) {
 932     Diag(Tok, diag::err_extraneous_rparen_in_condition)
 933       << FixItHint::CreateRemoval(Tok.getLocation());
 934     ConsumeParen();
 935   }
 936
 937   return false;
 938 }
 939
 940
 941 /// ParseIfStatement
 942 ///       if-statement: [C99 6.8.4.1]
 943 ///         'if' '(' expression ')' statement
 944 ///         'if' '(' expression ')' statement 'else' statement
 945 /// [C++]   'if' '(' condition ')' statement
 946 /// [C++]   'if' '(' condition ')' statement 'else' statement
 947 ///
 948 StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
 949   assert(Tok.is(tok::kw_if) && "Not an if stmt!");
 950   SourceLocation IfLoc = ConsumeToken();  // eat the 'if'.
 951
 952   if (Tok.isNot(tok::l_paren)) {
 953     Diag(Tok, diag::err_expected_lparen_after) << "if";
 954     SkipUntil(tok::semi);
 955     return StmtError();
 956   }
 957
 958   bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
 959
 960   // C99 6.8.4p3 - In C99, the if statement is a block.  This is not
 961   // the case for C90.
 962   //
 963   // C++ 6.4p3:
 964   // A name introduced by a declaration in a condition is in scope from its
 965   // point of declaration until the end of the substatements controlled by the
 966   // condition.
 967   // C++ 3.3.2p4:
 968   // Names declared in the for-init-statement, and in the condition of if,
 969   // while, for, and switch statements are local to the if, while, for, or
 970   // switch statement (including the controlled statement).
 971   //
 972   ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX);
 973
 974   // Parse the condition.
 975   ExprResult CondExp;
 976   Decl *CondVar = 0;
 977   if (ParseParenExprOrCondition(CondExp, CondVar, IfLoc, true))
 978     return StmtError();
 979
 980   FullExprArg FullCondExp(Actions.MakeFullExpr(CondExp.get(), IfLoc));
 981
 982   // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
 983   // there is no compound stmt.  C90 does not have this clause.  We only do this
 984   // if the body isn't a compound statement to avoid push/pop in common cases.
 985   //
 986   // C++ 6.4p1:
 987   // The substatement in a selection-statement (each substatement, in the else
 988   // form of the if statement) implicitly defines a local scope.
 989   //
 990   // For C++ we create a scope for the condition and a new scope for
 991   // substatements because:
 992   // -When the 'then' scope exits, we want the condition declaration to still be
 993   //    active for the 'else' scope too.
 994   // -Sema will detect name clashes by considering declarations of a
 995   //    'ControlScope' as part of its direct subscope.
 996   // -If we wanted the condition and substatement to be in the same scope, we
 997   //    would have to notify ParseStatement not to create a new scope. It's
 998   //    simpler to let it create a new scope.
 999   //
1000   ParseScope InnerScope(this, Scope::DeclScope,
1001                         C99orCXX && Tok.isNot(tok::l_brace));
1002
1003   // Read the 'then' stmt.
1004   SourceLocation ThenStmtLoc = Tok.getLocation();
1005
1006   SourceLocation InnerStatementTrailingElseLoc;
1007   StmtResult ThenStmt(ParseStatement(&InnerStatementTrailingElseLoc));
1008
1009   // Pop the 'if' scope if needed.
1010   InnerScope.Exit();
1011
1012   // If it has an else, parse it.
1013   SourceLocation ElseLoc;
1014   SourceLocation ElseStmtLoc;
1015   StmtResult ElseStmt;
1016
1017   if (Tok.is(tok::kw_else)) {
1018     if (TrailingElseLoc)
1019       *TrailingElseLoc = Tok.getLocation();
1020
1021     ElseLoc = ConsumeToken();
1022     ElseStmtLoc = Tok.getLocation();
1023
1024     // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
1025     // there is no compound stmt.  C90 does not have this clause.  We only do
1026     // this if the body isn't a compound statement to avoid push/pop in common
1027     // cases.
1028     //
1029     // C++ 6.4p1:
1030     // The substatement in a selection-statement (each substatement, in the else
1031     // form of the if statement) implicitly defines a local scope.
1032     //
1033     ParseScope InnerScope(this, Scope::DeclScope,
1034                           C99orCXX && Tok.isNot(tok::l_brace));
1035
1036     ElseStmt = ParseStatement();
1037
1038     // Pop the 'else' scope if needed.
1039     InnerScope.Exit();
1040   } else if (Tok.is(tok::code_completion)) {
1041     Actions.CodeCompleteAfterIf(getCurScope());
1042     cutOffParsing();
1043     return StmtError();
1044   } else if (InnerStatementTrailingElseLoc.isValid()) {
1045     Diag(InnerStatementTrailingElseLoc, diag::warn_dangling_else);
1046   }
1047
1048   IfScope.Exit();
1049
1050   // If the condition was invalid, discard the if statement.  We could recover
1051   // better by replacing it with a valid expr, but don't do that yet.
1052   if (CondExp.isInvalid() && !CondVar)
1053     return StmtError();
1054
1055   // If the then or else stmt is invalid and the other is valid (and present),
1056   // make turn the invalid one into a null stmt to avoid dropping the other
1057   // part.  If both are invalid, return error.
1058   if ((ThenStmt.isInvalid() && ElseStmt.isInvalid()) ||
1059       (ThenStmt.isInvalid() && ElseStmt.get() == 0) ||
1060       (ThenStmt.get() == 0  && ElseStmt.isInvalid())) {
1061     // Both invalid, or one is invalid and other is non-present: return error.
1062     return StmtError();
1063   }
1064
1065   // Now if either are invalid, replace with a ';'.
1066   if (ThenStmt.isInvalid())
1067     ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc);
1068   if (ElseStmt.isInvalid())
1069     ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
1070
1071   return Actions.ActOnIfStmt(IfLoc, FullCondExp, CondVar, ThenStmt.get(),
1072                              ElseLoc, ElseStmt.get());
1073 }
1074
1075 /// ParseSwitchStatement
1076 ///       switch-statement:
1077 ///         'switch' '(' expression ')' statement
1078 /// [C++]   'switch' '(' condition ')' statement
1079 StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
1080   assert(Tok.is(tok::kw_switch) && "Not a switch stmt!");
1081   SourceLocation SwitchLoc = ConsumeToken();  // eat the 'switch'.
1082
1083   if (Tok.isNot(tok::l_paren)) {
1084     Diag(Tok, diag::err_expected_lparen_after) << "switch";
1085     SkipUntil(tok::semi);
1086     return StmtError();
1087   }
1088
1089   bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1090
1091   // C99 6.8.4p3 - In C99, the switch statement is a block.  This is
1092   // not the case for C90.  Start the switch scope.
1093   //
1094   // C++ 6.4p3:
1095   // A name introduced by a declaration in a condition is in scope from its
1096   // point of declaration until the end of the substatements controlled by the
1097   // condition.
1098   // C++ 3.3.2p4:
1099   // Names declared in the for-init-statement, and in the condition of if,
1100   // while, for, and switch statements are local to the if, while, for, or
1101   // switch statement (including the controlled statement).
1102   //
1103   unsigned ScopeFlags = Scope::BreakScope | Scope::SwitchScope;
1104   if (C99orCXX)
1105     ScopeFlags |= Scope::DeclScope | Scope::ControlScope;
1106   ParseScope SwitchScope(this, ScopeFlags);
1107
1108   // Parse the condition.
1109   ExprResult Cond;
1110   Decl *CondVar = 0;
1111   if (ParseParenExprOrCondition(Cond, CondVar, SwitchLoc, false))
1112     return StmtError();
1113
1114   StmtResult Switch
1115     = Actions.ActOnStartOfSwitchStmt(SwitchLoc, Cond.get(), CondVar);
1116
1117   if (Switch.isInvalid()) {
1118     // Skip the switch body.
1119     // FIXME: This is not optimal recovery, but parsing the body is more
1120     // dangerous due to the presence of case and default statements, which
1121     // will have no place to connect back with the switch.
1122     if (Tok.is(tok::l_brace)) {
1123       ConsumeBrace();
1124       SkipUntil(tok::r_brace, false, false);
1125     } else
1126       SkipUntil(tok::semi);
1127     return Switch;
1128   }
1129
1130   // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if
1131   // there is no compound stmt.  C90 does not have this clause.  We only do this
1132   // if the body isn't a compound statement to avoid push/pop in common cases.
1133   //
1134   // C++ 6.4p1:
1135   // The substatement in a selection-statement (each substatement, in the else
1136   // form of the if statement) implicitly defines a local scope.
1137   //
1138   // See comments in ParseIfStatement for why we create a scope for the
1139   // condition and a new scope for substatement in C++.
1140   //
1141   ParseScope InnerScope(this, Scope::DeclScope,
1142                         C99orCXX && Tok.isNot(tok::l_brace));
1143
1144   // Read the body statement.
1145   StmtResult Body(ParseStatement(TrailingElseLoc));
1146
1147   // Pop the scopes.
1148   InnerScope.Exit();
1149   SwitchScope.Exit();
1150
1151   if (Body.isInvalid()) {
1152     // FIXME: Remove the case statement list from the Switch statement.
1153
1154     // Put the synthesized null statement on the same line as the end of switch
1155     // condition.
1156     SourceLocation SynthesizedNullStmtLocation = Cond.get()->getLocEnd();
1157     Body = Actions.ActOnNullStmt(SynthesizedNullStmtLocation);
1158   }
1159
1160   return Actions.ActOnFinishSwitchStmt(SwitchLoc, Switch.get(), Body.get());
1161 }
1162
1163 /// ParseWhileStatement
1164 ///       while-statement: [C99 6.8.5.1]
1165 ///         'while' '(' expression ')' statement
1166 /// [C++]   'while' '(' condition ')' statement
1167 StmtResult Parser::ParseWhileStatement(SourceLocation *TrailingElseLoc) {
1168   assert(Tok.is(tok::kw_while) && "Not a while stmt!");
1169   SourceLocation WhileLoc = Tok.getLocation();
1170   ConsumeToken();  // eat the 'while'.
1171
1172   if (Tok.isNot(tok::l_paren)) {
1173     Diag(Tok, diag::err_expected_lparen_after) << "while";
1174     SkipUntil(tok::semi);
1175     return StmtError();
1176   }
1177
1178   bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
1179
1180   // C99 6.8.5p5 - In C99, the while statement is a block.  This is not
1181   // the case for C90.  Start the loop scope.
1182   //
1183   // C++ 6.4p3:
1184   // A name introduced by a declaration in a condition is in scope from its
1185   // point of declaration until the end of the substatements controlled by the
1186   // condition.
1187   // C++ 3.3.2p4:
1188   // Names declared in the for-init-statement, and in the condition of if,
1189   // while, for, and switch statements are local to the if, while, for, or
1190   // switch statement (including the controlled statement).
1191   //
1192   unsigned ScopeFlags;
1193   if (C99orCXX)
1194     ScopeFlags = Scope::BreakScope | Scope::ContinueScope |
1195                  Scope::DeclScope  | Scope::ControlScope;
1196   else
1197     ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1198   ParseScope WhileScope(this, ScopeFlags);
1199
1200   // Parse the condition.
1201   ExprResult Cond;
1202   Decl *CondVar = 0;
1203   if (ParseParenExprOrCondition(Cond, CondVar, WhileLoc, true))
1204     return StmtError();
1205
1206   FullExprArg FullCond(Actions.MakeFullExpr(Cond.get(), WhileLoc));
1207
1208   // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if
1209   // there is no compound stmt.  C90 does not have this clause.  We only do this
1210   // if the body isn't a compound statement to avoid push/pop in common cases.
1211   //
1212   // C++ 6.5p2:
1213   // The substatement in an iteration-statement implicitly defines a local scope
1214   // which is entered and exited each time through the loop.
1215   //
1216   // See comments in ParseIfStatement for why we create a scope for the
1217   // condition and a new scope for substatement in C++.
1218   //
1219   ParseScope InnerScope(this, Scope::DeclScope,
1220                         C99orCXX && Tok.isNot(tok::l_brace));
1221
1222   // Read the body statement.
1223   StmtResult Body(ParseStatement(TrailingElseLoc));
1224
1225   // Pop the body scope if needed.
1226   InnerScope.Exit();
1227   WhileScope.Exit();
1228
1229   if ((Cond.isInvalid() && !CondVar) || Body.isInvalid())
1230     return StmtError();
1231
1232   return Actions.ActOnWhileStmt(WhileLoc, FullCond, CondVar, Body.get());
1233 }
1234
1235 /// ParseDoStatement
1236 ///       do-statement: [C99 6.8.5.2]
1237 ///         'do' statement 'while' '(' expression ')' ';'
1238 /// Note: this lets the caller parse the end ';'.
1239 StmtResult Parser::ParseDoStatement() {
1240   assert(Tok.is(tok::kw_do) && "Not a do stmt!");
1241   SourceLocation DoLoc = ConsumeToken();  // eat the 'do'.
1242
1243   // C99 6.8.5p5 - In C99, the do statement is a block.  This is not
1244   // the case for C90.  Start the loop scope.
1245   unsigned ScopeFlags;
1246   if (getLangOpts().C99)
1247     ScopeFlags = Scope::BreakScope | Scope::ContinueScope | Scope::DeclScope;
1248   else
1249     ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1250
1251   ParseScope DoScope(this, ScopeFlags);
1252
1253   // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if
1254   // there is no compound stmt.  C90 does not have this clause. We only do this
1255   // if the body isn't a compound statement to avoid push/pop in common cases.
1256   //
1257   // C++ 6.5p2:
1258   // The substatement in an iteration-statement implicitly defines a local scope
1259   // which is entered and exited each time through the loop.
1260   //
1261   ParseScope InnerScope(this, Scope::DeclScope,
1262                         (getLangOpts().C99 || getLangOpts().CPlusPlus) &&
1263                         Tok.isNot(tok::l_brace));
1264
1265   // Read the body statement.
1266   StmtResult Body(ParseStatement());
1267
1268   // Pop the body scope if needed.
1269   InnerScope.Exit();
1270
1271   if (Tok.isNot(tok::kw_while)) {
1272     if (!Body.isInvalid()) {
1273       Diag(Tok, diag::err_expected_while);
1274       Diag(DoLoc, diag::note_matching) << "do";
1275       SkipUntil(tok::semi, false, true);
1276     }
1277     return StmtError();
1278   }
1279   SourceLocation WhileLoc = ConsumeToken();
1280
1281   if (Tok.isNot(tok::l_paren)) {
1282     Diag(Tok, diag::err_expected_lparen_after) << "do/while";
1283     SkipUntil(tok::semi, false, true);
1284     return StmtError();
1285   }
1286
1287   // Parse the parenthesized condition.
1288   BalancedDelimiterTracker T(*this, tok::l_paren);
1289   T.consumeOpen();
1290
1291   // FIXME: Do not just parse the attribute contents and throw them away
1292   ParsedAttributesWithRange attrs(AttrFactory);
1293   MaybeParseCXX0XAttributes(attrs);
1294   ProhibitAttributes(attrs);
1295
1296   ExprResult Cond = ParseExpression();
1297   T.consumeClose();
1298   DoScope.Exit();
1299
1300   if (Cond.isInvalid() || Body.isInvalid())
1301     return StmtError();
1302
1303   return Actions.ActOnDoStmt(DoLoc, Body.get(), WhileLoc, T.getOpenLocation(),
1304                              Cond.get(), T.getCloseLocation());
1305 }
1306
1307 /// ParseForStatement
1308 ///       for-statement: [C99 6.8.5.3]
1309 ///         'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
1310 ///         'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
1311 /// [C++]   'for' '(' for-init-statement condition[opt] ';' expression[opt] ')'
1312 /// [C++]       statement
1313 /// [C++0x] 'for' '(' for-range-declaration : for-range-initializer ) statement
1314 /// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
1315 /// [OBJC2] 'for' '(' expr 'in' expr ')' statement
1316 ///
1317 /// [C++] for-init-statement:
1318 /// [C++]   expression-statement
1319 /// [C++]   simple-declaration
1320 ///
1321 /// [C++0x] for-range-declaration:
1322 /// [C++0x]   attribute-specifier-seq[opt] type-specifier-seq declarator
1323 /// [C++0x] for-range-initializer:
1324 /// [C++0x]   expression
1325 /// [C++0x]   braced-init-list            [TODO]
1326 StmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {
1327   assert(Tok.is(tok::kw_for) && "Not a for stmt!");
1328   SourceLocation ForLoc = ConsumeToken();  // eat the 'for'.
1329
1330   if (Tok.isNot(tok::l_paren)) {
1331     Diag(Tok, diag::err_expected_lparen_after) << "for";
1332     SkipUntil(tok::semi);
1333     return StmtError();
1334   }
1335
1336   bool C99orCXXorObjC = getLangOpts().C99 || getLangOpts().CPlusPlus ||
1337     getLangOpts().ObjC1;
1338
1339   // C99 6.8.5p5 - In C99, the for statement is a block.  This is not
1340   // the case for C90.  Start the loop scope.
1341   //
1342   // C++ 6.4p3:
1343   // A name introduced by a declaration in a condition is in scope from its
1344   // point of declaration until the end of the substatements controlled by the
1345   // condition.
1346   // C++ 3.3.2p4:
1347   // Names declared in the for-init-statement, and in the condition of if,
1348   // while, for, and switch statements are local to the if, while, for, or
1349   // switch statement (including the controlled statement).
1350   // C++ 6.5.3p1:
1351   // Names declared in the for-init-statement are in the same declarative-region
1352   // as those declared in the condition.
1353   //
1354   unsigned ScopeFlags;
1355   if (C99orCXXorObjC)
1356     ScopeFlags = Scope::BreakScope | Scope::ContinueScope |
1357                  Scope::DeclScope  | Scope::ControlScope;
1358   else
1359     ScopeFlags = Scope::BreakScope | Scope::ContinueScope;
1360
1361   ParseScope ForScope(this, ScopeFlags);
1362
1363   BalancedDelimiterTracker T(*this, tok::l_paren);
1364   T.consumeOpen();
1365
1366   ExprResult Value;
1367
1368   bool ForEach = false, ForRange = false;
1369   StmtResult FirstPart;
1370   bool SecondPartIsInvalid = false;
1371   FullExprArg SecondPart(Actions);
1372   ExprResult Collection;
1373   ForRangeInit ForRangeInit;
1374   FullExprArg ThirdPart(Actions);
1375   Decl *SecondVar = 0;
1376
1377   if (Tok.is(tok::code_completion)) {
1378     Actions.CodeCompleteOrdinaryName(getCurScope(),
1379                                      C99orCXXorObjC? Sema::PCC_ForInit
1380                                                    : Sema::PCC_Expression);
1381     cutOffParsing();
1382     return StmtError();
1383   }
1384
1385   ParsedAttributesWithRange attrs(AttrFactory);
1386   MaybeParseCXX0XAttributes(attrs);
1387
1388   // Parse the first part of the for specifier.
1389   if (Tok.is(tok::semi)) {  // for (;
1390     ProhibitAttributes(attrs);
1391     // no first part, eat the ';'.
1392     ConsumeToken();
1393   } else if (isForInitDeclaration()) {  // for (int X = 4;
1394     // Parse declaration, which eats the ';'.
1395     if (!C99orCXXorObjC)   // Use of C99-style for loops in C90 mode?
1396       Diag(Tok, diag::ext_c99_variable_decl_in_for_loop);
1397
1398     ParsedAttributesWithRange attrs(AttrFactory);
1399     MaybeParseCXX0XAttributes(attrs);
1400
1401     // In C++0x, "for (T NS:a" might not be a typo for ::
1402     bool MightBeForRangeStmt = getLangOpts().CPlusPlus;
1403     ColonProtectionRAIIObject ColonProtection(*this, MightBeForRangeStmt);
1404
1405     SourceLocation DeclStart = Tok.getLocation(), DeclEnd;
1406     StmtVector Stmts;
1407     DeclGroupPtrTy DG = ParseSimpleDeclaration(Stmts, Declarator::ForContext,
1408                                                DeclEnd, attrs, false,
1409                                                MightBeForRangeStmt ?
1410                                                  &ForRangeInit : 0);
1411     FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation());
1412
1413     if (ForRangeInit.ParsedForRangeDecl()) {
1414       Diag(ForRangeInit.ColonLoc, getLangOpts().CPlusPlus0x ?
1415            diag::warn_cxx98_compat_for_range : diag::ext_for_range);
1416
1417       ForRange = true;
1418     } else if (Tok.is(tok::semi)) {  // for (int x = 4;
1419       ConsumeToken();
1420     } else if ((ForEach = isTokIdentifier_in())) {
1421       Actions.ActOnForEachDeclStmt(DG);
1422       // ObjC: for (id x in expr)
1423       ConsumeToken(); // consume 'in'
1424
1425       if (Tok.is(tok::code_completion)) {
1426         Actions.CodeCompleteObjCForCollection(getCurScope(), DG);
1427         cutOffParsing();
1428         return StmtError();
1429       }
1430       Collection = ParseExpression();
1431     } else {
1432       Diag(Tok, diag::err_expected_semi_for);
1433     }
1434   } else {
1435     ProhibitAttributes(attrs);
1436     Value = ParseExpression();
1437
1438     ForEach = isTokIdentifier_in();
1439
1440     // Turn the expression into a stmt.
1441     if (!Value.isInvalid()) {
1442       if (ForEach)
1443         FirstPart = Actions.ActOnForEachLValueExpr(Value.get());
1444       else
1445         FirstPart = Actions.ActOnExprStmt(Actions.MakeFullExpr(Value.get()));
1446     }
1447
1448     if (Tok.is(tok::semi)) {
1449       ConsumeToken();
1450     } else if (ForEach) {
1451       ConsumeToken(); // consume 'in'
1452
1453       if (Tok.is(tok::code_completion)) {
1454         Actions.CodeCompleteObjCForCollection(getCurScope(), DeclGroupPtrTy());
1455         cutOffParsing();
1456         return StmtError();
1457       }
1458       Collection = ParseExpression();
1459     } else if (getLangOpts().CPlusPlus0x && Tok.is(tok::colon) && FirstPart.get()) {
1460       // User tried to write the reasonable, but ill-formed, for-range-statement
1461       //   for (expr : expr) { ... }
1462       Diag(Tok, diag::err_for_range_expected_decl)
1463         << FirstPart.get()->getSourceRange();
1464       SkipUntil(tok::r_paren, false, true);
1465       SecondPartIsInvalid = true;
1466     } else {
1467       if (!Value.isInvalid()) {
1468         Diag(Tok, diag::err_expected_semi_for);
1469       } else {
1470         // Skip until semicolon or rparen, don't consume it.
1471         SkipUntil(tok::r_paren, true, true);
1472         if (Tok.is(tok::semi))
1473           ConsumeToken();
1474       }
1475     }
1476   }
1477   if (!ForEach && !ForRange) {
1478     assert(!SecondPart.get() && "Shouldn't have a second expression yet.");
1479     // Parse the second part of the for specifier.
1480     if (Tok.is(tok::semi)) {  // for (...;;
1481       // no second part.
1482     } else if (Tok.is(tok::r_paren)) {
1483       // missing both semicolons.
1484     } else {
1485       ExprResult Second;
1486       if (getLangOpts().CPlusPlus)
1487         ParseCXXCondition(Second, SecondVar, ForLoc, true);
1488       else {
1489         Second = ParseExpression();
1490         if (!Second.isInvalid())
1491           Second = Actions.ActOnBooleanCondition(getCurScope(), ForLoc,
1492                                                  Second.get());
1493       }
1494       SecondPartIsInvalid = Second.isInvalid();
1495       SecondPart = Actions.MakeFullExpr(Second.get(), ForLoc);
1496     }
1497
1498     if (Tok.isNot(tok::semi)) {
1499       if (!SecondPartIsInvalid || SecondVar)
1500         Diag(Tok, diag::err_expected_semi_for);
1501       else
1502         // Skip until semicolon or rparen, don't consume it.
1503         SkipUntil(tok::r_paren, true, true);
1504     }
1505
1506     if (Tok.is(tok::semi)) {
1507       ConsumeToken();
1508     }
1509
1510     // Parse the third part of the for specifier.
1511     if (Tok.isNot(tok::r_paren)) {   // for (...;...;)
1512       ExprResult Third = ParseExpression();
1513       ThirdPart = Actions.MakeFullExpr(Third.take());
1514     }
1515   }
1516   // Match the ')'.
1517   T.consumeClose();
1518
1519   // We need to perform most of the semantic analysis for a C++0x for-range
1520   // statememt before parsing the body, in order to be able to deduce the type
1521   // of an auto-typed loop variable.
1522   StmtResult ForRangeStmt;
1523   StmtResult ForEachStmt;
1524
1525   if (ForRange) {
1526     ForRangeStmt = Actions.ActOnCXXForRangeStmt(ForLoc, FirstPart.take(),
1527                                                 ForRangeInit.ColonLoc,
1528                                                 ForRangeInit.RangeExpr.get(),
1529                                                 T.getCloseLocation(),
1530                                                 Sema::BFRK_Build);
1531
1532
1533   // Similarly, we need to do the semantic analysis for a for-range
1534   // statement immediately in order to close over temporaries correctly.
1535   } else if (ForEach) {
1536     ForEachStmt = Actions.ActOnObjCForCollectionStmt(ForLoc,
1537                                                      FirstPart.take(),
1538                                                      Collection.take(),
1539                                                      T.getCloseLocation());
1540   }
1541
1542   // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if
1543   // there is no compound stmt.  C90 does not have this clause.  We only do this
1544   // if the body isn't a compound statement to avoid push/pop in common cases.
1545   //
1546   // C++ 6.5p2:
1547   // The substatement in an iteration-statement implicitly defines a local scope
1548   // which is entered and exited each time through the loop.
1549   //
1550   // See comments in ParseIfStatement for why we create a scope for
1551   // for-init-statement/condition and a new scope for substatement in C++.
1552   //
1553   ParseScope InnerScope(this, Scope::DeclScope,
1554                         C99orCXXorObjC && Tok.isNot(tok::l_brace));
1555
1556   // Read the body statement.
1557   StmtResult Body(ParseStatement(TrailingElseLoc));
1558
1559   // Pop the body scope if needed.
1560   InnerScope.Exit();
1561
1562   // Leave the for-scope.
1563   ForScope.Exit();
1564
1565   if (Body.isInvalid())
1566     return StmtError();
1567
1568   if (ForEach)
1569    return Actions.FinishObjCForCollectionStmt(ForEachStmt.take(),
1570                                               Body.take());
1571
1572   if (ForRange)
1573     return Actions.FinishCXXForRangeStmt(ForRangeStmt.take(), Body.take());
1574
1575   return Actions.ActOnForStmt(ForLoc, T.getOpenLocation(), FirstPart.take(),
1576                               SecondPart, SecondVar, ThirdPart,
1577                               T.getCloseLocation(), Body.take());
1578 }
1579
1580 /// ParseGotoStatement
1581 ///       jump-statement:
1582 ///         'goto' identifier ';'
1583 /// [GNU]   'goto' '*' expression ';'
1584 ///
1585 /// Note: this lets the caller parse the end ';'.
1586 ///
1587 StmtResult Parser::ParseGotoStatement() {
1588   assert(Tok.is(tok::kw_goto) && "Not a goto stmt!");
1589   SourceLocation GotoLoc = ConsumeToken();  // eat the 'goto'.
1590
1591   StmtResult Res;
1592   if (Tok.is(tok::identifier)) {
1593     LabelDecl *LD = Actions.LookupOrCreateLabel(Tok.getIdentifierInfo(),
1594                                                 Tok.getLocation());
1595     Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), LD);
1596     ConsumeToken();
1597   } else if (Tok.is(tok::star)) {
1598     // GNU indirect goto extension.
1599     Diag(Tok, diag::ext_gnu_indirect_goto);
1600     SourceLocation StarLoc = ConsumeToken();
1601     ExprResult R(ParseExpression());
1602     if (R.isInvalid()) {  // Skip to the semicolon, but don't consume it.
1603       SkipUntil(tok::semi, false, true);
1604       return StmtError();
1605     }
1606     Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.take());
1607   } else {
1608     Diag(Tok, diag::err_expected_ident);
1609     return StmtError();
1610   }
1611
1612   return Res;
1613 }
1614
1615 /// ParseContinueStatement
1616 ///       jump-statement:
1617 ///         'continue' ';'
1618 ///
1619 /// Note: this lets the caller parse the end ';'.
1620 ///
1621 StmtResult Parser::ParseContinueStatement() {
1622   SourceLocation ContinueLoc = ConsumeToken();  // eat the 'continue'.
1623   return Actions.ActOnContinueStmt(ContinueLoc, getCurScope());
1624 }
1625
1626 /// ParseBreakStatement
1627 ///       jump-statement:
1628 ///         'break' ';'
1629 ///
1630 /// Note: this lets the caller parse the end ';'.
1631 ///
1632 StmtResult Parser::ParseBreakStatement() {
1633   SourceLocation BreakLoc = ConsumeToken();  // eat the 'break'.
1634   return Actions.ActOnBreakStmt(BreakLoc, getCurScope());
1635 }
1636
1637 /// ParseReturnStatement
1638 ///       jump-statement:
1639 ///         'return' expression[opt] ';'
1640 StmtResult Parser::ParseReturnStatement() {
1641   assert(Tok.is(tok::kw_return) && "Not a return stmt!");
1642   SourceLocation ReturnLoc = ConsumeToken();  // eat the 'return'.
1643
1644   ExprResult R;
1645   if (Tok.isNot(tok::semi)) {
1646     if (Tok.is(tok::code_completion)) {
1647       Actions.CodeCompleteReturn(getCurScope());
1648       cutOffParsing();
1649       return StmtError();
1650     }
1651
1652     if (Tok.is(tok::l_brace) && getLangOpts().CPlusPlus) {
1653       R = ParseInitializer();
1654       if (R.isUsable())
1655         Diag(R.get()->getLocStart(), getLangOpts().CPlusPlus0x ?
1656              diag::warn_cxx98_compat_generalized_initializer_lists :
1657              diag::ext_generalized_initializer_lists)
1658           << R.get()->getSourceRange();
1659     } else
1660         R = ParseExpression();
1661     if (R.isInvalid()) {  // Skip to the semicolon, but don't consume it.
1662       SkipUntil(tok::semi, false, true);
1663       return StmtError();
1664     }
1665   }
1666   return Actions.ActOnReturnStmt(ReturnLoc, R.take());
1667 }
1668
1669 /// ParseMicrosoftAsmStatement. When -fms-extensions/-fasm-blocks is enabled,
1670 /// this routine is called to collect the tokens for an MS asm statement.
1671 ///
1672 /// [MS]  ms-asm-statement:
1673 ///         ms-asm-block
1674 ///         ms-asm-block ms-asm-statement
1675 ///
1676 /// [MS]  ms-asm-block:
1677 ///         '__asm' ms-asm-line '\n'
1678 ///         '__asm' '{' ms-asm-instruction-block[opt] '}' ';'[opt]
1679 ///
1680 /// [MS]  ms-asm-instruction-block
1681 ///         ms-asm-line
1682 ///         ms-asm-line '\n' ms-asm-instruction-block
1683 ///
1684 StmtResult Parser::ParseMicrosoftAsmStatement(SourceLocation AsmLoc) {
1685   // MS-style inline assembly is not fully supported, so emit a warning.
1686   Diag(AsmLoc, diag::warn_unsupported_msasm);
1687
1688   SourceManager &SrcMgr = PP.getSourceManager();
1689   SourceLocation EndLoc = AsmLoc;
1690   SmallVector<Token, 4> AsmToks;
1691
1692   bool InBraces = false;
1693   unsigned short savedBraceCount = 0;
1694   bool InAsmComment = false;
1695   FileID FID;
1696   unsigned LineNo = 0;
1697   unsigned NumTokensRead = 0;
1698   SourceLocation LBraceLoc;
1699
1700   if (Tok.is(tok::l_brace)) {
1701     // Braced inline asm: consume the opening brace.
1702     InBraces = true;
1703     savedBraceCount = BraceCount;
1704     EndLoc = LBraceLoc = ConsumeBrace();
1705     ++NumTokensRead;
1706   } else {
1707     // Single-line inline asm; compute which line it is on.
1708     std::pair<FileID, unsigned> ExpAsmLoc =
1709       SrcMgr.getDecomposedExpansionLoc(EndLoc);
1710     FID = ExpAsmLoc.first;
1711     LineNo = SrcMgr.getLineNumber(FID, ExpAsmLoc.second);
1712   }
1713
1714   SourceLocation TokLoc = Tok.getLocation();
1715   do {
1716     // If we hit EOF, we're done, period.
1717     if (Tok.is(tok::eof))
1718       break;
1719
1720     if (!InAsmComment && Tok.is(tok::semi)) {
1721       // A semicolon in an asm is the start of a comment.
1722       InAsmComment = true;
1723       if (InBraces) {
1724         // Compute which line the comment is on.
1725         std::pair<FileID, unsigned> ExpSemiLoc =
1726           SrcMgr.getDecomposedExpansionLoc(TokLoc);
1727         FID = ExpSemiLoc.first;
1728         LineNo = SrcMgr.getLineNumber(FID, ExpSemiLoc.second);
1729       }
1730     } else if (!InBraces || InAsmComment) {
1731       // If end-of-line is significant, check whether this token is on a
1732       // new line.
1733       std::pair<FileID, unsigned> ExpLoc =
1734         SrcMgr.getDecomposedExpansionLoc(TokLoc);
1735       if (ExpLoc.first != FID ||
1736           SrcMgr.getLineNumber(ExpLoc.first, ExpLoc.second) != LineNo) {
1737         // If this is a single-line __asm, we're done.
1738         if (!InBraces)
1739           break;
1740         // We're no longer in a comment.
1741         InAsmComment = false;
1742       } else if (!InAsmComment && Tok.is(tok::r_brace)) {
1743         // Single-line asm always ends when a closing brace is seen.
1744         // FIXME: This is compatible with Apple gcc's -fasm-blocks; what
1745         // does MSVC do here?
1746         break;
1747       }
1748     }
1749     if (!InAsmComment && InBraces && Tok.is(tok::r_brace) &&
1750         BraceCount == (savedBraceCount + 1)) {
1751       // Consume the closing brace, and finish
1752       EndLoc = ConsumeBrace();
1753       break;
1754     }
1755
1756     // Consume the next token; make sure we don't modify the brace count etc.
1757     // if we are in a comment.
1758     EndLoc = TokLoc;
1759     if (InAsmComment)
1760       PP.Lex(Tok);
1761     else {
1762       AsmToks.push_back(Tok);
1763       ConsumeAnyToken();
1764     }
1765     TokLoc = Tok.getLocation();
1766     ++NumTokensRead;
1767   } while (1);
1768
1769   if (InBraces && BraceCount != savedBraceCount) {
1770     // __asm without closing brace (this can happen at EOF).
1771     Diag(Tok, diag::err_expected_rbrace);
1772     Diag(LBraceLoc, diag::note_matching) << "{";
1773     return StmtError();
1774   } else if (NumTokensRead == 0) {
1775     // Empty __asm.
1776     Diag(Tok, diag::err_expected_lbrace);
1777     return StmtError();
1778   }
1779
1780   // If MS-style inline assembly is disabled, then build an empty asm.
1781   if (!getLangOpts().EmitMicrosoftInlineAsm) {
1782     Token t;
1783     t.setKind(tok::string_literal);
1784     t.setLiteralData("\"/*FIXME: not done*/\"");
1785     t.clearFlag(Token::NeedsCleaning);
1786     t.setLength(21);
1787     ExprResult AsmString(Actions.ActOnStringLiteral(&t, 1));
1788     ExprVector Constraints;
1789     ExprVector Exprs;
1790     ExprVector Clobbers;
1791     return Actions.ActOnGCCAsmStmt(AsmLoc, true, true, 0, 0, 0, Constraints,
1792                                    Exprs, AsmString.take(), Clobbers, EndLoc);
1793   }
1794
1795   // FIXME: We should be passing source locations for better diagnostics.
1796   return Actions.ActOnMSAsmStmt(AsmLoc, LBraceLoc,
1797                                 llvm::makeArrayRef(AsmToks), EndLoc);
1798 }
1799
1800 /// ParseAsmStatement - Parse a GNU extended asm statement.
1801 ///       asm-statement:
1802 ///         gnu-asm-statement
1803 ///         ms-asm-statement
1804 ///
1805 /// [GNU] gnu-asm-statement:
1806 ///         'asm' type-qualifier[opt] '(' asm-argument ')' ';'
1807 ///
1808 /// [GNU] asm-argument:
1809 ///         asm-string-literal
1810 ///         asm-string-literal ':' asm-operands[opt]
1811 ///         asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
1812 ///         asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
1813 ///                 ':' asm-clobbers
1814 ///
1815 /// [GNU] asm-clobbers:
1816 ///         asm-string-literal
1817 ///         asm-clobbers ',' asm-string-literal
1818 ///
1819 StmtResult Parser::ParseAsmStatement(bool &msAsm) {
1820   assert(Tok.is(tok::kw_asm) && "Not an asm stmt");
1821   SourceLocation AsmLoc = ConsumeToken();
1822
1823   if (getLangOpts().MicrosoftExt && Tok.isNot(tok::l_paren) &&
1824       !isTypeQualifier()) {
1825     msAsm = true;
1826     return ParseMicrosoftAsmStatement(AsmLoc);
1827   }
1828   DeclSpec DS(AttrFactory);
1829   SourceLocation Loc = Tok.getLocation();
1830   ParseTypeQualifierListOpt(DS, true, false);
1831
1832   // GNU asms accept, but warn, about type-qualifiers other than volatile.
1833   if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
1834     Diag(Loc, diag::w_asm_qualifier_ignored) << "const";
1835   if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
1836     Diag(Loc, diag::w_asm_qualifier_ignored) << "restrict";
1837
1838   // Remember if this was a volatile asm.
1839   bool isVolatile = DS.getTypeQualifiers() & DeclSpec::TQ_volatile;
1840   if (Tok.isNot(tok::l_paren)) {
1841     Diag(Tok, diag::err_expected_lparen_after) << "asm";
1842     SkipUntil(tok::r_paren);
1843     return StmtError();
1844   }
1845   BalancedDelimiterTracker T(*this, tok::l_paren);
1846   T.consumeOpen();
1847
1848   ExprResult AsmString(ParseAsmStringLiteral());
1849   if (AsmString.isInvalid()) {
1850     // Consume up to and including the closing paren.
1851     T.skipToEnd();
1852     return StmtError();
1853   }
1854
1855   SmallVector<IdentifierInfo *, 4> Names;
1856   ExprVector Constraints;
1857   ExprVector Exprs;
1858   ExprVector Clobbers;
1859
1860   if (Tok.is(tok::r_paren)) {
1861     // We have a simple asm expression like 'asm("foo")'.
1862     T.consumeClose();
1863     return Actions.ActOnGCCAsmStmt(AsmLoc, /*isSimple*/ true, isVolatile,
1864                                    /*NumOutputs*/ 0, /*NumInputs*/ 0, 0,
1865                                    Constraints, Exprs, AsmString.take(),
1866                                    Clobbers, T.getCloseLocation());
1867   }
1868
1869   // Parse Outputs, if present.
1870   bool AteExtraColon = false;
1871   if (Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
1872     // In C++ mode, parse "::" like ": :".
1873     AteExtraColon = Tok.is(tok::coloncolon);
1874     ConsumeToken();
1875
1876     if (!AteExtraColon &&
1877         ParseAsmOperandsOpt(Names, Constraints, Exprs))
1878       return StmtError();
1879   }
1880
1881   unsigned NumOutputs = Names.size();
1882
1883   // Parse Inputs, if present.
1884   if (AteExtraColon ||
1885       Tok.is(tok::colon) || Tok.is(tok::coloncolon)) {
1886     // In C++ mode, parse "::" like ": :".
1887     if (AteExtraColon)
1888       AteExtraColon = false;
1889     else {
1890       AteExtraColon = Tok.is(tok::coloncolon);
1891       ConsumeToken();
1892     }
1893
1894     if (!AteExtraColon &&
1895         ParseAsmOperandsOpt(Names, Constraints, Exprs))
1896       return StmtError();
1897   }
1898
1899   assert(Names.size() == Constraints.size() &&
1900          Constraints.size() == Exprs.size() &&
1901          "Input operand size mismatch!");
1902
1903   unsigned NumInputs = Names.size() - NumOutputs;
1904
1905   // Parse the clobbers, if present.
1906   if (AteExtraColon || Tok.is(tok::colon)) {
1907     if (!AteExtraColon)
1908       ConsumeToken();
1909
1910     // Parse the asm-string list for clobbers if present.
1911     if (Tok.isNot(tok::r_paren)) {
1912       while (1) {
1913         ExprResult Clobber(ParseAsmStringLiteral());
1914
1915         if (Clobber.isInvalid())
1916           break;
1917
1918         Clobbers.push_back(Clobber.release());
1919
1920         if (Tok.isNot(tok::comma)) break;
1921         ConsumeToken();
1922       }
1923     }
1924   }
1925
1926   T.consumeClose();
1927   return Actions.ActOnGCCAsmStmt(AsmLoc, false, isVolatile, NumOutputs,
1928                                  NumInputs, Names.data(), Constraints, Exprs,
1929                                  AsmString.take(), Clobbers,
1930                                  T.getCloseLocation());
1931 }
1932
1933 /// ParseAsmOperands - Parse the asm-operands production as used by
1934 /// asm-statement, assuming the leading ':' token was eaten.
1935 ///
1936 /// [GNU] asm-operands:
1937 ///         asm-operand
1938 ///         asm-operands ',' asm-operand
1939 ///
1940 /// [GNU] asm-operand:
1941 ///         asm-string-literal '(' expression ')'
1942 ///         '[' identifier ']' asm-string-literal '(' expression ')'
1943 ///
1944 //
1945 // FIXME: Avoid unnecessary std::string trashing.
1946 bool Parser::ParseAsmOperandsOpt(SmallVectorImpl<IdentifierInfo *> &Names,
1947                                  SmallVectorImpl<Expr *> &Constraints,
1948                                  SmallVectorImpl<Expr *> &Exprs) {
1949   // 'asm-operands' isn't present?
1950   if (!isTokenStringLiteral() && Tok.isNot(tok::l_square))
1951     return false;
1952
1953   while (1) {
1954     // Read the [id] if present.
1955     if (Tok.is(tok::l_square)) {
1956       BalancedDelimiterTracker T(*this, tok::l_square);
1957       T.consumeOpen();
1958
1959       if (Tok.isNot(tok::identifier)) {
1960         Diag(Tok, diag::err_expected_ident);
1961         SkipUntil(tok::r_paren);
1962         return true;
1963       }
1964
1965       IdentifierInfo *II = Tok.getIdentifierInfo();
1966       ConsumeToken();
1967
1968       Names.push_back(II);
1969       T.consumeClose();
1970     } else
1971       Names.push_back(0);
1972
1973     ExprResult Constraint(ParseAsmStringLiteral());
1974     if (Constraint.isInvalid()) {
1975         SkipUntil(tok::r_paren);
1976         return true;
1977     }
1978     Constraints.push_back(Constraint.release());
1979
1980     if (Tok.isNot(tok::l_paren)) {
1981       Diag(Tok, diag::err_expected_lparen_after) << "asm operand";
1982       SkipUntil(tok::r_paren);
1983       return true;
1984     }
1985
1986     // Read the parenthesized expression.
1987     BalancedDelimiterTracker T(*this, tok::l_paren);
1988     T.consumeOpen();
1989     ExprResult Res(ParseExpression());
1990     T.consumeClose();
1991     if (Res.isInvalid()) {
1992       SkipUntil(tok::r_paren);
1993       return true;
1994     }
1995     Exprs.push_back(Res.release());
1996     // Eat the comma and continue parsing if it exists.
1997     if (Tok.isNot(tok::comma)) return false;
1998     ConsumeToken();
1999   }
2000 }
2001
2002 Decl *Parser::ParseFunctionStatementBody(Decl *Decl, ParseScope &BodyScope) {
2003   assert(Tok.is(tok::l_brace));
2004   SourceLocation LBraceLoc = Tok.getLocation();
2005
2006   if (SkipFunctionBodies && trySkippingFunctionBody()) {
2007     BodyScope.Exit();
2008     return Actions.ActOnFinishFunctionBody(Decl, 0);
2009   }
2010
2011   PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, LBraceLoc,
2012                                       "parsing function body");
2013
2014   // Do not enter a scope for the brace, as the arguments are in the same scope
2015   // (the function body) as the body itself.  Instead, just read the statement
2016   // list and put it into a CompoundStmt for safe keeping.
2017   StmtResult FnBody(ParseCompoundStatementBody());
2018
2019   // If the function body could not be parsed, make a bogus compoundstmt.
2020   if (FnBody.isInvalid()) {
2021     Sema::CompoundScopeRAII CompoundScope(Actions);
2022     FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc,
2023                                        MultiStmtArg(), false);
2024   }
2025
2026   BodyScope.Exit();
2027   return Actions.ActOnFinishFunctionBody(Decl, FnBody.take());
2028 }
2029
2030 /// ParseFunctionTryBlock - Parse a C++ function-try-block.
2031 ///
2032 ///       function-try-block:
2033 ///         'try' ctor-initializer[opt] compound-statement handler-seq
2034 ///
2035 Decl *Parser::ParseFunctionTryBlock(Decl *Decl, ParseScope &BodyScope) {
2036   assert(Tok.is(tok::kw_try) && "Expected 'try'");
2037   SourceLocation TryLoc = ConsumeToken();
2038
2039   PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, TryLoc,
2040                                       "parsing function try block");
2041
2042   // Constructor initializer list?
2043   if (Tok.is(tok::colon))
2044     ParseConstructorInitializer(Decl);
2045   else
2046     Actions.ActOnDefaultCtorInitializers(Decl);
2047
2048   if (SkipFunctionBodies && trySkippingFunctionBody()) {
2049     BodyScope.Exit();
2050     return Actions.ActOnFinishFunctionBody(Decl, 0);
2051   }
2052
2053   SourceLocation LBraceLoc = Tok.getLocation();
2054   StmtResult FnBody(ParseCXXTryBlockCommon(TryLoc, /*FnTry*/true));
2055   // If we failed to parse the try-catch, we just give the function an empty
2056   // compound statement as the body.
2057   if (FnBody.isInvalid()) {
2058     Sema::CompoundScopeRAII CompoundScope(Actions);
2059     FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc,
2060                                        MultiStmtArg(), false);
2061   }
2062
2063   BodyScope.Exit();
2064   return Actions.ActOnFinishFunctionBody(Decl, FnBody.take());
2065 }
2066
2067 bool Parser::trySkippingFunctionBody() {
2068   assert(Tok.is(tok::l_brace));
2069   assert(SkipFunctionBodies &&
2070          "Should only be called when SkipFunctionBodies is enabled");
2071
2072   if (!PP.isCodeCompletionEnabled()) {
2073     ConsumeBrace();
2074     SkipUntil(tok::r_brace, /*StopAtSemi=*/false, /*DontConsume=*/false);
2075     return true;
2076   }
2077
2078   // We're in code-completion mode. Skip parsing for all function bodies unless
2079   // the body contains the code-completion point.
2080   TentativeParsingAction PA(*this);
2081   ConsumeBrace();
2082   if (SkipUntil(tok::r_brace, /*StopAtSemi=*/false, /*DontConsume=*/false,
2083                 /*StopAtCodeCompletion=*/true)) {
2084     PA.Commit();
2085     return true;
2086   }
2087
2088   PA.Revert();
2089   return false;
2090 }
2091
2092 /// ParseCXXTryBlock - Parse a C++ try-block.
2093 ///
2094 ///       try-block:
2095 ///         'try' compound-statement handler-seq
2096 ///
2097 StmtResult Parser::ParseCXXTryBlock() {
2098   assert(Tok.is(tok::kw_try) && "Expected 'try'");
2099
2100   SourceLocation TryLoc = ConsumeToken();
2101   return ParseCXXTryBlockCommon(TryLoc);
2102 }
2103
2104 /// ParseCXXTryBlockCommon - Parse the common part of try-block and
2105 /// function-try-block.
2106 ///
2107 ///       try-block:
2108 ///         'try' compound-statement handler-seq
2109 ///
2110 ///       function-try-block:
2111 ///         'try' ctor-initializer[opt] compound-statement handler-seq
2112 ///
2113 ///       handler-seq:
2114 ///         handler handler-seq[opt]
2115 ///
2116 ///       [Borland] try-block:
2117 ///         'try' compound-statement seh-except-block
2118 ///         'try' compound-statment  seh-finally-block
2119 ///
2120 StmtResult Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc, bool FnTry) {
2121   if (Tok.isNot(tok::l_brace))
2122     return StmtError(Diag(Tok, diag::err_expected_lbrace));
2123   // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
2124
2125   StmtResult TryBlock(ParseCompoundStatement(/*isStmtExpr=*/false,
2126                       Scope::DeclScope |
2127                         (FnTry ? Scope::FnTryScope : Scope::TryScope)));
2128   if (TryBlock.isInvalid())
2129     return TryBlock;
2130
2131   // Borland allows SEH-handlers with 'try'
2132
2133   if ((Tok.is(tok::identifier) &&
2134        Tok.getIdentifierInfo() == getSEHExceptKeyword()) ||
2135       Tok.is(tok::kw___finally)) {
2136     // TODO: Factor into common return ParseSEHHandlerCommon(...)
2137     StmtResult Handler;
2138     if(Tok.getIdentifierInfo() == getSEHExceptKeyword()) {
2139       SourceLocation Loc = ConsumeToken();
2140       Handler = ParseSEHExceptBlock(Loc);
2141     }
2142     else {
2143       SourceLocation Loc = ConsumeToken();
2144       Handler = ParseSEHFinallyBlock(Loc);
2145     }
2146     if(Handler.isInvalid())
2147       return Handler;
2148
2149     return Actions.ActOnSEHTryBlock(true /* IsCXXTry */,
2150                                     TryLoc,
2151                                     TryBlock.take(),
2152                                     Handler.take());
2153   }
2154   else {
2155     StmtVector Handlers;
2156     ParsedAttributesWithRange attrs(AttrFactory);
2157     MaybeParseCXX0XAttributes(attrs);
2158     ProhibitAttributes(attrs);
2159
2160     if (Tok.isNot(tok::kw_catch))
2161       return StmtError(Diag(Tok, diag::err_expected_catch));
2162     while (Tok.is(tok::kw_catch)) {
2163       StmtResult Handler(ParseCXXCatchBlock(FnTry));
2164       if (!Handler.isInvalid())
2165         Handlers.push_back(Handler.release());
2166     }
2167     // Don't bother creating the full statement if we don't have any usable
2168     // handlers.
2169     if (Handlers.empty())
2170       return StmtError();
2171
2172     return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.take(),Handlers);
2173   }
2174 }
2175
2176 /// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard
2177 ///
2178 ///       handler:
2179 ///         'catch' '(' exception-declaration ')' compound-statement
2180 ///
2181 ///       exception-declaration:
2182 ///         type-specifier-seq declarator
2183 ///         type-specifier-seq abstract-declarator
2184 ///         type-specifier-seq
2185 ///         '...'
2186 ///
2187 StmtResult Parser::ParseCXXCatchBlock(bool FnCatch) {
2188   assert(Tok.is(tok::kw_catch) && "Expected 'catch'");
2189
2190   SourceLocation CatchLoc = ConsumeToken();
2191
2192   BalancedDelimiterTracker T(*this, tok::l_paren);
2193   if (T.expectAndConsume(diag::err_expected_lparen))
2194     return StmtError();
2195
2196   // C++ 3.3.2p3:
2197   // The name in a catch exception-declaration is local to the handler and
2198   // shall not be redeclared in the outermost block of the handler.
2199   ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope |
2200                           (FnCatch ? Scope::FnCatchScope : Scope::CatchScope));
2201
2202   // exception-declaration is equivalent to '...' or a parameter-declaration
2203   // without default arguments.
2204   Decl *ExceptionDecl = 0;
2205   if (Tok.isNot(tok::ellipsis)) {
2206     DeclSpec DS(AttrFactory);
2207     if (ParseCXXTypeSpecifierSeq(DS))
2208       return StmtError();
2209     Declarator ExDecl(DS, Declarator::CXXCatchContext);
2210     ParseDeclarator(ExDecl);
2211     ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl);
2212   } else
2213     ConsumeToken();
2214
2215   T.consumeClose();
2216   if (T.getCloseLocation().isInvalid())
2217     return StmtError();
2218
2219   if (Tok.isNot(tok::l_brace))
2220     return StmtError(Diag(Tok, diag::err_expected_lbrace));
2221
2222   // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
2223   StmtResult Block(ParseCompoundStatement());
2224   if (Block.isInvalid())
2225     return Block;
2226
2227   return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.take());
2228 }
2229
2230 void Parser::ParseMicrosoftIfExistsStatement(StmtVector &Stmts) {
2231   IfExistsCondition Result;
2232   if (ParseMicrosoftIfExistsCondition(Result))
2233     return;
2234
2235   // Handle dependent statements by parsing the braces as a compound statement.
2236   // This is not the same behavior as Visual C++, which don't treat this as a
2237   // compound statement, but for Clang's type checking we can't have anything
2238   // inside these braces escaping to the surrounding code.
2239   if (Result.Behavior == IEB_Dependent) {
2240     if (!Tok.is(tok::l_brace)) {
2241       Diag(Tok, diag::err_expected_lbrace);
2242       return;
2243     }
2244
2245     StmtResult Compound = ParseCompoundStatement();
2246     if (Compound.isInvalid())
2247       return;
2248
2249     StmtResult DepResult = Actions.ActOnMSDependentExistsStmt(Result.KeywordLoc,
2250                                                               Result.IsIfExists,
2251                                                               Result.SS,
2252                                                               Result.Name,
2253                                                               Compound.get());
2254     if (DepResult.isUsable())
2255       Stmts.push_back(DepResult.get());
2256     return;
2257   }
2258
2259   BalancedDelimiterTracker Braces(*this, tok::l_brace);
2260   if (Braces.consumeOpen()) {
2261     Diag(Tok, diag::err_expected_lbrace);
2262     return;
2263   }
2264
2265   switch (Result.Behavior) {
2266   case IEB_Parse:
2267     // Parse the statements below.
2268     break;
2269
2270   case IEB_Dependent:
2271     llvm_unreachable("Dependent case handled above");
2272
2273   case IEB_Skip:
2274     Braces.skipToEnd();
2275     return;
2276   }
2277
2278   // Condition is true, parse the statements.
2279   while (Tok.isNot(tok::r_brace)) {
2280     StmtResult R = ParseStatementOrDeclaration(Stmts, false);
2281     if (R.isUsable())
2282       Stmts.push_back(R.release());
2283   }
2284   Braces.consumeClose();
2285 }