Move ParseConditionalExpression to ParserBase.

src/preparser.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 367 matching lines @@
                                                        bool* ok);
 
   typename Traits::Type::Expression ParsePrimaryExpression(bool* ok);
   typename Traits::Type::Expression ParseExpression(bool accept_IN, bool* ok);
   typename Traits::Type::Expression ParseArrayLiteral(bool* ok);
   typename Traits::Type::Expression ParseObjectLiteral(bool* ok);
   typename Traits::Type::ExpressionList ParseArguments(bool* ok);
   typename Traits::Type::Expression ParseAssignmentExpression(bool accept_IN,
                                                               bool* ok);
   typename Traits::Type::Expression ParseYieldExpression(bool* ok);
+  typename Traits::Type::Expression ParseConditionalExpression(bool accept_IN,
+                                                               bool* ok);
 
   // Used to detect duplicates in object literals. Each of the values
   // kGetterProperty, kSetterProperty and kValueProperty represents
   // a type of object literal property. When parsing a property, its
   // type value is stored in the DuplicateFinder for the property name.
   // Values are chosen so that having intersection bits means the there is
   // an incompatibility.
   // I.e., you can add a getter to a property that already has a setter, since
   // kGetterProperty and kSetterProperty doesn't intersect, but not if it
   // already has a getter or a value. Adding the getter to an existing
@@ skipping 310 matching lines @@
   PreParserExpression NewVariableProxy(void* generator_variable) {
     return PreParserExpression::Default();
   }
 
   PreParserExpression NewYield(PreParserExpression generator_object,
                                PreParserExpression expression,
                                Yield::Kind yield_kind,
                                int pos) {
     return PreParserExpression::Default();
   }
+
+  PreParserExpression NewConditional(PreParserExpression condition,
+                                     PreParserExpression then_expression,
+                                     PreParserExpression else_expression,
+                                     int pos) {
+    return PreParserExpression::Default();
+  }
 };
 
 
 class PreParser;
 
 class PreParserTraits {
  public:
   struct Type {
     // TODO(marja): To be removed. The Traits object should contain all the data
     // it needs.
@@ skipping 152 matching lines @@
   // Temporary glue; these functions will move to ParserBase.
   PreParserExpression ParseV8Intrinsic(bool* ok);
   PreParserExpression ParseFunctionLiteral(
       PreParserIdentifier name,
       Scanner::Location function_name_location,
       bool name_is_strict_reserved,
       bool is_generator,
       int function_token_position,
       FunctionLiteral::FunctionType type,
       bool* ok);
-  PreParserExpression ParseConditionalExpression(bool accept_IN, bool* ok);
+  PreParserExpression ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
 
  private:
   PreParser* pre_parser_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
@@ skipping 781 matching lines @@
       ParseAssignmentExpression(false, CHECK_OK);
   typename Traits::Type::YieldExpression yield =
       factory()->NewYield(generator_object, expression, kind, pos);
   if (kind == Yield::DELEGATING) {
     yield->set_index(function_state_->NextHandlerIndex());
   }
   return yield;
 }
 
 
+// Precedence = 3
+template <class Traits>
+typename Traits::Type::Expression
+ParserBase<Traits>::ParseConditionalExpression(bool accept_IN, bool* ok) {
+  // ConditionalExpression ::
+  //   LogicalOrExpression
+  //   LogicalOrExpression '?' AssignmentExpression ':' AssignmentExpression
+
+  int pos = peek_position();
+  // We start using the binary expression parser for prec >= 4 only!
+  typename Traits::Type::Expression expression =
+      this->ParseBinaryExpression(4, accept_IN, CHECK_OK);
+  if (peek() != Token::CONDITIONAL) return expression;
+  Consume(Token::CONDITIONAL);
+  // In parsing the first assignment expression in conditional
+  // expressions we always accept the 'in' keyword; see ECMA-262,
+  // section 11.12, page 58.
+  typename Traits::Type::Expression left =
+      ParseAssignmentExpression(true, CHECK_OK);
+  Expect(Token::COLON, CHECK_OK);
+  typename Traits::Type::Expression right =
+      ParseAssignmentExpression(accept_IN, CHECK_OK);
+  return factory()->NewConditional(expression, left, right, pos);
+}
+
+
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property,
     PropertyKind type,
     bool* ok) {
   int old;
@@ skipping 20 matching lines @@
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H