ParseCXXInlineMethods.cpp revision 235864
1//===--- ParseCXXInlineMethods.cpp - C++ class inline methods parsing------===// 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 parsing for C++ class inline methods. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Parse/ParseDiagnostic.h" 15#include "clang/Parse/Parser.h" 16#include "clang/Sema/DeclSpec.h" 17#include "clang/Sema/Scope.h" 18#include "clang/AST/DeclTemplate.h" 19using namespace clang; 20 21/// ParseCXXInlineMethodDef - We parsed and verified that the specified 22/// Declarator is a well formed C++ inline method definition. Now lex its body 23/// and store its tokens for parsing after the C++ class is complete. 24Decl *Parser::ParseCXXInlineMethodDef(AccessSpecifier AS, 25 AttributeList *AccessAttrs, 26 ParsingDeclarator &D, 27 const ParsedTemplateInfo &TemplateInfo, 28 const VirtSpecifiers& VS, 29 FunctionDefinitionKind DefinitionKind, 30 ExprResult& Init) { 31 assert(D.isFunctionDeclarator() && "This isn't a function declarator!"); 32 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try) || 33 Tok.is(tok::equal)) && 34 "Current token not a '{', ':', '=', or 'try'!"); 35 36 MultiTemplateParamsArg TemplateParams(Actions, 37 TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->data() : 0, 38 TemplateInfo.TemplateParams ? TemplateInfo.TemplateParams->size() : 0); 39 40 Decl *FnD; 41 D.setFunctionDefinitionKind(DefinitionKind); 42 if (D.getDeclSpec().isFriendSpecified()) 43 FnD = Actions.ActOnFriendFunctionDecl(getCurScope(), D, 44 move(TemplateParams)); 45 else { 46 FnD = Actions.ActOnCXXMemberDeclarator(getCurScope(), AS, D, 47 move(TemplateParams), 0, 48 VS, /*HasDeferredInit=*/false); 49 if (FnD) { 50 Actions.ProcessDeclAttributeList(getCurScope(), FnD, AccessAttrs, 51 false, true); 52 bool TypeSpecContainsAuto 53 = D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto; 54 if (Init.isUsable()) 55 Actions.AddInitializerToDecl(FnD, Init.get(), false, 56 TypeSpecContainsAuto); 57 else 58 Actions.ActOnUninitializedDecl(FnD, TypeSpecContainsAuto); 59 } 60 } 61 62 HandleMemberFunctionDeclDelays(D, FnD); 63 64 D.complete(FnD); 65 66 if (Tok.is(tok::equal)) { 67 ConsumeToken(); 68 69 if (!FnD) { 70 SkipUntil(tok::semi); 71 return 0; 72 } 73 74 bool Delete = false; 75 SourceLocation KWLoc; 76 if (Tok.is(tok::kw_delete)) { 77 Diag(Tok, getLangOpts().CPlusPlus0x ? 78 diag::warn_cxx98_compat_deleted_function : 79 diag::ext_deleted_function); 80 81 KWLoc = ConsumeToken(); 82 Actions.SetDeclDeleted(FnD, KWLoc); 83 Delete = true; 84 } else if (Tok.is(tok::kw_default)) { 85 Diag(Tok, getLangOpts().CPlusPlus0x ? 86 diag::warn_cxx98_compat_defaulted_function : 87 diag::ext_defaulted_function); 88 89 KWLoc = ConsumeToken(); 90 Actions.SetDeclDefaulted(FnD, KWLoc); 91 } else { 92 llvm_unreachable("function definition after = not 'delete' or 'default'"); 93 } 94 95 if (Tok.is(tok::comma)) { 96 Diag(KWLoc, diag::err_default_delete_in_multiple_declaration) 97 << Delete; 98 SkipUntil(tok::semi); 99 } else { 100 ExpectAndConsume(tok::semi, diag::err_expected_semi_after, 101 Delete ? "delete" : "default", tok::semi); 102 } 103 104 return FnD; 105 } 106 107 // In delayed template parsing mode, if we are within a class template 108 // or if we are about to parse function member template then consume 109 // the tokens and store them for parsing at the end of the translation unit. 110 if (getLangOpts().DelayedTemplateParsing && 111 ((Actions.CurContext->isDependentContext() || 112 TemplateInfo.Kind != ParsedTemplateInfo::NonTemplate) && 113 !Actions.IsInsideALocalClassWithinATemplateFunction())) { 114 115 if (FnD) { 116 LateParsedTemplatedFunction *LPT = new LateParsedTemplatedFunction(FnD); 117 118 FunctionDecl *FD = 0; 119 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(FnD)) 120 FD = FunTmpl->getTemplatedDecl(); 121 else 122 FD = cast<FunctionDecl>(FnD); 123 Actions.CheckForFunctionRedefinition(FD); 124 125 LateParsedTemplateMap[FD] = LPT; 126 Actions.MarkAsLateParsedTemplate(FD); 127 LexTemplateFunctionForLateParsing(LPT->Toks); 128 } else { 129 CachedTokens Toks; 130 LexTemplateFunctionForLateParsing(Toks); 131 } 132 133 return FnD; 134 } 135 136 // Consume the tokens and store them for later parsing. 137 138 LexedMethod* LM = new LexedMethod(this, FnD); 139 getCurrentClass().LateParsedDeclarations.push_back(LM); 140 LM->TemplateScope = getCurScope()->isTemplateParamScope(); 141 CachedTokens &Toks = LM->Toks; 142 143 tok::TokenKind kind = Tok.getKind(); 144 // Consume everything up to (and including) the left brace of the 145 // function body. 146 if (ConsumeAndStoreFunctionPrologue(Toks)) { 147 // We didn't find the left-brace we expected after the 148 // constructor initializer; we already printed an error, and it's likely 149 // impossible to recover, so don't try to parse this method later. 150 // If we stopped at a semicolon, consume it to avoid an extra warning. 151 if (Tok.is(tok::semi)) 152 ConsumeToken(); 153 delete getCurrentClass().LateParsedDeclarations.back(); 154 getCurrentClass().LateParsedDeclarations.pop_back(); 155 return FnD; 156 } else { 157 // Consume everything up to (and including) the matching right brace. 158 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 159 } 160 161 // If we're in a function-try-block, we need to store all the catch blocks. 162 if (kind == tok::kw_try) { 163 while (Tok.is(tok::kw_catch)) { 164 ConsumeAndStoreUntil(tok::l_brace, Toks, /*StopAtSemi=*/false); 165 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 166 } 167 } 168 169 170 if (!FnD) { 171 // If semantic analysis could not build a function declaration, 172 // just throw away the late-parsed declaration. 173 delete getCurrentClass().LateParsedDeclarations.back(); 174 getCurrentClass().LateParsedDeclarations.pop_back(); 175 } 176 177 return FnD; 178} 179 180/// ParseCXXNonStaticMemberInitializer - We parsed and verified that the 181/// specified Declarator is a well formed C++ non-static data member 182/// declaration. Now lex its initializer and store its tokens for parsing 183/// after the class is complete. 184void Parser::ParseCXXNonStaticMemberInitializer(Decl *VarD) { 185 assert((Tok.is(tok::l_brace) || Tok.is(tok::equal)) && 186 "Current token not a '{' or '='!"); 187 188 LateParsedMemberInitializer *MI = 189 new LateParsedMemberInitializer(this, VarD); 190 getCurrentClass().LateParsedDeclarations.push_back(MI); 191 CachedTokens &Toks = MI->Toks; 192 193 tok::TokenKind kind = Tok.getKind(); 194 if (kind == tok::equal) { 195 Toks.push_back(Tok); 196 ConsumeToken(); 197 } 198 199 if (kind == tok::l_brace) { 200 // Begin by storing the '{' token. 201 Toks.push_back(Tok); 202 ConsumeBrace(); 203 204 // Consume everything up to (and including) the matching right brace. 205 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/true); 206 } else { 207 // Consume everything up to (but excluding) the comma or semicolon. 208 ConsumeAndStoreUntil(tok::comma, Toks, /*StopAtSemi=*/true, 209 /*ConsumeFinalToken=*/false); 210 } 211 212 // Store an artificial EOF token to ensure that we don't run off the end of 213 // the initializer when we come to parse it. 214 Token Eof; 215 Eof.startToken(); 216 Eof.setKind(tok::eof); 217 Eof.setLocation(Tok.getLocation()); 218 Toks.push_back(Eof); 219} 220 221Parser::LateParsedDeclaration::~LateParsedDeclaration() {} 222void Parser::LateParsedDeclaration::ParseLexedMethodDeclarations() {} 223void Parser::LateParsedDeclaration::ParseLexedMemberInitializers() {} 224void Parser::LateParsedDeclaration::ParseLexedMethodDefs() {} 225 226Parser::LateParsedClass::LateParsedClass(Parser *P, ParsingClass *C) 227 : Self(P), Class(C) {} 228 229Parser::LateParsedClass::~LateParsedClass() { 230 Self->DeallocateParsedClasses(Class); 231} 232 233void Parser::LateParsedClass::ParseLexedMethodDeclarations() { 234 Self->ParseLexedMethodDeclarations(*Class); 235} 236 237void Parser::LateParsedClass::ParseLexedMemberInitializers() { 238 Self->ParseLexedMemberInitializers(*Class); 239} 240 241void Parser::LateParsedClass::ParseLexedMethodDefs() { 242 Self->ParseLexedMethodDefs(*Class); 243} 244 245void Parser::LateParsedMethodDeclaration::ParseLexedMethodDeclarations() { 246 Self->ParseLexedMethodDeclaration(*this); 247} 248 249void Parser::LexedMethod::ParseLexedMethodDefs() { 250 Self->ParseLexedMethodDef(*this); 251} 252 253void Parser::LateParsedMemberInitializer::ParseLexedMemberInitializers() { 254 Self->ParseLexedMemberInitializer(*this); 255} 256 257/// ParseLexedMethodDeclarations - We finished parsing the member 258/// specification of a top (non-nested) C++ class. Now go over the 259/// stack of method declarations with some parts for which parsing was 260/// delayed (such as default arguments) and parse them. 261void Parser::ParseLexedMethodDeclarations(ParsingClass &Class) { 262 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 263 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope); 264 if (HasTemplateScope) 265 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 266 267 // The current scope is still active if we're the top-level class. 268 // Otherwise we'll need to push and enter a new scope. 269 bool HasClassScope = !Class.TopLevelClass; 270 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope, 271 HasClassScope); 272 if (HasClassScope) 273 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate); 274 275 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 276 Class.LateParsedDeclarations[i]->ParseLexedMethodDeclarations(); 277 } 278 279 if (HasClassScope) 280 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), Class.TagOrTemplate); 281} 282 283void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) { 284 // If this is a member template, introduce the template parameter scope. 285 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope); 286 if (LM.TemplateScope) 287 Actions.ActOnReenterTemplateScope(getCurScope(), LM.Method); 288 289 // Start the delayed C++ method declaration 290 Actions.ActOnStartDelayedCXXMethodDeclaration(getCurScope(), LM.Method); 291 292 // Introduce the parameters into scope and parse their default 293 // arguments. 294 ParseScope PrototypeScope(this, 295 Scope::FunctionPrototypeScope|Scope::DeclScope); 296 for (unsigned I = 0, N = LM.DefaultArgs.size(); I != N; ++I) { 297 // Introduce the parameter into scope. 298 Actions.ActOnDelayedCXXMethodParameter(getCurScope(), 299 LM.DefaultArgs[I].Param); 300 301 if (CachedTokens *Toks = LM.DefaultArgs[I].Toks) { 302 // Save the current token position. 303 SourceLocation origLoc = Tok.getLocation(); 304 305 // Parse the default argument from its saved token stream. 306 Toks->push_back(Tok); // So that the current token doesn't get lost 307 PP.EnterTokenStream(&Toks->front(), Toks->size(), true, false); 308 309 // Consume the previously-pushed token. 310 ConsumeAnyToken(); 311 312 // Consume the '='. 313 assert(Tok.is(tok::equal) && "Default argument not starting with '='"); 314 SourceLocation EqualLoc = ConsumeToken(); 315 316 // The argument isn't actually potentially evaluated unless it is 317 // used. 318 EnterExpressionEvaluationContext Eval(Actions, 319 Sema::PotentiallyEvaluatedIfUsed, 320 LM.DefaultArgs[I].Param); 321 322 ExprResult DefArgResult; 323 if (getLangOpts().CPlusPlus0x && Tok.is(tok::l_brace)) { 324 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 325 DefArgResult = ParseBraceInitializer(); 326 } else 327 DefArgResult = ParseAssignmentExpression(); 328 if (DefArgResult.isInvalid()) 329 Actions.ActOnParamDefaultArgumentError(LM.DefaultArgs[I].Param); 330 else { 331 if (Tok.is(tok::cxx_defaultarg_end)) 332 ConsumeToken(); 333 else 334 Diag(Tok.getLocation(), diag::err_default_arg_unparsed); 335 Actions.ActOnParamDefaultArgument(LM.DefaultArgs[I].Param, EqualLoc, 336 DefArgResult.take()); 337 } 338 339 assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, 340 Tok.getLocation()) && 341 "ParseAssignmentExpression went over the default arg tokens!"); 342 // There could be leftover tokens (e.g. because of an error). 343 // Skip through until we reach the original token position. 344 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 345 ConsumeAnyToken(); 346 347 delete Toks; 348 LM.DefaultArgs[I].Toks = 0; 349 } 350 } 351 352 PrototypeScope.Exit(); 353 354 // Finish the delayed C++ method declaration. 355 Actions.ActOnFinishDelayedCXXMethodDeclaration(getCurScope(), LM.Method); 356} 357 358/// ParseLexedMethodDefs - We finished parsing the member specification of a top 359/// (non-nested) C++ class. Now go over the stack of lexed methods that were 360/// collected during its parsing and parse them all. 361void Parser::ParseLexedMethodDefs(ParsingClass &Class) { 362 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 363 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, HasTemplateScope); 364 if (HasTemplateScope) 365 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 366 367 bool HasClassScope = !Class.TopLevelClass; 368 ParseScope ClassScope(this, Scope::ClassScope|Scope::DeclScope, 369 HasClassScope); 370 371 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 372 Class.LateParsedDeclarations[i]->ParseLexedMethodDefs(); 373 } 374} 375 376void Parser::ParseLexedMethodDef(LexedMethod &LM) { 377 // If this is a member template, introduce the template parameter scope. 378 ParseScope TemplateScope(this, Scope::TemplateParamScope, LM.TemplateScope); 379 if (LM.TemplateScope) 380 Actions.ActOnReenterTemplateScope(getCurScope(), LM.D); 381 382 // Save the current token position. 383 SourceLocation origLoc = Tok.getLocation(); 384 385 assert(!LM.Toks.empty() && "Empty body!"); 386 // Append the current token at the end of the new token stream so that it 387 // doesn't get lost. 388 LM.Toks.push_back(Tok); 389 PP.EnterTokenStream(LM.Toks.data(), LM.Toks.size(), true, false); 390 391 // Consume the previously pushed token. 392 ConsumeAnyToken(); 393 assert((Tok.is(tok::l_brace) || Tok.is(tok::colon) || Tok.is(tok::kw_try)) 394 && "Inline method not starting with '{', ':' or 'try'"); 395 396 // Parse the method body. Function body parsing code is similar enough 397 // to be re-used for method bodies as well. 398 ParseScope FnScope(this, Scope::FnScope|Scope::DeclScope); 399 Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D); 400 401 if (Tok.is(tok::kw_try)) { 402 ParseFunctionTryBlock(LM.D, FnScope); 403 assert(!PP.getSourceManager().isBeforeInTranslationUnit(origLoc, 404 Tok.getLocation()) && 405 "ParseFunctionTryBlock went over the cached tokens!"); 406 // There could be leftover tokens (e.g. because of an error). 407 // Skip through until we reach the original token position. 408 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 409 ConsumeAnyToken(); 410 return; 411 } 412 if (Tok.is(tok::colon)) { 413 ParseConstructorInitializer(LM.D); 414 415 // Error recovery. 416 if (!Tok.is(tok::l_brace)) { 417 FnScope.Exit(); 418 Actions.ActOnFinishFunctionBody(LM.D, 0); 419 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 420 ConsumeAnyToken(); 421 return; 422 } 423 } else 424 Actions.ActOnDefaultCtorInitializers(LM.D); 425 426 ParseFunctionStatementBody(LM.D, FnScope); 427 428 if (Tok.getLocation() != origLoc) { 429 // Due to parsing error, we either went over the cached tokens or 430 // there are still cached tokens left. If it's the latter case skip the 431 // leftover tokens. 432 // Since this is an uncommon situation that should be avoided, use the 433 // expensive isBeforeInTranslationUnit call. 434 if (PP.getSourceManager().isBeforeInTranslationUnit(Tok.getLocation(), 435 origLoc)) 436 while (Tok.getLocation() != origLoc && Tok.isNot(tok::eof)) 437 ConsumeAnyToken(); 438 } 439} 440 441/// ParseLexedMemberInitializers - We finished parsing the member specification 442/// of a top (non-nested) C++ class. Now go over the stack of lexed data member 443/// initializers that were collected during its parsing and parse them all. 444void Parser::ParseLexedMemberInitializers(ParsingClass &Class) { 445 bool HasTemplateScope = !Class.TopLevelClass && Class.TemplateScope; 446 ParseScope ClassTemplateScope(this, Scope::TemplateParamScope, 447 HasTemplateScope); 448 if (HasTemplateScope) 449 Actions.ActOnReenterTemplateScope(getCurScope(), Class.TagOrTemplate); 450 451 // Set or update the scope flags. 452 bool AlreadyHasClassScope = Class.TopLevelClass; 453 unsigned ScopeFlags = Scope::ClassScope|Scope::DeclScope; 454 ParseScope ClassScope(this, ScopeFlags, !AlreadyHasClassScope); 455 ParseScopeFlags ClassScopeFlags(this, ScopeFlags, AlreadyHasClassScope); 456 457 if (!AlreadyHasClassScope) 458 Actions.ActOnStartDelayedMemberDeclarations(getCurScope(), 459 Class.TagOrTemplate); 460 461 { 462 // C++11 [expr.prim.general]p4: 463 // Otherwise, if a member-declarator declares a non-static data member 464 // (9.2) of a class X, the expression this is a prvalue of type "pointer 465 // to X" within the optional brace-or-equal-initializer. It shall not 466 // appear elsewhere in the member-declarator. 467 Sema::CXXThisScopeRAII ThisScope(Actions, Class.TagOrTemplate, 468 /*TypeQuals=*/(unsigned)0); 469 470 for (size_t i = 0; i < Class.LateParsedDeclarations.size(); ++i) { 471 Class.LateParsedDeclarations[i]->ParseLexedMemberInitializers(); 472 } 473 } 474 475 if (!AlreadyHasClassScope) 476 Actions.ActOnFinishDelayedMemberDeclarations(getCurScope(), 477 Class.TagOrTemplate); 478 479 Actions.ActOnFinishDelayedMemberInitializers(Class.TagOrTemplate); 480} 481 482void Parser::ParseLexedMemberInitializer(LateParsedMemberInitializer &MI) { 483 if (!MI.Field || MI.Field->isInvalidDecl()) 484 return; 485 486 // Append the current token at the end of the new token stream so that it 487 // doesn't get lost. 488 MI.Toks.push_back(Tok); 489 PP.EnterTokenStream(MI.Toks.data(), MI.Toks.size(), true, false); 490 491 // Consume the previously pushed token. 492 ConsumeAnyToken(); 493 494 SourceLocation EqualLoc; 495 496 ExprResult Init = ParseCXXMemberInitializer(MI.Field, /*IsFunction=*/false, 497 EqualLoc); 498 499 Actions.ActOnCXXInClassMemberInitializer(MI.Field, EqualLoc, Init.release()); 500 501 // The next token should be our artificial terminating EOF token. 502 if (Tok.isNot(tok::eof)) { 503 SourceLocation EndLoc = PP.getLocForEndOfToken(PrevTokLocation); 504 if (!EndLoc.isValid()) 505 EndLoc = Tok.getLocation(); 506 // No fixit; we can't recover as if there were a semicolon here. 507 Diag(EndLoc, diag::err_expected_semi_decl_list); 508 509 // Consume tokens until we hit the artificial EOF. 510 while (Tok.isNot(tok::eof)) 511 ConsumeAnyToken(); 512 } 513 ConsumeAnyToken(); 514} 515 516/// ConsumeAndStoreUntil - Consume and store the token at the passed token 517/// container until the token 'T' is reached (which gets 518/// consumed/stored too, if ConsumeFinalToken). 519/// If StopAtSemi is true, then we will stop early at a ';' character. 520/// Returns true if token 'T1' or 'T2' was found. 521/// NOTE: This is a specialized version of Parser::SkipUntil. 522bool Parser::ConsumeAndStoreUntil(tok::TokenKind T1, tok::TokenKind T2, 523 CachedTokens &Toks, 524 bool StopAtSemi, bool ConsumeFinalToken) { 525 // We always want this function to consume at least one token if the first 526 // token isn't T and if not at EOF. 527 bool isFirstTokenConsumed = true; 528 while (1) { 529 // If we found one of the tokens, stop and return true. 530 if (Tok.is(T1) || Tok.is(T2)) { 531 if (ConsumeFinalToken) { 532 Toks.push_back(Tok); 533 ConsumeAnyToken(); 534 } 535 return true; 536 } 537 538 switch (Tok.getKind()) { 539 case tok::eof: 540 // Ran out of tokens. 541 return false; 542 543 case tok::l_paren: 544 // Recursively consume properly-nested parens. 545 Toks.push_back(Tok); 546 ConsumeParen(); 547 ConsumeAndStoreUntil(tok::r_paren, Toks, /*StopAtSemi=*/false); 548 break; 549 case tok::l_square: 550 // Recursively consume properly-nested square brackets. 551 Toks.push_back(Tok); 552 ConsumeBracket(); 553 ConsumeAndStoreUntil(tok::r_square, Toks, /*StopAtSemi=*/false); 554 break; 555 case tok::l_brace: 556 // Recursively consume properly-nested braces. 557 Toks.push_back(Tok); 558 ConsumeBrace(); 559 ConsumeAndStoreUntil(tok::r_brace, Toks, /*StopAtSemi=*/false); 560 break; 561 562 // Okay, we found a ']' or '}' or ')', which we think should be balanced. 563 // Since the user wasn't looking for this token (if they were, it would 564 // already be handled), this isn't balanced. If there is a LHS token at a 565 // higher level, we will assume that this matches the unbalanced token 566 // and return it. Otherwise, this is a spurious RHS token, which we skip. 567 case tok::r_paren: 568 if (ParenCount && !isFirstTokenConsumed) 569 return false; // Matches something. 570 Toks.push_back(Tok); 571 ConsumeParen(); 572 break; 573 case tok::r_square: 574 if (BracketCount && !isFirstTokenConsumed) 575 return false; // Matches something. 576 Toks.push_back(Tok); 577 ConsumeBracket(); 578 break; 579 case tok::r_brace: 580 if (BraceCount && !isFirstTokenConsumed) 581 return false; // Matches something. 582 Toks.push_back(Tok); 583 ConsumeBrace(); 584 break; 585 586 case tok::code_completion: 587 Toks.push_back(Tok); 588 ConsumeCodeCompletionToken(); 589 break; 590 591 case tok::string_literal: 592 case tok::wide_string_literal: 593 case tok::utf8_string_literal: 594 case tok::utf16_string_literal: 595 case tok::utf32_string_literal: 596 Toks.push_back(Tok); 597 ConsumeStringToken(); 598 break; 599 case tok::semi: 600 if (StopAtSemi) 601 return false; 602 // FALL THROUGH. 603 default: 604 // consume this token. 605 Toks.push_back(Tok); 606 ConsumeToken(); 607 break; 608 } 609 isFirstTokenConsumed = false; 610 } 611} 612 613/// \brief Consume tokens and store them in the passed token container until 614/// we've passed the try keyword and constructor initializers and have consumed 615/// the opening brace of the function body. The opening brace will be consumed 616/// if and only if there was no error. 617/// 618/// \return True on error. 619bool Parser::ConsumeAndStoreFunctionPrologue(CachedTokens &Toks) { 620 if (Tok.is(tok::kw_try)) { 621 Toks.push_back(Tok); 622 ConsumeToken(); 623 } 624 bool ReadInitializer = false; 625 if (Tok.is(tok::colon)) { 626 // Initializers can contain braces too. 627 Toks.push_back(Tok); 628 ConsumeToken(); 629 630 while (Tok.is(tok::identifier) || Tok.is(tok::coloncolon)) { 631 if (Tok.is(tok::eof) || Tok.is(tok::semi)) 632 return Diag(Tok.getLocation(), diag::err_expected_lbrace); 633 634 // Grab the identifier. 635 if (!ConsumeAndStoreUntil(tok::l_paren, tok::l_brace, Toks, 636 /*StopAtSemi=*/true, 637 /*ConsumeFinalToken=*/false)) 638 return Diag(Tok.getLocation(), diag::err_expected_lparen); 639 640 tok::TokenKind kind = Tok.getKind(); 641 Toks.push_back(Tok); 642 bool IsLParen = (kind == tok::l_paren); 643 SourceLocation LOpen = Tok.getLocation(); 644 645 if (IsLParen) { 646 ConsumeParen(); 647 } else { 648 assert(kind == tok::l_brace && "Must be left paren or brace here."); 649 ConsumeBrace(); 650 // In C++03, this has to be the start of the function body, which 651 // means the initializer is malformed; we'll diagnose it later. 652 if (!getLangOpts().CPlusPlus0x) 653 return false; 654 } 655 656 // Grab the initializer 657 if (!ConsumeAndStoreUntil(IsLParen ? tok::r_paren : tok::r_brace, 658 Toks, /*StopAtSemi=*/true)) { 659 Diag(Tok, IsLParen ? diag::err_expected_rparen : 660 diag::err_expected_rbrace); 661 Diag(LOpen, diag::note_matching) << (IsLParen ? "(" : "{"); 662 return true; 663 } 664 665 // Grab pack ellipsis, if present 666 if (Tok.is(tok::ellipsis)) { 667 Toks.push_back(Tok); 668 ConsumeToken(); 669 } 670 671 // Grab the separating comma, if any. 672 if (Tok.is(tok::comma)) { 673 Toks.push_back(Tok); 674 ConsumeToken(); 675 } else if (Tok.isNot(tok::l_brace)) { 676 ReadInitializer = true; 677 break; 678 } 679 } 680 } 681 682 // Grab any remaining garbage to be diagnosed later. We stop when we reach a 683 // brace: an opening one is the function body, while a closing one probably 684 // means we've reached the end of the class. 685 ConsumeAndStoreUntil(tok::l_brace, tok::r_brace, Toks, 686 /*StopAtSemi=*/true, 687 /*ConsumeFinalToken=*/false); 688 if (Tok.isNot(tok::l_brace)) { 689 if (ReadInitializer) 690 return Diag(Tok.getLocation(), diag::err_expected_lbrace_or_comma); 691 return Diag(Tok.getLocation(), diag::err_expected_lbrace); 692 } 693 694 Toks.push_back(Tok); 695 ConsumeBrace(); 696 return false; 697} 698