Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(8)

Side by Side Diff: src/parsing/parser.cc

Issue 1678303002: [es7] implement exponentiation operator proposal (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: update webkit test expectations Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « src/parsing/parser.h ('k') | src/parsing/parser-base.h » ('j') | src/parsing/parser-base.h » ('J')

Powered by Google App Engine
This is Rietveld 408576698