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