Invoke generated lexer along with baseline lexer to compare results.

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 24 matching lines @@
 #include "api.h"
 #include "ast.h"
 #include "char-predicates-inl.h"
 #include "messages.h"
 #include "platform.h"
 #include "runtime.h"
 #include "scanner-character-streams.h"
 #include "scopeinfo.h"
 #include "string-stream.h"
 #include "scanner.h"
+#include "lexer.h"
 
 using namespace v8::internal;
 
 Handle<String> ReadFile(const char* name, Isolate* isolate) {
   FILE* file = fopen(name, "rb");
   if (file == NULL) return Handle<String>();
 
   fseek(file, 0, SEEK_END);
   int size = ftell(file);
   rewind(file);
@@ skipping 22 matching lines @@
                       source, 0, source->length());
     scanner_->Initialize(stream_);
   }
 
   ~BaselineScanner() {
     delete scanner_;
     delete stream_;
     delete unicode_cache_;
   }
 
-  Token::Value Next() {
-    return scanner_->Next();
-  }
-
-  Scanner::Location Location() {
-    return scanner_->location();
+  Token::Value Next(int* beg_pos, int* end_pos) {
+    Token::Value res = scanner_->Next();
+    *beg_pos = scanner_->location().beg_pos;
+    *end_pos = scanner_->location().end_pos;
+    return res;
   }
 
  private:
   UnicodeCache* unicode_cache_;
   Scanner* scanner_;
   GenericStringUtf16CharacterStream* stream_;
 };
 
 
-class ExperimentalScanner {
-  explicit ExperimentalScanner(const char* fname);
-  ~ExperimentalScanner();
-  Token::Value Next();
-  Scanner::Location Location();
-};
-
-
 int main(int argc, char* argv[]) {
   v8::V8::InitializeICU();
   v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
   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();
       HandleScope handle_scope(isolate);
       BaselineScanner baseline(argv[1], isolate);
-      Token::Value current;
-      while ((current = baseline.Next()) != Token::EOS) {
-        printf("%11s => (%d, %d)\n",
-               Token::Name(current),
-               baseline.Location().beg_pos,
-               baseline.Location().end_pos);
-      }
+      ExperimentalScanner experimental(argv[1]);
+      Token::Value expected_token, actual_token;
+      int expected_beg, expected_end, actual_beg, actual_end;
+      do {
+        expected_token = baseline.Next(&expected_beg, &expected_end);
+        actual_token = experimental.Next(&actual_beg, &actual_end);
+        printf("=> %11s at (%d, %d)\n",
+               Token::Name(actual_token),
+               actual_beg, actual_end);
+        if (expected_token != actual_token ||
+            expected_beg != actual_beg ||
+            expected_end != actual_end) {
+          printf("MISMATCH:\n");
+          printf("Expected: %s at (%d, %d)\n",
+                 Token::Name(expected_token),
+                 expected_beg, expected_end);
+          printf("Actual:   %s at (%d, %d)\n",
+                 Token::Name(actual_token),
+                 actual_beg, actual_end);
+          return 1;
+        }
+      } while (actual_token != Token::EOS);
     }
   }
   v8::V8::Dispose();
   return 0;
 }