ParseExpr.cpp revision 4074eefc4c2dc0c554f2e79f7114b309053f9885
1//===--- ParseExpr.cpp - Expression 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 the Expression parsing implementation. Expressions in 11// C99 basically consist of a bunch of binary operators with unary operators and 12// other random stuff at the leaves. 13// 14// In the C99 grammar, these unary operators bind tightest and are represented 15// as the 'cast-expression' production. Everything else is either a binary 16// operator (e.g. '/') or a ternary operator ("?:"). The unary leaves are 17// handled by ParseCastExpression, the higher level pieces are handled by 18// ParseBinaryExpression. 19// 20//===----------------------------------------------------------------------===// 21 22#include "clang/Parse/Parser.h" 23#include "clang/Parse/DeclSpec.h" 24#include "clang/Parse/Scope.h" 25#include "clang/Parse/Template.h" 26#include "clang/Basic/PrettyStackTrace.h" 27#include "RAIIObjectsForParser.h" 28#include "llvm/ADT/SmallVector.h" 29#include "llvm/ADT/SmallString.h" 30using namespace clang; 31 32/// getBinOpPrecedence - Return the precedence of the specified binary operator 33/// token. This returns: 34/// 35static prec::Level getBinOpPrecedence(tok::TokenKind Kind, 36 bool GreaterThanIsOperator, 37 bool CPlusPlus0x) { 38 switch (Kind) { 39 case tok::greater: 40 // C++ [temp.names]p3: 41 // [...] When parsing a template-argument-list, the first 42 // non-nested > is taken as the ending delimiter rather than a 43 // greater-than operator. [...] 44 if (GreaterThanIsOperator) 45 return prec::Relational; 46 return prec::Unknown; 47 48 case tok::greatergreater: 49 // C++0x [temp.names]p3: 50 // 51 // [...] Similarly, the first non-nested >> is treated as two 52 // consecutive but distinct > tokens, the first of which is 53 // taken as the end of the template-argument-list and completes 54 // the template-id. [...] 55 if (GreaterThanIsOperator || !CPlusPlus0x) 56 return prec::Shift; 57 return prec::Unknown; 58 59 default: return prec::Unknown; 60 case tok::comma: return prec::Comma; 61 case tok::equal: 62 case tok::starequal: 63 case tok::slashequal: 64 case tok::percentequal: 65 case tok::plusequal: 66 case tok::minusequal: 67 case tok::lesslessequal: 68 case tok::greatergreaterequal: 69 case tok::ampequal: 70 case tok::caretequal: 71 case tok::pipeequal: return prec::Assignment; 72 case tok::question: return prec::Conditional; 73 case tok::pipepipe: return prec::LogicalOr; 74 case tok::ampamp: return prec::LogicalAnd; 75 case tok::pipe: return prec::InclusiveOr; 76 case tok::caret: return prec::ExclusiveOr; 77 case tok::amp: return prec::And; 78 case tok::exclaimequal: 79 case tok::equalequal: return prec::Equality; 80 case tok::lessequal: 81 case tok::less: 82 case tok::greaterequal: return prec::Relational; 83 case tok::lessless: return prec::Shift; 84 case tok::plus: 85 case tok::minus: return prec::Additive; 86 case tok::percent: 87 case tok::slash: 88 case tok::star: return prec::Multiplicative; 89 case tok::periodstar: 90 case tok::arrowstar: return prec::PointerToMember; 91 } 92} 93 94 95/// ParseExpression - Simple precedence-based parser for binary/ternary 96/// operators. 97/// 98/// Note: we diverge from the C99 grammar when parsing the assignment-expression 99/// production. C99 specifies that the LHS of an assignment operator should be 100/// parsed as a unary-expression, but consistency dictates that it be a 101/// conditional-expession. In practice, the important thing here is that the 102/// LHS of an assignment has to be an l-value, which productions between 103/// unary-expression and conditional-expression don't produce. Because we want 104/// consistency, we parse the LHS as a conditional-expression, then check for 105/// l-value-ness in semantic analysis stages. 106/// 107/// pm-expression: [C++ 5.5] 108/// cast-expression 109/// pm-expression '.*' cast-expression 110/// pm-expression '->*' cast-expression 111/// 112/// multiplicative-expression: [C99 6.5.5] 113/// Note: in C++, apply pm-expression instead of cast-expression 114/// cast-expression 115/// multiplicative-expression '*' cast-expression 116/// multiplicative-expression '/' cast-expression 117/// multiplicative-expression '%' cast-expression 118/// 119/// additive-expression: [C99 6.5.6] 120/// multiplicative-expression 121/// additive-expression '+' multiplicative-expression 122/// additive-expression '-' multiplicative-expression 123/// 124/// shift-expression: [C99 6.5.7] 125/// additive-expression 126/// shift-expression '<<' additive-expression 127/// shift-expression '>>' additive-expression 128/// 129/// relational-expression: [C99 6.5.8] 130/// shift-expression 131/// relational-expression '<' shift-expression 132/// relational-expression '>' shift-expression 133/// relational-expression '<=' shift-expression 134/// relational-expression '>=' shift-expression 135/// 136/// equality-expression: [C99 6.5.9] 137/// relational-expression 138/// equality-expression '==' relational-expression 139/// equality-expression '!=' relational-expression 140/// 141/// AND-expression: [C99 6.5.10] 142/// equality-expression 143/// AND-expression '&' equality-expression 144/// 145/// exclusive-OR-expression: [C99 6.5.11] 146/// AND-expression 147/// exclusive-OR-expression '^' AND-expression 148/// 149/// inclusive-OR-expression: [C99 6.5.12] 150/// exclusive-OR-expression 151/// inclusive-OR-expression '|' exclusive-OR-expression 152/// 153/// logical-AND-expression: [C99 6.5.13] 154/// inclusive-OR-expression 155/// logical-AND-expression '&&' inclusive-OR-expression 156/// 157/// logical-OR-expression: [C99 6.5.14] 158/// logical-AND-expression 159/// logical-OR-expression '||' logical-AND-expression 160/// 161/// conditional-expression: [C99 6.5.15] 162/// logical-OR-expression 163/// logical-OR-expression '?' expression ':' conditional-expression 164/// [GNU] logical-OR-expression '?' ':' conditional-expression 165/// [C++] the third operand is an assignment-expression 166/// 167/// assignment-expression: [C99 6.5.16] 168/// conditional-expression 169/// unary-expression assignment-operator assignment-expression 170/// [C++] throw-expression [C++ 15] 171/// 172/// assignment-operator: one of 173/// = *= /= %= += -= <<= >>= &= ^= |= 174/// 175/// expression: [C99 6.5.17] 176/// assignment-expression 177/// expression ',' assignment-expression 178/// 179Parser::OwningExprResult Parser::ParseExpression() { 180 OwningExprResult LHS(ParseAssignmentExpression()); 181 if (LHS.isInvalid()) return move(LHS); 182 183 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 184} 185 186/// This routine is called when the '@' is seen and consumed. 187/// Current token is an Identifier and is not a 'try'. This 188/// routine is necessary to disambiguate @try-statement from, 189/// for example, @encode-expression. 190/// 191Parser::OwningExprResult 192Parser::ParseExpressionWithLeadingAt(SourceLocation AtLoc) { 193 OwningExprResult LHS(ParseObjCAtExpression(AtLoc)); 194 if (LHS.isInvalid()) return move(LHS); 195 196 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 197} 198 199/// This routine is called when a leading '__extension__' is seen and 200/// consumed. This is necessary because the token gets consumed in the 201/// process of disambiguating between an expression and a declaration. 202Parser::OwningExprResult 203Parser::ParseExpressionWithLeadingExtension(SourceLocation ExtLoc) { 204 OwningExprResult LHS(Actions, true); 205 { 206 // Silence extension warnings in the sub-expression 207 ExtensionRAIIObject O(Diags); 208 209 LHS = ParseCastExpression(false); 210 if (LHS.isInvalid()) return move(LHS); 211 } 212 213 LHS = Actions.ActOnUnaryOp(CurScope, ExtLoc, tok::kw___extension__, 214 move(LHS)); 215 if (LHS.isInvalid()) return move(LHS); 216 217 return ParseRHSOfBinaryExpression(move(LHS), prec::Comma); 218} 219 220/// ParseAssignmentExpression - Parse an expr that doesn't include commas. 221/// 222Parser::OwningExprResult Parser::ParseAssignmentExpression() { 223 if (Tok.is(tok::code_completion)) { 224 Actions.CodeCompleteOrdinaryName(CurScope, Action::CCC_Expression); 225 ConsumeToken(); 226 } 227 228 if (Tok.is(tok::kw_throw)) 229 return ParseThrowExpression(); 230 231 OwningExprResult LHS(ParseCastExpression(false)); 232 if (LHS.isInvalid()) return move(LHS); 233 234 return ParseRHSOfBinaryExpression(move(LHS), prec::Assignment); 235} 236 237/// ParseAssignmentExprWithObjCMessageExprStart - Parse an assignment expression 238/// where part of an objc message send has already been parsed. In this case 239/// LBracLoc indicates the location of the '[' of the message send, and either 240/// ReceiverName or ReceiverExpr is non-null indicating the receiver of the 241/// message. 242/// 243/// Since this handles full assignment-expression's, it handles postfix 244/// expressions and other binary operators for these expressions as well. 245Parser::OwningExprResult 246Parser::ParseAssignmentExprWithObjCMessageExprStart(SourceLocation LBracLoc, 247 SourceLocation SuperLoc, 248 TypeTy *ReceiverType, 249 ExprArg ReceiverExpr) { 250 OwningExprResult R(ParseObjCMessageExpressionBody(LBracLoc, SuperLoc, 251 ReceiverType, 252 move(ReceiverExpr))); 253 if (R.isInvalid()) return move(R); 254 R = ParsePostfixExpressionSuffix(move(R)); 255 if (R.isInvalid()) return move(R); 256 return ParseRHSOfBinaryExpression(move(R), prec::Assignment); 257} 258 259 260Parser::OwningExprResult Parser::ParseConstantExpression() { 261 // C++ [basic.def.odr]p2: 262 // An expression is potentially evaluated unless it appears where an 263 // integral constant expression is required (see 5.19) [...]. 264 EnterExpressionEvaluationContext Unevaluated(Actions, 265 Action::Unevaluated); 266 267 OwningExprResult LHS(ParseCastExpression(false)); 268 if (LHS.isInvalid()) return move(LHS); 269 270 return ParseRHSOfBinaryExpression(move(LHS), prec::Conditional); 271} 272 273/// ParseRHSOfBinaryExpression - Parse a binary expression that starts with 274/// LHS and has a precedence of at least MinPrec. 275Parser::OwningExprResult 276Parser::ParseRHSOfBinaryExpression(OwningExprResult LHS, prec::Level MinPrec) { 277 prec::Level NextTokPrec = getBinOpPrecedence(Tok.getKind(), 278 GreaterThanIsOperator, 279 getLang().CPlusPlus0x); 280 SourceLocation ColonLoc; 281 282 while (1) { 283 // If this token has a lower precedence than we are allowed to parse (e.g. 284 // because we are called recursively, or because the token is not a binop), 285 // then we are done! 286 if (NextTokPrec < MinPrec) 287 return move(LHS); 288 289 // Consume the operator, saving the operator token for error reporting. 290 Token OpToken = Tok; 291 ConsumeToken(); 292 293 // Special case handling for the ternary operator. 294 OwningExprResult TernaryMiddle(Actions, true); 295 if (NextTokPrec == prec::Conditional) { 296 if (Tok.isNot(tok::colon)) { 297 // Don't parse FOO:BAR as if it were a typo for FOO::BAR. 298 ColonProtectionRAIIObject X(*this); 299 300 // Handle this production specially: 301 // logical-OR-expression '?' expression ':' conditional-expression 302 // In particular, the RHS of the '?' is 'expression', not 303 // 'logical-OR-expression' as we might expect. 304 TernaryMiddle = ParseExpression(); 305 if (TernaryMiddle.isInvalid()) 306 return move(TernaryMiddle); 307 } else { 308 // Special case handling of "X ? Y : Z" where Y is empty: 309 // logical-OR-expression '?' ':' conditional-expression [GNU] 310 TernaryMiddle = 0; 311 Diag(Tok, diag::ext_gnu_conditional_expr); 312 } 313 314 if (Tok.is(tok::colon)) { 315 // Eat the colon. 316 ColonLoc = ConsumeToken(); 317 } else { 318 Diag(Tok, diag::err_expected_colon) 319 << FixItHint::CreateInsertion(Tok.getLocation(), ": "); 320 Diag(OpToken, diag::note_matching) << "?"; 321 ColonLoc = Tok.getLocation(); 322 } 323 } 324 325 // Parse another leaf here for the RHS of the operator. 326 // ParseCastExpression works here because all RHS expressions in C have it 327 // as a prefix, at least. However, in C++, an assignment-expression could 328 // be a throw-expression, which is not a valid cast-expression. 329 // Therefore we need some special-casing here. 330 // Also note that the third operand of the conditional operator is 331 // an assignment-expression in C++. 332 OwningExprResult RHS(Actions); 333 if (getLang().CPlusPlus && NextTokPrec <= prec::Conditional) 334 RHS = ParseAssignmentExpression(); 335 else 336 RHS = ParseCastExpression(false); 337 if (RHS.isInvalid()) 338 return move(RHS); 339 340 // Remember the precedence of this operator and get the precedence of the 341 // operator immediately to the right of the RHS. 342 prec::Level ThisPrec = NextTokPrec; 343 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator, 344 getLang().CPlusPlus0x); 345 346 // Assignment and conditional expressions are right-associative. 347 bool isRightAssoc = ThisPrec == prec::Conditional || 348 ThisPrec == prec::Assignment; 349 350 // Get the precedence of the operator to the right of the RHS. If it binds 351 // more tightly with RHS than we do, evaluate it completely first. 352 if (ThisPrec < NextTokPrec || 353 (ThisPrec == NextTokPrec && isRightAssoc)) { 354 // If this is left-associative, only parse things on the RHS that bind 355 // more tightly than the current operator. If it is left-associative, it 356 // is okay, to bind exactly as tightly. For example, compile A=B=C=D as 357 // A=(B=(C=D)), where each paren is a level of recursion here. 358 // The function takes ownership of the RHS. 359 RHS = ParseRHSOfBinaryExpression(move(RHS), 360 static_cast<prec::Level>(ThisPrec + !isRightAssoc)); 361 if (RHS.isInvalid()) 362 return move(RHS); 363 364 NextTokPrec = getBinOpPrecedence(Tok.getKind(), GreaterThanIsOperator, 365 getLang().CPlusPlus0x); 366 } 367 assert(NextTokPrec <= ThisPrec && "Recursion didn't work!"); 368 369 if (!LHS.isInvalid()) { 370 // Combine the LHS and RHS into the LHS (e.g. build AST). 371 if (TernaryMiddle.isInvalid()) { 372 // If we're using '>>' as an operator within a template 373 // argument list (in C++98), suggest the addition of 374 // parentheses so that the code remains well-formed in C++0x. 375 if (!GreaterThanIsOperator && OpToken.is(tok::greatergreater)) 376 SuggestParentheses(OpToken.getLocation(), 377 diag::warn_cxx0x_right_shift_in_template_arg, 378 SourceRange(Actions.getExprRange(LHS.get()).getBegin(), 379 Actions.getExprRange(RHS.get()).getEnd())); 380 381 LHS = Actions.ActOnBinOp(CurScope, OpToken.getLocation(), 382 OpToken.getKind(), move(LHS), move(RHS)); 383 } else 384 LHS = Actions.ActOnConditionalOp(OpToken.getLocation(), ColonLoc, 385 move(LHS), move(TernaryMiddle), 386 move(RHS)); 387 } 388 } 389} 390 391/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is 392/// true, parse a unary-expression. isAddressOfOperand exists because an 393/// id-expression that is the operand of address-of gets special treatment 394/// due to member pointers. 395/// 396Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression, 397 bool isAddressOfOperand, 398 TypeTy *TypeOfCast) { 399 bool NotCastExpr; 400 OwningExprResult Res = ParseCastExpression(isUnaryExpression, 401 isAddressOfOperand, 402 NotCastExpr, 403 TypeOfCast); 404 if (NotCastExpr) 405 Diag(Tok, diag::err_expected_expression); 406 return move(Res); 407} 408 409/// ParseCastExpression - Parse a cast-expression, or, if isUnaryExpression is 410/// true, parse a unary-expression. isAddressOfOperand exists because an 411/// id-expression that is the operand of address-of gets special treatment 412/// due to member pointers. NotCastExpr is set to true if the token is not the 413/// start of a cast-expression, and no diagnostic is emitted in this case. 414/// 415/// cast-expression: [C99 6.5.4] 416/// unary-expression 417/// '(' type-name ')' cast-expression 418/// 419/// unary-expression: [C99 6.5.3] 420/// postfix-expression 421/// '++' unary-expression 422/// '--' unary-expression 423/// unary-operator cast-expression 424/// 'sizeof' unary-expression 425/// 'sizeof' '(' type-name ')' 426/// [GNU] '__alignof' unary-expression 427/// [GNU] '__alignof' '(' type-name ')' 428/// [C++0x] 'alignof' '(' type-id ')' 429/// [GNU] '&&' identifier 430/// [C++] new-expression 431/// [C++] delete-expression 432/// 433/// unary-operator: one of 434/// '&' '*' '+' '-' '~' '!' 435/// [GNU] '__extension__' '__real' '__imag' 436/// 437/// primary-expression: [C99 6.5.1] 438/// [C99] identifier 439/// [C++] id-expression 440/// constant 441/// string-literal 442/// [C++] boolean-literal [C++ 2.13.5] 443/// [C++0x] 'nullptr' [C++0x 2.14.7] 444/// '(' expression ')' 445/// '__func__' [C99 6.4.2.2] 446/// [GNU] '__FUNCTION__' 447/// [GNU] '__PRETTY_FUNCTION__' 448/// [GNU] '(' compound-statement ')' 449/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')' 450/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')' 451/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ',' 452/// assign-expr ')' 453/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')' 454/// [GNU] '__null' 455/// [OBJC] '[' objc-message-expr ']' 456/// [OBJC] '@selector' '(' objc-selector-arg ')' 457/// [OBJC] '@protocol' '(' identifier ')' 458/// [OBJC] '@encode' '(' type-name ')' 459/// [OBJC] objc-string-literal 460/// [C++] simple-type-specifier '(' expression-list[opt] ')' [C++ 5.2.3] 461/// [C++] typename-specifier '(' expression-list[opt] ')' [C++ 5.2.3] 462/// [C++] 'const_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 463/// [C++] 'dynamic_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 464/// [C++] 'reinterpret_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 465/// [C++] 'static_cast' '<' type-name '>' '(' expression ')' [C++ 5.2p1] 466/// [C++] 'typeid' '(' expression ')' [C++ 5.2p1] 467/// [C++] 'typeid' '(' type-id ')' [C++ 5.2p1] 468/// [C++] 'this' [C++ 9.3.2] 469/// [G++] unary-type-trait '(' type-id ')' 470/// [G++] binary-type-trait '(' type-id ',' type-id ')' [TODO] 471/// [clang] '^' block-literal 472/// 473/// constant: [C99 6.4.4] 474/// integer-constant 475/// floating-constant 476/// enumeration-constant -> identifier 477/// character-constant 478/// 479/// id-expression: [C++ 5.1] 480/// unqualified-id 481/// qualified-id 482/// 483/// unqualified-id: [C++ 5.1] 484/// identifier 485/// operator-function-id 486/// conversion-function-id 487/// '~' class-name 488/// template-id 489/// 490/// new-expression: [C++ 5.3.4] 491/// '::'[opt] 'new' new-placement[opt] new-type-id 492/// new-initializer[opt] 493/// '::'[opt] 'new' new-placement[opt] '(' type-id ')' 494/// new-initializer[opt] 495/// 496/// delete-expression: [C++ 5.3.5] 497/// '::'[opt] 'delete' cast-expression 498/// '::'[opt] 'delete' '[' ']' cast-expression 499/// 500/// [GNU] unary-type-trait: 501/// '__has_nothrow_assign' [TODO] 502/// '__has_nothrow_copy' [TODO] 503/// '__has_nothrow_constructor' [TODO] 504/// '__has_trivial_assign' [TODO] 505/// '__has_trivial_copy' [TODO] 506/// '__has_trivial_constructor' 507/// '__has_trivial_destructor' 508/// '__has_virtual_destructor' [TODO] 509/// '__is_abstract' [TODO] 510/// '__is_class' 511/// '__is_empty' [TODO] 512/// '__is_enum' 513/// '__is_pod' 514/// '__is_polymorphic' 515/// '__is_union' 516/// 517/// [GNU] binary-type-trait: 518/// '__is_base_of' [TODO] 519/// 520Parser::OwningExprResult Parser::ParseCastExpression(bool isUnaryExpression, 521 bool isAddressOfOperand, 522 bool &NotCastExpr, 523 TypeTy *TypeOfCast) { 524 OwningExprResult Res(Actions); 525 tok::TokenKind SavedKind = Tok.getKind(); 526 NotCastExpr = false; 527 528 // This handles all of cast-expression, unary-expression, postfix-expression, 529 // and primary-expression. We handle them together like this for efficiency 530 // and to simplify handling of an expression starting with a '(' token: which 531 // may be one of a parenthesized expression, cast-expression, compound literal 532 // expression, or statement expression. 533 // 534 // If the parsed tokens consist of a primary-expression, the cases below 535 // call ParsePostfixExpressionSuffix to handle the postfix expression 536 // suffixes. Cases that cannot be followed by postfix exprs should 537 // return without invoking ParsePostfixExpressionSuffix. 538 switch (SavedKind) { 539 case tok::l_paren: { 540 // If this expression is limited to being a unary-expression, the parent can 541 // not start a cast expression. 542 ParenParseOption ParenExprType = 543 isUnaryExpression ? CompoundLiteral : CastExpr; 544 TypeTy *CastTy; 545 SourceLocation LParenLoc = Tok.getLocation(); 546 SourceLocation RParenLoc; 547 548 { 549 // The inside of the parens don't need to be a colon protected scope. 550 ColonProtectionRAIIObject X(*this, false); 551 552 Res = ParseParenExpression(ParenExprType, false/*stopIfCastExr*/, 553 TypeOfCast, CastTy, RParenLoc); 554 if (Res.isInvalid()) return move(Res); 555 } 556 557 switch (ParenExprType) { 558 case SimpleExpr: break; // Nothing else to do. 559 case CompoundStmt: break; // Nothing else to do. 560 case CompoundLiteral: 561 // We parsed '(' type-name ')' '{' ... '}'. If any suffixes of 562 // postfix-expression exist, parse them now. 563 break; 564 case CastExpr: 565 // We have parsed the cast-expression and no postfix-expr pieces are 566 // following. 567 return move(Res); 568 } 569 570 // These can be followed by postfix-expr pieces. 571 return ParsePostfixExpressionSuffix(move(Res)); 572 } 573 574 // primary-expression 575 case tok::numeric_constant: 576 // constant: integer-constant 577 // constant: floating-constant 578 579 Res = Actions.ActOnNumericConstant(Tok); 580 ConsumeToken(); 581 582 // These can be followed by postfix-expr pieces. 583 return ParsePostfixExpressionSuffix(move(Res)); 584 585 case tok::kw_true: 586 case tok::kw_false: 587 return ParseCXXBoolLiteral(); 588 589 case tok::kw_nullptr: 590 return Actions.ActOnCXXNullPtrLiteral(ConsumeToken()); 591 592 case tok::identifier: { // primary-expression: identifier 593 // unqualified-id: identifier 594 // constant: enumeration-constant 595 // Turn a potentially qualified name into a annot_typename or 596 // annot_cxxscope if it would be valid. This handles things like x::y, etc. 597 if (getLang().CPlusPlus) { 598 // Avoid the unnecessary parse-time lookup in the common case 599 // where the syntax forbids a type. 600 const Token &Next = NextToken(); 601 if (Next.is(tok::coloncolon) || 602 (!ColonIsSacred && Next.is(tok::colon)) || 603 Next.is(tok::less) || 604 Next.is(tok::l_paren)) { 605 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. 606 if (TryAnnotateTypeOrScopeToken()) 607 return ExprError(); 608 if (!Tok.is(tok::identifier)) 609 return ParseCastExpression(isUnaryExpression, isAddressOfOperand); 610 } 611 } 612 613 // Consume the identifier so that we can see if it is followed by a '(' or 614 // '.'. 615 IdentifierInfo &II = *Tok.getIdentifierInfo(); 616 SourceLocation ILoc = ConsumeToken(); 617 618 // Support 'Class.property' and 'super.property' notation. 619 if (getLang().ObjC1 && Tok.is(tok::period) && 620 (Actions.getTypeName(II, ILoc, CurScope) || 621 // Allow the base to be 'super' if in an objc-method. 622 (&II == Ident_super && CurScope->isInObjcMethodScope()))) { 623 SourceLocation DotLoc = ConsumeToken(); 624 625 if (Tok.isNot(tok::identifier)) { 626 Diag(Tok, diag::err_expected_property_name); 627 return ExprError(); 628 } 629 IdentifierInfo &PropertyName = *Tok.getIdentifierInfo(); 630 SourceLocation PropertyLoc = ConsumeToken(); 631 632 Res = Actions.ActOnClassPropertyRefExpr(II, PropertyName, 633 ILoc, PropertyLoc); 634 // These can be followed by postfix-expr pieces. 635 return ParsePostfixExpressionSuffix(move(Res)); 636 } 637 638 // Function designators are allowed to be undeclared (C99 6.5.1p2), so we 639 // need to know whether or not this identifier is a function designator or 640 // not. 641 UnqualifiedId Name; 642 CXXScopeSpec ScopeSpec; 643 Name.setIdentifier(&II, ILoc); 644 Res = Actions.ActOnIdExpression(CurScope, ScopeSpec, Name, 645 Tok.is(tok::l_paren), false); 646 // These can be followed by postfix-expr pieces. 647 return ParsePostfixExpressionSuffix(move(Res)); 648 } 649 case tok::char_constant: // constant: character-constant 650 Res = Actions.ActOnCharacterConstant(Tok); 651 ConsumeToken(); 652 // These can be followed by postfix-expr pieces. 653 return ParsePostfixExpressionSuffix(move(Res)); 654 case tok::kw___func__: // primary-expression: __func__ [C99 6.4.2.2] 655 case tok::kw___FUNCTION__: // primary-expression: __FUNCTION__ [GNU] 656 case tok::kw___PRETTY_FUNCTION__: // primary-expression: __P..Y_F..N__ [GNU] 657 Res = Actions.ActOnPredefinedExpr(Tok.getLocation(), SavedKind); 658 ConsumeToken(); 659 // These can be followed by postfix-expr pieces. 660 return ParsePostfixExpressionSuffix(move(Res)); 661 case tok::string_literal: // primary-expression: string-literal 662 case tok::wide_string_literal: 663 Res = ParseStringLiteralExpression(); 664 if (Res.isInvalid()) return move(Res); 665 // This can be followed by postfix-expr pieces (e.g. "foo"[1]). 666 return ParsePostfixExpressionSuffix(move(Res)); 667 case tok::kw___builtin_va_arg: 668 case tok::kw___builtin_offsetof: 669 case tok::kw___builtin_choose_expr: 670 case tok::kw___builtin_types_compatible_p: 671 return ParseBuiltinPrimaryExpression(); 672 case tok::kw___null: 673 return Actions.ActOnGNUNullExpr(ConsumeToken()); 674 break; 675 case tok::plusplus: // unary-expression: '++' unary-expression 676 case tok::minusminus: { // unary-expression: '--' unary-expression 677 SourceLocation SavedLoc = ConsumeToken(); 678 Res = ParseCastExpression(true); 679 if (!Res.isInvalid()) 680 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 681 return move(Res); 682 } 683 case tok::amp: { // unary-expression: '&' cast-expression 684 // Special treatment because of member pointers 685 SourceLocation SavedLoc = ConsumeToken(); 686 Res = ParseCastExpression(false, true); 687 if (!Res.isInvalid()) 688 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 689 return move(Res); 690 } 691 692 case tok::star: // unary-expression: '*' cast-expression 693 case tok::plus: // unary-expression: '+' cast-expression 694 case tok::minus: // unary-expression: '-' cast-expression 695 case tok::tilde: // unary-expression: '~' cast-expression 696 case tok::exclaim: // unary-expression: '!' cast-expression 697 case tok::kw___real: // unary-expression: '__real' cast-expression [GNU] 698 case tok::kw___imag: { // unary-expression: '__imag' cast-expression [GNU] 699 SourceLocation SavedLoc = ConsumeToken(); 700 Res = ParseCastExpression(false); 701 if (!Res.isInvalid()) 702 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 703 return move(Res); 704 } 705 706 case tok::kw___extension__:{//unary-expression:'__extension__' cast-expr [GNU] 707 // __extension__ silences extension warnings in the subexpression. 708 ExtensionRAIIObject O(Diags); // Use RAII to do this. 709 SourceLocation SavedLoc = ConsumeToken(); 710 Res = ParseCastExpression(false); 711 if (!Res.isInvalid()) 712 Res = Actions.ActOnUnaryOp(CurScope, SavedLoc, SavedKind, move(Res)); 713 return move(Res); 714 } 715 case tok::kw_sizeof: // unary-expression: 'sizeof' unary-expression 716 // unary-expression: 'sizeof' '(' type-name ')' 717 case tok::kw_alignof: 718 case tok::kw___alignof: // unary-expression: '__alignof' unary-expression 719 // unary-expression: '__alignof' '(' type-name ')' 720 // unary-expression: 'alignof' '(' type-id ')' 721 return ParseSizeofAlignofExpression(); 722 case tok::ampamp: { // unary-expression: '&&' identifier 723 SourceLocation AmpAmpLoc = ConsumeToken(); 724 if (Tok.isNot(tok::identifier)) 725 return ExprError(Diag(Tok, diag::err_expected_ident)); 726 727 Diag(AmpAmpLoc, diag::ext_gnu_address_of_label); 728 Res = Actions.ActOnAddrLabel(AmpAmpLoc, Tok.getLocation(), 729 Tok.getIdentifierInfo()); 730 ConsumeToken(); 731 return move(Res); 732 } 733 case tok::kw_const_cast: 734 case tok::kw_dynamic_cast: 735 case tok::kw_reinterpret_cast: 736 case tok::kw_static_cast: 737 Res = ParseCXXCasts(); 738 // These can be followed by postfix-expr pieces. 739 return ParsePostfixExpressionSuffix(move(Res)); 740 case tok::kw_typeid: 741 Res = ParseCXXTypeid(); 742 // This can be followed by postfix-expr pieces. 743 return ParsePostfixExpressionSuffix(move(Res)); 744 case tok::kw_this: 745 Res = ParseCXXThis(); 746 // This can be followed by postfix-expr pieces. 747 return ParsePostfixExpressionSuffix(move(Res)); 748 749 case tok::kw_char: 750 case tok::kw_wchar_t: 751 case tok::kw_char16_t: 752 case tok::kw_char32_t: 753 case tok::kw_bool: 754 case tok::kw_short: 755 case tok::kw_int: 756 case tok::kw_long: 757 case tok::kw_signed: 758 case tok::kw_unsigned: 759 case tok::kw_float: 760 case tok::kw_double: 761 case tok::kw_void: 762 case tok::kw_typename: 763 case tok::kw_typeof: 764 case tok::kw___vector: 765 case tok::annot_typename: { 766 if (!getLang().CPlusPlus) { 767 Diag(Tok, diag::err_expected_expression); 768 return ExprError(); 769 } 770 771 if (SavedKind == tok::kw_typename) { 772 // postfix-expression: typename-specifier '(' expression-list[opt] ')' 773 if (TryAnnotateTypeOrScopeToken()) 774 return ExprError(); 775 } 776 777 // postfix-expression: simple-type-specifier '(' expression-list[opt] ')' 778 // 779 DeclSpec DS; 780 ParseCXXSimpleTypeSpecifier(DS); 781 if (Tok.isNot(tok::l_paren)) 782 return ExprError(Diag(Tok, diag::err_expected_lparen_after_type) 783 << DS.getSourceRange()); 784 785 Res = ParseCXXTypeConstructExpression(DS); 786 // This can be followed by postfix-expr pieces. 787 return ParsePostfixExpressionSuffix(move(Res)); 788 } 789 790 case tok::annot_cxxscope: { // [C++] id-expression: qualified-id 791 // If TryAnnotateTypeOrScopeToken annotates the token, tail recurse. 792 // (We can end up in this situation after tentative parsing.) 793 if (TryAnnotateTypeOrScopeToken()) 794 return ExprError(); 795 if (!Tok.is(tok::annot_cxxscope)) 796 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 797 NotCastExpr, TypeOfCast); 798 799 Token Next = NextToken(); 800 if (Next.is(tok::annot_template_id)) { 801 TemplateIdAnnotation *TemplateId 802 = static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue()); 803 if (TemplateId->Kind == TNK_Type_template) { 804 // We have a qualified template-id that we know refers to a 805 // type, translate it into a type and continue parsing as a 806 // cast expression. 807 CXXScopeSpec SS; 808 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/0, false); 809 AnnotateTemplateIdTokenAsType(&SS); 810 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 811 NotCastExpr, TypeOfCast); 812 } 813 } 814 815 // Parse as an id-expression. 816 Res = ParseCXXIdExpression(isAddressOfOperand); 817 return ParsePostfixExpressionSuffix(move(Res)); 818 } 819 820 case tok::annot_template_id: { // [C++] template-id 821 TemplateIdAnnotation *TemplateId 822 = static_cast<TemplateIdAnnotation *>(Tok.getAnnotationValue()); 823 if (TemplateId->Kind == TNK_Type_template) { 824 // We have a template-id that we know refers to a type, 825 // translate it into a type and continue parsing as a cast 826 // expression. 827 AnnotateTemplateIdTokenAsType(); 828 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 829 NotCastExpr, TypeOfCast); 830 } 831 832 // Fall through to treat the template-id as an id-expression. 833 } 834 835 case tok::kw_operator: // [C++] id-expression: operator/conversion-function-id 836 Res = ParseCXXIdExpression(isAddressOfOperand); 837 return ParsePostfixExpressionSuffix(move(Res)); 838 839 case tok::coloncolon: { 840 // ::foo::bar -> global qualified name etc. If TryAnnotateTypeOrScopeToken 841 // annotates the token, tail recurse. 842 if (TryAnnotateTypeOrScopeToken()) 843 return ExprError(); 844 if (!Tok.is(tok::coloncolon)) 845 return ParseCastExpression(isUnaryExpression, isAddressOfOperand); 846 847 // ::new -> [C++] new-expression 848 // ::delete -> [C++] delete-expression 849 SourceLocation CCLoc = ConsumeToken(); 850 if (Tok.is(tok::kw_new)) 851 return ParseCXXNewExpression(true, CCLoc); 852 if (Tok.is(tok::kw_delete)) 853 return ParseCXXDeleteExpression(true, CCLoc); 854 855 // This is not a type name or scope specifier, it is an invalid expression. 856 Diag(CCLoc, diag::err_expected_expression); 857 return ExprError(); 858 } 859 860 case tok::kw_new: // [C++] new-expression 861 return ParseCXXNewExpression(false, Tok.getLocation()); 862 863 case tok::kw_delete: // [C++] delete-expression 864 return ParseCXXDeleteExpression(false, Tok.getLocation()); 865 866 case tok::kw___is_pod: // [GNU] unary-type-trait 867 case tok::kw___is_class: 868 case tok::kw___is_enum: 869 case tok::kw___is_union: 870 case tok::kw___is_empty: 871 case tok::kw___is_polymorphic: 872 case tok::kw___is_abstract: 873 case tok::kw___is_literal: 874 case tok::kw___has_trivial_constructor: 875 case tok::kw___has_trivial_copy: 876 case tok::kw___has_trivial_assign: 877 case tok::kw___has_trivial_destructor: 878 return ParseUnaryTypeTrait(); 879 880 case tok::at: { 881 SourceLocation AtLoc = ConsumeToken(); 882 return ParseObjCAtExpression(AtLoc); 883 } 884 case tok::caret: 885 return ParsePostfixExpressionSuffix(ParseBlockLiteralExpression()); 886 case tok::code_completion: 887 Actions.CodeCompleteOrdinaryName(CurScope, Action::CCC_Expression); 888 ConsumeToken(); 889 return ParseCastExpression(isUnaryExpression, isAddressOfOperand, 890 NotCastExpr, TypeOfCast); 891 case tok::l_square: 892 // These can be followed by postfix-expr pieces. 893 if (getLang().ObjC1) 894 return ParsePostfixExpressionSuffix(ParseObjCMessageExpression()); 895 // FALL THROUGH. 896 default: 897 NotCastExpr = true; 898 return ExprError(); 899 } 900 901 // unreachable. 902 abort(); 903} 904 905/// ParsePostfixExpressionSuffix - Once the leading part of a postfix-expression 906/// is parsed, this method parses any suffixes that apply. 907/// 908/// postfix-expression: [C99 6.5.2] 909/// primary-expression 910/// postfix-expression '[' expression ']' 911/// postfix-expression '(' argument-expression-list[opt] ')' 912/// postfix-expression '.' identifier 913/// postfix-expression '->' identifier 914/// postfix-expression '++' 915/// postfix-expression '--' 916/// '(' type-name ')' '{' initializer-list '}' 917/// '(' type-name ')' '{' initializer-list ',' '}' 918/// 919/// argument-expression-list: [C99 6.5.2] 920/// argument-expression 921/// argument-expression-list ',' assignment-expression 922/// 923Parser::OwningExprResult 924Parser::ParsePostfixExpressionSuffix(OwningExprResult LHS) { 925 // Now that the primary-expression piece of the postfix-expression has been 926 // parsed, see if there are any postfix-expression pieces here. 927 SourceLocation Loc; 928 while (1) { 929 switch (Tok.getKind()) { 930 default: // Not a postfix-expression suffix. 931 return move(LHS); 932 case tok::l_square: { // postfix-expression: p-e '[' expression ']' 933 Loc = ConsumeBracket(); 934 OwningExprResult Idx(ParseExpression()); 935 936 SourceLocation RLoc = Tok.getLocation(); 937 938 if (!LHS.isInvalid() && !Idx.isInvalid() && Tok.is(tok::r_square)) { 939 LHS = Actions.ActOnArraySubscriptExpr(CurScope, move(LHS), Loc, 940 move(Idx), RLoc); 941 } else 942 LHS = ExprError(); 943 944 // Match the ']'. 945 MatchRHSPunctuation(tok::r_square, Loc); 946 break; 947 } 948 949 case tok::l_paren: { // p-e: p-e '(' argument-expression-list[opt] ')' 950 ExprVector ArgExprs(Actions); 951 CommaLocsTy CommaLocs; 952 953 Loc = ConsumeParen(); 954 955 if (Tok.is(tok::code_completion)) { 956 Actions.CodeCompleteCall(CurScope, LHS.get(), 0, 0); 957 ConsumeToken(); 958 } 959 960 if (Tok.isNot(tok::r_paren)) { 961 if (ParseExpressionList(ArgExprs, CommaLocs, &Action::CodeCompleteCall, 962 LHS.get())) { 963 SkipUntil(tok::r_paren); 964 return ExprError(); 965 } 966 } 967 968 // Match the ')'. 969 if (Tok.isNot(tok::r_paren)) { 970 MatchRHSPunctuation(tok::r_paren, Loc); 971 return ExprError(); 972 } 973 974 if (!LHS.isInvalid()) { 975 assert((ArgExprs.size() == 0 || ArgExprs.size()-1 == CommaLocs.size())&& 976 "Unexpected number of commas!"); 977 LHS = Actions.ActOnCallExpr(CurScope, move(LHS), Loc, 978 move_arg(ArgExprs), CommaLocs.data(), 979 Tok.getLocation()); 980 } 981 982 ConsumeParen(); 983 break; 984 } 985 case tok::arrow: 986 case tok::period: { 987 // postfix-expression: p-e '->' template[opt] id-expression 988 // postfix-expression: p-e '.' template[opt] id-expression 989 tok::TokenKind OpKind = Tok.getKind(); 990 SourceLocation OpLoc = ConsumeToken(); // Eat the "." or "->" token. 991 992 CXXScopeSpec SS; 993 Action::TypeTy *ObjectType = 0; 994 bool MayBePseudoDestructor = false; 995 if (getLang().CPlusPlus && !LHS.isInvalid()) { 996 LHS = Actions.ActOnStartCXXMemberReference(CurScope, move(LHS), 997 OpLoc, OpKind, ObjectType, 998 MayBePseudoDestructor); 999 if (LHS.isInvalid()) 1000 break; 1001 1002 ParseOptionalCXXScopeSpecifier(SS, ObjectType, false, 1003 &MayBePseudoDestructor); 1004 } 1005 1006 if (Tok.is(tok::code_completion)) { 1007 // Code completion for a member access expression. 1008 Actions.CodeCompleteMemberReferenceExpr(CurScope, LHS.get(), 1009 OpLoc, OpKind == tok::arrow); 1010 1011 ConsumeToken(); 1012 } 1013 1014 if (MayBePseudoDestructor) { 1015 LHS = ParseCXXPseudoDestructor(move(LHS), OpLoc, OpKind, SS, 1016 ObjectType); 1017 break; 1018 } 1019 1020 // Either the action has told is that this cannot be a 1021 // pseudo-destructor expression (based on the type of base 1022 // expression), or we didn't see a '~' in the right place. We 1023 // can still parse a destructor name here, but in that case it 1024 // names a real destructor. 1025 UnqualifiedId Name; 1026 if (ParseUnqualifiedId(SS, 1027 /*EnteringContext=*/false, 1028 /*AllowDestructorName=*/true, 1029 /*AllowConstructorName=*/false, 1030 ObjectType, 1031 Name)) 1032 return ExprError(); 1033 1034 if (!LHS.isInvalid()) 1035 LHS = Actions.ActOnMemberAccessExpr(CurScope, move(LHS), OpLoc, 1036 OpKind, SS, Name, ObjCImpDecl, 1037 Tok.is(tok::l_paren)); 1038 break; 1039 } 1040 case tok::plusplus: // postfix-expression: postfix-expression '++' 1041 case tok::minusminus: // postfix-expression: postfix-expression '--' 1042 if (!LHS.isInvalid()) { 1043 LHS = Actions.ActOnPostfixUnaryOp(CurScope, Tok.getLocation(), 1044 Tok.getKind(), move(LHS)); 1045 } 1046 ConsumeToken(); 1047 break; 1048 } 1049 } 1050} 1051 1052/// ParseExprAfterTypeofSizeofAlignof - We parsed a typeof/sizeof/alignof and 1053/// we are at the start of an expression or a parenthesized type-id. 1054/// OpTok is the operand token (typeof/sizeof/alignof). Returns the expression 1055/// (isCastExpr == false) or the type (isCastExpr == true). 1056/// 1057/// unary-expression: [C99 6.5.3] 1058/// 'sizeof' unary-expression 1059/// 'sizeof' '(' type-name ')' 1060/// [GNU] '__alignof' unary-expression 1061/// [GNU] '__alignof' '(' type-name ')' 1062/// [C++0x] 'alignof' '(' type-id ')' 1063/// 1064/// [GNU] typeof-specifier: 1065/// typeof ( expressions ) 1066/// typeof ( type-name ) 1067/// [GNU/C++] typeof unary-expression 1068/// 1069Parser::OwningExprResult 1070Parser::ParseExprAfterTypeofSizeofAlignof(const Token &OpTok, 1071 bool &isCastExpr, 1072 TypeTy *&CastTy, 1073 SourceRange &CastRange) { 1074 1075 assert((OpTok.is(tok::kw_typeof) || OpTok.is(tok::kw_sizeof) || 1076 OpTok.is(tok::kw___alignof) || OpTok.is(tok::kw_alignof)) && 1077 "Not a typeof/sizeof/alignof expression!"); 1078 1079 OwningExprResult Operand(Actions); 1080 1081 // If the operand doesn't start with an '(', it must be an expression. 1082 if (Tok.isNot(tok::l_paren)) { 1083 isCastExpr = false; 1084 if (OpTok.is(tok::kw_typeof) && !getLang().CPlusPlus) { 1085 Diag(Tok,diag::err_expected_lparen_after_id) << OpTok.getIdentifierInfo(); 1086 return ExprError(); 1087 } 1088 1089 // C++0x [expr.sizeof]p1: 1090 // [...] The operand is either an expression, which is an unevaluated 1091 // operand (Clause 5) [...] 1092 // 1093 // The GNU typeof and alignof extensions also behave as unevaluated 1094 // operands. 1095 EnterExpressionEvaluationContext Unevaluated(Actions, 1096 Action::Unevaluated); 1097 Operand = ParseCastExpression(true/*isUnaryExpression*/); 1098 } else { 1099 // If it starts with a '(', we know that it is either a parenthesized 1100 // type-name, or it is a unary-expression that starts with a compound 1101 // literal, or starts with a primary-expression that is a parenthesized 1102 // expression. 1103 ParenParseOption ExprType = CastExpr; 1104 SourceLocation LParenLoc = Tok.getLocation(), RParenLoc; 1105 1106 // C++0x [expr.sizeof]p1: 1107 // [...] The operand is either an expression, which is an unevaluated 1108 // operand (Clause 5) [...] 1109 // 1110 // The GNU typeof and alignof extensions also behave as unevaluated 1111 // operands. 1112 EnterExpressionEvaluationContext Unevaluated(Actions, 1113 Action::Unevaluated); 1114 Operand = ParseParenExpression(ExprType, true/*stopIfCastExpr*/, 1115 0/*TypeOfCast*/, 1116 CastTy, RParenLoc); 1117 CastRange = SourceRange(LParenLoc, RParenLoc); 1118 1119 // If ParseParenExpression parsed a '(typename)' sequence only, then this is 1120 // a type. 1121 if (ExprType == CastExpr) { 1122 isCastExpr = true; 1123 return ExprEmpty(); 1124 } 1125 1126 // If this is a parenthesized expression, it is the start of a 1127 // unary-expression, but doesn't include any postfix pieces. Parse these 1128 // now if present. 1129 Operand = ParsePostfixExpressionSuffix(move(Operand)); 1130 } 1131 1132 // If we get here, the operand to the typeof/sizeof/alignof was an expresion. 1133 isCastExpr = false; 1134 return move(Operand); 1135} 1136 1137 1138/// ParseSizeofAlignofExpression - Parse a sizeof or alignof expression. 1139/// unary-expression: [C99 6.5.3] 1140/// 'sizeof' unary-expression 1141/// 'sizeof' '(' type-name ')' 1142/// [GNU] '__alignof' unary-expression 1143/// [GNU] '__alignof' '(' type-name ')' 1144/// [C++0x] 'alignof' '(' type-id ')' 1145Parser::OwningExprResult Parser::ParseSizeofAlignofExpression() { 1146 assert((Tok.is(tok::kw_sizeof) || Tok.is(tok::kw___alignof) 1147 || Tok.is(tok::kw_alignof)) && 1148 "Not a sizeof/alignof expression!"); 1149 Token OpTok = Tok; 1150 ConsumeToken(); 1151 1152 bool isCastExpr; 1153 TypeTy *CastTy; 1154 SourceRange CastRange; 1155 OwningExprResult Operand = ParseExprAfterTypeofSizeofAlignof(OpTok, 1156 isCastExpr, 1157 CastTy, 1158 CastRange); 1159 1160 if (isCastExpr) 1161 return Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(), 1162 OpTok.is(tok::kw_sizeof), 1163 /*isType=*/true, CastTy, 1164 CastRange); 1165 1166 // If we get here, the operand to the sizeof/alignof was an expresion. 1167 if (!Operand.isInvalid()) 1168 Operand = Actions.ActOnSizeOfAlignOfExpr(OpTok.getLocation(), 1169 OpTok.is(tok::kw_sizeof), 1170 /*isType=*/false, 1171 Operand.release(), CastRange); 1172 return move(Operand); 1173} 1174 1175/// ParseBuiltinPrimaryExpression 1176/// 1177/// primary-expression: [C99 6.5.1] 1178/// [GNU] '__builtin_va_arg' '(' assignment-expression ',' type-name ')' 1179/// [GNU] '__builtin_offsetof' '(' type-name ',' offsetof-member-designator')' 1180/// [GNU] '__builtin_choose_expr' '(' assign-expr ',' assign-expr ',' 1181/// assign-expr ')' 1182/// [GNU] '__builtin_types_compatible_p' '(' type-name ',' type-name ')' 1183/// 1184/// [GNU] offsetof-member-designator: 1185/// [GNU] identifier 1186/// [GNU] offsetof-member-designator '.' identifier 1187/// [GNU] offsetof-member-designator '[' expression ']' 1188/// 1189Parser::OwningExprResult Parser::ParseBuiltinPrimaryExpression() { 1190 OwningExprResult Res(Actions); 1191 const IdentifierInfo *BuiltinII = Tok.getIdentifierInfo(); 1192 1193 tok::TokenKind T = Tok.getKind(); 1194 SourceLocation StartLoc = ConsumeToken(); // Eat the builtin identifier. 1195 1196 // All of these start with an open paren. 1197 if (Tok.isNot(tok::l_paren)) 1198 return ExprError(Diag(Tok, diag::err_expected_lparen_after_id) 1199 << BuiltinII); 1200 1201 SourceLocation LParenLoc = ConsumeParen(); 1202 // TODO: Build AST. 1203 1204 switch (T) { 1205 default: assert(0 && "Not a builtin primary expression!"); 1206 case tok::kw___builtin_va_arg: { 1207 OwningExprResult Expr(ParseAssignmentExpression()); 1208 if (Expr.isInvalid()) { 1209 SkipUntil(tok::r_paren); 1210 return ExprError(); 1211 } 1212 1213 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1214 return ExprError(); 1215 1216 TypeResult Ty = ParseTypeName(); 1217 1218 if (Tok.isNot(tok::r_paren)) { 1219 Diag(Tok, diag::err_expected_rparen); 1220 return ExprError(); 1221 } 1222 if (Ty.isInvalid()) 1223 Res = ExprError(); 1224 else 1225 Res = Actions.ActOnVAArg(StartLoc, move(Expr), Ty.get(), ConsumeParen()); 1226 break; 1227 } 1228 case tok::kw___builtin_offsetof: { 1229 SourceLocation TypeLoc = Tok.getLocation(); 1230 TypeResult Ty = ParseTypeName(); 1231 if (Ty.isInvalid()) { 1232 SkipUntil(tok::r_paren); 1233 return ExprError(); 1234 } 1235 1236 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1237 return ExprError(); 1238 1239 // We must have at least one identifier here. 1240 if (Tok.isNot(tok::identifier)) { 1241 Diag(Tok, diag::err_expected_ident); 1242 SkipUntil(tok::r_paren); 1243 return ExprError(); 1244 } 1245 1246 // Keep track of the various subcomponents we see. 1247 llvm::SmallVector<Action::OffsetOfComponent, 4> Comps; 1248 1249 Comps.push_back(Action::OffsetOfComponent()); 1250 Comps.back().isBrackets = false; 1251 Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); 1252 Comps.back().LocStart = Comps.back().LocEnd = ConsumeToken(); 1253 1254 // FIXME: This loop leaks the index expressions on error. 1255 while (1) { 1256 if (Tok.is(tok::period)) { 1257 // offsetof-member-designator: offsetof-member-designator '.' identifier 1258 Comps.push_back(Action::OffsetOfComponent()); 1259 Comps.back().isBrackets = false; 1260 Comps.back().LocStart = ConsumeToken(); 1261 1262 if (Tok.isNot(tok::identifier)) { 1263 Diag(Tok, diag::err_expected_ident); 1264 SkipUntil(tok::r_paren); 1265 return ExprError(); 1266 } 1267 Comps.back().U.IdentInfo = Tok.getIdentifierInfo(); 1268 Comps.back().LocEnd = ConsumeToken(); 1269 1270 } else if (Tok.is(tok::l_square)) { 1271 // offsetof-member-designator: offsetof-member-design '[' expression ']' 1272 Comps.push_back(Action::OffsetOfComponent()); 1273 Comps.back().isBrackets = true; 1274 Comps.back().LocStart = ConsumeBracket(); 1275 Res = ParseExpression(); 1276 if (Res.isInvalid()) { 1277 SkipUntil(tok::r_paren); 1278 return move(Res); 1279 } 1280 Comps.back().U.E = Res.release(); 1281 1282 Comps.back().LocEnd = 1283 MatchRHSPunctuation(tok::r_square, Comps.back().LocStart); 1284 } else { 1285 if (Tok.isNot(tok::r_paren)) { 1286 MatchRHSPunctuation(tok::r_paren, LParenLoc); 1287 Res = ExprError(); 1288 } else if (Ty.isInvalid()) { 1289 Res = ExprError(); 1290 } else { 1291 Res = Actions.ActOnBuiltinOffsetOf(CurScope, StartLoc, TypeLoc, 1292 Ty.get(), &Comps[0], 1293 Comps.size(), ConsumeParen()); 1294 } 1295 break; 1296 } 1297 } 1298 break; 1299 } 1300 case tok::kw___builtin_choose_expr: { 1301 OwningExprResult Cond(ParseAssignmentExpression()); 1302 if (Cond.isInvalid()) { 1303 SkipUntil(tok::r_paren); 1304 return move(Cond); 1305 } 1306 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1307 return ExprError(); 1308 1309 OwningExprResult Expr1(ParseAssignmentExpression()); 1310 if (Expr1.isInvalid()) { 1311 SkipUntil(tok::r_paren); 1312 return move(Expr1); 1313 } 1314 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1315 return ExprError(); 1316 1317 OwningExprResult Expr2(ParseAssignmentExpression()); 1318 if (Expr2.isInvalid()) { 1319 SkipUntil(tok::r_paren); 1320 return move(Expr2); 1321 } 1322 if (Tok.isNot(tok::r_paren)) { 1323 Diag(Tok, diag::err_expected_rparen); 1324 return ExprError(); 1325 } 1326 Res = Actions.ActOnChooseExpr(StartLoc, move(Cond), move(Expr1), 1327 move(Expr2), ConsumeParen()); 1328 break; 1329 } 1330 case tok::kw___builtin_types_compatible_p: 1331 TypeResult Ty1 = ParseTypeName(); 1332 1333 if (ExpectAndConsume(tok::comma, diag::err_expected_comma, "",tok::r_paren)) 1334 return ExprError(); 1335 1336 TypeResult Ty2 = ParseTypeName(); 1337 1338 if (Tok.isNot(tok::r_paren)) { 1339 Diag(Tok, diag::err_expected_rparen); 1340 return ExprError(); 1341 } 1342 1343 if (Ty1.isInvalid() || Ty2.isInvalid()) 1344 Res = ExprError(); 1345 else 1346 Res = Actions.ActOnTypesCompatibleExpr(StartLoc, Ty1.get(), Ty2.get(), 1347 ConsumeParen()); 1348 break; 1349 } 1350 1351 // These can be followed by postfix-expr pieces because they are 1352 // primary-expressions. 1353 return ParsePostfixExpressionSuffix(move(Res)); 1354} 1355 1356/// ParseParenExpression - This parses the unit that starts with a '(' token, 1357/// based on what is allowed by ExprType. The actual thing parsed is returned 1358/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type, 1359/// not the parsed cast-expression. 1360/// 1361/// primary-expression: [C99 6.5.1] 1362/// '(' expression ')' 1363/// [GNU] '(' compound-statement ')' (if !ParenExprOnly) 1364/// postfix-expression: [C99 6.5.2] 1365/// '(' type-name ')' '{' initializer-list '}' 1366/// '(' type-name ')' '{' initializer-list ',' '}' 1367/// cast-expression: [C99 6.5.4] 1368/// '(' type-name ')' cast-expression 1369/// 1370Parser::OwningExprResult 1371Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, 1372 TypeTy *TypeOfCast, TypeTy *&CastTy, 1373 SourceLocation &RParenLoc) { 1374 assert(Tok.is(tok::l_paren) && "Not a paren expr!"); 1375 GreaterThanIsOperatorScope G(GreaterThanIsOperator, true); 1376 SourceLocation OpenLoc = ConsumeParen(); 1377 OwningExprResult Result(Actions, true); 1378 bool isAmbiguousTypeId; 1379 CastTy = 0; 1380 1381 if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) { 1382 Diag(Tok, diag::ext_gnu_statement_expr); 1383 OwningStmtResult Stmt(ParseCompoundStatement(0, true)); 1384 ExprType = CompoundStmt; 1385 1386 // If the substmt parsed correctly, build the AST node. 1387 if (!Stmt.isInvalid() && Tok.is(tok::r_paren)) 1388 Result = Actions.ActOnStmtExpr(OpenLoc, move(Stmt), Tok.getLocation()); 1389 1390 } else if (ExprType >= CompoundLiteral && 1391 isTypeIdInParens(isAmbiguousTypeId)) { 1392 1393 // Otherwise, this is a compound literal expression or cast expression. 1394 1395 // In C++, if the type-id is ambiguous we disambiguate based on context. 1396 // If stopIfCastExpr is true the context is a typeof/sizeof/alignof 1397 // in which case we should treat it as type-id. 1398 // if stopIfCastExpr is false, we need to determine the context past the 1399 // parens, so we defer to ParseCXXAmbiguousParenExpression for that. 1400 if (isAmbiguousTypeId && !stopIfCastExpr) 1401 return ParseCXXAmbiguousParenExpression(ExprType, CastTy, 1402 OpenLoc, RParenLoc); 1403 1404 TypeResult Ty = ParseTypeName(); 1405 1406 // Match the ')'. 1407 if (Tok.is(tok::r_paren)) 1408 RParenLoc = ConsumeParen(); 1409 else 1410 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1411 1412 if (Tok.is(tok::l_brace)) { 1413 ExprType = CompoundLiteral; 1414 return ParseCompoundLiteralExpression(Ty.get(), OpenLoc, RParenLoc); 1415 } 1416 1417 if (ExprType == CastExpr) { 1418 // We parsed '(' type-name ')' and the thing after it wasn't a '{'. 1419 1420 if (Ty.isInvalid()) 1421 return ExprError(); 1422 1423 CastTy = Ty.get(); 1424 1425 // Note that this doesn't parse the subsequent cast-expression, it just 1426 // returns the parsed type to the callee. 1427 if (stopIfCastExpr) 1428 return OwningExprResult(Actions); 1429 1430 // Reject the cast of super idiom in ObjC. 1431 if (Tok.is(tok::identifier) && getLang().ObjC1 && 1432 Tok.getIdentifierInfo() == Ident_super && 1433 CurScope->isInObjcMethodScope() && 1434 GetLookAheadToken(1).isNot(tok::period)) { 1435 Diag(Tok.getLocation(), diag::err_illegal_super_cast) 1436 << SourceRange(OpenLoc, RParenLoc); 1437 return ExprError(); 1438 } 1439 1440 // Parse the cast-expression that follows it next. 1441 // TODO: For cast expression with CastTy. 1442 Result = ParseCastExpression(false, false, CastTy); 1443 if (!Result.isInvalid()) 1444 Result = Actions.ActOnCastExpr(CurScope, OpenLoc, CastTy, RParenLoc, 1445 move(Result)); 1446 return move(Result); 1447 } 1448 1449 Diag(Tok, diag::err_expected_lbrace_in_compound_literal); 1450 return ExprError(); 1451 } else if (TypeOfCast) { 1452 // Parse the expression-list. 1453 ExprVector ArgExprs(Actions); 1454 CommaLocsTy CommaLocs; 1455 1456 if (!ParseExpressionList(ArgExprs, CommaLocs)) { 1457 ExprType = SimpleExpr; 1458 Result = Actions.ActOnParenOrParenListExpr(OpenLoc, Tok.getLocation(), 1459 move_arg(ArgExprs), TypeOfCast); 1460 } 1461 } else { 1462 Result = ParseExpression(); 1463 ExprType = SimpleExpr; 1464 if (!Result.isInvalid() && Tok.is(tok::r_paren)) 1465 Result = Actions.ActOnParenExpr(OpenLoc, Tok.getLocation(), move(Result)); 1466 } 1467 1468 // Match the ')'. 1469 if (Result.isInvalid()) { 1470 SkipUntil(tok::r_paren); 1471 return ExprError(); 1472 } 1473 1474 if (Tok.is(tok::r_paren)) 1475 RParenLoc = ConsumeParen(); 1476 else 1477 MatchRHSPunctuation(tok::r_paren, OpenLoc); 1478 1479 return move(Result); 1480} 1481 1482/// ParseCompoundLiteralExpression - We have parsed the parenthesized type-name 1483/// and we are at the left brace. 1484/// 1485/// postfix-expression: [C99 6.5.2] 1486/// '(' type-name ')' '{' initializer-list '}' 1487/// '(' type-name ')' '{' initializer-list ',' '}' 1488/// 1489Parser::OwningExprResult 1490Parser::ParseCompoundLiteralExpression(TypeTy *Ty, 1491 SourceLocation LParenLoc, 1492 SourceLocation RParenLoc) { 1493 assert(Tok.is(tok::l_brace) && "Not a compound literal!"); 1494 if (!getLang().C99) // Compound literals don't exist in C90. 1495 Diag(LParenLoc, diag::ext_c99_compound_literal); 1496 OwningExprResult Result = ParseInitializer(); 1497 if (!Result.isInvalid() && Ty) 1498 return Actions.ActOnCompoundLiteral(LParenLoc, Ty, RParenLoc, move(Result)); 1499 return move(Result); 1500} 1501 1502/// ParseStringLiteralExpression - This handles the various token types that 1503/// form string literals, and also handles string concatenation [C99 5.1.1.2, 1504/// translation phase #6]. 1505/// 1506/// primary-expression: [C99 6.5.1] 1507/// string-literal 1508Parser::OwningExprResult Parser::ParseStringLiteralExpression() { 1509 assert(isTokenStringLiteral() && "Not a string literal!"); 1510 1511 // String concat. Note that keywords like __func__ and __FUNCTION__ are not 1512 // considered to be strings for concatenation purposes. 1513 llvm::SmallVector<Token, 4> StringToks; 1514 1515 do { 1516 StringToks.push_back(Tok); 1517 ConsumeStringToken(); 1518 } while (isTokenStringLiteral()); 1519 1520 // Pass the set of string tokens, ready for concatenation, to the actions. 1521 return Actions.ActOnStringLiteral(&StringToks[0], StringToks.size()); 1522} 1523 1524/// ParseExpressionList - Used for C/C++ (argument-)expression-list. 1525/// 1526/// argument-expression-list: 1527/// assignment-expression 1528/// argument-expression-list , assignment-expression 1529/// 1530/// [C++] expression-list: 1531/// [C++] assignment-expression 1532/// [C++] expression-list , assignment-expression 1533/// 1534bool Parser::ParseExpressionList(ExprListTy &Exprs, CommaLocsTy &CommaLocs, 1535 void (Action::*Completer)(Scope *S, 1536 void *Data, 1537 ExprTy **Args, 1538 unsigned NumArgs), 1539 void *Data) { 1540 while (1) { 1541 if (Tok.is(tok::code_completion)) { 1542 if (Completer) 1543 (Actions.*Completer)(CurScope, Data, Exprs.data(), Exprs.size()); 1544 ConsumeToken(); 1545 } 1546 1547 OwningExprResult Expr(ParseAssignmentExpression()); 1548 if (Expr.isInvalid()) 1549 return true; 1550 1551 Exprs.push_back(Expr.release()); 1552 1553 if (Tok.isNot(tok::comma)) 1554 return false; 1555 // Move to the next argument, remember where the comma was. 1556 CommaLocs.push_back(ConsumeToken()); 1557 } 1558} 1559 1560/// ParseBlockId - Parse a block-id, which roughly looks like int (int x). 1561/// 1562/// [clang] block-id: 1563/// [clang] specifier-qualifier-list block-declarator 1564/// 1565void Parser::ParseBlockId() { 1566 // Parse the specifier-qualifier-list piece. 1567 DeclSpec DS; 1568 ParseSpecifierQualifierList(DS); 1569 1570 // Parse the block-declarator. 1571 Declarator DeclaratorInfo(DS, Declarator::BlockLiteralContext); 1572 ParseDeclarator(DeclaratorInfo); 1573 1574 // We do this for: ^ __attribute__((noreturn)) {, as DS has the attributes. 1575 DeclaratorInfo.AddAttributes(DS.TakeAttributes(), 1576 SourceLocation()); 1577 1578 if (Tok.is(tok::kw___attribute)) { 1579 SourceLocation Loc; 1580 AttributeList *AttrList = ParseGNUAttributes(&Loc); 1581 DeclaratorInfo.AddAttributes(AttrList, Loc); 1582 } 1583 1584 // Inform sema that we are starting a block. 1585 Actions.ActOnBlockArguments(DeclaratorInfo, CurScope); 1586} 1587 1588/// ParseBlockLiteralExpression - Parse a block literal, which roughly looks 1589/// like ^(int x){ return x+1; } 1590/// 1591/// block-literal: 1592/// [clang] '^' block-args[opt] compound-statement 1593/// [clang] '^' block-id compound-statement 1594/// [clang] block-args: 1595/// [clang] '(' parameter-list ')' 1596/// 1597Parser::OwningExprResult Parser::ParseBlockLiteralExpression() { 1598 assert(Tok.is(tok::caret) && "block literal starts with ^"); 1599 SourceLocation CaretLoc = ConsumeToken(); 1600 1601 PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), CaretLoc, 1602 "block literal parsing"); 1603 1604 // Enter a scope to hold everything within the block. This includes the 1605 // argument decls, decls within the compound expression, etc. This also 1606 // allows determining whether a variable reference inside the block is 1607 // within or outside of the block. 1608 ParseScope BlockScope(this, Scope::BlockScope | Scope::FnScope | 1609 Scope::BreakScope | Scope::ContinueScope | 1610 Scope::DeclScope); 1611 1612 // Inform sema that we are starting a block. 1613 Actions.ActOnBlockStart(CaretLoc, CurScope); 1614 1615 // Parse the return type if present. 1616 DeclSpec DS; 1617 Declarator ParamInfo(DS, Declarator::BlockLiteralContext); 1618 // FIXME: Since the return type isn't actually parsed, it can't be used to 1619 // fill ParamInfo with an initial valid range, so do it manually. 1620 ParamInfo.SetSourceRange(SourceRange(Tok.getLocation(), Tok.getLocation())); 1621 1622 // If this block has arguments, parse them. There is no ambiguity here with 1623 // the expression case, because the expression case requires a parameter list. 1624 if (Tok.is(tok::l_paren)) { 1625 ParseParenDeclarator(ParamInfo); 1626 // Parse the pieces after the identifier as if we had "int(...)". 1627 // SetIdentifier sets the source range end, but in this case we're past 1628 // that location. 1629 SourceLocation Tmp = ParamInfo.getSourceRange().getEnd(); 1630 ParamInfo.SetIdentifier(0, CaretLoc); 1631 ParamInfo.SetRangeEnd(Tmp); 1632 if (ParamInfo.isInvalidType()) { 1633 // If there was an error parsing the arguments, they may have 1634 // tried to use ^(x+y) which requires an argument list. Just 1635 // skip the whole block literal. 1636 Actions.ActOnBlockError(CaretLoc, CurScope); 1637 return ExprError(); 1638 } 1639 1640 if (Tok.is(tok::kw___attribute)) { 1641 SourceLocation Loc; 1642 AttributeList *AttrList = ParseGNUAttributes(&Loc); 1643 ParamInfo.AddAttributes(AttrList, Loc); 1644 } 1645 1646 // Inform sema that we are starting a block. 1647 Actions.ActOnBlockArguments(ParamInfo, CurScope); 1648 } else if (!Tok.is(tok::l_brace)) { 1649 ParseBlockId(); 1650 } else { 1651 // Otherwise, pretend we saw (void). 1652 ParamInfo.AddTypeInfo(DeclaratorChunk::getFunction(true, false, 1653 SourceLocation(), 1654 0, 0, 0, 1655 false, SourceLocation(), 1656 false, 0, 0, 0, 1657 CaretLoc, CaretLoc, 1658 ParamInfo), 1659 CaretLoc); 1660 1661 if (Tok.is(tok::kw___attribute)) { 1662 SourceLocation Loc; 1663 AttributeList *AttrList = ParseGNUAttributes(&Loc); 1664 ParamInfo.AddAttributes(AttrList, Loc); 1665 } 1666 1667 // Inform sema that we are starting a block. 1668 Actions.ActOnBlockArguments(ParamInfo, CurScope); 1669 } 1670 1671 1672 OwningExprResult Result(Actions, true); 1673 if (!Tok.is(tok::l_brace)) { 1674 // Saw something like: ^expr 1675 Diag(Tok, diag::err_expected_expression); 1676 Actions.ActOnBlockError(CaretLoc, CurScope); 1677 return ExprError(); 1678 } 1679 1680 OwningStmtResult Stmt(ParseCompoundStatementBody()); 1681 if (!Stmt.isInvalid()) 1682 Result = Actions.ActOnBlockStmtExpr(CaretLoc, move(Stmt), CurScope); 1683 else 1684 Actions.ActOnBlockError(CaretLoc, CurScope); 1685 return move(Result); 1686} 1687