Preparser extracted into separate files that can be compiled to a library.

src/preparser.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 57 matching lines @@
 
 typedef int SourceElements;
 typedef int Expression;
 typedef int Statement;
 typedef int Identifier;
 typedef int Arguments;
 
 
 class PreParser {
  public:
+  enum PreParseResult {
+    kPreParseStackOverflow,
+    kPreParseSuccess
+  };
+
   PreParser() : scope_(NULL), allow_lazy_(true) { }

[fschneider, 2010/11/29 12:27:35]

stack_limit_ and stack_overflow_ should be initialized here?

[Lasse Reichstein, 2010/11/29 13:06:40]

Not really. In fact, allow_lazy_ shouldn't be initialized either, since it's
initialized before use in PerParseProgram.

However, this pattern of usage sucks.
I should make the constructor private, have it initialize the variables, and
make PreParseProgram static. I'll do that.
And while I'm at it, I think I can move the internally used types into the class
as well.

   ~PreParser() { }
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
-  bool PreParseProgram(i::JavaScriptScanner* scanner,
-                       i::ParserRecorder* log,
-                       bool allow_lazy) {
+  PreParseResult PreParseProgram(i::JavaScriptScanner* scanner,
+                                 i::ParserRecorder* log,
+                                 bool allow_lazy,
+                                 uintptr_t stack_limit) {
     allow_lazy_ = allow_lazy;
     scanner_ = scanner;
     log_ = log;
+    stack_limit_ = stack_limit;
+    stack_overflow_ = false;
     Scope top_scope(&scope_, kTopLevelScope);
     bool ok = true;
     ParseSourceElements(i::Token::EOS, &ok);
-    bool stack_overflow = scanner_->stack_overflow();
-    if (!ok && !stack_overflow) {
+    if (!ok && !stack_overflow_) {
       ReportUnexpectedToken(scanner_->current_token());
     }
-    return !stack_overflow;
+    return stack_overflow_ ? kPreParseStackOverflow : kPreParseSuccess;
   }
 
  private:
   enum ScopeType {
     kTopLevelScope,
     kFunctionScope
   };
 
   class Scope {
    public:
@@ skipping 86 matching lines @@
   Expression ParseFunctionLiteral(bool* ok);
 
   Identifier ParseIdentifier(bool* ok);
   Identifier ParseIdentifierName(bool* ok);
   Identifier ParseIdentifierOrGetOrSet(bool* is_get, bool* is_set, bool* ok);
 
   Identifier GetIdentifierSymbol();
   unsigned int HexDigitValue(char digit);
   Expression GetStringSymbol();
 
-
-  i::Token::Value peek() { return scanner_->peek(); }
-  i::Token::Value Next() {
-    i::Token::Value next = scanner_->Next();
-    return next;
+  i::Token::Value peek() {
+    if (stack_overflow_) return i::Token::ILLEGAL;
+    return scanner_->peek();
   }
 
-  void Consume(i::Token::Value token) {
-    Next();
+  i::Token::Value Next() {
+    if (stack_overflow_) return i::Token::ILLEGAL;
+    {
+      int marker;
+      if (reinterpret_cast<uintptr_t>(&marker) < stack_limit_) {
+        // Further calls to peek/Next will return illegal token.
+        // The current one will still be returned. It might already
+        // have been seen using peek.
+        stack_overflow_ = true;
+      }
+    }
+    return scanner_->Next();
   }
 
+  void Consume(i::Token::Value token) { Next(); }
+
   void Expect(i::Token::Value token, bool* ok) {
     if (Next() != token) {
       *ok = false;
     }
   }
 
   bool Check(i::Token::Value token) {
     i::Token::Value next = peek();
     if (next == token) {
       Consume(next);
       return true;
     }
     return false;
   }
   void ExpectSemicolon(bool* ok);
 
   static int Precedence(i::Token::Value tok, bool accept_IN);
 
   i::JavaScriptScanner* scanner_;
   i::ParserRecorder* log_;
   Scope* scope_;
+  uintptr_t stack_limit_;
+  bool stack_overflow_;
   bool allow_lazy_;
 };
 } }  // v8::preparser
 
 #endif  // V8_PREPARSER_H