ParseStmt.cpp revision 212904
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/// [OBC] objc-throw-statement 44/// [OBC] objc-try-catch-statement 45/// [OBC] objc-synchronized-statement 46/// [GNU] asm-statement 47/// [OMP] openmp-construct [TODO] 48/// 49/// labeled-statement: 50/// identifier ':' statement 51/// 'case' constant-expression ':' statement 52/// 'default' ':' statement 53/// 54/// selection-statement: 55/// if-statement 56/// switch-statement 57/// 58/// iteration-statement: 59/// while-statement 60/// do-statement 61/// for-statement 62/// 63/// expression-statement: 64/// expression[opt] ';' 65/// 66/// jump-statement: 67/// 'goto' identifier ';' 68/// 'continue' ';' 69/// 'break' ';' 70/// 'return' expression[opt] ';' 71/// [GNU] 'goto' '*' expression ';' 72/// 73/// [OBC] objc-throw-statement: 74/// [OBC] '@' 'throw' expression ';' 75/// [OBC] '@' 'throw' ';' 76/// 77StmtResult 78Parser::ParseStatementOrDeclaration(bool OnlyStatement) { 79 const char *SemiError = 0; 80 StmtResult Res; 81 82 ParenBraceBracketBalancer BalancerRAIIObj(*this); 83 84 CXX0XAttributeList Attr; 85 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) 86 Attr = ParseCXX0XAttributes(); 87 llvm::OwningPtr<AttributeList> AttrList(Attr.AttrList); 88 89 // Cases in this switch statement should fall through if the parser expects 90 // the token to end in a semicolon (in which case SemiError should be set), 91 // or they directly 'return;' if not. 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(OnlyStatement); 105 106 case tok::identifier: 107 if (NextToken().is(tok::colon)) { // C99 6.8.1: labeled-statement 108 // identifier ':' statement 109 return ParseLabeledStatement(AttrList.take()); 110 } 111 // PASS THROUGH. 112 113 default: { 114 if ((getLang().CPlusPlus || !OnlyStatement) && isDeclarationStatement()) { 115 SourceLocation DeclStart = Tok.getLocation(), DeclEnd; 116 AttrList.take(); //Passing 'Attr' to ParseDeclaration transfers ownership. 117 DeclGroupPtrTy Decl = ParseDeclaration(Declarator::BlockContext, DeclEnd, 118 Attr); 119 return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd); 120 } 121 122 if (Tok.is(tok::r_brace)) { 123 Diag(Tok, diag::err_expected_statement); 124 return StmtError(); 125 } 126 127 // FIXME: Use the attributes 128 // expression[opt] ';' 129 ExprResult Expr(ParseExpression()); 130 if (Expr.isInvalid()) { 131 // If the expression is invalid, skip ahead to the next semicolon or '}'. 132 // Not doing this opens us up to the possibility of infinite loops if 133 // ParseExpression does not consume any tokens. 134 SkipUntil(tok::r_brace, /*StopAtSemi=*/true, /*DontConsume=*/true); 135 if (Tok.is(tok::semi)) 136 ConsumeToken(); 137 return StmtError(); 138 } 139 // Otherwise, eat the semicolon. 140 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr); 141 return Actions.ActOnExprStmt(Actions.MakeFullExpr(Expr.get())); 142 } 143 144 case tok::kw_case: // C99 6.8.1: labeled-statement 145 return ParseCaseStatement(AttrList.take()); 146 case tok::kw_default: // C99 6.8.1: labeled-statement 147 return ParseDefaultStatement(AttrList.take()); 148 149 case tok::l_brace: // C99 6.8.2: compound-statement 150 return ParseCompoundStatement(AttrList.take()); 151 case tok::semi: // C99 6.8.3p3: expression[opt] ';' 152 return Actions.ActOnNullStmt(ConsumeToken()); 153 154 case tok::kw_if: // C99 6.8.4.1: if-statement 155 return ParseIfStatement(AttrList.take()); 156 case tok::kw_switch: // C99 6.8.4.2: switch-statement 157 return ParseSwitchStatement(AttrList.take()); 158 159 case tok::kw_while: // C99 6.8.5.1: while-statement 160 return ParseWhileStatement(AttrList.take()); 161 case tok::kw_do: // C99 6.8.5.2: do-statement 162 Res = ParseDoStatement(AttrList.take()); 163 SemiError = "do/while"; 164 break; 165 case tok::kw_for: // C99 6.8.5.3: for-statement 166 return ParseForStatement(AttrList.take()); 167 168 case tok::kw_goto: // C99 6.8.6.1: goto-statement 169 Res = ParseGotoStatement(AttrList.take()); 170 SemiError = "goto"; 171 break; 172 case tok::kw_continue: // C99 6.8.6.2: continue-statement 173 Res = ParseContinueStatement(AttrList.take()); 174 SemiError = "continue"; 175 break; 176 case tok::kw_break: // C99 6.8.6.3: break-statement 177 Res = ParseBreakStatement(AttrList.take()); 178 SemiError = "break"; 179 break; 180 case tok::kw_return: // C99 6.8.6.4: return-statement 181 Res = ParseReturnStatement(AttrList.take()); 182 SemiError = "return"; 183 break; 184 185 case tok::kw_asm: { 186 if (Attr.HasAttr) 187 Diag(Attr.Range.getBegin(), diag::err_attributes_not_allowed) 188 << Attr.Range; 189 bool msAsm = false; 190 Res = ParseAsmStatement(msAsm); 191 if (msAsm) return move(Res); 192 SemiError = "asm"; 193 break; 194 } 195 196 case tok::kw_try: // C++ 15: try-block 197 return ParseCXXTryBlock(AttrList.take()); 198 } 199 200 // If we reached this code, the statement must end in a semicolon. 201 if (Tok.is(tok::semi)) { 202 ConsumeToken(); 203 } else if (!Res.isInvalid()) { 204 // If the result was valid, then we do want to diagnose this. Use 205 // ExpectAndConsume to emit the diagnostic, even though we know it won't 206 // succeed. 207 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_stmt, SemiError); 208 // Skip until we see a } or ;, but don't eat it. 209 SkipUntil(tok::r_brace, true, true); 210 } 211 212 return move(Res); 213} 214 215/// ParseLabeledStatement - We have an identifier and a ':' after it. 216/// 217/// labeled-statement: 218/// identifier ':' statement 219/// [GNU] identifier ':' attributes[opt] statement 220/// 221StmtResult Parser::ParseLabeledStatement(AttributeList *Attr) { 222 assert(Tok.is(tok::identifier) && Tok.getIdentifierInfo() && 223 "Not an identifier!"); 224 225 llvm::OwningPtr<AttributeList> AttrList(Attr); 226 Token IdentTok = Tok; // Save the whole token. 227 ConsumeToken(); // eat the identifier. 228 229 assert(Tok.is(tok::colon) && "Not a label!"); 230 231 // identifier ':' statement 232 SourceLocation ColonLoc = ConsumeToken(); 233 234 // Read label attributes, if present. 235 if (Tok.is(tok::kw___attribute)) 236 AttrList.reset(addAttributeLists(AttrList.take(), ParseGNUAttributes())); 237 238 StmtResult SubStmt(ParseStatement()); 239 240 // Broken substmt shouldn't prevent the label from being added to the AST. 241 if (SubStmt.isInvalid()) 242 SubStmt = Actions.ActOnNullStmt(ColonLoc); 243 244 // FIXME: use attributes? 245 return Actions.ActOnLabelStmt(IdentTok.getLocation(), 246 IdentTok.getIdentifierInfo(), 247 ColonLoc, SubStmt.get()); 248} 249 250/// ParseCaseStatement 251/// labeled-statement: 252/// 'case' constant-expression ':' statement 253/// [GNU] 'case' constant-expression '...' constant-expression ':' statement 254/// 255StmtResult Parser::ParseCaseStatement(AttributeList *Attr) { 256 assert(Tok.is(tok::kw_case) && "Not a case stmt!"); 257 // FIXME: Use attributes? 258 delete Attr; 259 260 // It is very very common for code to contain many case statements recursively 261 // nested, as in (but usually without indentation): 262 // case 1: 263 // case 2: 264 // case 3: 265 // case 4: 266 // case 5: etc. 267 // 268 // Parsing this naively works, but is both inefficient and can cause us to run 269 // out of stack space in our recursive descent parser. As a special case, 270 // flatten this recursion into an iterative loop. This is complex and gross, 271 // but all the grossness is constrained to ParseCaseStatement (and some 272 // wierdness in the actions), so this is just local grossness :). 273 274 // TopLevelCase - This is the highest level we have parsed. 'case 1' in the 275 // example above. 276 StmtResult TopLevelCase(true); 277 278 // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which 279 // gets updated each time a new case is parsed, and whose body is unset so 280 // far. When parsing 'case 4', this is the 'case 3' node. 281 StmtTy *DeepestParsedCaseStmt = 0; 282 283 // While we have case statements, eat and stack them. 284 do { 285 SourceLocation CaseLoc = ConsumeToken(); // eat the 'case'. 286 287 if (Tok.is(tok::code_completion)) { 288 Actions.CodeCompleteCase(getCurScope()); 289 ConsumeCodeCompletionToken(); 290 } 291 292 /// We don't want to treat 'case x : y' as a potential typo for 'case x::y'. 293 /// Disable this form of error recovery while we're parsing the case 294 /// expression. 295 ColonProtectionRAIIObject ColonProtection(*this); 296 297 ExprResult LHS(ParseConstantExpression()); 298 if (LHS.isInvalid()) { 299 SkipUntil(tok::colon); 300 return StmtError(); 301 } 302 303 // GNU case range extension. 304 SourceLocation DotDotDotLoc; 305 ExprResult RHS; 306 if (Tok.is(tok::ellipsis)) { 307 Diag(Tok, diag::ext_gnu_case_range); 308 DotDotDotLoc = ConsumeToken(); 309 310 RHS = ParseConstantExpression(); 311 if (RHS.isInvalid()) { 312 SkipUntil(tok::colon); 313 return StmtError(); 314 } 315 } 316 317 ColonProtection.restore(); 318 319 if (Tok.isNot(tok::colon)) { 320 Diag(Tok, diag::err_expected_colon_after) << "'case'"; 321 SkipUntil(tok::colon); 322 return StmtError(); 323 } 324 325 SourceLocation ColonLoc = ConsumeToken(); 326 327 StmtResult Case = 328 Actions.ActOnCaseStmt(CaseLoc, LHS.get(), DotDotDotLoc, 329 RHS.get(), ColonLoc); 330 331 // If we had a sema error parsing this case, then just ignore it and 332 // continue parsing the sub-stmt. 333 if (Case.isInvalid()) { 334 if (TopLevelCase.isInvalid()) // No parsed case stmts. 335 return ParseStatement(); 336 // Otherwise, just don't add it as a nested case. 337 } else { 338 // If this is the first case statement we parsed, it becomes TopLevelCase. 339 // Otherwise we link it into the current chain. 340 Stmt *NextDeepest = Case.get(); 341 if (TopLevelCase.isInvalid()) 342 TopLevelCase = move(Case); 343 else 344 Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, Case.get()); 345 DeepestParsedCaseStmt = NextDeepest; 346 } 347 348 // Handle all case statements. 349 } while (Tok.is(tok::kw_case)); 350 351 assert(!TopLevelCase.isInvalid() && "Should have parsed at least one case!"); 352 353 // If we found a non-case statement, start by parsing it. 354 StmtResult SubStmt; 355 356 if (Tok.isNot(tok::r_brace)) { 357 SubStmt = ParseStatement(); 358 } else { 359 // Nicely diagnose the common error "switch (X) { case 4: }", which is 360 // not valid. 361 // FIXME: add insertion hint. 362 Diag(Tok, diag::err_label_end_of_compound_statement); 363 SubStmt = true; 364 } 365 366 // Broken sub-stmt shouldn't prevent forming the case statement properly. 367 if (SubStmt.isInvalid()) 368 SubStmt = Actions.ActOnNullStmt(SourceLocation()); 369 370 // Install the body into the most deeply-nested case. 371 Actions.ActOnCaseStmtBody(DeepestParsedCaseStmt, SubStmt.get()); 372 373 // Return the top level parsed statement tree. 374 return move(TopLevelCase); 375} 376 377/// ParseDefaultStatement 378/// labeled-statement: 379/// 'default' ':' statement 380/// Note that this does not parse the 'statement' at the end. 381/// 382StmtResult Parser::ParseDefaultStatement(AttributeList *Attr) { 383 //FIXME: Use attributes? 384 delete Attr; 385 386 assert(Tok.is(tok::kw_default) && "Not a default stmt!"); 387 SourceLocation DefaultLoc = ConsumeToken(); // eat the 'default'. 388 389 if (Tok.isNot(tok::colon)) { 390 Diag(Tok, diag::err_expected_colon_after) << "'default'"; 391 SkipUntil(tok::colon); 392 return StmtError(); 393 } 394 395 SourceLocation ColonLoc = ConsumeToken(); 396 397 // Diagnose the common error "switch (X) {... default: }", which is not valid. 398 if (Tok.is(tok::r_brace)) { 399 Diag(Tok, diag::err_label_end_of_compound_statement); 400 return StmtError(); 401 } 402 403 StmtResult SubStmt(ParseStatement()); 404 if (SubStmt.isInvalid()) 405 return StmtError(); 406 407 return Actions.ActOnDefaultStmt(DefaultLoc, ColonLoc, 408 SubStmt.get(), getCurScope()); 409} 410 411 412/// ParseCompoundStatement - Parse a "{}" block. 413/// 414/// compound-statement: [C99 6.8.2] 415/// { block-item-list[opt] } 416/// [GNU] { label-declarations block-item-list } [TODO] 417/// 418/// block-item-list: 419/// block-item 420/// block-item-list block-item 421/// 422/// block-item: 423/// declaration 424/// [GNU] '__extension__' declaration 425/// statement 426/// [OMP] openmp-directive [TODO] 427/// 428/// [GNU] label-declarations: 429/// [GNU] label-declaration 430/// [GNU] label-declarations label-declaration 431/// 432/// [GNU] label-declaration: 433/// [GNU] '__label__' identifier-list ';' 434/// 435/// [OMP] openmp-directive: [TODO] 436/// [OMP] barrier-directive 437/// [OMP] flush-directive 438/// 439StmtResult Parser::ParseCompoundStatement(AttributeList *Attr, 440 bool isStmtExpr) { 441 //FIXME: Use attributes? 442 delete Attr; 443 444 assert(Tok.is(tok::l_brace) && "Not a compount stmt!"); 445 446 // Enter a scope to hold everything within the compound stmt. Compound 447 // statements can always hold declarations. 448 ParseScope CompoundScope(this, Scope::DeclScope); 449 450 // Parse the statements in the body. 451 return ParseCompoundStatementBody(isStmtExpr); 452} 453 454 455/// ParseCompoundStatementBody - Parse a sequence of statements and invoke the 456/// ActOnCompoundStmt action. This expects the '{' to be the current token, and 457/// consume the '}' at the end of the block. It does not manipulate the scope 458/// stack. 459StmtResult Parser::ParseCompoundStatementBody(bool isStmtExpr) { 460 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), 461 Tok.getLocation(), 462 "in compound statement ('{}')"); 463 464 SourceLocation LBraceLoc = ConsumeBrace(); // eat the '{'. 465 466 // TODO: "__label__ X, Y, Z;" is the GNU "Local Label" extension. These are 467 // only allowed at the start of a compound stmt regardless of the language. 468 469 typedef StmtVector StmtsTy; 470 StmtsTy Stmts(Actions); 471 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 472 StmtResult R; 473 if (Tok.isNot(tok::kw___extension__)) { 474 R = ParseStatementOrDeclaration(false); 475 } else { 476 // __extension__ can start declarations and it can also be a unary 477 // operator for expressions. Consume multiple __extension__ markers here 478 // until we can determine which is which. 479 // FIXME: This loses extension expressions in the AST! 480 SourceLocation ExtLoc = ConsumeToken(); 481 while (Tok.is(tok::kw___extension__)) 482 ConsumeToken(); 483 484 CXX0XAttributeList Attr; 485 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) 486 Attr = ParseCXX0XAttributes(); 487 488 // If this is the start of a declaration, parse it as such. 489 if (isDeclarationStatement()) { 490 // __extension__ silences extension warnings in the subdeclaration. 491 // FIXME: Save the __extension__ on the decl as a node somehow? 492 ExtensionRAIIObject O(Diags); 493 494 SourceLocation DeclStart = Tok.getLocation(), DeclEnd; 495 DeclGroupPtrTy Res = ParseDeclaration(Declarator::BlockContext, DeclEnd, 496 Attr); 497 R = Actions.ActOnDeclStmt(Res, DeclStart, DeclEnd); 498 } else { 499 // Otherwise this was a unary __extension__ marker. 500 ExprResult Res(ParseExpressionWithLeadingExtension(ExtLoc)); 501 502 if (Res.isInvalid()) { 503 SkipUntil(tok::semi); 504 continue; 505 } 506 507 // FIXME: Use attributes? 508 // Eat the semicolon at the end of stmt and convert the expr into a 509 // statement. 510 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr); 511 R = Actions.ActOnExprStmt(Actions.MakeFullExpr(Res.get())); 512 } 513 } 514 515 if (R.isUsable()) 516 Stmts.push_back(R.release()); 517 } 518 519 // We broke out of the while loop because we found a '}' or EOF. 520 if (Tok.isNot(tok::r_brace)) { 521 Diag(Tok, diag::err_expected_rbrace); 522 Diag(LBraceLoc, diag::note_matching) << "{"; 523 return StmtError(); 524 } 525 526 SourceLocation RBraceLoc = ConsumeBrace(); 527 return Actions.ActOnCompoundStmt(LBraceLoc, RBraceLoc, move_arg(Stmts), 528 isStmtExpr); 529} 530 531/// ParseParenExprOrCondition: 532/// [C ] '(' expression ')' 533/// [C++] '(' condition ')' [not allowed if OnlyAllowCondition=true] 534/// 535/// This function parses and performs error recovery on the specified condition 536/// or expression (depending on whether we're in C++ or C mode). This function 537/// goes out of its way to recover well. It returns true if there was a parser 538/// error (the right paren couldn't be found), which indicates that the caller 539/// should try to recover harder. It returns false if the condition is 540/// successfully parsed. Note that a successful parse can still have semantic 541/// errors in the condition. 542bool Parser::ParseParenExprOrCondition(ExprResult &ExprResult, 543 Decl *&DeclResult, 544 SourceLocation Loc, 545 bool ConvertToBoolean) { 546 bool ParseError = false; 547 548 SourceLocation LParenLoc = ConsumeParen(); 549 if (getLang().CPlusPlus) 550 ParseError = ParseCXXCondition(ExprResult, DeclResult, Loc, 551 ConvertToBoolean); 552 else { 553 ExprResult = ParseExpression(); 554 DeclResult = 0; 555 556 // If required, convert to a boolean value. 557 if (!ExprResult.isInvalid() && ConvertToBoolean) 558 ExprResult 559 = Actions.ActOnBooleanCondition(getCurScope(), Loc, ExprResult.get()); 560 } 561 562 // If the parser was confused by the condition and we don't have a ')', try to 563 // recover by skipping ahead to a semi and bailing out. If condexp is 564 // semantically invalid but we have well formed code, keep going. 565 if (ExprResult.isInvalid() && !DeclResult && Tok.isNot(tok::r_paren)) { 566 SkipUntil(tok::semi); 567 // Skipping may have stopped if it found the containing ')'. If so, we can 568 // continue parsing the if statement. 569 if (Tok.isNot(tok::r_paren)) 570 return true; 571 } 572 573 // Otherwise the condition is valid or the rparen is present. 574 MatchRHSPunctuation(tok::r_paren, LParenLoc); 575 return false; 576} 577 578 579/// ParseIfStatement 580/// if-statement: [C99 6.8.4.1] 581/// 'if' '(' expression ')' statement 582/// 'if' '(' expression ')' statement 'else' statement 583/// [C++] 'if' '(' condition ')' statement 584/// [C++] 'if' '(' condition ')' statement 'else' statement 585/// 586StmtResult Parser::ParseIfStatement(AttributeList *Attr) { 587 // FIXME: Use attributes? 588 delete Attr; 589 590 assert(Tok.is(tok::kw_if) && "Not an if stmt!"); 591 SourceLocation IfLoc = ConsumeToken(); // eat the 'if'. 592 593 if (Tok.isNot(tok::l_paren)) { 594 Diag(Tok, diag::err_expected_lparen_after) << "if"; 595 SkipUntil(tok::semi); 596 return StmtError(); 597 } 598 599 bool C99orCXX = getLang().C99 || getLang().CPlusPlus; 600 601 // C99 6.8.4p3 - In C99, the if statement is a block. This is not 602 // the case for C90. 603 // 604 // C++ 6.4p3: 605 // A name introduced by a declaration in a condition is in scope from its 606 // point of declaration until the end of the substatements controlled by the 607 // condition. 608 // C++ 3.3.2p4: 609 // Names declared in the for-init-statement, and in the condition of if, 610 // while, for, and switch statements are local to the if, while, for, or 611 // switch statement (including the controlled statement). 612 // 613 ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX); 614 615 // Parse the condition. 616 ExprResult CondExp; 617 Decl *CondVar = 0; 618 if (ParseParenExprOrCondition(CondExp, CondVar, IfLoc, true)) 619 return StmtError(); 620 621 FullExprArg FullCondExp(Actions.MakeFullExpr(CondExp.get())); 622 623 // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if 624 // there is no compound stmt. C90 does not have this clause. We only do this 625 // if the body isn't a compound statement to avoid push/pop in common cases. 626 // 627 // C++ 6.4p1: 628 // The substatement in a selection-statement (each substatement, in the else 629 // form of the if statement) implicitly defines a local scope. 630 // 631 // For C++ we create a scope for the condition and a new scope for 632 // substatements because: 633 // -When the 'then' scope exits, we want the condition declaration to still be 634 // active for the 'else' scope too. 635 // -Sema will detect name clashes by considering declarations of a 636 // 'ControlScope' as part of its direct subscope. 637 // -If we wanted the condition and substatement to be in the same scope, we 638 // would have to notify ParseStatement not to create a new scope. It's 639 // simpler to let it create a new scope. 640 // 641 ParseScope InnerScope(this, Scope::DeclScope, 642 C99orCXX && Tok.isNot(tok::l_brace)); 643 644 // Read the 'then' stmt. 645 SourceLocation ThenStmtLoc = Tok.getLocation(); 646 StmtResult ThenStmt(ParseStatement()); 647 648 // Pop the 'if' scope if needed. 649 InnerScope.Exit(); 650 651 // If it has an else, parse it. 652 SourceLocation ElseLoc; 653 SourceLocation ElseStmtLoc; 654 StmtResult ElseStmt; 655 656 if (Tok.is(tok::kw_else)) { 657 ElseLoc = ConsumeToken(); 658 ElseStmtLoc = Tok.getLocation(); 659 660 // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if 661 // there is no compound stmt. C90 does not have this clause. We only do 662 // this if the body isn't a compound statement to avoid push/pop in common 663 // cases. 664 // 665 // C++ 6.4p1: 666 // The substatement in a selection-statement (each substatement, in the else 667 // form of the if statement) implicitly defines a local scope. 668 // 669 ParseScope InnerScope(this, Scope::DeclScope, 670 C99orCXX && Tok.isNot(tok::l_brace)); 671 672 ElseStmt = ParseStatement(); 673 674 // Pop the 'else' scope if needed. 675 InnerScope.Exit(); 676 } 677 678 IfScope.Exit(); 679 680 // If the condition was invalid, discard the if statement. We could recover 681 // better by replacing it with a valid expr, but don't do that yet. 682 if (CondExp.isInvalid() && !CondVar) 683 return StmtError(); 684 685 // If the then or else stmt is invalid and the other is valid (and present), 686 // make turn the invalid one into a null stmt to avoid dropping the other 687 // part. If both are invalid, return error. 688 if ((ThenStmt.isInvalid() && ElseStmt.isInvalid()) || 689 (ThenStmt.isInvalid() && ElseStmt.get() == 0) || 690 (ThenStmt.get() == 0 && ElseStmt.isInvalid())) { 691 // Both invalid, or one is invalid and other is non-present: return error. 692 return StmtError(); 693 } 694 695 // Now if either are invalid, replace with a ';'. 696 if (ThenStmt.isInvalid()) 697 ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc); 698 if (ElseStmt.isInvalid()) 699 ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc); 700 701 return Actions.ActOnIfStmt(IfLoc, FullCondExp, CondVar, ThenStmt.get(), 702 ElseLoc, ElseStmt.get()); 703} 704 705/// ParseSwitchStatement 706/// switch-statement: 707/// 'switch' '(' expression ')' statement 708/// [C++] 'switch' '(' condition ')' statement 709StmtResult Parser::ParseSwitchStatement(AttributeList *Attr) { 710 // FIXME: Use attributes? 711 delete Attr; 712 713 assert(Tok.is(tok::kw_switch) && "Not a switch stmt!"); 714 SourceLocation SwitchLoc = ConsumeToken(); // eat the 'switch'. 715 716 if (Tok.isNot(tok::l_paren)) { 717 Diag(Tok, diag::err_expected_lparen_after) << "switch"; 718 SkipUntil(tok::semi); 719 return StmtError(); 720 } 721 722 bool C99orCXX = getLang().C99 || getLang().CPlusPlus; 723 724 // C99 6.8.4p3 - In C99, the switch statement is a block. This is 725 // not the case for C90. Start the switch scope. 726 // 727 // C++ 6.4p3: 728 // A name introduced by a declaration in a condition is in scope from its 729 // point of declaration until the end of the substatements controlled by the 730 // condition. 731 // C++ 3.3.2p4: 732 // Names declared in the for-init-statement, and in the condition of if, 733 // while, for, and switch statements are local to the if, while, for, or 734 // switch statement (including the controlled statement). 735 // 736 unsigned ScopeFlags = Scope::BreakScope; 737 if (C99orCXX) 738 ScopeFlags |= Scope::DeclScope | Scope::ControlScope; 739 ParseScope SwitchScope(this, ScopeFlags); 740 741 // Parse the condition. 742 ExprResult Cond; 743 Decl *CondVar = 0; 744 if (ParseParenExprOrCondition(Cond, CondVar, SwitchLoc, false)) 745 return StmtError(); 746 747 StmtResult Switch 748 = Actions.ActOnStartOfSwitchStmt(SwitchLoc, Cond.get(), CondVar); 749 750 if (Switch.isInvalid()) { 751 // Skip the switch body. 752 // FIXME: This is not optimal recovery, but parsing the body is more 753 // dangerous due to the presence of case and default statements, which 754 // will have no place to connect back with the switch. 755 if (Tok.is(tok::l_brace)) { 756 ConsumeBrace(); 757 SkipUntil(tok::r_brace, false, false); 758 } else 759 SkipUntil(tok::semi); 760 return move(Switch); 761 } 762 763 // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if 764 // there is no compound stmt. C90 does not have this clause. We only do this 765 // if the body isn't a compound statement to avoid push/pop in common cases. 766 // 767 // C++ 6.4p1: 768 // The substatement in a selection-statement (each substatement, in the else 769 // form of the if statement) implicitly defines a local scope. 770 // 771 // See comments in ParseIfStatement for why we create a scope for the 772 // condition and a new scope for substatement in C++. 773 // 774 ParseScope InnerScope(this, Scope::DeclScope, 775 C99orCXX && Tok.isNot(tok::l_brace)); 776 777 // Read the body statement. 778 StmtResult Body(ParseStatement()); 779 780 // Pop the scopes. 781 InnerScope.Exit(); 782 SwitchScope.Exit(); 783 784 if (Body.isInvalid()) 785 // FIXME: Remove the case statement list from the Switch statement. 786 Body = Actions.ActOnNullStmt(Tok.getLocation()); 787 788 return Actions.ActOnFinishSwitchStmt(SwitchLoc, Switch.get(), Body.get()); 789} 790 791/// ParseWhileStatement 792/// while-statement: [C99 6.8.5.1] 793/// 'while' '(' expression ')' statement 794/// [C++] 'while' '(' condition ')' statement 795StmtResult Parser::ParseWhileStatement(AttributeList *Attr) { 796 // FIXME: Use attributes? 797 delete Attr; 798 799 assert(Tok.is(tok::kw_while) && "Not a while stmt!"); 800 SourceLocation WhileLoc = Tok.getLocation(); 801 ConsumeToken(); // eat the 'while'. 802 803 if (Tok.isNot(tok::l_paren)) { 804 Diag(Tok, diag::err_expected_lparen_after) << "while"; 805 SkipUntil(tok::semi); 806 return StmtError(); 807 } 808 809 bool C99orCXX = getLang().C99 || getLang().CPlusPlus; 810 811 // C99 6.8.5p5 - In C99, the while statement is a block. This is not 812 // the case for C90. Start the loop scope. 813 // 814 // C++ 6.4p3: 815 // A name introduced by a declaration in a condition is in scope from its 816 // point of declaration until the end of the substatements controlled by the 817 // condition. 818 // C++ 3.3.2p4: 819 // Names declared in the for-init-statement, and in the condition of if, 820 // while, for, and switch statements are local to the if, while, for, or 821 // switch statement (including the controlled statement). 822 // 823 unsigned ScopeFlags; 824 if (C99orCXX) 825 ScopeFlags = Scope::BreakScope | Scope::ContinueScope | 826 Scope::DeclScope | Scope::ControlScope; 827 else 828 ScopeFlags = Scope::BreakScope | Scope::ContinueScope; 829 ParseScope WhileScope(this, ScopeFlags); 830 831 // Parse the condition. 832 ExprResult Cond; 833 Decl *CondVar = 0; 834 if (ParseParenExprOrCondition(Cond, CondVar, WhileLoc, true)) 835 return StmtError(); 836 837 FullExprArg FullCond(Actions.MakeFullExpr(Cond.get())); 838 839 // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if 840 // there is no compound stmt. C90 does not have this clause. We only do this 841 // if the body isn't a compound statement to avoid push/pop in common cases. 842 // 843 // C++ 6.5p2: 844 // The substatement in an iteration-statement implicitly defines a local scope 845 // which is entered and exited each time through the loop. 846 // 847 // See comments in ParseIfStatement for why we create a scope for the 848 // condition and a new scope for substatement in C++. 849 // 850 ParseScope InnerScope(this, Scope::DeclScope, 851 C99orCXX && Tok.isNot(tok::l_brace)); 852 853 // Read the body statement. 854 StmtResult Body(ParseStatement()); 855 856 // Pop the body scope if needed. 857 InnerScope.Exit(); 858 WhileScope.Exit(); 859 860 if ((Cond.isInvalid() && !CondVar) || Body.isInvalid()) 861 return StmtError(); 862 863 return Actions.ActOnWhileStmt(WhileLoc, FullCond, CondVar, Body.get()); 864} 865 866/// ParseDoStatement 867/// do-statement: [C99 6.8.5.2] 868/// 'do' statement 'while' '(' expression ')' ';' 869/// Note: this lets the caller parse the end ';'. 870StmtResult Parser::ParseDoStatement(AttributeList *Attr) { 871 // FIXME: Use attributes? 872 delete Attr; 873 874 assert(Tok.is(tok::kw_do) && "Not a do stmt!"); 875 SourceLocation DoLoc = ConsumeToken(); // eat the 'do'. 876 877 // C99 6.8.5p5 - In C99, the do statement is a block. This is not 878 // the case for C90. Start the loop scope. 879 unsigned ScopeFlags; 880 if (getLang().C99) 881 ScopeFlags = Scope::BreakScope | Scope::ContinueScope | Scope::DeclScope; 882 else 883 ScopeFlags = Scope::BreakScope | Scope::ContinueScope; 884 885 ParseScope DoScope(this, ScopeFlags); 886 887 // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if 888 // there is no compound stmt. C90 does not have this clause. We only do this 889 // if the body isn't a compound statement to avoid push/pop in common cases. 890 // 891 // C++ 6.5p2: 892 // The substatement in an iteration-statement implicitly defines a local scope 893 // which is entered and exited each time through the loop. 894 // 895 ParseScope InnerScope(this, Scope::DeclScope, 896 (getLang().C99 || getLang().CPlusPlus) && 897 Tok.isNot(tok::l_brace)); 898 899 // Read the body statement. 900 StmtResult Body(ParseStatement()); 901 902 // Pop the body scope if needed. 903 InnerScope.Exit(); 904 905 if (Tok.isNot(tok::kw_while)) { 906 if (!Body.isInvalid()) { 907 Diag(Tok, diag::err_expected_while); 908 Diag(DoLoc, diag::note_matching) << "do"; 909 SkipUntil(tok::semi, false, true); 910 } 911 return StmtError(); 912 } 913 SourceLocation WhileLoc = ConsumeToken(); 914 915 if (Tok.isNot(tok::l_paren)) { 916 Diag(Tok, diag::err_expected_lparen_after) << "do/while"; 917 SkipUntil(tok::semi, false, true); 918 return StmtError(); 919 } 920 921 // Parse the parenthesized condition. 922 SourceLocation LPLoc = ConsumeParen(); 923 ExprResult Cond = ParseExpression(); 924 SourceLocation RPLoc = MatchRHSPunctuation(tok::r_paren, LPLoc); 925 DoScope.Exit(); 926 927 if (Cond.isInvalid() || Body.isInvalid()) 928 return StmtError(); 929 930 return Actions.ActOnDoStmt(DoLoc, Body.get(), WhileLoc, LPLoc, 931 Cond.get(), RPLoc); 932} 933 934/// ParseForStatement 935/// for-statement: [C99 6.8.5.3] 936/// 'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement 937/// 'for' '(' declaration expr[opt] ';' expr[opt] ')' statement 938/// [C++] 'for' '(' for-init-statement condition[opt] ';' expression[opt] ')' 939/// [C++] statement 940/// [OBJC2] 'for' '(' declaration 'in' expr ')' statement 941/// [OBJC2] 'for' '(' expr 'in' expr ')' statement 942/// 943/// [C++] for-init-statement: 944/// [C++] expression-statement 945/// [C++] simple-declaration 946/// 947StmtResult Parser::ParseForStatement(AttributeList *Attr) { 948 // FIXME: Use attributes? 949 delete Attr; 950 951 assert(Tok.is(tok::kw_for) && "Not a for stmt!"); 952 SourceLocation ForLoc = ConsumeToken(); // eat the 'for'. 953 954 if (Tok.isNot(tok::l_paren)) { 955 Diag(Tok, diag::err_expected_lparen_after) << "for"; 956 SkipUntil(tok::semi); 957 return StmtError(); 958 } 959 960 bool C99orCXXorObjC = getLang().C99 || getLang().CPlusPlus || getLang().ObjC1; 961 962 // C99 6.8.5p5 - In C99, the for statement is a block. This is not 963 // the case for C90. Start the loop scope. 964 // 965 // C++ 6.4p3: 966 // A name introduced by a declaration in a condition is in scope from its 967 // point of declaration until the end of the substatements controlled by the 968 // condition. 969 // C++ 3.3.2p4: 970 // Names declared in the for-init-statement, and in the condition of if, 971 // while, for, and switch statements are local to the if, while, for, or 972 // switch statement (including the controlled statement). 973 // C++ 6.5.3p1: 974 // Names declared in the for-init-statement are in the same declarative-region 975 // as those declared in the condition. 976 // 977 unsigned ScopeFlags; 978 if (C99orCXXorObjC) 979 ScopeFlags = Scope::BreakScope | Scope::ContinueScope | 980 Scope::DeclScope | Scope::ControlScope; 981 else 982 ScopeFlags = Scope::BreakScope | Scope::ContinueScope; 983 984 ParseScope ForScope(this, ScopeFlags); 985 986 SourceLocation LParenLoc = ConsumeParen(); 987 ExprResult Value; 988 989 bool ForEach = false; 990 StmtResult FirstPart; 991 bool SecondPartIsInvalid = false; 992 FullExprArg SecondPart(Actions); 993 ExprResult Collection; 994 FullExprArg ThirdPart(Actions); 995 Decl *SecondVar = 0; 996 997 if (Tok.is(tok::code_completion)) { 998 Actions.CodeCompleteOrdinaryName(getCurScope(), 999 C99orCXXorObjC? Sema::PCC_ForInit 1000 : Sema::PCC_Expression); 1001 ConsumeCodeCompletionToken(); 1002 } 1003 1004 // Parse the first part of the for specifier. 1005 if (Tok.is(tok::semi)) { // for (; 1006 // no first part, eat the ';'. 1007 ConsumeToken(); 1008 } else if (isSimpleDeclaration()) { // for (int X = 4; 1009 // Parse declaration, which eats the ';'. 1010 if (!C99orCXXorObjC) // Use of C99-style for loops in C90 mode? 1011 Diag(Tok, diag::ext_c99_variable_decl_in_for_loop); 1012 1013 AttributeList *AttrList = 0; 1014 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) 1015 AttrList = ParseCXX0XAttributes().AttrList; 1016 1017 SourceLocation DeclStart = Tok.getLocation(), DeclEnd; 1018 DeclGroupPtrTy DG = ParseSimpleDeclaration(Declarator::ForContext, DeclEnd, 1019 AttrList, false); 1020 FirstPart = Actions.ActOnDeclStmt(DG, DeclStart, Tok.getLocation()); 1021 1022 if (Tok.is(tok::semi)) { // for (int x = 4; 1023 ConsumeToken(); 1024 } else if ((ForEach = isTokIdentifier_in())) { 1025 Actions.ActOnForEachDeclStmt(DG); 1026 // ObjC: for (id x in expr) 1027 ConsumeToken(); // consume 'in' 1028 1029 if (Tok.is(tok::code_completion)) { 1030 Actions.CodeCompleteObjCForCollection(getCurScope(), DG); 1031 ConsumeCodeCompletionToken(); 1032 } 1033 Collection = ParseExpression(); 1034 } else { 1035 Diag(Tok, diag::err_expected_semi_for); 1036 SkipUntil(tok::semi); 1037 } 1038 } else { 1039 Value = ParseExpression(); 1040 1041 // Turn the expression into a stmt. 1042 if (!Value.isInvalid()) 1043 FirstPart = Actions.ActOnExprStmt(Actions.MakeFullExpr(Value.get())); 1044 1045 if (Tok.is(tok::semi)) { 1046 ConsumeToken(); 1047 } else if ((ForEach = isTokIdentifier_in())) { 1048 ConsumeToken(); // consume 'in' 1049 1050 if (Tok.is(tok::code_completion)) { 1051 Actions.CodeCompleteObjCForCollection(getCurScope(), DeclGroupPtrTy()); 1052 ConsumeCodeCompletionToken(); 1053 } 1054 Collection = ParseExpression(); 1055 } else { 1056 if (!Value.isInvalid()) Diag(Tok, diag::err_expected_semi_for); 1057 SkipUntil(tok::semi); 1058 } 1059 } 1060 if (!ForEach) { 1061 assert(!SecondPart.get() && "Shouldn't have a second expression yet."); 1062 // Parse the second part of the for specifier. 1063 if (Tok.is(tok::semi)) { // for (...;; 1064 // no second part. 1065 } else { 1066 ExprResult Second; 1067 if (getLang().CPlusPlus) 1068 ParseCXXCondition(Second, SecondVar, ForLoc, true); 1069 else { 1070 Second = ParseExpression(); 1071 if (!Second.isInvalid()) 1072 Second = Actions.ActOnBooleanCondition(getCurScope(), ForLoc, 1073 Second.get()); 1074 } 1075 SecondPartIsInvalid = Second.isInvalid(); 1076 SecondPart = Actions.MakeFullExpr(Second.get()); 1077 } 1078 1079 if (Tok.is(tok::semi)) { 1080 ConsumeToken(); 1081 } else { 1082 if (!SecondPartIsInvalid || SecondVar) 1083 Diag(Tok, diag::err_expected_semi_for); 1084 SkipUntil(tok::semi); 1085 } 1086 1087 // Parse the third part of the for specifier. 1088 if (Tok.isNot(tok::r_paren)) { // for (...;...;) 1089 ExprResult Third = ParseExpression(); 1090 ThirdPart = Actions.MakeFullExpr(Third.take()); 1091 } 1092 } 1093 // Match the ')'. 1094 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc); 1095 1096 // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if 1097 // there is no compound stmt. C90 does not have this clause. We only do this 1098 // if the body isn't a compound statement to avoid push/pop in common cases. 1099 // 1100 // C++ 6.5p2: 1101 // The substatement in an iteration-statement implicitly defines a local scope 1102 // which is entered and exited each time through the loop. 1103 // 1104 // See comments in ParseIfStatement for why we create a scope for 1105 // for-init-statement/condition and a new scope for substatement in C++. 1106 // 1107 ParseScope InnerScope(this, Scope::DeclScope, 1108 C99orCXXorObjC && Tok.isNot(tok::l_brace)); 1109 1110 // Read the body statement. 1111 StmtResult Body(ParseStatement()); 1112 1113 // Pop the body scope if needed. 1114 InnerScope.Exit(); 1115 1116 // Leave the for-scope. 1117 ForScope.Exit(); 1118 1119 if (Body.isInvalid()) 1120 return StmtError(); 1121 1122 if (!ForEach) 1123 return Actions.ActOnForStmt(ForLoc, LParenLoc, FirstPart.take(), SecondPart, 1124 SecondVar, ThirdPart, RParenLoc, Body.take()); 1125 1126 // FIXME: It isn't clear how to communicate the late destruction of 1127 // C++ temporaries used to create the collection. 1128 return Actions.ActOnObjCForCollectionStmt(ForLoc, LParenLoc, FirstPart.take(), 1129 Collection.take(), RParenLoc, 1130 Body.take()); 1131} 1132 1133/// ParseGotoStatement 1134/// jump-statement: 1135/// 'goto' identifier ';' 1136/// [GNU] 'goto' '*' expression ';' 1137/// 1138/// Note: this lets the caller parse the end ';'. 1139/// 1140StmtResult Parser::ParseGotoStatement(AttributeList *Attr) { 1141 // FIXME: Use attributes? 1142 delete Attr; 1143 1144 assert(Tok.is(tok::kw_goto) && "Not a goto stmt!"); 1145 SourceLocation GotoLoc = ConsumeToken(); // eat the 'goto'. 1146 1147 StmtResult Res; 1148 if (Tok.is(tok::identifier)) { 1149 Res = Actions.ActOnGotoStmt(GotoLoc, Tok.getLocation(), 1150 Tok.getIdentifierInfo()); 1151 ConsumeToken(); 1152 } else if (Tok.is(tok::star)) { 1153 // GNU indirect goto extension. 1154 Diag(Tok, diag::ext_gnu_indirect_goto); 1155 SourceLocation StarLoc = ConsumeToken(); 1156 ExprResult R(ParseExpression()); 1157 if (R.isInvalid()) { // Skip to the semicolon, but don't consume it. 1158 SkipUntil(tok::semi, false, true); 1159 return StmtError(); 1160 } 1161 Res = Actions.ActOnIndirectGotoStmt(GotoLoc, StarLoc, R.take()); 1162 } else { 1163 Diag(Tok, diag::err_expected_ident); 1164 return StmtError(); 1165 } 1166 1167 return move(Res); 1168} 1169 1170/// ParseContinueStatement 1171/// jump-statement: 1172/// 'continue' ';' 1173/// 1174/// Note: this lets the caller parse the end ';'. 1175/// 1176StmtResult Parser::ParseContinueStatement(AttributeList *Attr) { 1177 // FIXME: Use attributes? 1178 delete Attr; 1179 1180 SourceLocation ContinueLoc = ConsumeToken(); // eat the 'continue'. 1181 return Actions.ActOnContinueStmt(ContinueLoc, getCurScope()); 1182} 1183 1184/// ParseBreakStatement 1185/// jump-statement: 1186/// 'break' ';' 1187/// 1188/// Note: this lets the caller parse the end ';'. 1189/// 1190StmtResult Parser::ParseBreakStatement(AttributeList *Attr) { 1191 // FIXME: Use attributes? 1192 delete Attr; 1193 1194 SourceLocation BreakLoc = ConsumeToken(); // eat the 'break'. 1195 return Actions.ActOnBreakStmt(BreakLoc, getCurScope()); 1196} 1197 1198/// ParseReturnStatement 1199/// jump-statement: 1200/// 'return' expression[opt] ';' 1201StmtResult Parser::ParseReturnStatement(AttributeList *Attr) { 1202 // FIXME: Use attributes? 1203 delete Attr; 1204 1205 assert(Tok.is(tok::kw_return) && "Not a return stmt!"); 1206 SourceLocation ReturnLoc = ConsumeToken(); // eat the 'return'. 1207 1208 ExprResult R; 1209 if (Tok.isNot(tok::semi)) { 1210 if (Tok.is(tok::code_completion)) { 1211 Actions.CodeCompleteReturn(getCurScope()); 1212 ConsumeCodeCompletionToken(); 1213 SkipUntil(tok::semi, false, true); 1214 return StmtError(); 1215 } 1216 1217 R = ParseExpression(); 1218 if (R.isInvalid()) { // Skip to the semicolon, but don't consume it. 1219 SkipUntil(tok::semi, false, true); 1220 return StmtError(); 1221 } 1222 } 1223 return Actions.ActOnReturnStmt(ReturnLoc, R.take()); 1224} 1225 1226/// FuzzyParseMicrosoftAsmStatement. When -fms-extensions is enabled, this 1227/// routine is called to skip/ignore tokens that comprise the MS asm statement. 1228StmtResult Parser::FuzzyParseMicrosoftAsmStatement() { 1229 if (Tok.is(tok::l_brace)) { 1230 unsigned short savedBraceCount = BraceCount; 1231 do { 1232 ConsumeAnyToken(); 1233 } while (BraceCount > savedBraceCount && Tok.isNot(tok::eof)); 1234 } else { 1235 // From the MS website: If used without braces, the __asm keyword means 1236 // that the rest of the line is an assembly-language statement. 1237 SourceManager &SrcMgr = PP.getSourceManager(); 1238 SourceLocation TokLoc = Tok.getLocation(); 1239 unsigned LineNo = SrcMgr.getInstantiationLineNumber(TokLoc); 1240 do { 1241 ConsumeAnyToken(); 1242 TokLoc = Tok.getLocation(); 1243 } while ((SrcMgr.getInstantiationLineNumber(TokLoc) == LineNo) && 1244 Tok.isNot(tok::r_brace) && Tok.isNot(tok::semi) && 1245 Tok.isNot(tok::eof)); 1246 } 1247 Token t; 1248 t.setKind(tok::string_literal); 1249 t.setLiteralData("\"/*FIXME: not done*/\""); 1250 t.clearFlag(Token::NeedsCleaning); 1251 t.setLength(21); 1252 ExprResult AsmString(Actions.ActOnStringLiteral(&t, 1)); 1253 ExprVector Constraints(Actions); 1254 ExprVector Exprs(Actions); 1255 ExprVector Clobbers(Actions); 1256 return Actions.ActOnAsmStmt(Tok.getLocation(), true, true, 0, 0, 0, 1257 move_arg(Constraints), move_arg(Exprs), 1258 AsmString.take(), move_arg(Clobbers), 1259 Tok.getLocation(), true); 1260} 1261 1262/// ParseAsmStatement - Parse a GNU extended asm statement. 1263/// asm-statement: 1264/// gnu-asm-statement 1265/// ms-asm-statement 1266/// 1267/// [GNU] gnu-asm-statement: 1268/// 'asm' type-qualifier[opt] '(' asm-argument ')' ';' 1269/// 1270/// [GNU] asm-argument: 1271/// asm-string-literal 1272/// asm-string-literal ':' asm-operands[opt] 1273/// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt] 1274/// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt] 1275/// ':' asm-clobbers 1276/// 1277/// [GNU] asm-clobbers: 1278/// asm-string-literal 1279/// asm-clobbers ',' asm-string-literal 1280/// 1281/// [MS] ms-asm-statement: 1282/// '__asm' assembly-instruction ';'[opt] 1283/// '__asm' '{' assembly-instruction-list '}' ';'[opt] 1284/// 1285/// [MS] assembly-instruction-list: 1286/// assembly-instruction ';'[opt] 1287/// assembly-instruction-list ';' assembly-instruction ';'[opt] 1288/// 1289StmtResult Parser::ParseAsmStatement(bool &msAsm) { 1290 assert(Tok.is(tok::kw_asm) && "Not an asm stmt"); 1291 SourceLocation AsmLoc = ConsumeToken(); 1292 1293 if (getLang().Microsoft && Tok.isNot(tok::l_paren) && !isTypeQualifier()) { 1294 msAsm = true; 1295 return FuzzyParseMicrosoftAsmStatement(); 1296 } 1297 DeclSpec DS; 1298 SourceLocation Loc = Tok.getLocation(); 1299 ParseTypeQualifierListOpt(DS, true, false); 1300 1301 // GNU asms accept, but warn, about type-qualifiers other than volatile. 1302 if (DS.getTypeQualifiers() & DeclSpec::TQ_const) 1303 Diag(Loc, diag::w_asm_qualifier_ignored) << "const"; 1304 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict) 1305 Diag(Loc, diag::w_asm_qualifier_ignored) << "restrict"; 1306 1307 // Remember if this was a volatile asm. 1308 bool isVolatile = DS.getTypeQualifiers() & DeclSpec::TQ_volatile; 1309 if (Tok.isNot(tok::l_paren)) { 1310 Diag(Tok, diag::err_expected_lparen_after) << "asm"; 1311 SkipUntil(tok::r_paren); 1312 return StmtError(); 1313 } 1314 Loc = ConsumeParen(); 1315 1316 ExprResult AsmString(ParseAsmStringLiteral()); 1317 if (AsmString.isInvalid()) 1318 return StmtError(); 1319 1320 llvm::SmallVector<IdentifierInfo *, 4> Names; 1321 ExprVector Constraints(Actions); 1322 ExprVector Exprs(Actions); 1323 ExprVector Clobbers(Actions); 1324 1325 if (Tok.is(tok::r_paren)) { 1326 // We have a simple asm expression like 'asm("foo")'. 1327 SourceLocation RParenLoc = ConsumeParen(); 1328 return Actions.ActOnAsmStmt(AsmLoc, /*isSimple*/ true, isVolatile, 1329 /*NumOutputs*/ 0, /*NumInputs*/ 0, 0, 1330 move_arg(Constraints), move_arg(Exprs), 1331 AsmString.take(), move_arg(Clobbers), 1332 RParenLoc); 1333 } 1334 1335 // Parse Outputs, if present. 1336 bool AteExtraColon = false; 1337 if (Tok.is(tok::colon) || Tok.is(tok::coloncolon)) { 1338 // In C++ mode, parse "::" like ": :". 1339 AteExtraColon = Tok.is(tok::coloncolon); 1340 ConsumeToken(); 1341 1342 if (!AteExtraColon && 1343 ParseAsmOperandsOpt(Names, Constraints, Exprs)) 1344 return StmtError(); 1345 } 1346 1347 unsigned NumOutputs = Names.size(); 1348 1349 // Parse Inputs, if present. 1350 if (AteExtraColon || 1351 Tok.is(tok::colon) || Tok.is(tok::coloncolon)) { 1352 // In C++ mode, parse "::" like ": :". 1353 if (AteExtraColon) 1354 AteExtraColon = false; 1355 else { 1356 AteExtraColon = Tok.is(tok::coloncolon); 1357 ConsumeToken(); 1358 } 1359 1360 if (!AteExtraColon && 1361 ParseAsmOperandsOpt(Names, Constraints, Exprs)) 1362 return StmtError(); 1363 } 1364 1365 assert(Names.size() == Constraints.size() && 1366 Constraints.size() == Exprs.size() && 1367 "Input operand size mismatch!"); 1368 1369 unsigned NumInputs = Names.size() - NumOutputs; 1370 1371 // Parse the clobbers, if present. 1372 if (AteExtraColon || Tok.is(tok::colon)) { 1373 if (!AteExtraColon) 1374 ConsumeToken(); 1375 1376 // Parse the asm-string list for clobbers if present. 1377 if (Tok.isNot(tok::r_paren)) { 1378 while (1) { 1379 ExprResult Clobber(ParseAsmStringLiteral()); 1380 1381 if (Clobber.isInvalid()) 1382 break; 1383 1384 Clobbers.push_back(Clobber.release()); 1385 1386 if (Tok.isNot(tok::comma)) break; 1387 ConsumeToken(); 1388 } 1389 } 1390 } 1391 1392 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, Loc); 1393 return Actions.ActOnAsmStmt(AsmLoc, false, isVolatile, 1394 NumOutputs, NumInputs, Names.data(), 1395 move_arg(Constraints), move_arg(Exprs), 1396 AsmString.take(), move_arg(Clobbers), 1397 RParenLoc); 1398} 1399 1400/// ParseAsmOperands - Parse the asm-operands production as used by 1401/// asm-statement, assuming the leading ':' token was eaten. 1402/// 1403/// [GNU] asm-operands: 1404/// asm-operand 1405/// asm-operands ',' asm-operand 1406/// 1407/// [GNU] asm-operand: 1408/// asm-string-literal '(' expression ')' 1409/// '[' identifier ']' asm-string-literal '(' expression ')' 1410/// 1411// 1412// FIXME: Avoid unnecessary std::string trashing. 1413bool Parser::ParseAsmOperandsOpt(llvm::SmallVectorImpl<IdentifierInfo *> &Names, 1414 llvm::SmallVectorImpl<ExprTy *> &Constraints, 1415 llvm::SmallVectorImpl<ExprTy *> &Exprs) { 1416 // 'asm-operands' isn't present? 1417 if (!isTokenStringLiteral() && Tok.isNot(tok::l_square)) 1418 return false; 1419 1420 while (1) { 1421 // Read the [id] if present. 1422 if (Tok.is(tok::l_square)) { 1423 SourceLocation Loc = ConsumeBracket(); 1424 1425 if (Tok.isNot(tok::identifier)) { 1426 Diag(Tok, diag::err_expected_ident); 1427 SkipUntil(tok::r_paren); 1428 return true; 1429 } 1430 1431 IdentifierInfo *II = Tok.getIdentifierInfo(); 1432 ConsumeToken(); 1433 1434 Names.push_back(II); 1435 MatchRHSPunctuation(tok::r_square, Loc); 1436 } else 1437 Names.push_back(0); 1438 1439 ExprResult Constraint(ParseAsmStringLiteral()); 1440 if (Constraint.isInvalid()) { 1441 SkipUntil(tok::r_paren); 1442 return true; 1443 } 1444 Constraints.push_back(Constraint.release()); 1445 1446 if (Tok.isNot(tok::l_paren)) { 1447 Diag(Tok, diag::err_expected_lparen_after) << "asm operand"; 1448 SkipUntil(tok::r_paren); 1449 return true; 1450 } 1451 1452 // Read the parenthesized expression. 1453 SourceLocation OpenLoc = ConsumeParen(); 1454 ExprResult Res(ParseExpression()); 1455 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1456 if (Res.isInvalid()) { 1457 SkipUntil(tok::r_paren); 1458 return true; 1459 } 1460 Exprs.push_back(Res.release()); 1461 // Eat the comma and continue parsing if it exists. 1462 if (Tok.isNot(tok::comma)) return false; 1463 ConsumeToken(); 1464 } 1465 1466 return true; 1467} 1468 1469Decl *Parser::ParseFunctionStatementBody(Decl *Decl) { 1470 assert(Tok.is(tok::l_brace)); 1471 SourceLocation LBraceLoc = Tok.getLocation(); 1472 1473 PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, LBraceLoc, 1474 "parsing function body"); 1475 1476 // Do not enter a scope for the brace, as the arguments are in the same scope 1477 // (the function body) as the body itself. Instead, just read the statement 1478 // list and put it into a CompoundStmt for safe keeping. 1479 StmtResult FnBody(ParseCompoundStatementBody()); 1480 1481 // If the function body could not be parsed, make a bogus compoundstmt. 1482 if (FnBody.isInvalid()) 1483 FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, 1484 MultiStmtArg(Actions), false); 1485 1486 return Actions.ActOnFinishFunctionBody(Decl, FnBody.take()); 1487} 1488 1489/// ParseFunctionTryBlock - Parse a C++ function-try-block. 1490/// 1491/// function-try-block: 1492/// 'try' ctor-initializer[opt] compound-statement handler-seq 1493/// 1494Decl *Parser::ParseFunctionTryBlock(Decl *Decl) { 1495 assert(Tok.is(tok::kw_try) && "Expected 'try'"); 1496 SourceLocation TryLoc = ConsumeToken(); 1497 1498 PrettyDeclStackTraceEntry CrashInfo(Actions, Decl, TryLoc, 1499 "parsing function try block"); 1500 1501 // Constructor initializer list? 1502 if (Tok.is(tok::colon)) 1503 ParseConstructorInitializer(Decl); 1504 1505 SourceLocation LBraceLoc = Tok.getLocation(); 1506 StmtResult FnBody(ParseCXXTryBlockCommon(TryLoc)); 1507 // If we failed to parse the try-catch, we just give the function an empty 1508 // compound statement as the body. 1509 if (FnBody.isInvalid()) 1510 FnBody = Actions.ActOnCompoundStmt(LBraceLoc, LBraceLoc, 1511 MultiStmtArg(Actions), false); 1512 1513 return Actions.ActOnFinishFunctionBody(Decl, FnBody.take()); 1514} 1515 1516/// ParseCXXTryBlock - Parse a C++ try-block. 1517/// 1518/// try-block: 1519/// 'try' compound-statement handler-seq 1520/// 1521StmtResult Parser::ParseCXXTryBlock(AttributeList* Attr) { 1522 // FIXME: Add attributes? 1523 delete Attr; 1524 1525 assert(Tok.is(tok::kw_try) && "Expected 'try'"); 1526 1527 SourceLocation TryLoc = ConsumeToken(); 1528 return ParseCXXTryBlockCommon(TryLoc); 1529} 1530 1531/// ParseCXXTryBlockCommon - Parse the common part of try-block and 1532/// function-try-block. 1533/// 1534/// try-block: 1535/// 'try' compound-statement handler-seq 1536/// 1537/// function-try-block: 1538/// 'try' ctor-initializer[opt] compound-statement handler-seq 1539/// 1540/// handler-seq: 1541/// handler handler-seq[opt] 1542/// 1543StmtResult Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc) { 1544 if (Tok.isNot(tok::l_brace)) 1545 return StmtError(Diag(Tok, diag::err_expected_lbrace)); 1546 // FIXME: Possible draft standard bug: attribute-specifier should be allowed? 1547 StmtResult TryBlock(ParseCompoundStatement(0)); 1548 if (TryBlock.isInvalid()) 1549 return move(TryBlock); 1550 1551 StmtVector Handlers(Actions); 1552 if (getLang().CPlusPlus0x && isCXX0XAttributeSpecifier()) { 1553 CXX0XAttributeList Attr = ParseCXX0XAttributes(); 1554 Diag(Attr.Range.getBegin(), diag::err_attributes_not_allowed) 1555 << Attr.Range; 1556 } 1557 if (Tok.isNot(tok::kw_catch)) 1558 return StmtError(Diag(Tok, diag::err_expected_catch)); 1559 while (Tok.is(tok::kw_catch)) { 1560 StmtResult Handler(ParseCXXCatchBlock()); 1561 if (!Handler.isInvalid()) 1562 Handlers.push_back(Handler.release()); 1563 } 1564 // Don't bother creating the full statement if we don't have any usable 1565 // handlers. 1566 if (Handlers.empty()) 1567 return StmtError(); 1568 1569 return Actions.ActOnCXXTryBlock(TryLoc, TryBlock.take(), move_arg(Handlers)); 1570} 1571 1572/// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard 1573/// 1574/// handler: 1575/// 'catch' '(' exception-declaration ')' compound-statement 1576/// 1577/// exception-declaration: 1578/// type-specifier-seq declarator 1579/// type-specifier-seq abstract-declarator 1580/// type-specifier-seq 1581/// '...' 1582/// 1583StmtResult Parser::ParseCXXCatchBlock() { 1584 assert(Tok.is(tok::kw_catch) && "Expected 'catch'"); 1585 1586 SourceLocation CatchLoc = ConsumeToken(); 1587 1588 SourceLocation LParenLoc = Tok.getLocation(); 1589 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen)) 1590 return StmtError(); 1591 1592 // C++ 3.3.2p3: 1593 // The name in a catch exception-declaration is local to the handler and 1594 // shall not be redeclared in the outermost block of the handler. 1595 ParseScope CatchScope(this, Scope::DeclScope | Scope::ControlScope); 1596 1597 // exception-declaration is equivalent to '...' or a parameter-declaration 1598 // without default arguments. 1599 Decl *ExceptionDecl = 0; 1600 if (Tok.isNot(tok::ellipsis)) { 1601 DeclSpec DS; 1602 if (ParseCXXTypeSpecifierSeq(DS)) 1603 return StmtError(); 1604 Declarator ExDecl(DS, Declarator::CXXCatchContext); 1605 ParseDeclarator(ExDecl); 1606 ExceptionDecl = Actions.ActOnExceptionDeclarator(getCurScope(), ExDecl); 1607 } else 1608 ConsumeToken(); 1609 1610 if (MatchRHSPunctuation(tok::r_paren, LParenLoc).isInvalid()) 1611 return StmtError(); 1612 1613 if (Tok.isNot(tok::l_brace)) 1614 return StmtError(Diag(Tok, diag::err_expected_lbrace)); 1615 1616 // FIXME: Possible draft standard bug: attribute-specifier should be allowed? 1617 StmtResult Block(ParseCompoundStatement(0)); 1618 if (Block.isInvalid()) 1619 return move(Block); 1620 1621 return Actions.ActOnCXXCatchBlock(CatchLoc, ExceptionDecl, Block.take()); 1622} 1623