Add a command line option to generate source code for a script

runtime/bin/main.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
@@ skipping 45 matching lines @@
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* package_root = NULL;
 
 
 // Global flag that is used to indicate that we want to compile all the
 // dart functions and not run anything.
 static bool has_compile_all = false;
 
 
+// Global flag that is used to indicate that we want to print the source code
+// for script that is being run.
+static bool has_print_script = false;
+
+
 static bool IsValidFlag(const char* name,
                         const char* prefix,
                         intptr_t prefix_length) {
   intptr_t name_length = strlen(name);
   return ((name_length > prefix_length) &&
           (strncmp(name, prefix, prefix_length) == 0));
 }
 
 
 static bool has_version_option = false;
@@ skipping 103 matching lines @@
   }
   if (vmstats_port < 0) {
     Log::PrintErr("unrecognized --stats option syntax. "
                     "Use --stats[:<port number>]\n");
     return false;
   }
   return true;
 }
 
 
+static bool ProcessPrintScriptOption(const char* arg) {
+  ASSERT(arg != NULL);
+  if (*arg != '\0') {
+    return false;
+  }
+  has_print_script = true;
+  return true;
+}
+
+
 static bool ProcessVmStatsRootOption(const char* arg) {
   ASSERT(arg != NULL);
   vmstats_root = arg;
   return true;
 }
 
 
 static bool ProcessGenScriptSnapshotOption(const char* filename) {
   if (filename != NULL && strlen(filename) != 0) {
     // Ensure that are already running using a full snapshot.
@@ skipping 32 matching lines @@
   { "--package-root=", ProcessPackageRootOption },
   { "-p", ProcessPackageRootOption },
   // VM specific options to the standalone dart program.
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
   { "--use-script-snapshot=", ProcessUseScriptSnapshotOption },
   { "--generate-script-snapshot=", ProcessGenScriptSnapshotOption },
   { "--stats-root=", ProcessVmStatsRootOption },
   { "--stats", ProcessVmStatsOption },
+  { "--print-script", ProcessPrintScriptOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   while (name != NULL) {
     int length = strlen(name);
     if (strncmp(option, name, length) == 0) {
@@ skipping 325 matching lines @@
 "  sets a breakpoint at specified location where <location> is one of :\n"
 "  url:<line_num> e.g. test.dart:10\n"
 "  [<class_name>.]<function_name> e.g. B.foo\n"
 "\n"
 "--use-script-snapshot=<file_name>\n"
 "  executes Dart script present in the specified snapshot file\n"
 "\n"
 "--generate-script-snapshot=<file_name>\n"
 "  loads Dart script and generates a snapshot in the specified file\n"
 "\n"
+"--print-source\n"
+"  generates Dart source code back and prints it after parsing a Dart script\n"
+"\n"
 "--stats[:<port number>]\n"
 "  enables VM stats service and listens on specified port for HTTP requests\n"
 "  (default port number is dynamically assigned)\n"
 "\n"
 "--stats-root=<path>\n"
 "  where to find static files used by the vmstats application\n"
 "  (used during vmstats plug-in development)\n"
 "\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
@@ skipping 72 matching lines @@
 
 static void ShutdownIsolate(void* callback_data) {
   IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
   VmStats::RemoveIsolate(isolate_data);
   EventHandler* handler = isolate_data->event_handler;
   if (handler != NULL) handler->Shutdown();
   delete isolate_data;
 }
 
 
+static Dart_Handle GenerateScriptSource() {
+  Dart_Handle library_url = Dart_LibraryUrl(Dart_RootLibrary());
+  if (Dart_IsError(library_url)) {
+    return library_url;
+  }
+  Dart_Handle script_urls = Dart_GetScriptURLs(library_url);
+  if (Dart_IsError(script_urls)) {
+    return script_urls;
+  }
+  intptr_t length;
+  Dart_Handle result = Dart_ListLength(script_urls, &length);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  for (intptr_t i = 0; i < length; i++) {
+    Dart_Handle script_url = Dart_ListGetAt(script_urls, i);
+    if (Dart_IsError(script_url)) {
+      return script_url;
+    }
+    result = Dart_GenerateScriptSource(library_url, script_url);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+    const char* script_source = NULL;
+    result = Dart_StringToCString(result, &script_source);
+    if (Dart_IsError(result)) {
+      return result;
+    }
+    Log::Print("%s\n", script_source);
+  }
+  return Dart_True();
+}
+
+
 int main(int argc, char** argv) {
   char* executable_name;
   char* script_name;
   CommandLineOptions vm_options(argc);
   CommandLineOptions dart_options(argc);
   bool print_flags_seen = false;
 
   // Perform platform specific initialization.
   if (!Platform::Initialize()) {
     Log::PrintErr("Initialization failed\n");
@@ skipping 110 matching lines @@
     }
     // Set debug breakpoint if specified on the command line.
     if (breakpoint_at != NULL) {
       result = SetBreakpoint(breakpoint_at, library);
       if (Dart_IsError(result)) {
         return ErrorExit("Error setting breakpoint at '%s': %s\n",
                          breakpoint_at,
                          Dart_GetError(result));
       }
     }
+    if (has_print_script) {
+      result = GenerateScriptSource();
+      if (Dart_IsError(result)) {
+        return ErrorExit("%s\n", Dart_GetError(result));
+      }
+    }
 
     // Lookup and invoke the top level main function.
     result = Dart_Invoke(library, DartUtils::NewString("main"), 0, NULL);
     if (Dart_IsError(result)) {
       return ErrorExit("%s\n", Dart_GetError(result));
     }
     // Keep handling messages until the last active receive port is closed.
     result = Dart_RunLoop();
     if (Dart_IsError(result)) {
       return ErrorExit("%s\n", Dart_GetError(result));
     }
   }
 
   Dart_ExitScope();
   if (vmstats_port >= 0) {
     VmStats::Stop();
   }
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) free(argv[i]);
   }
 
   return Process::GlobalExitCode();
 }