OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/parsing/parser.h" | 5 #include "src/parsing/parser.h" |
6 | 6 |
7 #include "src/api.h" | 7 #include "src/api.h" |
8 #include "src/ast/ast.h" | 8 #include "src/ast/ast.h" |
9 #include "src/ast/ast-expression-rewriter.h" | 9 #include "src/ast/ast-expression-rewriter.h" |
10 #include "src/ast/ast-expression-visitor.h" | 10 #include "src/ast/ast-expression-visitor.h" |
(...skipping 420 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
431 uint32_t value = DoubleToUint32(x_val) >> shift; | 431 uint32_t value = DoubleToUint32(x_val) >> shift; |
432 *x = factory->NewNumberLiteral(value, pos, has_dot); | 432 *x = factory->NewNumberLiteral(value, pos, has_dot); |
433 return true; | 433 return true; |
434 } | 434 } |
435 case Token::SAR: { | 435 case Token::SAR: { |
436 uint32_t shift = DoubleToInt32(y_val) & 0x1f; | 436 uint32_t shift = DoubleToInt32(y_val) & 0x1f; |
437 int value = ArithmeticShiftRight(DoubleToInt32(x_val), shift); | 437 int value = ArithmeticShiftRight(DoubleToInt32(x_val), shift); |
438 *x = factory->NewNumberLiteral(value, pos, has_dot); | 438 *x = factory->NewNumberLiteral(value, pos, has_dot); |
439 return true; | 439 return true; |
440 } | 440 } |
| 441 case Token::EXP: { |
| 442 double value = std::pow(x_val, y_val); |
| 443 int int_value = static_cast<int>(value); |
| 444 *x = factory->NewNumberLiteral( |
| 445 int_value == value && value != -0.0 ? int_value : value, pos, |
| 446 has_dot); |
| 447 return true; |
| 448 } |
441 default: | 449 default: |
442 break; | 450 break; |
443 } | 451 } |
| 452 } else if (op == Token::EXP) { |
| 453 Zone* zone = parser_->zone(); |
| 454 ZoneList<Expression*>* args = new (zone) ZoneList<Expression*>(2, zone); |
| 455 args->Add(*x, zone); |
| 456 args->Add(y, zone); |
| 457 *x = factory->NewCallRuntime(Context::MATH_POW_METHOD_INDEX, args, pos); |
| 458 return true; |
444 } | 459 } |
445 return false; | 460 return false; |
446 } | 461 } |
447 | 462 |
448 | 463 |
449 Expression* ParserTraits::BuildUnaryExpression(Expression* expression, | 464 Expression* ParserTraits::BuildUnaryExpression(Expression* expression, |
450 Token::Value op, int pos, | 465 Token::Value op, int pos, |
451 AstNodeFactory* factory) { | 466 AstNodeFactory* factory) { |
452 DCHECK(expression != NULL); | 467 DCHECK(expression != NULL); |
453 if (expression->IsLiteral()) { | 468 if (expression->IsLiteral()) { |
(...skipping 312 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
766 set_allow_harmony_sloppy_function(FLAG_harmony_sloppy_function); | 781 set_allow_harmony_sloppy_function(FLAG_harmony_sloppy_function); |
767 set_allow_harmony_sloppy_let(FLAG_harmony_sloppy_let); | 782 set_allow_harmony_sloppy_let(FLAG_harmony_sloppy_let); |
768 set_allow_harmony_default_parameters(FLAG_harmony_default_parameters); | 783 set_allow_harmony_default_parameters(FLAG_harmony_default_parameters); |
769 set_allow_harmony_destructuring_bind(FLAG_harmony_destructuring_bind); | 784 set_allow_harmony_destructuring_bind(FLAG_harmony_destructuring_bind); |
770 set_allow_harmony_destructuring_assignment( | 785 set_allow_harmony_destructuring_assignment( |
771 FLAG_harmony_destructuring_assignment); | 786 FLAG_harmony_destructuring_assignment); |
772 set_allow_strong_mode(FLAG_strong_mode); | 787 set_allow_strong_mode(FLAG_strong_mode); |
773 set_allow_legacy_const(FLAG_legacy_const); | 788 set_allow_legacy_const(FLAG_legacy_const); |
774 set_allow_harmony_do_expressions(FLAG_harmony_do_expressions); | 789 set_allow_harmony_do_expressions(FLAG_harmony_do_expressions); |
775 set_allow_harmony_function_name(FLAG_harmony_function_name); | 790 set_allow_harmony_function_name(FLAG_harmony_function_name); |
| 791 set_allow_harmony_exponentiation_operator( |
| 792 FLAG_harmony_exponentiation_operator); |
776 for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount; | 793 for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount; |
777 ++feature) { | 794 ++feature) { |
778 use_counts_[feature] = 0; | 795 use_counts_[feature] = 0; |
779 } | 796 } |
780 if (info->ast_value_factory() == NULL) { | 797 if (info->ast_value_factory() == NULL) { |
781 // info takes ownership of AstValueFactory. | 798 // info takes ownership of AstValueFactory. |
782 info->set_ast_value_factory(new AstValueFactory(zone(), info->hash_seed())); | 799 info->set_ast_value_factory(new AstValueFactory(zone(), info->hash_seed())); |
783 info->set_ast_value_factory_owned(); | 800 info->set_ast_value_factory_owned(); |
784 ast_value_factory_ = info->ast_value_factory(); | 801 ast_value_factory_ = info->ast_value_factory(); |
785 } | 802 } |
(...skipping 3991 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4777 #define SET_ALLOW(name) reusable_preparser_->set_allow_##name(allow_##name()); | 4794 #define SET_ALLOW(name) reusable_preparser_->set_allow_##name(allow_##name()); |
4778 SET_ALLOW(natives); | 4795 SET_ALLOW(natives); |
4779 SET_ALLOW(harmony_sloppy); | 4796 SET_ALLOW(harmony_sloppy); |
4780 SET_ALLOW(harmony_sloppy_let); | 4797 SET_ALLOW(harmony_sloppy_let); |
4781 SET_ALLOW(harmony_default_parameters); | 4798 SET_ALLOW(harmony_default_parameters); |
4782 SET_ALLOW(harmony_destructuring_bind); | 4799 SET_ALLOW(harmony_destructuring_bind); |
4783 SET_ALLOW(harmony_destructuring_assignment); | 4800 SET_ALLOW(harmony_destructuring_assignment); |
4784 SET_ALLOW(strong_mode); | 4801 SET_ALLOW(strong_mode); |
4785 SET_ALLOW(harmony_do_expressions); | 4802 SET_ALLOW(harmony_do_expressions); |
4786 SET_ALLOW(harmony_function_name); | 4803 SET_ALLOW(harmony_function_name); |
| 4804 SET_ALLOW(harmony_exponentiation_operator); |
4787 #undef SET_ALLOW | 4805 #undef SET_ALLOW |
4788 } | 4806 } |
4789 PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction( | 4807 PreParser::PreParseResult result = reusable_preparser_->PreParseLazyFunction( |
4790 language_mode(), function_state_->kind(), scope_->has_simple_parameters(), | 4808 language_mode(), function_state_->kind(), scope_->has_simple_parameters(), |
4791 logger, bookmark); | 4809 logger, bookmark); |
4792 if (pre_parse_timer_ != NULL) { | 4810 if (pre_parse_timer_ != NULL) { |
4793 pre_parse_timer_->Stop(); | 4811 pre_parse_timer_->Stop(); |
4794 } | 4812 } |
4795 return result; | 4813 return result; |
4796 } | 4814 } |
(...skipping 682 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5479 void Parser::RaiseLanguageMode(LanguageMode mode) { | 5497 void Parser::RaiseLanguageMode(LanguageMode mode) { |
5480 SetLanguageMode(scope_, | 5498 SetLanguageMode(scope_, |
5481 static_cast<LanguageMode>(scope_->language_mode() | mode)); | 5499 static_cast<LanguageMode>(scope_->language_mode() | mode)); |
5482 } | 5500 } |
5483 | 5501 |
5484 | 5502 |
5485 void ParserTraits::RewriteDestructuringAssignments() { | 5503 void ParserTraits::RewriteDestructuringAssignments() { |
5486 parser_->RewriteDestructuringAssignments(); | 5504 parser_->RewriteDestructuringAssignments(); |
5487 } | 5505 } |
5488 | 5506 |
| 5507 Expression* ParserTraits::RewriteAssignExponentiation(Expression* left, |
| 5508 Expression* right, |
| 5509 int pos) { |
| 5510 return parser_->RewriteAssignExponentiation(left, right, pos); |
| 5511 } |
5489 | 5512 |
5490 Expression* ParserTraits::RewriteNonPattern( | 5513 Expression* ParserTraits::RewriteNonPattern( |
5491 Expression* expr, const ExpressionClassifier* classifier, bool* ok) { | 5514 Expression* expr, const ExpressionClassifier* classifier, bool* ok) { |
5492 return parser_->RewriteNonPattern(expr, classifier, ok); | 5515 return parser_->RewriteNonPattern(expr, classifier, ok); |
5493 } | 5516 } |
5494 | 5517 |
5495 | 5518 |
5496 ObjectLiteralProperty* ParserTraits::RewriteNonPatternObjectLiteralProperty( | 5519 ObjectLiteralProperty* ParserTraits::RewriteNonPatternObjectLiteralProperty( |
5497 ObjectLiteralProperty* property, const ExpressionClassifier* classifier, | 5520 ObjectLiteralProperty* property, const ExpressionClassifier* classifier, |
5498 bool* ok) { | 5521 bool* ok) { |
(...skipping 75 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5574 RewritableAssignmentExpression* to_rewrite = | 5597 RewritableAssignmentExpression* to_rewrite = |
5575 pair.assignment->AsRewritableAssignmentExpression(); | 5598 pair.assignment->AsRewritableAssignmentExpression(); |
5576 Scope* scope = pair.scope; | 5599 Scope* scope = pair.scope; |
5577 DCHECK_NOT_NULL(to_rewrite); | 5600 DCHECK_NOT_NULL(to_rewrite); |
5578 if (!to_rewrite->is_rewritten()) { | 5601 if (!to_rewrite->is_rewritten()) { |
5579 PatternRewriter::RewriteDestructuringAssignment(this, to_rewrite, scope); | 5602 PatternRewriter::RewriteDestructuringAssignment(this, to_rewrite, scope); |
5580 } | 5603 } |
5581 } | 5604 } |
5582 } | 5605 } |
5583 | 5606 |
| 5607 Expression* Parser::RewriteAssignExponentiation(Expression* left, |
| 5608 Expression* right, int pos) { |
| 5609 // TODO(bmeurer): remove rewriting craziness and replace with |
| 5610 // backend support for exponent op, some day |
| 5611 ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone()); |
| 5612 if (left->IsVariableProxy()) { |
| 5613 VariableProxy* lhs = left->AsVariableProxy(); |
| 5614 |
| 5615 Expression* result; |
| 5616 DCHECK_NOT_NULL(lhs->raw_name()); |
| 5617 result = |
| 5618 this->ExpressionFromIdentifier(lhs->raw_name(), lhs->position(), |
| 5619 lhs->end_position(), scope_, factory()); |
| 5620 args->Add(left, zone()); |
| 5621 args->Add(right, zone()); |
| 5622 Expression* call = |
| 5623 factory()->NewCallRuntime(Context::MATH_POW_METHOD_INDEX, args, pos); |
| 5624 return factory()->NewAssignment(Token::ASSIGN, result, call, pos); |
| 5625 } else if (left->IsProperty()) { |
| 5626 Property* prop = left->AsProperty(); |
| 5627 auto temp_obj = scope_->NewTemporary(ast_value_factory()->empty_string()); |
| 5628 auto temp_key = scope_->NewTemporary(ast_value_factory()->empty_string()); |
| 5629 Expression* assign_obj = factory()->NewAssignment( |
| 5630 Token::ASSIGN, factory()->NewVariableProxy(temp_obj), prop->obj(), |
| 5631 RelocInfo::kNoPosition); |
| 5632 Expression* assign_key = factory()->NewAssignment( |
| 5633 Token::ASSIGN, factory()->NewVariableProxy(temp_key), prop->key(), |
| 5634 RelocInfo::kNoPosition); |
| 5635 args->Add(factory()->NewProperty(factory()->NewVariableProxy(temp_obj), |
| 5636 factory()->NewVariableProxy(temp_key), |
| 5637 left->position()), |
| 5638 zone()); |
| 5639 args->Add(right, zone()); |
| 5640 Expression* call = |
| 5641 factory()->NewCallRuntime(Context::MATH_POW_METHOD_INDEX, args, pos); |
| 5642 Expression* assign = |
| 5643 factory()->NewAssignment(Token::ASSIGN, left, call, pos); |
| 5644 return factory()->NewBinaryOperation( |
| 5645 Token::COMMA, assign_obj, |
| 5646 factory()->NewBinaryOperation(Token::COMMA, assign_key, assign, pos), |
| 5647 pos); |
| 5648 } else { |
| 5649 return factory()->NewAssignment(Token::ASSIGN_MUL, left, right, pos); |
| 5650 } |
| 5651 } |
5584 | 5652 |
5585 Expression* Parser::RewriteSpreads(ArrayLiteral* lit) { | 5653 Expression* Parser::RewriteSpreads(ArrayLiteral* lit) { |
5586 // Array literals containing spreads are rewritten using do expressions, e.g. | 5654 // Array literals containing spreads are rewritten using do expressions, e.g. |
5587 // [1, 2, 3, ...x, 4, ...y, 5] | 5655 // [1, 2, 3, ...x, 4, ...y, 5] |
5588 // is roughly rewritten as: | 5656 // is roughly rewritten as: |
5589 // do { | 5657 // do { |
5590 // $R = [1, 2, 3]; | 5658 // $R = [1, 2, 3]; |
5591 // for ($i of x) %AppendElement($R, $i); | 5659 // for ($i of x) %AppendElement($R, $i); |
5592 // %AppendElement($R, 4); | 5660 // %AppendElement($R, 4); |
5593 // for ($j of y) %AppendElement($R, $j); | 5661 // for ($j of y) %AppendElement($R, $j); |
(...skipping 736 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6330 | 6398 |
6331 statements->Add(get_return, zone); | 6399 statements->Add(get_return, zone); |
6332 statements->Add(check_return, zone); | 6400 statements->Add(check_return, zone); |
6333 statements->Add(call_return, zone); | 6401 statements->Add(call_return, zone); |
6334 statements->Add(validate_output, zone); | 6402 statements->Add(validate_output, zone); |
6335 } | 6403 } |
6336 | 6404 |
6337 | 6405 |
6338 } // namespace internal | 6406 } // namespace internal |
6339 } // namespace v8 | 6407 } // namespace v8 |
OLD | NEW |