Move ParseRegexpLiteral 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 207 matching lines @@
   // whether it is strict mode future reserved.
   typename Traits::IdentifierType ParseIdentifierOrStrictReservedWord(
       bool* is_strict_reserved,
       bool* ok);
   typename Traits::IdentifierType ParseIdentifierName(bool* ok);
   // Parses an identifier and determines whether or not it is 'get' or 'set'.
   typename Traits::IdentifierType ParseIdentifierNameOrGetOrSet(bool* is_get,
                                                                 bool* is_set,
                                                                 bool* ok);
 
+  typename Traits::ExpressionType ParseRegExpLiteral(bool seen_equal, 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
   // setter will store the value (kGetterProperty | kSetterProperty), which
@@ skipping 182 matching lines @@
 };
 
 class PreParser;
 
 
 class PreParserTraits {
  public:
   typedef PreParser* ParserType;
   // Return types for traversing functions.
   typedef PreParserIdentifier IdentifierType;
+  typedef PreParserExpression ExpressionType;
 
   explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
 
   // Helper functions for recursive descent.
   bool is_classic_mode() const;
   bool is_generator() const;
   static bool IsEvalOrArguments(IdentifierType identifier) {
     return identifier.IsEvalOrArguments();
   }
+  int NextMaterializedLiteralIndex();
 
   // Reporting errors.
   void ReportMessageAt(Scanner::Location location,
                        const char* message,
                        Vector<const char*> args);
   void ReportMessageAt(Scanner::Location location,
                        const char* type,
                        const char* name_opt);
   void ReportMessageAt(int start_pos,
                        int end_pos,
                        const char* type,
                        const char* name_opt);
 
-  // Identifiers:
+  // "null" return type creators.
   static IdentifierType EmptyIdentifier() {
     return PreParserIdentifier::Default();
   }
+  static ExpressionType EmptyExpression() {
+    return PreParserExpression::Default();
+  }
 
+  // Producing data during the recursive descent.
   IdentifierType GetSymbol();
+  static IdentifierType NextLiteralString(PretenureFlag tenured) {
+    return PreParserIdentifier::Default();
+  }
+  ExpressionType NewRegExpLiteral(IdentifierType js_pattern,
+                                  IdentifierType js_flags,
+                                  int literal_index,
+                                  int pos) {
+    return PreParserExpression::Default();
+  }
 
  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 141 matching lines @@
           type_(type),
           materialized_literal_count_(0),
           expected_properties_(0),
           with_nesting_count_(0),
           language_mode_(
               (prev_ != NULL) ? prev_->language_mode() : CLASSIC_MODE),
           is_generator_(false) {
       *variable = this;
     }
     ~Scope() { *variable_ = prev_; }
-    void NextMaterializedLiteralIndex() { materialized_literal_count_++; }
+    int NextMaterializedLiteralIndex() { return materialized_literal_count_++; }
     void AddProperty() { expected_properties_++; }
     ScopeType type() { return type_; }
     int expected_properties() { return expected_properties_; }
     int materialized_literal_count() { return materialized_literal_count_; }
     bool IsInsideWith() { return with_nesting_count_ != 0; }
     bool is_generator() { return is_generator_; }
     void set_is_generator(bool is_generator) { is_generator_ = is_generator; }
     bool is_classic_mode() {
       return language_mode_ == CLASSIC_MODE;
     }
@@ skipping 64 matching lines @@
   Expression ParseBinaryExpression(int prec, bool accept_IN, bool* ok);
   Expression ParseUnaryExpression(bool* ok);
   Expression ParsePostfixExpression(bool* ok);
   Expression ParseLeftHandSideExpression(bool* ok);
   Expression ParseNewExpression(bool* ok);
   Expression ParseMemberExpression(bool* ok);
   Expression ParseMemberWithNewPrefixesExpression(unsigned new_count, bool* ok);
   Expression ParsePrimaryExpression(bool* ok);
   Expression ParseArrayLiteral(bool* ok);
   Expression ParseObjectLiteral(bool* ok);
-  Expression ParseRegExpLiteral(bool seen_equal, bool* ok);
   Expression ParseV8Intrinsic(bool* ok);
 
   Arguments ParseArguments(bool* ok);
   Expression ParseFunctionLiteral(
       Identifier name,
       Scanner::Location function_name_location,
       bool name_is_strict_reserved,
       bool is_generator,
       bool* ok);
   void ParseLazyFunctionLiteralBody(bool* ok);
@@ skipping 126 matching lines @@
   if (scanner()->is_literal_ascii() &&
       scanner()->literal_length() == 3) {
     const char* token = scanner()->literal_ascii_string().start();
     *is_get = strncmp(token, "get", 3) == 0;
     *is_set = !*is_get && strncmp(token, "set", 3) == 0;
   }
   return result;
 }
 
 
+template <class Traits>
+typename Traits::ExpressionType
+ParserBase<Traits>::ParseRegExpLiteral(bool seen_equal, bool* ok) {
+  int pos = peek_position();
+  if (!scanner()->ScanRegExpPattern(seen_equal)) {
+    Next();
+    ReportMessage("unterminated_regexp", Vector<const char*>::empty());
+    *ok = false;
+    return Traits::EmptyExpression();
+  }
+
+  int literal_index = this->NextMaterializedLiteralIndex();
+
+  typename Traits::IdentifierType js_pattern = this->NextLiteralString(TENURED);
+  if (!scanner()->ScanRegExpFlags()) {
+    Next();
+    ReportMessageAt(scanner()->location(), "invalid_regexp_flags");
+    *ok = false;
+    return Traits::EmptyExpression();
+  }
+  typename Traits::IdentifierType js_flags = this->NextLiteralString(TENURED);
+  Next();
+  return this->NewRegExpLiteral(js_pattern, js_flags, literal_index, pos);
+}
+
+
 template <typename Traits>
 void ParserBase<Traits>::ObjectLiteralChecker::CheckProperty(
     Token::Value property,
     PropertyKind type,
     bool* ok) {
   int old;
   if (property == Token::NUMBER) {
     old = finder_.AddNumber(scanner()->literal_ascii_string(), type);
   } else if (scanner()->is_literal_ascii()) {
     old = finder_.AddAsciiSymbol(scanner()->literal_ascii_string(), type);
@@ skipping 18 matching lines @@
                                "accessor_get_set");
     }
     *ok = false;
   }
 }
 
 
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H