blob: 7bc7a9c9a76b03b9975b4a815768cc48587e445e [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file was developed by Chris Lattner and is distributed under
6// the University of Illinois Open Source 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 "clang/Basic/Diagnostic.h"
17#include "clang/Parse/DeclSpec.h"
18#include "clang/Parse/Scope.h"
19using namespace clang;
20
21//===----------------------------------------------------------------------===//
22// C99 6.8: Statements and Blocks.
23//===----------------------------------------------------------------------===//
24
25/// ParseStatementOrDeclaration - Read 'statement' or 'declaration'.
26/// StatementOrDeclaration:
27/// statement
28/// declaration
29///
30/// statement:
31/// labeled-statement
32/// compound-statement
33/// expression-statement
34/// selection-statement
35/// iteration-statement
36/// jump-statement
37/// [OBC] objc-throw-statement [TODO]
38/// [OBC] objc-try-catch-statement [TODO]
39/// [OBC] objc-synchronized-statement [TODO]
40/// [GNU] asm-statement
41/// [OMP] openmp-construct [TODO]
42///
43/// labeled-statement:
44/// identifier ':' statement
45/// 'case' constant-expression ':' statement
46/// 'default' ':' statement
47///
48/// selection-statement:
49/// if-statement
50/// switch-statement
51///
52/// iteration-statement:
53/// while-statement
54/// do-statement
55/// for-statement
56///
57/// expression-statement:
58/// expression[opt] ';'
59///
60/// jump-statement:
61/// 'goto' identifier ';'
62/// 'continue' ';'
63/// 'break' ';'
64/// 'return' expression[opt] ';'
65/// [GNU] 'goto' '*' expression ';'
66///
67/// [OBC] objc-throw-statement: [TODO]
68/// [OBC] '@' 'throw' expression ';' [TODO]
69/// [OBC] '@' 'throw' ';' [TODO]
70///
71Parser::StmtResult Parser::ParseStatementOrDeclaration(bool OnlyStatement) {
72 const char *SemiError = 0;
73 Parser::StmtResult Res;
74
75 // Cases in this switch statement should fall through if the parser expects
76 // the token to end in a semicolon (in which case SemiError should be set),
77 // or they directly 'return;' if not.
78 switch (Tok.getKind()) {
79 case tok::identifier: // C99 6.8.1: labeled-statement
80 // identifier ':' statement
81 // declaration (if !OnlyStatement)
82 // expression[opt] ';'
83 return ParseIdentifierStatement(OnlyStatement);
84
85 default:
86 if (!OnlyStatement && isDeclarationSpecifier()) {
87 // TODO: warn/disable if declaration is in the middle of a block and !C99.
88 return Actions.ParseDeclStmt(ParseDeclaration(Declarator::BlockContext));
89 } else if (Tok.getKind() == tok::r_brace) {
90 Diag(Tok, diag::err_expected_statement);
91 return true;
92 } else {
93 // expression[opt] ';'
94 ExprResult Res = ParseExpression();
95 if (Res.isInvalid) {
96 // If the expression is invalid, skip ahead to the next semicolon. Not
97 // doing this opens us up to the possibility of infinite loops if
98 // ParseExpression does not consume any tokens.
99 SkipUntil(tok::semi);
100 return true;
101 }
102 // Otherwise, eat the semicolon.
103 ExpectAndConsume(tok::semi, diag::err_expected_semi_after_expr);
104 return Actions.ParseExprStmt(Res.Val);
105 }
106
107 case tok::kw_case: // C99 6.8.1: labeled-statement
108 return ParseCaseStatement();
109 case tok::kw_default: // C99 6.8.1: labeled-statement
110 return ParseDefaultStatement();
111
112 case tok::l_brace: // C99 6.8.2: compound-statement
113 return ParseCompoundStatement();
114 case tok::semi: // C99 6.8.3p3: expression[opt] ';'
115 return Actions.ParseNullStmt(ConsumeToken());
116
117 case tok::kw_if: // C99 6.8.4.1: if-statement
118 return ParseIfStatement();
119 case tok::kw_switch: // C99 6.8.4.2: switch-statement
120 return ParseSwitchStatement();
121
122 case tok::kw_while: // C99 6.8.5.1: while-statement
123 return ParseWhileStatement();
124 case tok::kw_do: // C99 6.8.5.2: do-statement
125 Res = ParseDoStatement();
126 SemiError = "do/while loop";
127 break;
128 case tok::kw_for: // C99 6.8.5.3: for-statement
129 return ParseForStatement();
130
131 case tok::kw_goto: // C99 6.8.6.1: goto-statement
132 Res = ParseGotoStatement();
133 SemiError = "goto statement";
134 break;
135 case tok::kw_continue: // C99 6.8.6.2: continue-statement
136 Res = ParseContinueStatement();
137 SemiError = "continue statement";
138 break;
139 case tok::kw_break: // C99 6.8.6.3: break-statement
140 Res = ParseBreakStatement();
141 SemiError = "break statement";
142 break;
143 case tok::kw_return: // C99 6.8.6.4: return-statement
144 Res = ParseReturnStatement();
145 SemiError = "return statement";
146 break;
147
148 case tok::kw_asm:
149 Res = ParseAsmStatement();
150 SemiError = "asm statement";
151 break;
152 }
153
154 // If we reached this code, the statement must end in a semicolon.
155 if (Tok.getKind() == tok::semi) {
156 ConsumeToken();
157 } else {
158 Diag(Tok, diag::err_expected_semi_after, SemiError);
159 SkipUntil(tok::semi);
160 }
161 return Res;
162}
163
164/// ParseIdentifierStatement - Because we don't have two-token lookahead, we
165/// have a bit of a quandry here. Reading the identifier is necessary to see if
166/// there is a ':' after it. If there is, this is a label, regardless of what
167/// else the identifier can mean. If not, this is either part of a declaration
168/// (if the identifier is a type-name) or part of an expression.
169///
170/// labeled-statement:
171/// identifier ':' statement
172/// [GNU] identifier ':' attributes[opt] statement
173/// declaration (if !OnlyStatement)
174/// expression[opt] ';'
175///
176Parser::StmtResult Parser::ParseIdentifierStatement(bool OnlyStatement) {
177 assert(Tok.getKind() == tok::identifier && Tok.getIdentifierInfo() &&
178 "Not an identifier!");
179
180 LexerToken IdentTok = Tok; // Save the whole token.
181 ConsumeToken(); // eat the identifier.
182
183 // identifier ':' statement
184 if (Tok.getKind() == tok::colon) {
185 SourceLocation ColonLoc = ConsumeToken();
186
187 // Read label attributes, if present.
188 DeclTy *AttrList = 0;
189 if (Tok.getKind() == tok::kw___attribute)
190 // TODO: save these somewhere.
191 AttrList = ParseAttributes();
192
193 StmtResult SubStmt = ParseStatement();
194
195 // Broken substmt shouldn't prevent the label from being added to the AST.
196 if (SubStmt.isInvalid)
197 SubStmt = Actions.ParseNullStmt(ColonLoc);
198
199 return Actions.ParseLabelStmt(IdentTok.getLocation(),
200 IdentTok.getIdentifierInfo(),
201 ColonLoc, SubStmt.Val);
202 }
203
204 // Check to see if this is a declaration.
205 void *TypeRep;
206 if (!OnlyStatement &&
207 (TypeRep = Actions.isTypeName(*IdentTok.getIdentifierInfo(), CurScope))) {
208 // Handle this. Warn/disable if in middle of block and !C99.
209 DeclSpec DS;
210
211 // Add the typedef name to the start of the decl-specs.
212 const char *PrevSpec = 0;
213 int isInvalid = DS.SetTypeSpecType(DeclSpec::TST_typedef,
214 IdentTok.getLocation(), PrevSpec,
215 TypeRep);
216 assert(!isInvalid && "First declspec can't be invalid!");
217
218 // ParseDeclarationSpecifiers will continue from there.
219 ParseDeclarationSpecifiers(DS);
220
221 // C99 6.7.2.3p6: Handle "struct-or-union identifier;", "enum { X };"
222 // declaration-specifiers init-declarator-list[opt] ';'
223 if (Tok.getKind() == tok::semi) {
224 // TODO: emit error on 'int;' or 'const enum foo;'.
225 // if (!DS.isMissingDeclaratorOk()) Diag(...);
226
227 ConsumeToken();
228 // FIXME: Return this as a type decl.
229 return 0;
230 }
231
232 // Parse all the declarators.
233 Declarator DeclaratorInfo(DS, Declarator::BlockContext);
234 ParseDeclarator(DeclaratorInfo);
235
236 DeclTy *Decl = ParseInitDeclaratorListAfterFirstDeclarator(DeclaratorInfo);
237 return Decl ? Actions.ParseDeclStmt(Decl) : 0;
238 }
239
240 // Otherwise, this is an expression. Seed it with II and parse it.
241 ExprResult Res = ParseExpressionWithLeadingIdentifier(IdentTok);
242 if (Res.isInvalid) {
243 SkipUntil(tok::semi);
244 return true;
245 } else if (Tok.getKind() != tok::semi) {
246 Diag(Tok, diag::err_expected_semi_after, "expression");
247 SkipUntil(tok::semi);
248 return true;
249 } else {
250 ConsumeToken();
251 // Convert expr to a stmt.
252 return Actions.ParseExprStmt(Res.Val);
253 }
254}
255
256/// ParseCaseStatement
257/// labeled-statement:
258/// 'case' constant-expression ':' statement
259/// [GNU] 'case' constant-expression '...' constant-expression ':' statement
260///
261/// Note that this does not parse the 'statement' at the end.
262///
263Parser::StmtResult Parser::ParseCaseStatement() {
264 assert(Tok.getKind() == tok::kw_case && "Not a case stmt!");
265 SourceLocation CaseLoc = ConsumeToken(); // eat the 'case'.
266
267 ExprResult LHS = ParseConstantExpression();
268 if (LHS.isInvalid) {
269 SkipUntil(tok::colon);
270 return true;
271 }
272
273 // GNU case range extension.
274 SourceLocation DotDotDotLoc;
275 ExprTy *RHSVal = 0;
276 if (Tok.getKind() == tok::ellipsis) {
277 Diag(Tok, diag::ext_gnu_case_range);
278 DotDotDotLoc = ConsumeToken();
279
280 ExprResult RHS = ParseConstantExpression();
281 if (RHS.isInvalid) {
282 SkipUntil(tok::colon);
283 return true;
284 }
285 RHSVal = RHS.Val;
286 }
287
288 if (Tok.getKind() != tok::colon) {
289 Diag(Tok, diag::err_expected_colon_after, "'case'");
290 SkipUntil(tok::colon);
291 return true;
292 }
293
294 SourceLocation ColonLoc = ConsumeToken();
295
296 // Diagnose the common error "switch (X) { case 4: }", which is not valid.
297 if (Tok.getKind() == tok::r_brace) {
298 Diag(Tok, diag::err_label_end_of_compound_statement);
299 return true;
300 }
301
302 StmtResult SubStmt = ParseStatement();
303
304 // Broken substmt shouldn't prevent the case from being added to the AST.
305 if (SubStmt.isInvalid)
306 SubStmt = Actions.ParseNullStmt(ColonLoc);
307
308 // TODO: look up enclosing switch stmt.
309 return Actions.ParseCaseStmt(CaseLoc, LHS.Val, DotDotDotLoc, RHSVal, ColonLoc,
310 SubStmt.Val);
311}
312
313/// ParseDefaultStatement
314/// labeled-statement:
315/// 'default' ':' statement
316/// Note that this does not parse the 'statement' at the end.
317///
318Parser::StmtResult Parser::ParseDefaultStatement() {
319 assert(Tok.getKind() == tok::kw_default && "Not a default stmt!");
320 SourceLocation DefaultLoc = ConsumeToken(); // eat the 'default'.
321
322 if (Tok.getKind() != tok::colon) {
323 Diag(Tok, diag::err_expected_colon_after, "'default'");
324 SkipUntil(tok::colon);
325 return true;
326 }
327
328 SourceLocation ColonLoc = ConsumeToken();
329
330 // Diagnose the common error "switch (X) {... default: }", which is not valid.
331 if (Tok.getKind() == tok::r_brace) {
332 Diag(Tok, diag::err_label_end_of_compound_statement);
333 return true;
334 }
335
336 StmtResult SubStmt = ParseStatement();
337 if (SubStmt.isInvalid)
338 return true;
339
340 // TODO: look up enclosing switch stmt.
341 return Actions.ParseDefaultStmt(DefaultLoc, ColonLoc, SubStmt.Val);
342}
343
344
345/// ParseCompoundStatement - Parse a "{}" block.
346///
347/// compound-statement: [C99 6.8.2]
348/// { block-item-list[opt] }
349/// [GNU] { label-declarations block-item-list } [TODO]
350///
351/// block-item-list:
352/// block-item
353/// block-item-list block-item
354///
355/// block-item:
356/// declaration
357/// [GNU] '__extension__' declaration [TODO]
358/// statement
359/// [OMP] openmp-directive [TODO]
360///
361/// [GNU] label-declarations:
362/// [GNU] label-declaration
363/// [GNU] label-declarations label-declaration
364///
365/// [GNU] label-declaration:
366/// [GNU] '__label__' identifier-list ';'
367///
368/// [OMP] openmp-directive: [TODO]
369/// [OMP] barrier-directive
370/// [OMP] flush-directive
371///
372Parser::StmtResult Parser::ParseCompoundStatement() {
373 assert(Tok.getKind() == tok::l_brace && "Not a compount stmt!");
374
375 // Enter a scope to hold everything within the compound stmt.
376 EnterScope(0);
377
378 // Parse the statements in the body.
379 StmtResult Body = ParseCompoundStatementBody();
380
381 ExitScope();
382 return Body;
383}
384
385
386/// ParseCompoundStatementBody - Parse a sequence of statements and invoke the
387/// ParseCompoundStmt action. This expects the '{' to be the current token, and
388/// consume the '}' at the end of the block. It does not manipulate the scope
389/// stack.
390Parser::StmtResult Parser::ParseCompoundStatementBody() {
391 SourceLocation LBraceLoc = ConsumeBrace(); // eat the '{'.
392
393 // TODO: "__label__ X, Y, Z;" is the GNU "Local Label" extension. These are
394 // only allowed at the start of a compound stmt.
395
396 llvm::SmallVector<StmtTy*, 32> Stmts;
397 while (Tok.getKind() != tok::r_brace && Tok.getKind() != tok::eof) {
398 StmtResult R = ParseStatementOrDeclaration(false);
399 if (!R.isInvalid && R.Val)
400 Stmts.push_back(R.Val);
401 }
402
403 // We broke out of the while loop because we found a '}' or EOF.
404 if (Tok.getKind() != tok::r_brace) {
405 Diag(Tok, diag::err_expected_rbrace);
406 return 0;
407 }
408
409 SourceLocation RBraceLoc = ConsumeBrace();
410 return Actions.ParseCompoundStmt(LBraceLoc, RBraceLoc,
411 &Stmts[0], Stmts.size());
412}
413
414/// ParseIfStatement
415/// if-statement: [C99 6.8.4.1]
416/// 'if' '(' expression ')' statement
417/// 'if' '(' expression ')' statement 'else' statement
418///
419Parser::StmtResult Parser::ParseIfStatement() {
420 assert(Tok.getKind() == tok::kw_if && "Not an if stmt!");
421 SourceLocation IfLoc = ConsumeToken(); // eat the 'if'.
422
423 if (Tok.getKind() != tok::l_paren) {
424 Diag(Tok, diag::err_expected_lparen_after, "if");
425 SkipUntil(tok::semi);
426 return true;
427 }
428
429 // Parse the condition.
430 ExprResult CondExp = ParseSimpleParenExpression();
431 if (CondExp.isInvalid) {
432 SkipUntil(tok::semi);
433 return true;
434 }
435
436 // Read the if condition.
437 StmtResult CondStmt = ParseStatement();
438
439 // Broken substmt shouldn't prevent the label from being added to the AST.
440 if (CondStmt.isInvalid)
441 CondStmt = Actions.ParseNullStmt(Tok.getLocation());
442
443
444 // If it has an else, parse it.
445 SourceLocation ElseLoc;
446 StmtResult ElseStmt(false);
447 if (Tok.getKind() == tok::kw_else) {
448 ElseLoc = ConsumeToken();
449 ElseStmt = ParseStatement();
450
451 if (ElseStmt.isInvalid)
452 ElseStmt = Actions.ParseNullStmt(ElseLoc);
453 }
454
455 return Actions.ParseIfStmt(IfLoc, CondExp.Val, CondStmt.Val,
456 ElseLoc, ElseStmt.Val);
457}
458
459/// ParseSwitchStatement
460/// switch-statement:
461/// 'switch' '(' expression ')' statement
462Parser::StmtResult Parser::ParseSwitchStatement() {
463 assert(Tok.getKind() == tok::kw_switch && "Not a switch stmt!");
464 SourceLocation SwitchLoc = ConsumeToken(); // eat the 'switch'.
465
466 if (Tok.getKind() != tok::l_paren) {
467 Diag(Tok, diag::err_expected_lparen_after, "switch");
468 SkipUntil(tok::semi);
469 return true;
470 }
471
472 // Start the switch scope.
473 EnterScope(Scope::BreakScope);
474
475 // Parse the condition.
476 ExprResult Cond = ParseSimpleParenExpression();
477
478 // Read the body statement.
479 StmtResult Body = ParseStatement();
480
481 ExitScope();
482
483 if (Cond.isInvalid || Body.isInvalid) return true;
484
485 return Actions.ParseSwitchStmt(SwitchLoc, Cond.Val, Body.Val);
486}
487
488/// ParseWhileStatement
489/// while-statement: [C99 6.8.5.1]
490/// 'while' '(' expression ')' statement
491Parser::StmtResult Parser::ParseWhileStatement() {
492 assert(Tok.getKind() == tok::kw_while && "Not a while stmt!");
493 SourceLocation WhileLoc = Tok.getLocation();
494 ConsumeToken(); // eat the 'while'.
495
496 if (Tok.getKind() != tok::l_paren) {
497 Diag(Tok, diag::err_expected_lparen_after, "while");
498 SkipUntil(tok::semi);
499 return true;
500 }
501
502 // Start the loop scope.
503 EnterScope(Scope::BreakScope | Scope::ContinueScope);
504
505 // Parse the condition.
506 ExprResult Cond = ParseSimpleParenExpression();
507
508 // Read the body statement.
509 StmtResult Body = ParseStatement();
510
511 ExitScope();
512
513 if (Cond.isInvalid || Body.isInvalid) return true;
514
515 return Actions.ParseWhileStmt(WhileLoc, Cond.Val, Body.Val);
516}
517
518/// ParseDoStatement
519/// do-statement: [C99 6.8.5.2]
520/// 'do' statement 'while' '(' expression ')' ';'
521/// Note: this lets the caller parse the end ';'.
522Parser::StmtResult Parser::ParseDoStatement() {
523 assert(Tok.getKind() == tok::kw_do && "Not a do stmt!");
524 SourceLocation DoLoc = ConsumeToken(); // eat the 'do'.
525
526 // Start the loop scope.
527 EnterScope(Scope::BreakScope | Scope::ContinueScope);
528
529 // Read the body statement.
530 StmtResult Body = ParseStatement();
531
532 if (Tok.getKind() != tok::kw_while) {
533 ExitScope();
534 Diag(Tok, diag::err_expected_while);
535 Diag(DoLoc, diag::err_matching, "do");
536 SkipUntil(tok::semi);
537 return true;
538 }
539 SourceLocation WhileLoc = ConsumeToken();
540
541 if (Tok.getKind() != tok::l_paren) {
542 ExitScope();
543 Diag(Tok, diag::err_expected_lparen_after, "do/while");
544 SkipUntil(tok::semi);
545 return true;
546 }
547
548 // Parse the condition.
549 ExprResult Cond = ParseSimpleParenExpression();
550
551 ExitScope();
552
553 if (Cond.isInvalid || Body.isInvalid) return true;
554
555 return Actions.ParseDoStmt(DoLoc, Body.Val, WhileLoc, Cond.Val);
556}
557
558/// ParseForStatement
559/// for-statement: [C99 6.8.5.3]
560/// 'for' '(' expr[opt] ';' expr[opt] ';' expr[opt] ')' statement
561/// 'for' '(' declaration expr[opt] ';' expr[opt] ')' statement
562Parser::StmtResult Parser::ParseForStatement() {
563 assert(Tok.getKind() == tok::kw_for && "Not a for stmt!");
564 SourceLocation ForLoc = ConsumeToken(); // eat the 'for'.
565
566 if (Tok.getKind() != tok::l_paren) {
567 Diag(Tok, diag::err_expected_lparen_after, "for");
568 SkipUntil(tok::semi);
569 return true;
570 }
571
572 EnterScope(Scope::BreakScope | Scope::ContinueScope);
573
574 SourceLocation LParenLoc = ConsumeParen();
575 ExprResult Value;
576
577 StmtTy *FirstPart = 0;
578 ExprTy *SecondPart = 0;
579 StmtTy *ThirdPart = 0;
580
581 // Parse the first part of the for specifier.
582 if (Tok.getKind() == tok::semi) { // for (;
583 // no first part, eat the ';'.
584 ConsumeToken();
585 } else if (isDeclarationSpecifier()) { // for (int X = 4;
586 // Parse declaration, which eats the ';'.
587 if (!getLang().C99) // Use of C99-style for loops in C90 mode?
588 Diag(Tok, diag::ext_c99_variable_decl_in_for_loop);
589 DeclTy *aBlockVarDecl = ParseDeclaration(Declarator::ForContext);
590 StmtResult stmtResult = Actions.ParseDeclStmt(aBlockVarDecl);
591 FirstPart = stmtResult.isInvalid ? 0 : stmtResult.Val;
592 } else {
593 Value = ParseExpression();
594
595 // Turn the expression into a stmt.
596 if (!Value.isInvalid) {
597 StmtResult R = Actions.ParseExprStmt(Value.Val);
598 if (!R.isInvalid)
599 FirstPart = R.Val;
600 }
601
602 if (Tok.getKind() == tok::semi) {
603 ConsumeToken();
604 } else {
605 if (!Value.isInvalid) Diag(Tok, diag::err_expected_semi_for);
606 SkipUntil(tok::semi);
607 }
608 }
609
610 // Parse the second part of the for specifier.
611 if (Tok.getKind() == tok::semi) { // for (...;;
612 // no second part.
613 Value = ExprResult();
614 } else {
615 Value = ParseExpression();
616 if (!Value.isInvalid)
617 SecondPart = Value.Val;
618 }
619
620 if (Tok.getKind() == tok::semi) {
621 ConsumeToken();
622 } else {
623 if (!Value.isInvalid) Diag(Tok, diag::err_expected_semi_for);
624 SkipUntil(tok::semi);
625 }
626
627 // Parse the third part of the for specifier.
628 if (Tok.getKind() == tok::r_paren) { // for (...;...;)
629 // no third part.
630 Value = ExprResult();
631 } else {
632 Value = ParseExpression();
633 if (!Value.isInvalid) {
634 // Turn the expression into a stmt.
635 StmtResult R = Actions.ParseExprStmt(Value.Val);
636 if (!R.isInvalid)
637 ThirdPart = R.Val;
638 }
639 }
640
641 // Match the ')'.
642 SourceLocation RParenLoc = MatchRHSPunctuation(tok::r_paren, LParenLoc);
643
644 // Read the body statement.
645 StmtResult Body = ParseStatement();
646
647 // Leave the for-scope.
648 ExitScope();
649
650 if (Body.isInvalid)
651 return Body;
652
653 return Actions.ParseForStmt(ForLoc, LParenLoc, FirstPart, SecondPart,
654 ThirdPart, RParenLoc, Body.Val);
655}
656
657/// ParseGotoStatement
658/// jump-statement:
659/// 'goto' identifier ';'
660/// [GNU] 'goto' '*' expression ';'
661///
662/// Note: this lets the caller parse the end ';'.
663///
664Parser::StmtResult Parser::ParseGotoStatement() {
665 assert(Tok.getKind() == tok::kw_goto && "Not a goto stmt!");
666 SourceLocation GotoLoc = ConsumeToken(); // eat the 'goto'.
667
668 StmtResult Res;
669 if (Tok.getKind() == tok::identifier) {
670 Res = Actions.ParseGotoStmt(GotoLoc, Tok.getLocation(),
671 Tok.getIdentifierInfo());
672 ConsumeToken();
673 } else if (Tok.getKind() == tok::star && !getLang().NoExtensions) {
674 // GNU indirect goto extension.
675 Diag(Tok, diag::ext_gnu_indirect_goto);
676 SourceLocation StarLoc = ConsumeToken();
677 ExprResult R = ParseExpression();
678 if (R.isInvalid) { // Skip to the semicolon, but don't consume it.
679 SkipUntil(tok::semi, false, true);
680 return true;
681 }
682 Res = Actions.ParseIndirectGotoStmt(GotoLoc, StarLoc, R.Val);
683 }
684 return Res;
685}
686
687/// ParseContinueStatement
688/// jump-statement:
689/// 'continue' ';'
690///
691/// Note: this lets the caller parse the end ';'.
692///
693Parser::StmtResult Parser::ParseContinueStatement() {
694 SourceLocation ContinueLoc = ConsumeToken(); // eat the 'continue'.
695 return Actions.ParseContinueStmt(ContinueLoc, CurScope);
696}
697
698/// ParseBreakStatement
699/// jump-statement:
700/// 'break' ';'
701///
702/// Note: this lets the caller parse the end ';'.
703///
704Parser::StmtResult Parser::ParseBreakStatement() {
705 SourceLocation BreakLoc = ConsumeToken(); // eat the 'break'.
706 return Actions.ParseBreakStmt(BreakLoc, CurScope);
707}
708
709/// ParseReturnStatement
710/// jump-statement:
711/// 'return' expression[opt] ';'
712Parser::StmtResult Parser::ParseReturnStatement() {
713 assert(Tok.getKind() == tok::kw_return && "Not a return stmt!");
714 SourceLocation ReturnLoc = ConsumeToken(); // eat the 'return'.
715
716 ExprResult R(0);
717 if (Tok.getKind() != tok::semi) {
718 R = ParseExpression();
719 if (R.isInvalid) { // Skip to the semicolon, but don't consume it.
720 SkipUntil(tok::semi, false, true);
721 return true;
722 }
723 }
724 return Actions.ParseReturnStmt(ReturnLoc, R.Val);
725}
726
727/// ParseAsmStatement - Parse a GNU extended asm statement.
728/// [GNU] asm-statement:
729/// 'asm' type-qualifier[opt] '(' asm-argument ')' ';'
730///
731/// [GNU] asm-argument:
732/// asm-string-literal
733/// asm-string-literal ':' asm-operands[opt]
734/// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
735/// asm-string-literal ':' asm-operands[opt] ':' asm-operands[opt]
736/// ':' asm-clobbers
737///
738/// [GNU] asm-clobbers:
739/// asm-string-literal
740/// asm-clobbers ',' asm-string-literal
741///
742Parser::StmtResult Parser::ParseAsmStatement() {
743 assert(Tok.getKind() == tok::kw_asm && "Not an asm stmt");
744 ConsumeToken();
745
746 DeclSpec DS;
747 SourceLocation Loc = Tok.getLocation();
748 ParseTypeQualifierListOpt(DS);
749
750 // GNU asms accept, but warn, about type-qualifiers other than volatile.
751 if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
752 Diag(Loc, diag::w_asm_qualifier_ignored, "const");
753 if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
754 Diag(Loc, diag::w_asm_qualifier_ignored, "restrict");
755
756 // Remember if this was a volatile asm.
757 //bool isVolatile = DS.TypeQualifiers & DeclSpec::TQ_volatile;
758
759 if (Tok.getKind() != tok::l_paren) {
760 Diag(Tok, diag::err_expected_lparen_after, "asm");
761 SkipUntil(tok::r_paren);
762 return true;
763 }
764 Loc = ConsumeParen();
765
766 ParseAsmStringLiteral();
767
768 // Parse Outputs, if present.
769 ParseAsmOperandsOpt();
770
771 // Parse Inputs, if present.
772 ParseAsmOperandsOpt();
773
774 // Parse the clobbers, if present.
775 if (Tok.getKind() == tok::colon) {
776 ConsumeToken();
777
778 if (isTokenStringLiteral()) {
779 // Parse the asm-string list for clobbers.
780 while (1) {
781 ParseAsmStringLiteral();
782
783 if (Tok.getKind() != tok::comma) break;
784 ConsumeToken();
785 }
786 }
787 }
788
789 MatchRHSPunctuation(tok::r_paren, Loc);
790
791 // FIXME: Implement action for asm parsing.
792 return false;
793}
794
795/// ParseAsmOperands - Parse the asm-operands production as used by
796/// asm-statement. We also parse a leading ':' token. If the leading colon is
797/// not present, we do not parse anything.
798///
799/// [GNU] asm-operands:
800/// asm-operand
801/// asm-operands ',' asm-operand
802///
803/// [GNU] asm-operand:
804/// asm-string-literal '(' expression ')'
805/// '[' identifier ']' asm-string-literal '(' expression ')'
806///
807void Parser::ParseAsmOperandsOpt() {
808 // Only do anything if this operand is present.
809 if (Tok.getKind() != tok::colon) return;
810 ConsumeToken();
811
812 // 'asm-operands' isn't present?
813 if (!isTokenStringLiteral() && Tok.getKind() != tok::l_square)
814 return;
815
816 while (1) {
817 // Read the [id] if present.
818 if (Tok.getKind() == tok::l_square) {
819 SourceLocation Loc = ConsumeBracket();
820
821 if (Tok.getKind() != tok::identifier) {
822 Diag(Tok, diag::err_expected_ident);
823 SkipUntil(tok::r_paren);
824 return;
825 }
826 MatchRHSPunctuation(tok::r_square, Loc);
827 }
828
829 ParseAsmStringLiteral();
830
831 if (Tok.getKind() != tok::l_paren) {
832 Diag(Tok, diag::err_expected_lparen_after, "asm operand");
833 SkipUntil(tok::r_paren);
834 return;
835 }
836
837 // Read the parenthesized expression.
838 ExprResult Res = ParseSimpleParenExpression();
839 if (Res.isInvalid) {
840 SkipUntil(tok::r_paren);
841 return;
842 }
843
844 // Eat the comma and continue parsing if it exists.
845 if (Tok.getKind() != tok::comma) return;
846 ConsumeToken();
847 }
848}