Lines Matching refs:EXPRESSION
168 Block* ParseVariableDeclarations(bool accept_IN, Expression** var, bool* ok);
175 Block* WithHelper(Expression* obj,
186 Expression* MakeCatchContext(Handle<String> id, VariableProxy* value);
190 Expression* ParseExpression(bool accept_IN, bool* ok);
191 Expression* ParseAssignmentExpression(bool accept_IN, bool* ok);
192 Expression* ParseConditionalExpression(bool accept_IN, bool* ok);
193 Expression* ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
194 Expression* ParseUnaryExpression(bool* ok);
195 Expression* ParsePostfixExpression(bool* ok);
196 Expression* ParseLeftHandSideExpression(bool* ok);
197 Expression* ParseNewExpression(bool* ok);
198 Expression* ParseMemberExpression(bool* ok);
199 Expression* ParseNewPrefix(PositionStack* stack, bool* ok);
200 Expression* ParseMemberWithNewPrefixesExpression(PositionStack* stack,
202 Expression* ParsePrimaryExpression(bool* ok);
203 Expression* ParseArrayLiteral(bool* ok);
204 Expression* ParseObjectLiteral(bool* ok);
205 Expression* ParseRegExpLiteral(bool seen_equal, bool* ok);
216 void BuildArrayLiteralBoilerplateLiterals(ZoneList<Expression*>* properties,
223 // If the expression is a literal, return the literal value;
224 // if the expression is a materialized literal and is simple return a
228 Handle<Object> GetBoilerplateValue(Expression* expression);
231 EXPRESSION,
236 ZoneList<Expression*>* ParseArguments(bool* ok);
244 Expression* ParseV8Intrinsic(bool* ok);
279 Expression* NewThrowReferenceError(Handle<String> type);
284 Expression* NewThrowSyntaxError(Handle<String> type, Handle<Object> first);
288 Expression* NewThrowTypeError(Handle<String> type,
293 Expression* NewThrowError(Handle<String> constructor,
302 Expression* ParseJson(bool* ok);
307 Expression* ParseJsonValue(bool* ok);
313 Expression* ParseJsonObject(bool* ok);
318 Expression* ParseJsonArray(bool* ok);
408 // "Adds" an empty expression. Does nothing except consume a
659 // Parser state of containing expression, if any.
666 // Index in captures array of first capture in this sub-expression, if any.
667 // Also the capture index of this sub-expression itself, if group_type
812 virtual Expression* NewProperty(Expression* obj, Expression* key, int pos) {
820 virtual Expression* NewCall(Expression* expression,
821 ZoneList<Expression*>* arguments,
866 virtual Expression* NewProperty(Expression* obj, Expression* key, int pos) {
870 virtual Expression* NewCall(Expression* expression,
871 ZoneList<Expression*>* arguments,
873 return new Call(expression, arguments, pos);
1312 FunctionLiteralType type = is_expression ? EXPRESSION : DECLARATION;
1353 Expression* expression = ParseJson(&ok);
1356 statement.Add(new ExpressionStatement(expression));
1419 return exp_stat->expression()->AsAssignment();
1454 static bool SameObject(Expression* e1, Expression* e2) {
1477 static bool PropertyOfSameObject(Expression* e1, Expression* e2) {
1856 Expression* expression =
1859 top_scope_->SetIllegalRedeclaration(expression);
2026 Expression* dummy; // to satisfy the ParseVariableDeclarations() signature
2039 Expression** var,
2094 // Parse initialization expression if present and/or needed. A
2121 Expression* value = NULL;
2157 ZoneList<Expression*>* arguments = new ZoneList<Expression*>(2);
2235 // Expression ';'
2238 Expression* expr = ParseExpression(true, CHECK_OK);
2269 // Parsed expression statement.
2277 // 'if' '(' Expression ')' Statement ('else' Statement)?
2281 Expression* condition = ParseExpression(true, CHECK_OK);
2314 Expression* throw_error = NewThrowSyntaxError(error_type, label);
2347 Expression* throw_error = NewThrowSyntaxError(error_type, label);
2358 // 'return' Expression? ';'
2372 Expression* throw_error = NewThrowSyntaxError(type, Handle<Object>::null());
2385 Expression* expr = ParseExpression(true, CHECK_OK);
2391 Block* Parser::WithHelper(Expression* obj,
2406 // 1: Evaluate the with expression.
2432 Expression ')' Statement
2436 Expression* expr = ParseExpression(true, CHECK_OK);
2445 // 'case' Expression ':' Statement*
2448 Expression* label = NULL; // NULL expression indicates default case
2479 // 'switch' '(' Expression ')' '{' CaseClause* '}'
2486 Expression* tag = ParseExpression(true, CHECK_OK);
2505 // 'throw' Expression ';'
2514 Expression* exception = ParseExpression(true, CHECK_OK);
2574 Expression* obj = NEW(CatchExtensionObject(name_literal, catch_var));
2630 // 'do' Statement 'while' '(' Expression ')' ';'
2645 Expression* cond = ParseExpression(true, CHECK_OK);
2661 // 'while' '(' Expression ')' Statement
2668 Expression* cond = ParseExpression(true, CHECK_OK);
2679 // 'for' '(' Expression? ';' Expression? ';' Expression? ')' Statement
2687 Expression* each = NULL;
2695 Expression* enumerable = ParseExpression(true, CHECK_OK);
2715 Expression* expression = ParseExpression(false, CHECK_OK);
2717 // Signal a reference error if the expression is an invalid
2718 // left-hand side expression. We could report this as a syntax
2721 if (expression == NULL || !expression->IsValidLeftHandSide()) {
2723 expression = NewThrowReferenceError(type);
2729 Expression* enumerable = ParseExpression(true, CHECK_OK);
2733 if (loop) loop->Initialize(expression, enumerable, body);
2739 init = NEW(ExpressionStatement(expression));
2751 Expression* cond = NULL;
2762 Expression* exp = ParseExpression(true, CHECK_OK);
2775 Expression* Parser::ParseExpression(bool accept_IN, bool* ok) {
2776 // Expression ::
2778 // Expression ',' AssignmentExpression
2780 Expression* result = ParseAssignmentExpression(accept_IN, CHECK_OK);
2783 Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);
2791 Expression* Parser::ParseAssignmentExpression(bool accept_IN, bool* ok) {
2796 Expression* expression = ParseConditionalExpression(accept_IN, CHECK_OK);
2799 // Parsed conditional expression only (no assignment).
2800 return expression;
2803 // Signal a reference error if the expression is an invalid left-hand
2804 // side expression. We could report this as a syntax error here but
2807 if (expression == NULL || !expression->IsValidLeftHandSide()) {
2809 expression = NewThrowReferenceError(type);
2814 Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);
2821 Property* property = expression ? expression->AsProperty() : NULL;
2829 return NEW(Assignment(op, expression, right, pos));
2834 Expression* Parser::ParseConditionalExpression(bool accept_IN, bool* ok) {
2839 // We start using the binary expression parser for prec >= 4 only!
2840 Expression* expression = ParseBinaryExpression(4, accept_IN, CHECK_OK);
2841 if (peek() != Token::CONDITIONAL) return expression;
2843 // In parsing the first assignment expression in conditional
2846 Expression* left = ParseAssignmentExpression(true, CHECK_OK);
2848 Expression* right = ParseAssignmentExpression(accept_IN, CHECK_OK);
2849 return NEW(Conditional(expression, left, right));
2855 return 0; // 0 precedence will terminate binary expression parsing
2862 Expression* Parser::ParseBinaryExpression(int prec, bool accept_IN, bool* ok) {
2864 Expression* x = ParseUnaryExpression(CHECK_OK);
2869 Expression* y = ParseBinaryExpression(prec1 + 1, accept_IN, CHECK_OK);
2968 Expression* Parser::ParseUnaryExpression(bool* ok) {
2984 Expression* expression = ParseUnaryExpression(CHECK_OK);
2987 if (expression != NULL && expression->AsLiteral() &&
2988 expression->AsLiteral()->handle()->IsNumber()) {
2989 double value = expression->AsLiteral()->handle()->Number();
2992 return expression;
3001 return NEW(UnaryOperation(op, expression));
3005 Expression* expression = ParseUnaryExpression(CHECK_OK);
3006 // Signal a reference error if the expression is an invalid
3007 // left-hand side expression. We could report this as a syntax
3010 if (expression == NULL || !expression->IsValidLeftHandSide()) {
3012 expression = NewThrowReferenceError(type);
3014 return NEW(CountOperation(true /* prefix */, op, expression));
3022 Expression* Parser::ParsePostfixExpression(bool* ok) {
3026 Expression* expression = ParseLeftHandSideExpression(CHECK_OK);
3028 // Signal a reference error if the expression is an invalid
3029 // left-hand side expression. We could report this as a syntax
3032 if (expression == NULL || !expression->IsValidLeftHandSide()) {
3034 expression = NewThrowReferenceError(type);
3037 expression = NEW(CountOperation(false /* postfix */, next, expression));
3039 return expression;
3043 Expression* Parser::ParseLeftHandSideExpression(bool* ok) {
3047 Expression* result;
3059 Expression* index = ParseExpression(true, CHECK_OK);
3067 ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
3107 Expression* Parser::ParseNewPrefix(PositionStack* stack, bool* ok) {
3112 // 'new' can either be a part of the new expression (where it isn't
3113 // followed by an argument list) or a part of the member expression,
3117 // member expression parser, which is only allowed to match argument
3122 Expression* result;
3131 result = NEW(CallNew(result, new ZoneList<Expression*>(0), last));
3137 Expression* Parser::ParseNewExpression(bool* ok) {
3143 Expression* Parser::ParseMemberExpression(bool* ok) {
3148 Expression* Parser::ParseMemberWithNewPrefixesExpression(PositionStack* stack,
3152 // ('[' Expression ']' | '.' Identifier | Arguments)*
3154 // Parse the initial primary or function expression.
3155 Expression* result = NULL;
3172 Expression* index = ParseExpression(true, CHECK_OK);
3187 ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
3239 Expression* Parser::ParsePrimaryExpression(bool* ok) {
3251 // '(' Expression ')'
3253 Expression* result = NULL;
3355 void Parser::BuildArrayLiteralBoilerplateLiterals(ZoneList<Expression*>* values,
3382 Expression* Parser::ParseArrayLiteral(bool* ok) {
3384 // '[' Expression? (',' Expression?)* ']'
3386 ZoneListWrapper<Expression> values = factory()->NewList<Expression>(4);
3389 Expression* elem;
3439 bool CompileTimeValue::IsCompileTimeValue(Expression* expression) {
3440 MaterializedLiteral* lit = expression->AsMaterializedLiteral();
3444 Handle<FixedArray> CompileTimeValue::GetValue(Expression* expression) {
3445 ASSERT(IsCompileTimeValue(expression));
3447 ObjectLiteral* object_literal = expression->AsObjectLiteral();
3453 ArrayLiteral* array_literal = expression->AsArrayLiteral();
3473 Handle<Object> Parser::GetBoilerplateValue(Expression* expression) {
3474 if (expression->AsLiteral() != NULL) {
3475 return expression->AsLiteral()->handle();
3477 if (CompileTimeValue::IsCompileTimeValue(expression)) {
3478 return CompileTimeValue::GetValue(expression);
3521 Expression* Parser::ParseObjectLiteral(bool* ok) {
3592 Expression* value = ParseAssignmentExpression(true, CHECK_OK);
3626 Expression* Parser::ParseRegExpLiteral(bool seen_equal, bool* ok) {
3660 ZoneList<Expression*>* Parser::ParseArguments(bool* ok) {
3664 ZoneListWrapper<Expression> result = factory()->NewList<Expression>(4);
3668 Expression* argument = ParseAssignmentExpression(true, CHECK_OK);
3687 // The name associated with this function. If it's a function expression,
3689 // variable declared and initialized with the function (expression). In
3694 if (is_named && (type == EXPRESSION || type == NESTED)) {
3726 // If we have a named function expression, we add a local variable
3800 Expression* Parser::ParseV8Intrinsic(bool* ok) {
3808 ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
3988 Expression* Parser::NewThrowReferenceError(Handle<String> type) {
3994 Expression* Parser::NewThrowSyntaxError(Handle<String> type,
4002 Expression* Parser::NewThrowTypeError(Handle<String> type,
4013 Expression* Parser::NewThrowError(Handle<String> constructor,
4027 ZoneList<Expression*>* args = new ZoneList<Expression*>(2);
4037 Expression* Parser::ParseJson(bool* ok) {
4038 Expression* result = ParseJsonValue(CHECK_OK);
4045 Expression* Parser::ParseJsonValue(bool* ok) {
4076 Expression* result = ParseJsonObject(CHECK_OK);
4080 Expression* result = ParseJsonArray(CHECK_OK);
4092 Expression* Parser::ParseJsonObject(bool* ok) {
4103 Expression* value = ParseJsonValue(CHECK_OK);
4142 Expression* Parser::ParseJsonArray(bool* ok) {
4145 ZoneListWrapper<Expression> values = factory()->NewList<Expression>(4);
4148 Expression* exp = ParseJsonValue(CHECK_OK);
4212 ReportError(CStrVector("Regular expression too large"));
