Create template system for strict-mode tests.

preparser/preparser-process.cc

 // Copyright 2011 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 21 matching lines @@
 
 #include "../include/v8stdint.h"
 #include "../include/v8-preparser.h"
 
 #include "../src/preparse-data-format.h"
 
 namespace i = v8::internal;
 
 // This file is only used for testing the stand-alone preparser
 // library.
-// The first argument must be the path of a JavaScript source file.
+// The first argument must be the path of a JavaScript source file, or
+// the flags "-e" and the next argument is then the source of a JavaScript
+// program.
 // Optionally this can be followed by the word "throws" (case sensitive),
 // which signals that the parsing is expected to throw - the default is
 // to expect the parsing to not throw.
 // The command line can further be followed by a message text (the
 // *type* of the exception to throw), and even more optionally, the
 // start and end position reported with the exception.
 //
 // This source file is preparsed and tested against the expectations, and if
 // successful, the resulting preparser data is written to stdout.
 // Diagnostic output is output on stderr.
 // The source file must contain only ASCII characters (UTF-8 isn't supported).
 // The file is read into memory, so it should have a reasonable size.
 
 
 // Adapts an ASCII string to the UnicodeInputStream interface.
 class AsciiInputStream : public v8::UnicodeInputStream {
  public:
-  AsciiInputStream(uint8_t* buffer, size_t length)
+  AsciiInputStream(const uint8_t* buffer, size_t length)
       : buffer_(buffer),
         end_offset_(static_cast<int>(length)),
         offset_(0) { }
 
   virtual ~AsciiInputStream() { }
 
   virtual void PushBack(int32_t ch) {
     offset_--;
 #ifdef DEBUG
     if (offset_ < 0 ||
@@ skipping 98 matching lines @@
 
   const uint8_t* const data_;
   const int length_;
   const char* message_;
 };
 
 
 template <typename T>
 class ScopedPointer {
  public:
+  explicit ScopedPointer() : pointer_(NULL) {}
   explicit ScopedPointer(T* pointer) : pointer_(pointer) {}
-  ~ScopedPointer() { delete[] pointer_; }
+  ~ScopedPointer() { if (pointer_ != NULL) delete[] pointer_; }
   T& operator[](int index) { return pointer_[index]; }
   T* operator*() { return pointer_ ;}
+  T*& operator=(T* new_value) {
+    if (pointer_ != NULL) delete[] pointer_;
+    pointer_ = new_value;
+  }
  private:
   T* pointer_;
 };
 
 
 
 void fail(v8::PreParserData* data, const char* message, ...) {
   va_list args;
   va_start(args, message);
   vfprintf(stderr, message, args);
@@ skipping 98 matching lines @@
         }
       }
     }
   }
   return expects;
 }
 
 
 int main(int argc, const char* argv[]) {
   // Parse command line.
-  // Format:  preparser <scriptfile> ["throws" [<exn-type> [<start> [<end>]]]]
-  // Any flags on the line are ignored.
+  // Format:  preparser (<scriptfile> | -e "<source>")
+  //                    ["throws" [<exn-type> [<start> [<end>]]]]
+  // Any flags (except an initial -s) are ignored.
 
   // Check for mandatory filename argument.
   int arg_index = 1;
-  while (argc > arg_index && IsFlag(argv[arg_index])) arg_index++;
   if (argc <= arg_index) {
     fail(NULL, "ERROR: No filename on command line.\n");
   }
+  const uint8_t* source = NULL;
   const char* filename = argv[arg_index];
+  if (!strcmp(filename, "-e")) {
+    arg_index++;
+    if (argc <= arg_index) {
+      fail(NULL, "ERROR: No source after -e on command line.\n");
+    }
+    source = reinterpret_cast<const uint8_t*>(argv[arg_index]);
+  }
   // Check remainder of command line for exception expectations.
   arg_index++;
   ExceptionExpectation expects =
       ParseExpectation(argc - arg_index, argv + arg_index);
 
-  // Open JS file.
-  FILE* input = fopen(filename, "rb");
-  if (input == NULL) {
-    perror("ERROR: Error opening file");
-    fflush(stderr);
-    return EXIT_FAILURE;
+  ScopedPointer<uint8_t> buffer;
+  size_t length;
+
+  if (source == NULL) {
+    // Open JS file.
+    FILE* input = fopen(filename, "rb");
+    if (input == NULL) {
+      perror("ERROR: Error opening file");
+      fflush(stderr);
+      return EXIT_FAILURE;
+    }
+    // Find length of JS file.
+    if (fseek(input, 0, SEEK_END) != 0) {
+      perror("ERROR: Error during seek");
+      fflush(stderr);
+      return EXIT_FAILURE;
+    }
+    length = static_cast<size_t>(ftell(input));
+    rewind(input);
+    // Read JS file into memory buffer.
+    buffer = new uint8_t[length];
+    if (!ReadBuffer(input, *buffer, length)) {
+      perror("ERROR: Reading file");
+      fflush(stderr);
+      return EXIT_FAILURE;
+    }
+    fclose(input);
+    source = *buffer;
+  } else {
+    length = strlen(reinterpret_cast<const char*>(source));
   }
 
-  // Find length of JS file.
-  if (fseek(input, 0, SEEK_END) != 0) {
-    perror("ERROR: Error during seek");
-    fflush(stderr);
-    return EXIT_FAILURE;
-  }
-  size_t length = static_cast<size_t>(ftell(input));
-  rewind(input);
-
-  // Read JS file into memory buffer.
-  ScopedPointer<uint8_t> buffer(new uint8_t[length]);
-  if (!ReadBuffer(input, *buffer, length)) {
-    perror("ERROR: Reading file");
-    fflush(stderr);
-    return EXIT_FAILURE;
-  }
-  fclose(input);
-
   // Preparse input file.
-  AsciiInputStream input_buffer(*buffer, length);
+  AsciiInputStream input_buffer(source, length);
   size_t kMaxStackSize = 64 * 1024 * sizeof(void*);  // NOLINT
   v8::PreParserData data = v8::Preparse(&input_buffer, kMaxStackSize);
 
   // Fail if stack overflow.
   if (data.stack_overflow()) {
     fail(&data, "ERROR: Stack overflow\n");
   }
 
   // Check that the expected exception is thrown, if an exception is
   // expected.
   CheckException(&data, &expects);
 
   return EXIT_SUCCESS;
 }