Doing diffs in .: --- ./include/clang/Parse/Parser.h.~1~ 2008-02-25 14:56:49.000000000 -0800 +++ ./include/clang/Parse/Parser.h 2008-02-25 19:51:28.000000000 -0800 @@ -323,7 +323,8 @@ private: ExprResult ParseAssignmentExpressionWithLeadingStar(const Token &Tok); ExprResult ParseRHSOfBinaryExpression(ExprResult LHS, unsigned MinPrec); - ExprResult ParseCastExpression(bool isUnaryExpression); + ExprResult ParseCastExpression(bool isUnaryExpression, + bool AllowThrow = false); ExprResult ParsePostfixExpressionSuffix(ExprResult LHS); ExprResult ParseSizeofAlignofExpression(); ExprResult ParseBuiltinPrimaryExpression(); --- ./Parse/ParseExpr.cpp.~1~ 2008-02-25 14:56:18.000000000 -0800 +++ ./Parse/ParseExpr.cpp 2008-02-25 19:56:18.000000000 -0800 @@ -167,10 +167,7 @@ static prec::Level getBinOpPrecedence(to /// expression ',' assignment-expression /// Parser::ExprResult Parser::ParseExpression() { - if (Tok.is(tok::kw_throw)) - return ParseThrowExpression(); - - ExprResult LHS = ParseCastExpression(false); + ExprResult LHS = ParseCastExpression(false, true); if (LHS.isInvalid) return LHS; return ParseRHSOfBinaryExpression(LHS, prec::Comma); @@ -191,10 +188,7 @@ Parser::ExprResult Parser::ParseExpressi /// ParseAssignmentExpression - Parse an expr that doesn't include commas. /// Parser::ExprResult Parser::ParseAssignmentExpression() { - if (Tok.is(tok::kw_throw)) - return ParseThrowExpression(); - - ExprResult LHS = ParseCastExpression(false); + ExprResult LHS = ParseCastExpression(false, true); if (LHS.isInvalid) return LHS; return ParseRHSOfBinaryExpression(LHS, prec::Assignment); @@ -283,7 +277,7 @@ ParseAssignmentExpressionWithLeadingStar // Parse the cast-expression that follows the '*'. This will parse the // "*(int*)P" part of "*(int*)P+B". - ExprResult Res = ParseCastExpression(false); + ExprResult Res = ParseCastExpression(false, true); if (Res.isInvalid) return Res; // Combine StarTok + Res to get the new AST for the combined expression.. @@ -357,7 +351,7 @@ Parser::ParseRHSOfBinaryExpression(ExprR } // Parse another leaf here for the RHS of the operator. - ExprResult RHS = ParseCastExpression(false); + ExprResult RHS = ParseCastExpression(false, MinPrec <= prec::Assignment); if (RHS.isInvalid) { Actions.DeleteExpr(LHS.Val); Actions.DeleteExpr(TernaryMiddle.Val); @@ -434,7 +428,6 @@ Parser::ParseRHSOfBinaryExpression(ExprR /// identifier /// constant /// string-literal -/// [C++] boolean-literal [C++ 2.13.5] /// '(' expression ')' /// '__func__' [C99 6.4.2.2] /// [GNU] '__FUNCTION__' @@ -460,11 +453,18 @@ Parser::ParseRHSOfBinaryExpression(ExprR /// floating-constant /// enumeration-constant -> identifier /// character-constant +/// [C++] boolean-literal [C++ 2.13.5] /// -Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression) { +Parser::ExprResult Parser::ParseCastExpression(bool isUnaryExpression, + bool AllowThrow) { ExprResult Res; tok::TokenKind SavedKind = Tok.getKind(); + // We also handle 'throw' as it represents a leaf or unary operator. + if (AllowThrow && Tok.is(tok::kw_throw)) { + return ParseThrowExpression(); + } + // This handles all of cast-expression, unary-expression, postfix-expression, // and primary-expression. We handle them together like this for efficiency // and to simplify handling of an expression starting with a '(' token: which @@ -477,8 +477,8 @@ Parser::ExprResult Parser::ParseCastExpr // return without invoking ParsePostfixExpressionSuffix. switch (SavedKind) { case tok::l_paren: { - // If this expression is limited to being a unary-expression, the parent can - // not start a cast expression. + // If this expression is limited to being a unary-expression, the + // parent can not start a cast expression. ParenParseOption ParenExprType = isUnaryExpression ? CompoundLiteral : CastExpr; TypeTy *CastTy; @@ -519,6 +519,7 @@ Parser::ExprResult Parser::ParseCastExpr // These can be followed by postfix-expr pieces. return ParsePostfixExpressionSuffix(Res); + // constant (aka C++ literal): boolean-literal case tok::kw_true: case tok::kw_false: return ParseCXXBoolLiteral(); --- ./Parse/ParseExprCXX.cpp.~1~ 2008-02-25 15:34:48.000000000 -0800 +++ ./Parse/ParseExprCXX.cpp 2008-02-25 20:02:27.000000000 -0800 @@ -77,6 +77,34 @@ Parser::ExprResult Parser::ParseCXXBoolL return Actions.ActOnCXXBoolLiteral(ConsumeToken(), Kind); } +/// Returns true is Tok starts an expression. +/// FIXME: Any added support for Objective-C or C++ will need updates +/// to the below. +bool TokenStartsExpression(Token Tok) { + return (Tok.is(tok::kw_throw) || Tok.is(tok::l_paren) || + Tok.is(tok::plusplus) || Tok.is(tok::minusminus) || + Tok.is(tok::amp) || Tok.is(tok::star) || + Tok.is(tok::plus) || Tok.is(tok::minus) || + Tok.is(tok::tilde) || Tok.is(tok::exclaim) || + Tok.is(tok::kw___real) || Tok.is(tok::kw___imag) || + Tok.is(tok::kw___extension__) || Tok.is(tok::kw_sizeof) || + Tok.is(tok::kw___alignof) || Tok.is(tok::ampamp) || + Tok.is(tok::identifier) || Tok.is(tok::numeric_constant) || + Tok.is(tok::char_constant) || Tok.is(tok::kw_true) || + Tok.is(tok::kw_false) || Tok.is(tok::kw___func__) || + Tok.is(tok::kw___FUNCTION__) || + Tok.is(tok::kw___PRETTY_FUNCTION__) || + Tok.is(tok::string_literal) || Tok.is(tok::wide_string_literal) || + Tok.is(tok::kw___builtin_va_arg) || + Tok.is(tok::kw___builtin_offsetof) || + Tok.is(tok::kw___builtin_choose_expr) || + Tok.is(tok::kw___builtin_overload) || + Tok.is(tok::kw___builtin_types_compatible_p) || + Tok.is(tok::kw_const_cast) || Tok.is(tok::kw_dynamic_cast) || + Tok.is(tok::kw_reinterpret_cast) || Tok.is(tok::kw_static_cast) || + Tok.is(tok::at) || Tok.is(tok::l_square)); +} + /// ParseThrowExpression - This handles the C++ throw expression. /// /// throw-expression: [C++ 15] @@ -87,9 +115,7 @@ Parser::ExprResult Parser::ParseThrowExp ExprResult Expr; SourceLocation ThrowLoc = ConsumeToken(); // Eat the throw token. - // FIXME: Anything that isn't an assignment-expression should bail out now. - if (Tok.is(tok::semi) || Tok.is(tok::r_paren) || Tok.is(tok::colon) || - Tok.is(tok::comma)) + if (!TokenStartsExpression(Tok)) return Actions.ActOnCXXThrow(ThrowLoc); Expr = ParseAssignmentExpression(); --------------