Remove old preparser option and behavior from the parser.

src/parser.h

 // Copyright 2010 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 13 matching lines @@
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_PARSER_H_
 #define V8_PARSER_H_
 
 #include "allocation.h"
 #include "ast.h"
 #include "scanner.h"
+#include "scopes.h"
 
 namespace v8 {
 namespace internal {
 
 class CompilationInfo;
 class FuncNameInferrer;
-class ParserFactory;
 class ParserLog;
 class PositionStack;
 class Target;
 class TemporaryScope;
 
 template <typename T> class ZoneListWrapper;
 
 
 class ParserMessage : public Malloced {
  public:
@@ skipping 119 matching lines @@
         reinterpret_cast<intptr_t>(backing_store) % sizeof(unsigned)));
   }
 
   // Read strings written by ParserRecorder::WriteString.
   static const char* ReadString(unsigned* start, int* chars);
 
   friend class ScriptData;
 };
 
 
-class ParserLog BASE_EMBEDDED {
- public:
-  virtual ~ParserLog() { }
-
-  // Records the occurrence of a function.
-  virtual void LogFunction(int start, int end, int literals, int properties) {}
-  // Records the occurrence of a symbol in the source. The vector holds the
-  // UTF-8 encoded symbol content.
-  virtual void LogSymbol(int start, Vector<const char> symbol) {}
-  // Records the occurrence of a symbol in the source. The symbol pointer
-  // points to the UTF-8 encoded symbol content.
-  virtual void LogSymbol(int start, const char* symbol, int length) {}
-  // Return the current position in the function entry log.
-  virtual int function_position() { return 0; }
-  // Return the current position in the symbol entry log.
-  // Notice: Functions and symbols are currently logged separately.
-  virtual int symbol_position() { return 0; }
-  // Return the number of distinct symbols logged.
-  virtual int symbol_ids() { return 0; }
-  // Pauses recording. The Log-functions above will do nothing during pausing.
-  // Pauses can be nested.
-  virtual void PauseRecording() {}
-  // Ends a recording pause.
-  virtual void ResumeRecording() {}
-  // Extracts a representation of the logged data that can be used by
-  // ScriptData.
-  virtual Vector<unsigned> ExtractData() {
-    return Vector<unsigned>();
-  };
-};
-
-
 // Record only functions.
-class PartialParserRecorder: public ParserLog {
+class PartialParserRecorder {
  public:
   PartialParserRecorder();
 
-  virtual void LogFunction(int start, int end, int literals, int properties) {
+  void LogFunction(int start, int end, int literals, int properties) {
     function_store_.Add(start);
     function_store_.Add(end);
     function_store_.Add(literals);
     function_store_.Add(properties);
   }
 
+  void LogSymbol(int start, const char* symbol, int length) { }
+
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
   void LogMessage(int start,
                   int end,
                   const char* message,
                   const char* argument_opt) {
     Scanner::Location location(start, end);
     Vector<const char*> arguments;
     if (argument_opt != NULL) {
       arguments = Vector<const char*>(&argument_opt, 1);
     }
     this->LogMessage(location, message, arguments);
   }
 
-  virtual int function_position() { return function_store_.size(); }
+  int function_position() { return function_store_.size(); }
 
-  virtual void LogMessage(Scanner::Location loc,
-                          const char* message,
-                          Vector<const char*> args);
+  void LogMessage(Scanner::Location loc,
+                  const char* message,
+                  Vector<const char*> args);
 
-  virtual Vector<unsigned> ExtractData();
+  Vector<unsigned> ExtractData();
 
-  virtual void PauseRecording() {
+  void PauseRecording() {
     pause_count_++;
     is_recording_ = false;
   }
 
-  virtual void ResumeRecording() {
+  void ResumeRecording() {
     ASSERT(pause_count_ > 0);
     if (--pause_count_ == 0) is_recording_ = !has_error();
   }
 
+  int symbol_position() { return 0; }
+  int symbol_ids() { return 0; }
+
  protected:
   bool has_error() {
     return static_cast<bool>(preamble_[ScriptDataImpl::kHasErrorOffset]);
   }
 
   bool is_recording() {
     return is_recording_;
   }
 
   void WriteString(Vector<const char> str);
 
   Collector<unsigned> function_store_;
   unsigned preamble_[ScriptDataImpl::kHeaderSize];
   bool is_recording_;
   int pause_count_;
 
 #ifdef DEBUG
   int prev_start_;
 #endif
 };
 
 
 // Record both functions and symbols.
 class CompleteParserRecorder: public PartialParserRecorder {
  public:
   CompleteParserRecorder();
 
-  virtual void LogSymbol(int start, Vector<const char> literal);
+  void LogSymbol(int start, Vector<const char> literal);
 
-  virtual void LogSymbol(int start, const char* symbol, int length) {
+  void LogSymbol(int start, const char* symbol, int length) {
     LogSymbol(start, Vector<const char>(symbol, length));
   }
 
-  virtual Vector<unsigned> ExtractData();
+  Vector<unsigned> ExtractData();
 
-  virtual int symbol_position() { return symbol_store_.size(); }
-  virtual int symbol_ids() { return symbol_id_; }
+  int symbol_position() { return symbol_store_.size(); }
+  int symbol_ids() { return symbol_id_; }
 
  private:
   static int vector_hash(Vector<const char> string) {
     int hash = 0;
     for (int i = 0; i < string.length(); i++) {
       int c = string[i];
       hash += c;
       hash += (hash << 10);
       hash ^= (hash >> 6);
     }
@@ skipping 31 matching lines @@
                                   unibrow::CharacterStream* stream,
                                   v8::Extension* extension);
 
   // Preparser that only does preprocessing that makes sense if only used
   // immediately after.
   static ScriptDataImpl* PartialPreParse(Handle<String> source,
                                          unibrow::CharacterStream* stream,
                                          v8::Extension* extension);
 };
 
+// ----------------------------------------------------------------------------
+// REGEXP PARSING
 
 // A BuffferedZoneList is an automatically growing list, just like (and backed
 // by) a ZoneList, that is optimized for the case of adding and removing
 // a single element. The last element added is stored outside the backing list,
 // and if no more than one element is ever added, the ZoneList isn't even
 // allocated.
 // Elements must not be NULL pointers.
 template <typename T, int initial_size>
 class BufferedZoneList {
  public:
@@ skipping 195 matching lines @@
     // Stored disjunction's capture index (if any).
     int disjunction_capture_index_;
   };
 
   uc32 current() { return current_; }
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in()->length(); }
   uc32 Next();
   FlatStringReader* in() { return in_; }
   void ScanForCaptures();
+
+  Handle<String>* error_;
+  ZoneList<RegExpCapture*>* captures_;
+  FlatStringReader* in_;
   uc32 current_;
+  int next_pos_;
+  // The capture count is only valid after we have scanned for captures.
+  int capture_count_;
   bool has_more_;
   bool multiline_;
-  int next_pos_;
-  FlatStringReader* in_;
-  Handle<String>* error_;
   bool simple_;
   bool contains_anchor_;
-  ZoneList<RegExpCapture*>* captures_;
   bool is_scanned_for_captures_;
-  // The capture count is only valid after we have scanned for captures.
-  int capture_count_;
   bool failed_;
 };
 
+// ----------------------------------------------------------------------------
+// JAVASCRIPT PARSING
 
 class Parser {
  public:
-  Parser(Handle<Script> script, bool allow_natives_syntax,
-         v8::Extension* extension, ParserMode is_pre_parsing,
-         ParserFactory* factory, ParserLog* log, ScriptDataImpl* pre_data);
+  Parser(Handle<Script> script,
+         bool allow_natives_syntax,
+         v8::Extension* extension,
+         ScriptDataImpl* pre_data);
   virtual ~Parser() { }
 
-  void ReportMessage(const char* message, Vector<const char*> args);
-  virtual void ReportMessageAt(Scanner::Location loc,
-                               const char* message,
-                               Vector<const char*> args) = 0;
-
-
   // Returns NULL if parsing failed.
   FunctionLiteral* ParseProgram(Handle<String> source,
                                 bool in_global_context);
+
   FunctionLiteral* ParseLazy(Handle<SharedFunctionInfo> info);
 
-  // The minimum number of contiguous assignment that will
-  // be treated as an initialization block. Benchmarks show that
-  // the overhead exceeds the savings below this limit.
-  static const int kMinInitializationBlock = 3;
+  void ReportMessageAt(Scanner::Location loc,
+                       const char* message,
+                       Vector<const char*> args);
 
  protected:
-
   enum Mode {
     PARSE_LAZILY,
     PARSE_EAGERLY
   };
 
   // Report syntax error
   void ReportUnexpectedToken(Token::Value token);
   void ReportInvalidPreparseData(Handle<String> name, bool* ok);
-
-  Handle<Script> script_;
-  Scanner scanner_;
-
-  Scope* top_scope_;
-  int with_nesting_level_;
-
-  TemporaryScope* temp_scope_;
-  Mode mode_;
-
-  Target* target_stack_;  // for break, continue statements
-  bool allow_natives_syntax_;
-  v8::Extension* extension_;
-  ParserFactory* factory_;
-  ParserLog* log_;
-  bool is_pre_parsing_;
-  ScriptDataImpl* pre_data_;
-  FuncNameInferrer* fni_;
+  void ReportMessage(const char* message, Vector<const char*> args);
 
   bool inside_with() const { return with_nesting_level_ > 0; }
-  ParserFactory* factory() const { return factory_; }
-  ParserLog* log() const { return log_; }
   Scanner& scanner()  { return scanner_; }
   Mode mode() const { return mode_; }
   ScriptDataImpl* pre_data() const { return pre_data_; }
 
   // All ParseXXX functions take as the last argument an *ok parameter
   // which is set to false if parsing failed; it is unchanged otherwise.
   // By making the 'exception handling' explicit, we are forced to check
   // for failure at the call sites.
-  void* ParseSourceElements(ZoneListWrapper<Statement>* processor,
+  void* ParseSourceElements(ZoneList<Statement*>* processor,
                             int end_token, bool* ok);
   Statement* ParseStatement(ZoneStringList* labels, bool* ok);
   Statement* ParseFunctionDeclaration(bool* ok);
   Statement* ParseNativeDeclaration(bool* ok);
   Block* ParseBlock(ZoneStringList* labels, bool* ok);
   Block* ParseVariableStatement(bool* ok);
   Block* ParseVariableDeclarations(bool accept_IN, Expression** var, bool* ok);
   Statement* ParseExpressionOrLabelledStatement(ZoneStringList* labels,
                                                 bool* ok);
   IfStatement* ParseIfStatement(ZoneStringList* labels, bool* ok);
@@ skipping 92 matching lines @@
   Literal* GetLiteralTheHole();
   Literal* GetLiteralNumber(double value);
 
   Handle<String> ParseIdentifier(bool* ok);
   Handle<String> ParseIdentifierName(bool* ok);
   Handle<String> ParseIdentifierOrGetOrSet(bool* is_get,
                                            bool* is_set,
                                            bool* ok);
 
   // Parser support
-  virtual VariableProxy* Declare(Handle<String> name, Variable::Mode mode,
-                                 FunctionLiteral* fun,
-                                 bool resolve,
-                                 bool* ok) = 0;
+  VariableProxy* Declare(Handle<String> name, Variable::Mode mode,
+                         FunctionLiteral* fun,
+                         bool resolve,
+                         bool* ok);
 
   bool TargetStackContainsLabel(Handle<String> label);
   BreakableStatement* LookupBreakTarget(Handle<String> label, bool* ok);
   IterationStatement* LookupContinueTarget(Handle<String> label, bool* ok);
 
   void RegisterTargetUse(BreakTarget* target, Target* stop);
 
+  // Factory methods.
+
+  Statement* EmptyStatement() {
+    static v8::internal::EmptyStatement empty;
+    return &empty;
+  }
+
+  Scope* NewScope(Scope* parent, Scope::Type type, bool inside_with);
+
+  Handle<String> LookupSymbol(int symbol_id,
+                              Vector<const char> string);
+
+  Handle<String> LookupCachedSymbol(int symbol_id,
+                                    Vector<const char> string);
+
+  Expression* NewCall(Expression* expression,
+                      ZoneList<Expression*>* arguments,
+                      int pos) {
+    return new Call(expression, arguments, pos);
+  }
+
+
   // Create a number literal.
   Literal* NewNumberLiteral(double value);
 
   // Generate AST node that throw a ReferenceError with the given type.
   Expression* NewThrowReferenceError(Handle<String> type);
 
   // Generate AST node that throw a SyntaxError with the given
   // type. The first argument may be null (in the handle sense) in
   // which case no arguments are passed to the constructor.
   Expression* NewThrowSyntaxError(Handle<String> type, Handle<Object> first);
 
   // Generate AST node that throw a TypeError with the given
   // type. Both arguments must be non-null (in the handle sense).
   Expression* NewThrowTypeError(Handle<String> type,
                                 Handle<Object> first,
                                 Handle<Object> second);
 
   // Generic AST generator for throwing errors from compiled code.
   Expression* NewThrowError(Handle<String> constructor,
                             Handle<String> type,
                             Vector< Handle<Object> > arguments);
+
+  ZoneList<Handle<String> > symbol_cache_;
+
+  Handle<Script> script_;
+  Scanner scanner_;
+
+  Scope* top_scope_;
+  int with_nesting_level_;
+
+  TemporaryScope* temp_scope_;
+  Mode mode_;
+
+  Target* target_stack_;  // for break, continue statements
+  bool allow_natives_syntax_;
+  v8::Extension* extension_;
+  bool is_pre_parsing_;
+  ScriptDataImpl* pre_data_;
+  FuncNameInferrer* fni_;
 };
 
 
 // Support for handling complex values (array and object literals) that
 // can be fully handled at compile time.
 class CompileTimeValue: public AllStatic {
  public:
   enum Type {
     OBJECT_LITERAL_FAST_ELEMENTS,
     OBJECT_LITERAL_SLOW_ELEMENTS,
@@ skipping 14 matching lines @@
   static Handle<FixedArray> GetElements(Handle<FixedArray> value);
 
  private:
   static const int kTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
 
+// ----------------------------------------------------------------------------
+// JSON PARSING
+
 // JSON is a subset of JavaScript, as specified in, e.g., the ECMAScript 5
 // specification section 15.12.1 (and appendix A.8).
 // The grammar is given section 15.12.1.2 (and appendix A.8.2).
 class JsonParser BASE_EMBEDDED {
  public:
   // Parse JSON input as a single JSON value.
   // Returns null handle and sets exception if parsing failed.
   static Handle<Object> Parse(Handle<String> source) {
     return JsonParser().ParseJson(source);
   }
@@ skipping 26 matching lines @@
   // return a null handle. Primarily for readability.
   Handle<Object> ReportUnexpectedToken() { return Handle<Object>::null(); }
   // Converts the currently parsed literal to a JavaScript String.
   Handle<String> GetString();
 
   Scanner scanner_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_