Update d8 preemption mode to support multiple files per line. Each line is r...

src/d8.cc

 // Copyright 2008 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 401 matching lines @@
   for (int i = 0; i < size;) {
     int read = fread(&chars[i], 1, size - i, file);
     i += read;
   }
   fclose(file);
   *size_out = size;
   return chars;
 }
 
 
+static char* ReadToken(const char* data, char token) {
+  char* next = ::strchr(data, token);
+  if (next != NULL) {
+    *next = '\0';
+    return (next + 1);
+  }
+
+  return NULL;
+}
+
+
+static char* ReadLine(const char* data) {
+  return ReadToken(data, '\n');
+}
+
+
+static char* ReadWord(const char* data) {
+  return ReadToken(data, ' ');
+}
+
+
 // Reads a file into a v8 string.
 Handle<String> Shell::ReadFile(const char* name) {
   int size = 0;
   char* chars = ReadChars(name, &size);
   if (chars == NULL) return Handle<String>();
   Handle<String> result = String::New(chars);
   delete[] chars;
   return result;
 }
 
@@ skipping 34 matching lines @@
   Locker locker;
   HandleScope scope;
   Handle<ObjectTemplate> global_template = ObjectTemplate::New();
   global_template->Set(String::New("print"),
                        FunctionTemplate::New(Shell::Print));
   global_template->Set(String::New("load"),
                        FunctionTemplate::New(Shell::Load));
   global_template->Set(String::New("version"),
                        FunctionTemplate::New(Shell::Version));
 
-  Persistent<Context> thread_context = Context::New(NULL, global_template);
-  thread_context->SetSecurityToken(Undefined());
-
-  Context::Scope context_scope(thread_context);
-
   char* ptr = const_cast<char*>(files_.start());
   while ((ptr != NULL) && (*ptr != '\0')) {
     // For each newline-separated line.
-    char *filename = ptr;
-    char* next = ::strchr(ptr, '\n');
-    if (next != NULL) {
-      *next = '\0';
-      ptr = (next + 1);
-    } else {
-      ptr = NULL;
+    char* next_line = ReadLine(ptr);
+
+    if (*ptr == '#') {
+      // Skip comment lines.
+      ptr = next_line;
+      continue;
     }
-    Handle<String> str = Shell::ReadFile(filename);
-    Shell::ExecuteString(str, String::New(filename), false, false);
+
+    Persistent<Context> thread_context = Context::New(NULL, global_template);
+    thread_context->SetSecurityToken(Undefined());
+    Context::Scope context_scope(thread_context);
+
+    while ((ptr != NULL) && (*ptr != '\0')) {
+      char* filename = ptr;
+      ptr = ReadWord(ptr);
+
+      // Skip empty strings.
+      if (strlen(filename) == 0) {
+        break;
+      }
+
+      Handle<String> str = Shell::ReadFile(filename);
+      if (str.IsEmpty()) {
+        printf("WARNING: %s not found\n", filename);
+        break;
+      }
+
+      Shell::ExecuteString(str, String::New(filename), false, false);
+    }
+
+    thread_context.Dispose();
+    ptr = next_line;
   }
-
-  thread_context.Dispose();
 }
 
 
 int Shell::Main(int argc, char* argv[]) {
   i::FlagList::SetFlagsFromCommandLine(&argc, argv, true);
   if (i::FLAG_help) {
     return 1;
   }
   Initialize();
   bool run_shell = (argc == 1);
@@ skipping 62 matching lines @@
   return 0;
 }
 
 
 }  // namespace v8
 
 
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }