Experimental parser: Add an option to lexer shell to ignore after ILLEGAL.

src/lexer/lexer-shell.cc

 // Copyright 2013 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 179 matching lines @@
 
 
 std::pair<TimeDelta, TimeDelta> ProcessFile(
     const char* fname,
     Encoding encoding,
     Isolate* isolate,
     bool run_baseline,
     bool run_experimental,
     bool print_tokens,
     bool check_tokens,
+    bool break_after_illegal,
     int repeat) {
   if (print_tokens) {
     printf("Processing file %s\n", fname);
   }
   HandleScope handle_scope(isolate);
   std::vector<TokenWithLocation> baseline_tokens, experimental_tokens;
   TimeDelta baseline_time, experimental_time;
   if (run_baseline) {
     baseline_time = RunBaselineScanner(
         fname, isolate, encoding, print_tokens || check_tokens,
@@ skipping 13 matching lines @@
   if ((print_tokens || check_tokens) && run_baseline && run_experimental) {
     if (print_tokens) {
       printf("No of tokens in Baseline:     %d\n",
              static_cast<int>(baseline_tokens.size()));
       printf("No of tokens in Experimental: %d\n",
              static_cast<int>(experimental_tokens.size()));
       printf("Baseline and Experimental:\n");
     }
     for (size_t i = 0; i < experimental_tokens.size(); ++i) {
       if (print_tokens) experimental_tokens[i].Print("=>");
+      if (baseline_tokens[i].value == Token::ILLEGAL) {
+        if (experimental_tokens[i].value != Token::ILLEGAL ||
+            experimental_tokens[i].beg != baseline_tokens[i].beg) {
+          printf("MISMATCH:\n");
+          baseline_tokens[i].Print("Expected: ");
+          experimental_tokens[i].Print("Actual:   ");
+          exit(1);
+        }
+        if (break_after_illegal)
+          break;
+        continue;
+      }
       if (experimental_tokens[i] != baseline_tokens[i]) {
         printf("MISMATCH:\n");
         baseline_tokens[i].Print("Expected: ");
         experimental_tokens[i].Print("Actual:   ");
         exit(1);
       }
     }
   }
   return std::make_pair(baseline_time, experimental_time);
 }
 
 
 int main(int argc, char* argv[]) {
   v8::V8::InitializeICU();
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   Encoding encoding = LATIN1;
   bool print_tokens = false;
   bool run_baseline = true;
   bool run_experimental = true;
   bool check_tokens = true;
+  bool break_after_illegal = false;
   std::vector<std::string> fnames;
   std::string benchmark;
   int repeat = 1;
   for (int i = 0; i < argc; ++i) {
     if (strcmp(argv[i], "--latin1") == 0) {
       encoding = LATIN1;
     } else if (strcmp(argv[i], "--utf8") == 0) {
       encoding = UTF8;
     } else if (strcmp(argv[i], "--utf16") == 0) {
       encoding = UTF16;
     } else if (strcmp(argv[i], "--print-tokens") == 0) {
       print_tokens = true;
     } else if (strcmp(argv[i], "--no-baseline") == 0) {
       run_baseline = false;
     } else if (strcmp(argv[i], "--no-experimental") == 0) {
       run_experimental = false;
     } else if (strcmp(argv[i], "--no-check") == 0) {
       check_tokens = false;
+    } else if (strcmp(argv[i], "--break-after-illegal") == 0) {
+      break_after_illegal = true;
     } else if (strncmp(argv[i], "--benchmark=", 12) == 0) {
       benchmark = std::string(argv[i]).substr(12);
     } else if (strncmp(argv[i], "--repeat=", 9) == 0) {
       std::string repeat_str = std::string(argv[i]).substr(9);
       repeat = atoi(repeat_str.c_str());
     } else if (i > 0 && argv[i][0] != '-') {
       fnames.push_back(std::string(argv[i]));
     }
   }
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   {
     v8::HandleScope handle_scope(isolate);
     v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
     v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
     ASSERT(!context.IsEmpty());
     {
       v8::Context::Scope scope(context);
       Isolate* isolate = Isolate::Current();
       double baseline_total = 0, experimental_total = 0;
       for (size_t i = 0; i < fnames.size(); i++) {
         std::pair<TimeDelta, TimeDelta> times;
         check_tokens = check_tokens && run_baseline && run_experimental;
         times = ProcessFile(fnames[i].c_str(), encoding, isolate, run_baseline,
                             run_experimental, print_tokens, check_tokens,
-                            repeat);
+                            break_after_illegal, repeat);
         baseline_total += times.first.InMillisecondsF();
         experimental_total += times.second.InMillisecondsF();
       }
       if (run_baseline) {
         printf("Baseline%s(RunTime): %.f ms\n", benchmark.c_str(),
                baseline_total);
       }
       if (run_experimental) {
         if (benchmark.empty()) benchmark = "Experimental";
         printf("%s(RunTime): %.f ms\n", benchmark.c_str(),
                experimental_total);
       }
     }
   }
   v8::V8::Dispose();
   return 0;
 }