Changed interface to preparser to not require pushback support.

preparser/preparser-process.cc

 // 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 109 matching lines @@
       *ok = false;
       return 0;
     }
     n = (n << 8) + static_cast<uint32_t>(c);
   }
   return n;
 }
 
 
 bool ReadBuffer(FILE* source, void* buffer, size_t length) {
-  size_t actually_read = fread(buffer, 1, length, stdin);
+  size_t actually_read = fread(buffer, 1, length, source);
   return (actually_read == length);
 }
 
 
 bool WriteBuffer(FILE* dest, const void* buffer, size_t length) {
   size_t actually_written = fwrite(buffer, 1, length, dest);
   return (actually_written == length);
 }
 
 
 template <typename T>
 class ScopedPointer {
  public:
   explicit ScopedPointer(T* pointer) : pointer_(pointer) {}
   ~ScopedPointer() { delete[] pointer_; }
   T& operator[](int index) { return pointer_[index]; }
   T* operator*() { return pointer_ ;}
  private:
   T* pointer_;
 };
 
 
-// Preparse stdin and output result on stdout.
-int PreParseIO() {
+// Preparse input and output result on stdout.
+int PreParseIO(FILE* input) {
   fprintf(stderr, "LOG: Enter parsing loop\n");
   bool ok = true;
-  uint32_t length = ReadUInt32(stdin, &ok);
+  uint32_t length = ReadUInt32(input, &ok);
+  fprintf(stderr, "LOG: Input length: %d\n", length);
   if (!ok) return kErrorReading;
   ScopedPointer<uint8_t> buffer(new uint8_t[length]);
 
-  if (!ReadBuffer(stdin, *buffer, length)) {
+  if (!ReadBuffer(input, *buffer, length)) {
     return kErrorReading;
   }
   UTF8InputStream input_buffer(*buffer, static_cast<size_t>(length));
 
   v8::PreParserData data =
-      v8::Preparse(&input_buffer, 64 * sizeof(void*));  // NOLINT
+      v8::Preparse(&input_buffer, 64 * 1024 * sizeof(void*));  // NOLINT
   if (data.stack_overflow()) {
+    fprintf(stderr, "LOG: Stack overflow\n");
+    fflush(stderr);
     // Report stack overflow error/no-preparser-data.
     WriteUInt32(stdout, 0, &ok);
     if (!ok) return kErrorWriting;
     return 0;
   }
 
   uint32_t size = data.size();
+  fprintf(stderr, "LOG: Success, data size: %u\n", size);
+  fflush(stderr);
   WriteUInt32(stdout, size, &ok);
   if (!ok) return kErrorWriting;
   if (!WriteBuffer(stdout, data.data(), size)) {
     return kErrorWriting;
   }
   return 0;
 }
 
 } }  // namespace v8::internal
 
 
 int main(int argc, char* argv[]) {
+  FILE* input = stdin;
+  if (argc > 1) {
+    char* arg = argv[1];
+    FILE* file = fopen(arg, "rb");
+    if (!file) return EXIT_FAILURE;
+  }
   int status = 0;
   do {
-    status = v8::internal::PreParseIO();
+    status = v8::internal::PreParseIO(input);
   } while (status == 0);
   fprintf(stderr, "EXIT: Failure %d\n", status);
+  fflush(stderr);
   return EXIT_FAILURE;
 }