1 //===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Statement and Block portions of the Parser
13 //===----------------------------------------------------------------------===//
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"
23 using namespace clang
;
25 //===----------------------------------------------------------------------===//
26 // C99 6.8: Statements and Blocks.
27 //===----------------------------------------------------------------------===//
29 /// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
30 /// StatementOrDeclaration:
36 /// compound-statement
37 /// expression-statement
38 /// selection-statement
39 /// iteration-statement
41 /// [C++] declaration-statement
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]
49 /// labeled-statement:
50 /// identifier ':' statement
51 /// 'case' constant-expression ':' statement
52 /// 'default' ':' statement
54 /// selection-statement:
58 /// iteration-statement:
63 /// expression-statement:
64 /// expression[opt] ';'
67 /// 'goto' identifier ';'
70 /// 'return' expression[opt] ';'
71 /// [GNU] 'goto' '*' expression ';'
73 /// [OBC] objc-throw-statement:
74 /// [OBC] '@' 'throw' expression ';'
75 /// [OBC] '@' 'throw' ';'
78 Parser::ParseStatementOrDeclaration(StmtVector
&Stmts
, bool OnlyStatement
) {
79 const char *SemiError
= 0;
82 ParenBraceBracketBalancer
BalancerRAIIObj(*this);
84 ParsedAttributesWithRange attrs
;
85 MaybeParseCXX0XAttributes(attrs
);
87 // Cases in this switch statement should fall through if the parser expects
88 // the token to end in a semicolon (in which case SemiError should be set),
89 // or they directly 'return;' if not.
90 tok::TokenKind Kind
= Tok
.getKind();
93 case tok::at
: // May be a @try or @throw statement
95 AtLoc
= ConsumeToken(); // consume @
96 return ParseObjCAtStatement(AtLoc
);
99 case tok::code_completion
:
100 Actions
.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement
);
101 ConsumeCodeCompletionToken();
102 return ParseStatementOrDeclaration(Stmts
, OnlyStatement
);
104 case tok::identifier
:
105 if (NextToken().is(tok::colon
)) { // C99 6.8.1: labeled-statement
106 // identifier ':' statement
107 return ParseLabeledStatement(attrs
);
112 if ((getLang().CPlusPlus
|| !OnlyStatement
) && isDeclarationStatement()) {
113 SourceLocation DeclStart
= Tok
.getLocation(), DeclEnd
;
114 DeclGroupPtrTy Decl
= ParseDeclaration(Stmts
, Declarator::BlockContext
,
116 return Actions
.ActOnDeclStmt(Decl
, DeclStart
, DeclEnd
);
119 if (Tok
.is(tok::r_brace
)) {
120 Diag(Tok
, diag::err_expected_statement
);
124 // FIXME: Use the attributes
125 // expression[opt] ';'
126 ExprResult
Expr(ParseExpression());
127 if (Expr
.isInvalid()) {
128 // If the expression is invalid, skip ahead to the next semicolon or '}'.
129 // Not doing this opens us up to the possibility of infinite loops if
130 // ParseExpression does not consume any tokens.
131 SkipUntil(tok::r_brace
, /*StopAtSemi=*/true, /*DontConsume=*/true);
132 if (Tok
.is(tok::semi
))
136 // Otherwise, eat the semicolon.
137 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr
);
138 return Actions
.ActOnExprStmt(Actions
.MakeFullExpr(Expr
.get()));
141 case tok::kw_case
: // C99 6.8.1: labeled-statement
142 return ParseCaseStatement(attrs
);
143 case tok::kw_default
: // C99 6.8.1: labeled-statement
144 return ParseDefaultStatement(attrs
);
146 case tok::l_brace
: // C99 6.8.2: compound-statement
147 return ParseCompoundStatement(attrs
);
148 case tok::semi
: { // C99 6.8.3p3: expression[opt] ';'
149 bool LeadingEmptyMacro
= Tok
.hasLeadingEmptyMacro();
150 return Actions
.ActOnNullStmt(ConsumeToken(), LeadingEmptyMacro
);
153 case tok::kw_if
: // C99 6.8.4.1: if-statement
154 return ParseIfStatement(attrs
);
155 case tok::kw_switch
: // C99 6.8.4.2: switch-statement
156 return ParseSwitchStatement(attrs
);
158 case tok::kw_while
: // C99 6.8.5.1: while-statement
159 return ParseWhileStatement(attrs
);
160 case tok::kw_do
: // C99 6.8.5.2: do-statement
161 Res
= ParseDoStatement(attrs
);
162 SemiError
= "do/while";
164 case tok::kw_for
: // C99 6.8.5.3: for-statement
165 return ParseForStatement(attrs
);
167 case tok::kw_goto
: // C99 6.8.6.1: goto-statement
168 Res
= ParseGotoStatement(attrs
);
171 case tok::kw_continue
: // C99 6.8.6.2: continue-statement
172 Res
= ParseContinueStatement(attrs
);
173 SemiError
= "continue";
175 case tok::kw_break
: // C99 6.8.6.3: break-statement
176 Res
= ParseBreakStatement(attrs
);
179 case tok::kw_return
: // C99 6.8.6.4: return-statement
180 Res
= ParseReturnStatement(attrs
);
181 SemiError
= "return";
185 ProhibitAttributes(attrs
);
187 Res
= ParseAsmStatement(msAsm
);
188 Res
= Actions
.ActOnFinishFullStmt(Res
.get());
189 if (msAsm
) return move(Res
);
194 case tok::kw_try
: // C++ 15: try-block
195 return ParseCXXTryBlock(attrs
);
198 // If we reached this code, the statement must end in a semicolon.
199 if (Tok
.is(tok::semi
)) {
201 } else if (!Res
.isInvalid()) {
202 // If the result was valid, then we do want to diagnose this. Use
203 // ExpectAndConsume to emit the diagnostic, even though we know it won't
205 ExpectAndConsume(tok::semi
, diag::err_expected_semi_after_stmt
, SemiError
);
206 // Skip until we see a } or ;, but don't eat it.
207 SkipUntil(tok::r_brace
, true, true);
213 /// ParseLabeledStatement - We have an identifier and a ':' after it.
215 /// labeled-statement:
216 /// identifier ':' statement
217 /// [GNU] identifier ':' attributes[opt] statement
219 StmtResult
Parser::ParseLabeledStatement(ParsedAttributes
&attrs
) {
220 assert(Tok
.is(tok::identifier
) && Tok
.getIdentifierInfo() &&
221 "Not an identifier!");
223 Token IdentTok
= Tok
; // Save the whole token.
224 ConsumeToken(); // eat the identifier.
226 assert(Tok
.is(tok::colon
) && "Not a label!");
228 // identifier ':' statement
229 SourceLocation ColonLoc
= ConsumeToken();
231 // Read label attributes, if present.
232 MaybeParseGNUAttributes(attrs
);
234 StmtResult
SubStmt(ParseStatement());
236 // Broken substmt shouldn't prevent the label from being added to the AST.
237 if (SubStmt
.isInvalid())
238 SubStmt
= Actions
.ActOnNullStmt(ColonLoc
);
240 LabelDecl
*LD
= Actions
.LookupOrCreateLabel(IdentTok
.getIdentifierInfo(),
241 IdentTok
.getLocation());
242 if (AttributeList
*Attrs
= attrs
.getList())
243 Actions
.ProcessDeclAttributeList(Actions
.CurScope
, LD
, Attrs
);
245 return Actions
.ActOnLabelStmt(IdentTok
.getLocation(), LD
, ColonLoc
,
249 /// ParseCaseStatement
250 /// labeled-statement:
251 /// 'case' constant-expression ':' statement
252 /// [GNU] 'case' constant-expression '...' constant-expression ':' statement
254 StmtResult
Parser::ParseCaseStatement(ParsedAttributes
&attrs
) {
255 assert(Tok
.is(tok::kw_case
) && "Not a case stmt!");
256 // FIXME: Use attributes?
258 // It is very very common for code to contain many case statements recursively
259 // nested, as in (but usually without indentation):
266 // Parsing this naively works, but is both inefficient and can cause us to run
267 // out of stack space in our recursive descent parser. As a special case,
268 // flatten this recursion into an iterative loop. This is complex and gross,
269 // but all the grossness is constrained to ParseCaseStatement (and some
270 // wierdness in the actions), so this is just local grossness :).
272 // TopLevelCase - This is the highest level we have parsed. 'case 1' in the
274 StmtResult
TopLevelCase(true);
276 // DeepestParsedCaseStmt - This is the deepest statement we have parsed, which
277 // gets updated each time a new case is parsed, and whose body is unset so
278 // far. When parsing 'case 4', this is the 'case 3' node.
279 StmtTy
*DeepestParsedCaseStmt
= 0;
281 // While we have case statements, eat and stack them.
283 SourceLocation CaseLoc
= ConsumeToken(); // eat the 'case'.
285 if (Tok
.is(tok::code_completion
)) {
286 Actions
.CodeCompleteCase(getCurScope());
287 ConsumeCodeCompletionToken();
290 /// We don't want to treat 'case x : y' as a potential typo for 'case x::y'.
291 /// Disable this form of error recovery while we're parsing the case
293 ColonProtectionRAIIObject
ColonProtection(*this);
295 ExprResult
LHS(ParseConstantExpression());
296 if (LHS
.isInvalid()) {
297 SkipUntil(tok::colon
);
301 // GNU case range extension.
302 SourceLocation DotDotDotLoc
;
304 if (Tok
.is(tok::ellipsis
)) {
305 Diag(Tok
, diag::ext_gnu_case_range
);
306 DotDotDotLoc
= ConsumeToken();
308 RHS
= ParseConstantExpression();
309 if (RHS
.isInvalid()) {
310 SkipUntil(tok::colon
);
315 ColonProtection
.restore();
317 SourceLocation ColonLoc
;
318 if (Tok
.is(tok::colon
)) {
319 ColonLoc
= ConsumeToken();
321 // Treat "case blah;" as a typo for "case blah:".
322 } else if (Tok
.is(tok::semi
)) {
323 ColonLoc
= ConsumeToken();
324 Diag(ColonLoc
, diag::err_expected_colon_after
) << "'case'"
325 << FixItHint::CreateReplacement(ColonLoc
, ":");
327 SourceLocation ExpectedLoc
= PP
.getLocForEndOfToken(PrevTokLocation
);
328 Diag(ExpectedLoc
, diag::err_expected_colon_after
) << "'case'"
329 << FixItHint::CreateInsertion(ExpectedLoc
, ":");
330 ColonLoc
= ExpectedLoc
;
334 Actions
.ActOnCaseStmt(CaseLoc
, LHS
.get(), DotDotDotLoc
,
335 RHS
.get(), ColonLoc
);
337 // If we had a sema error parsing this case, then just ignore it and
338 // continue parsing the sub-stmt.
339 if (Case
.isInvalid()) {
340 if (TopLevelCase
.isInvalid()) // No parsed case stmts.
341 return ParseStatement();
342 // Otherwise, just don't add it as a nested case.
344 // If this is the first case statement we parsed, it becomes TopLevelCase.
345 // Otherwise we link it into the current chain.
346 Stmt
*NextDeepest
= Case
.get();
347 if (TopLevelCase
.isInvalid())
348 TopLevelCase
= move(Case
);
350 Actions
.ActOnCaseStmtBody(DeepestParsedCaseStmt
, Case
.get());
351 DeepestParsedCaseStmt
= NextDeepest
;
354 // Handle all case statements.
355 } while (Tok
.is(tok::kw_case
));
357 assert(!TopLevelCase
.isInvalid() && "Should have parsed at least one case!");
359 // If we found a non-case statement, start by parsing it.
362 if (Tok
.isNot(tok::r_brace
)) {
363 SubStmt
= ParseStatement();
365 // Nicely diagnose the common error "switch (X) { case 4: }", which is
367 // FIXME: add insertion hint.
368 Diag(Tok
, diag::err_label_end_of_compound_statement
);
372 // Broken sub-stmt shouldn't prevent forming the case statement properly.
373 if (SubStmt
.isInvalid())
374 SubStmt
= Actions
.ActOnNullStmt(SourceLocation());
376 // Install the body into the most deeply-nested case.
377 Actions
.ActOnCaseStmtBody(DeepestParsedCaseStmt
, SubStmt
.get());
379 // Return the top level parsed statement tree.
380 return move(TopLevelCase
);
383 /// ParseDefaultStatement
384 /// labeled-statement:
385 /// 'default' ':' statement
386 /// Note that this does not parse the 'statement' at the end.
388 StmtResult
Parser::ParseDefaultStatement(ParsedAttributes
&attrs
) {
389 //FIXME: Use attributes?
391 assert(Tok
.is(tok::kw_default
) && "Not a default stmt!");
392 SourceLocation DefaultLoc
= ConsumeToken(); // eat the 'default'.
394 SourceLocation ColonLoc
;
395 if (Tok
.is(tok::colon
)) {
396 ColonLoc
= ConsumeToken();
398 // Treat "default;" as a typo for "default:".
399 } else if (Tok
.is(tok::semi
)) {
400 ColonLoc
= ConsumeToken();
401 Diag(ColonLoc
, diag::err_expected_colon_after
) << "'default'"
402 << FixItHint::CreateReplacement(ColonLoc
, ":");
404 SourceLocation ExpectedLoc
= PP
.getLocForEndOfToken(PrevTokLocation
);
405 Diag(ExpectedLoc
, diag::err_expected_colon_after
) << "'default'"
406 << FixItHint::CreateInsertion(ExpectedLoc
, ":");
407 ColonLoc
= ExpectedLoc
;
410 // Diagnose the common error "switch (X) {... default: }", which is not valid.
411 if (Tok
.is(tok::r_brace
)) {
412 Diag(Tok
, diag::err_label_end_of_compound_statement
);
416 StmtResult
SubStmt(ParseStatement());
417 if (SubStmt
.isInvalid())
420 return Actions
.ActOnDefaultStmt(DefaultLoc
, ColonLoc
,
421 SubStmt
.get(), getCurScope());
425 /// ParseCompoundStatement - Parse a "{}" block.
427 /// compound-statement: [C99 6.8.2]
428 /// { block-item-list[opt] }
429 /// [GNU] { label-declarations block-item-list } [TODO]
433 /// block-item-list block-item
437 /// [GNU] '__extension__' declaration
439 /// [OMP] openmp-directive [TODO]
441 /// [GNU] label-declarations:
442 /// [GNU] label-declaration
443 /// [GNU] label-declarations label-declaration
445 /// [GNU] label-declaration:
446 /// [GNU] '__label__' identifier-list ';'
448 /// [OMP] openmp-directive: [TODO]
449 /// [OMP] barrier-directive
450 /// [OMP] flush-directive
452 StmtResult
Parser::ParseCompoundStatement(ParsedAttributes
&attrs
,
454 //FIXME: Use attributes?
456 assert(Tok
.is(tok::l_brace
) && "Not a compount stmt!");
458 // Enter a scope to hold everything within the compound stmt. Compound
459 // statements can always hold declarations.
460 ParseScope
CompoundScope(this, Scope::DeclScope
);
462 // Parse the statements in the body.
463 return ParseCompoundStatementBody(isStmtExpr
);
467 /// ParseCompoundStatementBody - Parse a sequence of statements and invoke the
468 /// ActOnCompoundStmt action. This expects the '{' to be the current token, and
469 /// consume the '}' at the end of the block. It does not manipulate the scope
471 StmtResult
Parser::ParseCompoundStatementBody(bool isStmtExpr
) {
472 PrettyStackTraceLoc
CrashInfo(PP
.getSourceManager(),
474 "in compound statement ('{}')");
475 InMessageExpressionRAIIObject
InMessage(*this, false);
477 SourceLocation LBraceLoc
= ConsumeBrace(); // eat the '{'.
479 StmtVector
Stmts(Actions
);
481 // "__label__ X, Y, Z;" is the GNU "Local Label" extension. These are
482 // only allowed at the start of a compound stmt regardless of the language.
483 while (Tok
.is(tok::kw___label__
)) {
484 SourceLocation LabelLoc
= ConsumeToken();
485 Diag(LabelLoc
, diag::ext_gnu_local_label
);
487 llvm::SmallVector
<Decl
*, 8> DeclsInGroup
;
489 if (Tok
.isNot(tok::identifier
)) {
490 Diag(Tok
, diag::err_expected_ident
);
494 IdentifierInfo
*II
= Tok
.getIdentifierInfo();
495 SourceLocation IdLoc
= ConsumeToken();
496 DeclsInGroup
.push_back(Actions
.LookupOrCreateLabel(II
, IdLoc
, true));
498 if (!Tok
.is(tok::comma
))
504 DeclGroupPtrTy Res
= Actions
.FinalizeDeclaratorGroup(getCurScope(), DS
,
505 DeclsInGroup
.data(), DeclsInGroup
.size());
506 StmtResult R
= Actions
.ActOnDeclStmt(Res
, LabelLoc
, Tok
.getLocation());
508 ExpectAndConsume(tok::semi
, diag::err_expected_semi_declaration
);
510 Stmts
.push_back(R
.release());
513 while (Tok
.isNot(tok::r_brace
) && Tok
.isNot(tok::eof
)) {
514 if (Tok
.is(tok::annot_pragma_unused
)) {
515 HandlePragmaUnused();
520 if (Tok
.isNot(tok::kw___extension__
)) {
521 R
= ParseStatementOrDeclaration(Stmts
, false);
523 // __extension__ can start declarations and it can also be a unary
524 // operator for expressions. Consume multiple __extension__ markers here
525 // until we can determine which is which.
526 // FIXME: This loses extension expressions in the AST!
527 SourceLocation ExtLoc
= ConsumeToken();
528 while (Tok
.is(tok::kw___extension__
))
531 ParsedAttributesWithRange attrs
;
532 MaybeParseCXX0XAttributes(attrs
);
534 // If this is the start of a declaration, parse it as such.
535 if (isDeclarationStatement()) {
536 // __extension__ silences extension warnings in the subdeclaration.
537 // FIXME: Save the __extension__ on the decl as a node somehow?
538 ExtensionRAIIObject
O(Diags
);
540 SourceLocation DeclStart
= Tok
.getLocation(), DeclEnd
;
541 DeclGroupPtrTy Res
= ParseDeclaration(Stmts
,
542 Declarator::BlockContext
, DeclEnd
,
544 R
= Actions
.ActOnDeclStmt(Res
, DeclStart
, DeclEnd
);
546 // Otherwise this was a unary __extension__ marker.
547 ExprResult
Res(ParseExpressionWithLeadingExtension(ExtLoc
));
549 if (Res
.isInvalid()) {
550 SkipUntil(tok::semi
);
554 // FIXME: Use attributes?
555 // Eat the semicolon at the end of stmt and convert the expr into a
557 ExpectAndConsumeSemi(diag::err_expected_semi_after_expr
);
558 R
= Actions
.ActOnExprStmt(Actions
.MakeFullExpr(Res
.get()));
563 Stmts
.push_back(R
.release());
566 // We broke out of the while loop because we found a '}' or EOF.
567 if (Tok
.isNot(tok::r_brace
)) {
568 Diag(Tok
, diag::err_expected_rbrace
);
569 Diag(LBraceLoc
, diag::note_matching
) << "{";
573 SourceLocation RBraceLoc
= ConsumeBrace();
574 return Actions
.ActOnCompoundStmt(LBraceLoc
, RBraceLoc
, move_arg(Stmts
),
578 /// ParseParenExprOrCondition:
579 /// [C ] '(' expression ')'
580 /// [C++] '(' condition ')' [not allowed if OnlyAllowCondition=true]
582 /// This function parses and performs error recovery on the specified condition
583 /// or expression (depending on whether we're in C++ or C mode). This function
584 /// goes out of its way to recover well. It returns true if there was a parser
585 /// error (the right paren couldn't be found), which indicates that the caller
586 /// should try to recover harder. It returns false if the condition is
587 /// successfully parsed. Note that a successful parse can still have semantic
588 /// errors in the condition.
589 bool Parser::ParseParenExprOrCondition(ExprResult
&ExprResult
,
592 bool ConvertToBoolean
) {
593 SourceLocation LParenLoc
= ConsumeParen();
594 if (getLang().CPlusPlus
)
595 ParseCXXCondition(ExprResult
, DeclResult
, Loc
, ConvertToBoolean
);
597 ExprResult
= ParseExpression();
600 // If required, convert to a boolean value.
601 if (!ExprResult
.isInvalid() && ConvertToBoolean
)
603 = Actions
.ActOnBooleanCondition(getCurScope(), Loc
, ExprResult
.get());
606 // If the parser was confused by the condition and we don't have a ')', try to
607 // recover by skipping ahead to a semi and bailing out. If condexp is
608 // semantically invalid but we have well formed code, keep going.
609 if (ExprResult
.isInvalid() && !DeclResult
&& Tok
.isNot(tok::r_paren
)) {
610 SkipUntil(tok::semi
);
611 // Skipping may have stopped if it found the containing ')'. If so, we can
612 // continue parsing the if statement.
613 if (Tok
.isNot(tok::r_paren
))
617 // Otherwise the condition is valid or the rparen is present.
618 MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
624 /// if-statement: [C99 6.8.4.1]
625 /// 'if' '(' expression ')' statement
626 /// 'if' '(' expression ')' statement 'else' statement
627 /// [C++] 'if' '(' condition ')' statement
628 /// [C++] 'if' '(' condition ')' statement 'else' statement
630 StmtResult
Parser::ParseIfStatement(ParsedAttributes
&attrs
) {
631 // FIXME: Use attributes?
633 assert(Tok
.is(tok::kw_if
) && "Not an if stmt!");
634 SourceLocation IfLoc
= ConsumeToken(); // eat the 'if'.
636 if (Tok
.isNot(tok::l_paren
)) {
637 Diag(Tok
, diag::err_expected_lparen_after
) << "if";
638 SkipUntil(tok::semi
);
642 bool C99orCXX
= getLang().C99
|| getLang().CPlusPlus
;
644 // C99 6.8.4p3 - In C99, the if statement is a block. This is not
648 // A name introduced by a declaration in a condition is in scope from its
649 // point of declaration until the end of the substatements controlled by the
652 // Names declared in the for-init-statement, and in the condition of if,
653 // while, for, and switch statements are local to the if, while, for, or
654 // switch statement (including the controlled statement).
656 ParseScope
IfScope(this, Scope::DeclScope
| Scope::ControlScope
, C99orCXX
);
658 // Parse the condition.
661 if (ParseParenExprOrCondition(CondExp
, CondVar
, IfLoc
, true))
664 FullExprArg
FullCondExp(Actions
.MakeFullExpr(CondExp
.get()));
666 // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
667 // there is no compound stmt. C90 does not have this clause. We only do this
668 // if the body isn't a compound statement to avoid push/pop in common cases.
671 // The substatement in a selection-statement (each substatement, in the else
672 // form of the if statement) implicitly defines a local scope.
674 // For C++ we create a scope for the condition and a new scope for
675 // substatements because:
676 // -When the 'then' scope exits, we want the condition declaration to still be
677 // active for the 'else' scope too.
678 // -Sema will detect name clashes by considering declarations of a
679 // 'ControlScope' as part of its direct subscope.
680 // -If we wanted the condition and substatement to be in the same scope, we
681 // would have to notify ParseStatement not to create a new scope. It's
682 // simpler to let it create a new scope.
684 ParseScope
InnerScope(this, Scope::DeclScope
,
685 C99orCXX
&& Tok
.isNot(tok::l_brace
));
687 // Read the 'then' stmt.
688 SourceLocation ThenStmtLoc
= Tok
.getLocation();
689 StmtResult
ThenStmt(ParseStatement());
691 // Pop the 'if' scope if needed.
694 // If it has an else, parse it.
695 SourceLocation ElseLoc
;
696 SourceLocation ElseStmtLoc
;
699 if (Tok
.is(tok::kw_else
)) {
700 ElseLoc
= ConsumeToken();
701 ElseStmtLoc
= Tok
.getLocation();
703 // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
704 // there is no compound stmt. C90 does not have this clause. We only do
705 // this if the body isn't a compound statement to avoid push/pop in common
709 // The substatement in a selection-statement (each substatement, in the else
710 // form of the if statement) implicitly defines a local scope.
712 ParseScope
InnerScope(this, Scope::DeclScope
,
713 C99orCXX
&& Tok
.isNot(tok::l_brace
));
715 ElseStmt
= ParseStatement();
717 // Pop the 'else' scope if needed.
723 // If the condition was invalid, discard the if statement. We could recover
724 // better by replacing it with a valid expr, but don't do that yet.
725 if (CondExp
.isInvalid() && !CondVar
)
728 // If the then or else stmt is invalid and the other is valid (and present),
729 // make turn the invalid one into a null stmt to avoid dropping the other
730 // part. If both are invalid, return error.
731 if ((ThenStmt
.isInvalid() && ElseStmt
.isInvalid()) ||
732 (ThenStmt
.isInvalid() && ElseStmt
.get() == 0) ||
733 (ThenStmt
.get() == 0 && ElseStmt
.isInvalid())) {
734 // Both invalid, or one is invalid and other is non-present: return error.
738 // Now if either are invalid, replace with a ';'.
739 if (ThenStmt
.isInvalid())
740 ThenStmt
= Actions
.ActOnNullStmt(ThenStmtLoc
);
741 if (ElseStmt
.isInvalid())
742 ElseStmt
= Actions
.ActOnNullStmt(ElseStmtLoc
);
744 return Actions
.ActOnIfStmt(IfLoc
, FullCondExp
, CondVar
, ThenStmt
.get(),
745 ElseLoc
, ElseStmt
.get());
748 /// ParseSwitchStatement
749 /// switch-statement:
750 /// 'switch' '(' expression ')' statement
751 /// [C++] 'switch' '(' condition ')' statement
752 StmtResult
Parser::ParseSwitchStatement(ParsedAttributes
&attrs
) {
753 // FIXME: Use attributes?
755 assert(Tok
.is(tok::kw_switch
) && "Not a switch stmt!");
756 SourceLocation SwitchLoc
= ConsumeToken(); // eat the 'switch'.
758 if (Tok
.isNot(tok::l_paren
)) {
759 Diag(Tok
, diag::err_expected_lparen_after
) << "switch";
760 SkipUntil(tok::semi
);
764 bool C99orCXX
= getLang().C99
|| getLang().CPlusPlus
;
766 // C99 6.8.4p3 - In C99, the switch statement is a block. This is
767 // not the case for C90. Start the switch scope.
770 // A name introduced by a declaration in a condition is in scope from its
771 // point of declaration until the end of the substatements controlled by the
774 // Names declared in the for-init-statement, and in the condition of if,
775 // while, for, and switch statements are local to the if, while, for, or
776 // switch statement (including the controlled statement).
778 unsigned ScopeFlags
= Scope::BreakScope
;
780 ScopeFlags
|= Scope::DeclScope
| Scope::ControlScope
;
781 ParseScope
SwitchScope(this, ScopeFlags
);
783 // Parse the condition.
786 if (ParseParenExprOrCondition(Cond
, CondVar
, SwitchLoc
, false))
790 = Actions
.ActOnStartOfSwitchStmt(SwitchLoc
, Cond
.get(), CondVar
);
792 if (Switch
.isInvalid()) {
793 // Skip the switch body.
794 // FIXME: This is not optimal recovery, but parsing the body is more
795 // dangerous due to the presence of case and default statements, which
796 // will have no place to connect back with the switch.
797 if (Tok
.is(tok::l_brace
)) {
799 SkipUntil(tok::r_brace
, false, false);
801 SkipUntil(tok::semi
);
805 // C99 6.8.4p3 - In C99, the body of the switch statement is a scope, even if
806 // there is no compound stmt. C90 does not have this clause. We only do this
807 // if the body isn't a compound statement to avoid push/pop in common cases.
810 // The substatement in a selection-statement (each substatement, in the else
811 // form of the if statement) implicitly defines a local scope.
813 // See comments in ParseIfStatement for why we create a scope for the
814 // condition and a new scope for substatement in C++.
816 ParseScope
InnerScope(this, Scope::DeclScope
,
817 C99orCXX
&& Tok
.isNot(tok::l_brace
));
819 // Read the body statement.
820 StmtResult
Body(ParseStatement());
826 if (Body
.isInvalid())
827 // FIXME: Remove the case statement list from the Switch statement.
828 Body
= Actions
.ActOnNullStmt(Tok
.getLocation());
830 return Actions
.ActOnFinishSwitchStmt(SwitchLoc
, Switch
.get(), Body
.get());
833 /// ParseWhileStatement
834 /// while-statement: [C99 6.8.5.1]
835 /// 'while' '(' expression ')' statement
836 /// [C++] 'while' '(' condition ')' statement
837 StmtResult
Parser::ParseWhileStatement(ParsedAttributes
&attrs
) {
838 // FIXME: Use attributes?
840 assert(Tok
.is(tok::kw_while
) && "Not a while stmt!");
841 SourceLocation WhileLoc
= Tok
.getLocation();
842 ConsumeToken(); // eat the 'while'.
844 if (Tok
.isNot(tok::l_paren
)) {
845 Diag(Tok
, diag::err_expected_lparen_after
) << "while";
846 SkipUntil(tok::semi
);
850 bool C99orCXX
= getLang().C99
|| getLang().CPlusPlus
;
852 // C99 6.8.5p5 - In C99, the while statement is a block. This is not
853 // the case for C90. Start the loop scope.
856 // A name introduced by a declaration in a condition is in scope from its
857 // point of declaration until the end of the substatements controlled by the
860 // Names declared in the for-init-statement, and in the condition of if,
861 // while, for, and switch statements are local to the if, while, for, or
862 // switch statement (including the controlled statement).
866 ScopeFlags
= Scope::BreakScope
| Scope::ContinueScope
|
867 Scope::DeclScope
| Scope::ControlScope
;
869 ScopeFlags
= Scope::BreakScope
| Scope::ContinueScope
;
870 ParseScope
WhileScope(this, ScopeFlags
);
872 // Parse the condition.
875 if (ParseParenExprOrCondition(Cond
, CondVar
, WhileLoc
, true))
878 FullExprArg
FullCond(Actions
.MakeFullExpr(Cond
.get()));
880 // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if
881 // there is no compound stmt. C90 does not have this clause. We only do this
882 // if the body isn't a compound statement to avoid push/pop in common cases.
885 // The substatement in an iteration-statement implicitly defines a local scope
886 // which is entered and exited each time through the loop.
888 // See comments in ParseIfStatement for why we create a scope for the
889 // condition and a new scope for substatement in C++.
891 ParseScope
InnerScope(this, Scope::DeclScope
,
892 C99orCXX
&& Tok
.isNot(tok::l_brace
));
894 // Read the body statement.
895 StmtResult
Body(ParseStatement());
897 // Pop the body scope if needed.
901 if ((Cond
.isInvalid() && !CondVar
) || Body
.isInvalid())
904 return Actions
.ActOnWhileStmt(WhileLoc
, FullCond
, CondVar
, Body
.get());
908 /// do-statement: [C99 6.8.5.2]
909 /// 'do' statement 'while' '(' expression ')' ';'
910 /// Note: this lets the caller parse the end ';'.
911 StmtResult
Parser::ParseDoStatement(ParsedAttributes
&attrs
) {
912 // FIXME: Use attributes?
914 assert(Tok
.is(tok::kw_do
) && "Not a do stmt!");
915 SourceLocation DoLoc
= ConsumeToken(); // eat the 'do'.
917 // C99 6.8.5p5 - In C99, the do statement is a block. This is not
918 // the case for C90. Start the loop scope.
921 ScopeFlags
= Scope::BreakScope
| Scope::ContinueScope
| Scope::DeclScope
;
923 ScopeFlags
= Scope::BreakScope
| Scope::ContinueScope
;
925 ParseScope
DoScope(this, ScopeFlags
);
927 // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if
928 // there is no compound stmt. C90 does not have this clause. We only do this
929 // if the body isn't a compound statement to avoid push/pop in common cases.
932 // The substatement in an iteration-statement implicitly defines a local scope
933 // which is entered and exited each time through the loop.
935 ParseScope
InnerScope(this, Scope::DeclScope
,
936 (getLang().C99
|| getLang().CPlusPlus
) &&
937 Tok
.isNot(tok::l_brace
));
939 // Read the body statement.
940 StmtResult
Body(ParseStatement());
942 // Pop the body scope if needed.
945 if (Tok
.isNot(tok::kw_while
)) {
946 if (!Body
.isInvalid()) {
947 Diag(Tok
, diag::err_expected_while
);
948 Diag(DoLoc
, diag::note_matching
) << "do";
949 SkipUntil(tok::semi
, false, true);
953 SourceLocation WhileLoc
= ConsumeToken();
955 if (Tok
.isNot(tok::l_paren
)) {
956 Diag(Tok
, diag::err_expected_lparen_after
) << "do/while";
957 SkipUntil(tok::semi
, false, true);
961 // Parse the parenthesized condition.
962 SourceLocation LPLoc
= ConsumeParen();
963 ExprResult Cond
= ParseExpression();
964 SourceLocation RPLoc
= MatchRHSPunctuation(tok::r_paren
, LPLoc
);
967 if (Cond
.isInvalid() || Body
.isInvalid())
970 return Actions
.ActOnDoStmt(DoLoc
, Body
.get(), WhileLoc
, LPLoc
,
974 /// ParseForStatement
975 /// for-statement: [C99 6.8.5.3]
976 /// 'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
977 /// 'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
978 /// [C++] 'for' '(' for-init-statement condition[opt] ';' expression[opt] ')'
980 /// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
981 /// [OBJC2] 'for' '(' expr 'in' expr ')' statement
983 /// [C++] for-init-statement:
984 /// [C++] expression-statement
985 /// [C++] simple-declaration
987 StmtResult
Parser::ParseForStatement(ParsedAttributes
&attrs
) {
988 // FIXME: Use attributes?
990 assert(Tok
.is(tok::kw_for
) && "Not a for stmt!");
991 SourceLocation ForLoc
= ConsumeToken(); // eat the 'for'.
993 if (Tok
.isNot(tok::l_paren
)) {
994 Diag(Tok
, diag::err_expected_lparen_after
) << "for";
995 SkipUntil(tok::semi
);
999 bool C99orCXXorObjC
= getLang().C99
|| getLang().CPlusPlus
|| getLang().ObjC1
;
1001 // C99 6.8.5p5 - In C99, the for statement is a block. This is not
1002 // the case for C90. Start the loop scope.
1005 // A name introduced by a declaration in a condition is in scope from its
1006 // point of declaration until the end of the substatements controlled by the
1009 // Names declared in the for-init-statement, and in the condition of if,
1010 // while, for, and switch statements are local to the if, while, for, or
1011 // switch statement (including the controlled statement).
1013 // Names declared in the for-init-statement are in the same declarative-region
1014 // as those declared in the condition.
1016 unsigned ScopeFlags
;
1018 ScopeFlags
= Scope::BreakScope
| Scope::ContinueScope
|
1019 Scope::DeclScope
| Scope::ControlScope
;
1021 ScopeFlags
= Scope::BreakScope
| Scope::ContinueScope
;
1023 ParseScope
ForScope(this, ScopeFlags
);
1025 SourceLocation LParenLoc
= ConsumeParen();
1028 bool ForEach
= false;
1029 StmtResult FirstPart
;
1030 bool SecondPartIsInvalid
= false;
1031 FullExprArg
SecondPart(Actions
);
1032 ExprResult Collection
;
1033 FullExprArg
ThirdPart(Actions
);
1034 Decl
*SecondVar
= 0;
1036 if (Tok
.is(tok::code_completion
)) {
1037 Actions
.CodeCompleteOrdinaryName(getCurScope(),
1038 C99orCXXorObjC
? Sema::PCC_ForInit
1039 : Sema::PCC_Expression
);
1040 ConsumeCodeCompletionToken();
1043 // Parse the first part of the for specifier.
1044 if (Tok
.is(tok::semi
)) { // for (;
1045 // no first part, eat the ';'.
1047 } else if (isSimpleDeclaration()) { // for (int X = 4;
1048 // Parse declaration, which eats the ';'.
1049 if (!C99orCXXorObjC
) // Use of C99-style for loops in C90 mode?
1050 Diag(Tok
, diag::ext_c99_variable_decl_in_for_loop
);
1052 ParsedAttributesWithRange attrs
;
1053 MaybeParseCXX0XAttributes(attrs
);
1055 SourceLocation DeclStart
= Tok
.getLocation(), DeclEnd
;
1056 StmtVector
Stmts(Actions
);
1057 DeclGroupPtrTy DG
= ParseSimpleDeclaration(Stmts
, Declarator::ForContext
,
1058 DeclEnd
, attrs
, false);
1059 FirstPart
= Actions
.ActOnDeclStmt(DG
, DeclStart
, Tok
.getLocation());
1061 if (Tok
.is(tok::semi
)) { // for (int x = 4;
1063 } else if ((ForEach
= isTokIdentifier_in())) {
1064 Actions
.ActOnForEachDeclStmt(DG
);
1065 // ObjC: for (id x in expr)
1066 ConsumeToken(); // consume 'in'
1068 if (Tok
.is(tok::code_completion
)) {
1069 Actions
.CodeCompleteObjCForCollection(getCurScope(), DG
);
1070 ConsumeCodeCompletionToken();
1072 Collection
= ParseExpression();
1074 Diag(Tok
, diag::err_expected_semi_for
);
1077 Value
= ParseExpression();
1079 ForEach
= isTokIdentifier_in();
1081 // Turn the expression into a stmt.
1082 if (!Value
.isInvalid()) {
1084 FirstPart
= Actions
.ActOnForEachLValueExpr(Value
.get());
1086 FirstPart
= Actions
.ActOnExprStmt(Actions
.MakeFullExpr(Value
.get()));
1089 if (Tok
.is(tok::semi
)) {
1091 } else if (ForEach
) {
1092 ConsumeToken(); // consume 'in'
1094 if (Tok
.is(tok::code_completion
)) {
1095 Actions
.CodeCompleteObjCForCollection(getCurScope(), DeclGroupPtrTy());
1096 ConsumeCodeCompletionToken();
1098 Collection
= ParseExpression();
1100 if (!Value
.isInvalid()) {
1101 Diag(Tok
, diag::err_expected_semi_for
);
1103 // Skip until semicolon or rparen, don't consume it.
1104 SkipUntil(tok::r_paren
, true, true);
1105 if (Tok
.is(tok::semi
))
1111 assert(!SecondPart
.get() && "Shouldn't have a second expression yet.");
1112 // Parse the second part of the for specifier.
1113 if (Tok
.is(tok::semi
)) { // for (...;;
1115 } else if (Tok
.is(tok::r_paren
)) {
1116 // missing both semicolons.
1119 if (getLang().CPlusPlus
)
1120 ParseCXXCondition(Second
, SecondVar
, ForLoc
, true);
1122 Second
= ParseExpression();
1123 if (!Second
.isInvalid())
1124 Second
= Actions
.ActOnBooleanCondition(getCurScope(), ForLoc
,
1127 SecondPartIsInvalid
= Second
.isInvalid();
1128 SecondPart
= Actions
.MakeFullExpr(Second
.get());
1131 if (Tok
.isNot(tok::semi
)) {
1132 if (!SecondPartIsInvalid
|| SecondVar
)
1133 Diag(Tok
, diag::err_expected_semi_for
);
1135 // Skip until semicolon or rparen, don't consume it.
1136 SkipUntil(tok::r_paren
, true, true);
1139 if (Tok
.is(tok::semi
)) {
1143 // Parse the third part of the for specifier.
1144 if (Tok
.isNot(tok::r_paren
)) { // for (...;...;)
1145 ExprResult Third
= ParseExpression();
1146 ThirdPart
= Actions
.MakeFullExpr(Third
.take());
1150 SourceLocation RParenLoc
= MatchRHSPunctuation(tok::r_paren
, LParenLoc
);
1152 // C99 6.8.5p5 - In C99, the body of the if statement is a scope, even if
1153 // there is no compound stmt. C90 does not have this clause. We only do this
1154 // if the body isn't a compound statement to avoid push/pop in common cases.
1157 // The substatement in an iteration-statement implicitly defines a local scope
1158 // which is entered and exited each time through the loop.
1160 // See comments in ParseIfStatement for why we create a scope for
1161 // for-init-statement/condition and a new scope for substatement in C++.
1163 ParseScope
InnerScope(this, Scope::DeclScope
,
1164 C99orCXXorObjC
&& Tok
.isNot(tok::l_brace
));
1166 // Read the body statement.
1167 StmtResult
Body(ParseStatement());
1169 // Pop the body scope if needed.
1172 // Leave the for-scope.
1175 if (Body
.isInvalid())
1179 return Actions
.ActOnForStmt(ForLoc
, LParenLoc
, FirstPart
.take(), SecondPart
,
1180 SecondVar
, ThirdPart
, RParenLoc
, Body
.take());
1182 // FIXME: It isn't clear how to communicate the late destruction of
1183 // C++ temporaries used to create the collection.
1184 return Actions
.ActOnObjCForCollectionStmt(ForLoc
, LParenLoc
, FirstPart
.take(),
1185 Collection
.take(), RParenLoc
,
1189 /// ParseGotoStatement
1191 /// 'goto' identifier ';'
1192 /// [GNU] 'goto' '*' expression ';'
1194 /// Note: this lets the caller parse the end ';'.
1196 StmtResult
Parser::ParseGotoStatement(ParsedAttributes
&attrs
) {
1197 // FIXME: Use attributes?
1199 assert(Tok
.is(tok::kw_goto
) && "Not a goto stmt!");
1200 SourceLocation GotoLoc
= ConsumeToken(); // eat the 'goto'.
1203 if (Tok
.is(tok::identifier
)) {
1204 LabelDecl
*LD
= Actions
.LookupOrCreateLabel(Tok
.getIdentifierInfo(),
1206 Res
= Actions
.ActOnGotoStmt(GotoLoc
, Tok
.getLocation(), LD
);
1208 } else if (Tok
.is(tok::star
)) {
1209 // GNU indirect goto extension.
1210 Diag(Tok
, diag::ext_gnu_indirect_goto
);
1211 SourceLocation StarLoc
= ConsumeToken();
1212 ExprResult
R(ParseExpression());
1213 if (R
.isInvalid()) { // Skip to the semicolon, but don't consume it.
1214 SkipUntil(tok::semi
, false, true);
1217 Res
= Actions
.ActOnIndirectGotoStmt(GotoLoc
, StarLoc
, R
.take());
1219 Diag(Tok
, diag::err_expected_ident
);
1226 /// ParseContinueStatement
1230 /// Note: this lets the caller parse the end ';'.
1232 StmtResult
Parser::ParseContinueStatement(ParsedAttributes
&attrs
) {
1233 // FIXME: Use attributes?
1235 SourceLocation ContinueLoc
= ConsumeToken(); // eat the 'continue'.
1236 return Actions
.ActOnContinueStmt(ContinueLoc
, getCurScope());
1239 /// ParseBreakStatement
1243 /// Note: this lets the caller parse the end ';'.
1245 StmtResult
Parser::ParseBreakStatement(ParsedAttributes
&attrs
) {
1246 // FIXME: Use attributes?
1248 SourceLocation BreakLoc
= ConsumeToken(); // eat the 'break'.
1249 return Actions
.ActOnBreakStmt(BreakLoc
, getCurScope());
1252 /// ParseReturnStatement
1254 /// 'return' expression[opt] ';'
1255 StmtResult
Parser::ParseReturnStatement(ParsedAttributes
&attrs
) {
1256 // FIXME: Use attributes?
1258 assert(Tok
.is(tok::kw_return
) && "Not a return stmt!");
1259 SourceLocation ReturnLoc
= ConsumeToken(); // eat the 'return'.
1262 if (Tok
.isNot(tok::semi
)) {
1263 if (Tok
.is(tok::code_completion
)) {
1264 Actions
.CodeCompleteReturn(getCurScope());
1265 ConsumeCodeCompletionToken();
1266 SkipUntil(tok::semi
, false, true);
1270 R
= ParseExpression();
1271 if (R
.isInvalid()) { // Skip to the semicolon, but don't consume it.
1272 SkipUntil(tok::semi
, false, true);
1276 return Actions
.ActOnReturnStmt(ReturnLoc
, R
.take());
1279 /// FuzzyParseMicrosoftAsmStatement. When -fms-extensions is enabled, this
1280 /// routine is called to skip/ignore tokens that comprise the MS asm statement.
1281 StmtResult
Parser::FuzzyParseMicrosoftAsmStatement(SourceLocation AsmLoc
) {
1282 SourceLocation EndLoc
;
1283 if (Tok
.is(tok::l_brace
)) {
1284 unsigned short savedBraceCount
= BraceCount
;
1286 EndLoc
= Tok
.getLocation();
1288 } while (BraceCount
> savedBraceCount
&& Tok
.isNot(tok::eof
));
1290 // From the MS website: If used without braces, the __asm keyword means
1291 // that the rest of the line is an assembly-language statement.
1292 SourceManager
&SrcMgr
= PP
.getSourceManager();
1293 SourceLocation TokLoc
= Tok
.getLocation();
1294 unsigned LineNo
= SrcMgr
.getInstantiationLineNumber(TokLoc
);
1298 TokLoc
= Tok
.getLocation();
1299 } while ((SrcMgr
.getInstantiationLineNumber(TokLoc
) == LineNo
) &&
1300 Tok
.isNot(tok::r_brace
) && Tok
.isNot(tok::semi
) &&
1301 Tok
.isNot(tok::eof
));
1304 t
.setKind(tok::string_literal
);
1305 t
.setLiteralData("\"/*FIXME: not done*/\"");
1306 t
.clearFlag(Token::NeedsCleaning
);
1308 ExprResult
AsmString(Actions
.ActOnStringLiteral(&t
, 1));
1309 ExprVector
Constraints(Actions
);
1310 ExprVector
Exprs(Actions
);
1311 ExprVector
Clobbers(Actions
);
1312 return Actions
.ActOnAsmStmt(AsmLoc
, true, true, 0, 0, 0,
1313 move_arg(Constraints
), move_arg(Exprs
),
1314 AsmString
.take(), move_arg(Clobbers
),
1318 /// ParseAsmStatement - Parse a GNU extended asm statement.
1320 /// gnu-asm-statement
1321 /// ms-asm-statement
1323 /// [GNU] gnu-asm-statement:
1324 /// 'asm' type-qualifier[opt] '(' asm-argument ')' ';'
1326 /// [GNU] asm-argument:
1327 /// asm-string-literal
1328 /// asm-string-literal ':' asm-operands[opt]
1329 /// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
1330 /// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
1331 /// ':' asm-clobbers
1333 /// [GNU] asm-clobbers:
1334 /// asm-string-literal
1335 /// asm-clobbers ',' asm-string-literal
1337 /// [MS] ms-asm-statement:
1338 /// '__asm' assembly-instruction ';'[opt]
1339 /// '__asm' '{' assembly-instruction-list '}' ';'[opt]
1341 /// [MS] assembly-instruction-list:
1342 /// assembly-instruction ';'[opt]
1343 /// assembly-instruction-list ';' assembly-instruction ';'[opt]
1345 StmtResult
Parser::ParseAsmStatement(bool &msAsm
) {
1346 assert(Tok
.is(tok::kw_asm
) && "Not an asm stmt");
1347 SourceLocation AsmLoc
= ConsumeToken();
1349 if (getLang().Microsoft
&& Tok
.isNot(tok::l_paren
) && !isTypeQualifier()) {
1351 return FuzzyParseMicrosoftAsmStatement(AsmLoc
);
1354 SourceLocation Loc
= Tok
.getLocation();
1355 ParseTypeQualifierListOpt(DS
, true, false);
1357 // GNU asms accept, but warn, about type-qualifiers other than volatile.
1358 if (DS
.getTypeQualifiers() & DeclSpec::TQ_const
)
1359 Diag(Loc
, diag::w_asm_qualifier_ignored
) << "const";
1360 if (DS
.getTypeQualifiers() & DeclSpec::TQ_restrict
)
1361 Diag(Loc
, diag::w_asm_qualifier_ignored
) << "restrict";
1363 // Remember if this was a volatile asm.
1364 bool isVolatile
= DS
.getTypeQualifiers() & DeclSpec::TQ_volatile
;
1365 if (Tok
.isNot(tok::l_paren
)) {
1366 Diag(Tok
, diag::err_expected_lparen_after
) << "asm";
1367 SkipUntil(tok::r_paren
);
1370 Loc
= ConsumeParen();
1372 ExprResult
AsmString(ParseAsmStringLiteral());
1373 if (AsmString
.isInvalid())
1376 llvm::SmallVector
<IdentifierInfo
*, 4> Names
;
1377 ExprVector
Constraints(Actions
);
1378 ExprVector
Exprs(Actions
);
1379 ExprVector
Clobbers(Actions
);
1381 if (Tok
.is(tok::r_paren
)) {
1382 // We have a simple asm expression like 'asm("foo")'.
1383 SourceLocation RParenLoc
= ConsumeParen();
1384 return Actions
.ActOnAsmStmt(AsmLoc
, /*isSimple*/ true, isVolatile
,
1385 /*NumOutputs*/ 0, /*NumInputs*/ 0, 0,
1386 move_arg(Constraints
), move_arg(Exprs
),
1387 AsmString
.take(), move_arg(Clobbers
),
1391 // Parse Outputs, if present.
1392 bool AteExtraColon
= false;
1393 if (Tok
.is(tok::colon
) || Tok
.is(tok::coloncolon
)) {
1394 // In C++ mode, parse "::" like ": :".
1395 AteExtraColon
= Tok
.is(tok::coloncolon
);
1398 if (!AteExtraColon
&&
1399 ParseAsmOperandsOpt(Names
, Constraints
, Exprs
))
1403 unsigned NumOutputs
= Names
.size();
1405 // Parse Inputs, if present.
1406 if (AteExtraColon
||
1407 Tok
.is(tok::colon
) || Tok
.is(tok::coloncolon
)) {
1408 // In C++ mode, parse "::" like ": :".
1410 AteExtraColon
= false;
1412 AteExtraColon
= Tok
.is(tok::coloncolon
);
1416 if (!AteExtraColon
&&
1417 ParseAsmOperandsOpt(Names
, Constraints
, Exprs
))
1421 assert(Names
.size() == Constraints
.size() &&
1422 Constraints
.size() == Exprs
.size() &&
1423 "Input operand size mismatch!");
1425 unsigned NumInputs
= Names
.size() - NumOutputs
;
1427 // Parse the clobbers, if present.
1428 if (AteExtraColon
|| Tok
.is(tok::colon
)) {
1432 // Parse the asm-string list for clobbers if present.
1433 if (Tok
.isNot(tok::r_paren
)) {
1435 ExprResult
Clobber(ParseAsmStringLiteral());
1437 if (Clobber
.isInvalid())
1440 Clobbers
.push_back(Clobber
.release());
1442 if (Tok
.isNot(tok::comma
)) break;
1448 SourceLocation RParenLoc
= MatchRHSPunctuation(tok::r_paren
, Loc
);
1449 return Actions
.ActOnAsmStmt(AsmLoc
, false, isVolatile
,
1450 NumOutputs
, NumInputs
, Names
.data(),
1451 move_arg(Constraints
), move_arg(Exprs
),
1452 AsmString
.take(), move_arg(Clobbers
),
1456 /// ParseAsmOperands - Parse the asm-operands production as used by
1457 /// asm-statement, assuming the leading ':' token was eaten.
1459 /// [GNU] asm-operands:
1461 /// asm-operands ',' asm-operand
1463 /// [GNU] asm-operand:
1464 /// asm-string-literal '(' expression ')'
1465 /// '[' identifier ']' asm-string-literal '(' expression ')'
1468 // FIXME: Avoid unnecessary std::string trashing.
1469 bool Parser::ParseAsmOperandsOpt(llvm::SmallVectorImpl
<IdentifierInfo
*> &Names
,
1470 llvm::SmallVectorImpl
<ExprTy
*> &Constraints
,
1471 llvm::SmallVectorImpl
<ExprTy
*> &Exprs
) {
1472 // 'asm-operands' isn't present?
1473 if (!isTokenStringLiteral() && Tok
.isNot(tok::l_square
))
1477 // Read the [id] if present.
1478 if (Tok
.is(tok::l_square
)) {
1479 SourceLocation Loc
= ConsumeBracket();
1481 if (Tok
.isNot(tok::identifier
)) {
1482 Diag(Tok
, diag::err_expected_ident
);
1483 SkipUntil(tok::r_paren
);
1487 IdentifierInfo
*II
= Tok
.getIdentifierInfo();
1490 Names
.push_back(II
);
1491 MatchRHSPunctuation(tok::r_square
, Loc
);
1495 ExprResult
Constraint(ParseAsmStringLiteral());
1496 if (Constraint
.isInvalid()) {
1497 SkipUntil(tok::r_paren
);
1500 Constraints
.push_back(Constraint
.release());
1502 if (Tok
.isNot(tok::l_paren
)) {
1503 Diag(Tok
, diag::err_expected_lparen_after
) << "asm operand";
1504 SkipUntil(tok::r_paren
);
1508 // Read the parenthesized expression.
1509 SourceLocation OpenLoc
= ConsumeParen();
1510 ExprResult
Res(ParseExpression());
1511 MatchRHSPunctuation(tok::r_paren
, OpenLoc
);
1512 if (Res
.isInvalid()) {
1513 SkipUntil(tok::r_paren
);
1516 Exprs
.push_back(Res
.release());
1517 // Eat the comma and continue parsing if it exists.
1518 if (Tok
.isNot(tok::comma
)) return false;
1525 Decl
*Parser::ParseFunctionStatementBody(Decl
*Decl
) {
1526 assert(Tok
.is(tok::l_brace
));
1527 SourceLocation LBraceLoc
= Tok
.getLocation();
1529 if (PP
.isCodeCompletionEnabled())
1530 if (trySkippingFunctionBodyForCodeCompletion())
1531 return Actions
.ActOnFinishFunctionBody(Decl
, 0);
1533 PrettyDeclStackTraceEntry
CrashInfo(Actions
, Decl
, LBraceLoc
,
1534 "parsing function body");
1536 // Do not enter a scope for the brace, as the arguments are in the same scope
1537 // (the function body) as the body itself. Instead, just read the statement
1538 // list and put it into a CompoundStmt for safe keeping.
1539 StmtResult
FnBody(ParseCompoundStatementBody());
1541 // If the function body could not be parsed, make a bogus compoundstmt.
1542 if (FnBody
.isInvalid())
1543 FnBody
= Actions
.ActOnCompoundStmt(LBraceLoc
, LBraceLoc
,
1544 MultiStmtArg(Actions
), false);
1546 return Actions
.ActOnFinishFunctionBody(Decl
, FnBody
.take());
1549 /// ParseFunctionTryBlock - Parse a C++ function-try-block.
1551 /// function-try-block:
1552 /// 'try' ctor-initializer[opt] compound-statement handler-seq
1554 Decl
*Parser::ParseFunctionTryBlock(Decl
*Decl
) {
1555 assert(Tok
.is(tok::kw_try
) && "Expected 'try'");
1556 SourceLocation TryLoc
= ConsumeToken();
1558 PrettyDeclStackTraceEntry
CrashInfo(Actions
, Decl
, TryLoc
,
1559 "parsing function try block");
1561 // Constructor initializer list?
1562 if (Tok
.is(tok::colon
))
1563 ParseConstructorInitializer(Decl
);
1565 if (PP
.isCodeCompletionEnabled())
1566 if (trySkippingFunctionBodyForCodeCompletion())
1567 return Actions
.ActOnFinishFunctionBody(Decl
, 0);
1569 SourceLocation LBraceLoc
= Tok
.getLocation();
1570 StmtResult
FnBody(ParseCXXTryBlockCommon(TryLoc
));
1571 // If we failed to parse the try-catch, we just give the function an empty
1572 // compound statement as the body.
1573 if (FnBody
.isInvalid())
1574 FnBody
= Actions
.ActOnCompoundStmt(LBraceLoc
, LBraceLoc
,
1575 MultiStmtArg(Actions
), false);
1577 return Actions
.ActOnFinishFunctionBody(Decl
, FnBody
.take());
1580 bool Parser::trySkippingFunctionBodyForCodeCompletion() {
1581 assert(Tok
.is(tok::l_brace
));
1582 assert(PP
.isCodeCompletionEnabled() &&
1583 "Should only be called when in code-completion mode");
1585 // We're in code-completion mode. Skip parsing for all function bodies unless
1586 // the body contains the code-completion point.
1587 TentativeParsingAction
PA(*this);
1589 if (SkipUntil(tok::r_brace
, /*StopAtSemi=*/false, /*DontConsume=*/false,
1590 /*StopAtCodeCompletion=*/true)) {
1599 /// ParseCXXTryBlock - Parse a C++ try-block.
1602 /// 'try' compound-statement handler-seq
1604 StmtResult
Parser::ParseCXXTryBlock(ParsedAttributes
&attrs
) {
1605 // FIXME: Add attributes?
1607 assert(Tok
.is(tok::kw_try
) && "Expected 'try'");
1609 SourceLocation TryLoc
= ConsumeToken();
1610 return ParseCXXTryBlockCommon(TryLoc
);
1613 /// ParseCXXTryBlockCommon - Parse the common part of try-block and
1614 /// function-try-block.
1617 /// 'try' compound-statement handler-seq
1619 /// function-try-block:
1620 /// 'try' ctor-initializer[opt] compound-statement handler-seq
1623 /// handler handler-seq[opt]
1625 StmtResult
Parser::ParseCXXTryBlockCommon(SourceLocation TryLoc
) {
1626 if (Tok
.isNot(tok::l_brace
))
1627 return StmtError(Diag(Tok
, diag::err_expected_lbrace
));
1628 // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
1629 ParsedAttributesWithRange attrs
;
1630 StmtResult
TryBlock(ParseCompoundStatement(attrs
));
1631 if (TryBlock
.isInvalid())
1632 return move(TryBlock
);
1634 StmtVector
Handlers(Actions
);
1635 MaybeParseCXX0XAttributes(attrs
);
1636 ProhibitAttributes(attrs
);
1638 if (Tok
.isNot(tok::kw_catch
))
1639 return StmtError(Diag(Tok
, diag::err_expected_catch
));
1640 while (Tok
.is(tok::kw_catch
)) {
1641 StmtResult
Handler(ParseCXXCatchBlock());
1642 if (!Handler
.isInvalid())
1643 Handlers
.push_back(Handler
.release());
1645 // Don't bother creating the full statement if we don't have any usable
1647 if (Handlers
.empty())
1650 return Actions
.ActOnCXXTryBlock(TryLoc
, TryBlock
.take(), move_arg(Handlers
));
1653 /// ParseCXXCatchBlock - Parse a C++ catch block, called handler in the standard
1656 /// 'catch' '(' exception-declaration ')' compound-statement
1658 /// exception-declaration:
1659 /// type-specifier-seq declarator
1660 /// type-specifier-seq abstract-declarator
1661 /// type-specifier-seq
1664 StmtResult
Parser::ParseCXXCatchBlock() {
1665 assert(Tok
.is(tok::kw_catch
) && "Expected 'catch'");
1667 SourceLocation CatchLoc
= ConsumeToken();
1669 SourceLocation LParenLoc
= Tok
.getLocation();
1670 if (ExpectAndConsume(tok::l_paren
, diag::err_expected_lparen
))
1674 // The name in a catch exception-declaration is local to the handler and
1675 // shall not be redeclared in the outermost block of the handler.
1676 ParseScope
CatchScope(this, Scope::DeclScope
| Scope::ControlScope
);
1678 // exception-declaration is equivalent to '...' or a parameter-declaration
1679 // without default arguments.
1680 Decl
*ExceptionDecl
= 0;
1681 if (Tok
.isNot(tok::ellipsis
)) {
1683 if (ParseCXXTypeSpecifierSeq(DS
))
1685 Declarator
ExDecl(DS
, Declarator::CXXCatchContext
);
1686 ParseDeclarator(ExDecl
);
1687 ExceptionDecl
= Actions
.ActOnExceptionDeclarator(getCurScope(), ExDecl
);
1691 if (MatchRHSPunctuation(tok::r_paren
, LParenLoc
).isInvalid())
1694 if (Tok
.isNot(tok::l_brace
))
1695 return StmtError(Diag(Tok
, diag::err_expected_lbrace
));
1697 // FIXME: Possible draft standard bug: attribute-specifier should be allowed?
1698 ParsedAttributes attrs
;
1699 StmtResult
Block(ParseCompoundStatement(attrs
));
1700 if (Block
.isInvalid())
1703 return Actions
.ActOnCXXCatchBlock(CatchLoc
, ExceptionDecl
, Block
.take());