Initial NOOP VM Service

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"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dbg_connection.h"
 #include "bin/directory.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/process.h"
+#include "bin/vmservice_impl.h"
 #include "platform/globals.h"
 
 namespace dart {
 namespace bin {
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
 // Global state that stores a pointer to the application script snapshot.
@@ skipping 26 matching lines @@
 static bool has_compile_all = false;
 // Global flag that is used to indicate that we want to check function
 // fingerprints.
 static bool has_check_function_fingerprints = 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;
 
 
+// VM Service options.
+static bool start_vm_service = false;
+static int vm_service_server_port = -1;
+static const int DEFAULT_VM_SERVICE_SERVER_PORT = 8181;
+
+
 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 113 matching lines @@
                     filename);
       return false;
     }
     generate_script_snapshot = true;
     return true;
   }
   return false;
 }
 
 
+static bool ProcessEnableVmServiceOption(const char* port) {
+  ASSERT(port != NULL);
+  vm_service_server_port = -1;
+  if (*port == '\0') {
+    vm_service_server_port = DEFAULT_VM_SERVICE_SERVER_PORT;
+  } else {
+    if ((*port == '=') || (*port == ':')) {
+      vm_service_server_port = atoi(port + 1);
+    }
+  }
+  if (vm_service_server_port < 0) {
+    Log::PrintErr("unrecognized --enable-vm-service option syntax. "
+                    "Use --enable-vm-service[:<port number>]\n");
+    return false;
+  }
+  start_vm_service = true;
+  return true;
+}
+
 static struct {
   const char* option_name;
   bool (*process)(const char* option);
 } main_options[] = {
   // Standard options shared with dart2js.
   { "--version", ProcessVersionOption },
   { "--help", ProcessHelpOption },
   { "-h", ProcessHelpOption },
   { "--verbose", ProcessVerboseOption },
   { "-v", ProcessVerboseOption },
   { "--package-root=", ProcessPackageRootOption },
   // VM specific options to the standalone dart program.
   { "--break-at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
   { "--snapshot=", ProcessGenScriptSnapshotOption },
   { "--print-script", ProcessPrintScriptOption },
   { "--check-function-fingerprints", ProcessFingerprintedFunctions },
+  { "--enable-vm-service", ProcessEnableVmServiceOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   int option_length = strlen(option);
   while (name != NULL) {
     int length = strlen(name);
@@ skipping 312 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"
 "--snapshot=<file_name>\n"
 "  loads Dart script and generates a snapshot in the specified file\n"
 "\n"
 "--print-script\n"
 "  generates Dart source code back and prints it after parsing a Dart script\n"
 "\n"
+"--enable-vm-service[:<port number>]\n"
+"  enables the VM service and listens on specified port for connections\n"
+"  (default port number is 8181)\n"
+"\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
     const char* print_flags = "--print_flags";
     Dart_SetVMFlags(1, &print_flags);
   }
 }
 
 
 static Dart_Handle SetBreakpoint(const char* breakpoint_at,
                                  Dart_Handle library) {
@@ skipping 151 matching lines @@
   // Start the debugger wire protocol handler if necessary.
   if (start_debugger) {
     ASSERT(debug_port >= 0);
     bool print_msg = verbose_debug_seen || (debug_port == 0);
     debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
     if (print_msg) {
       Log::Print("Debugger listening on port %d\n", debug_port);
     }
   }
 
+  // Start the VM service isolate, if necessary.
+  if (start_vm_service) {
+    ASSERT(vm_service_server_port >= 0);
+    bool r = VmService::Start(vm_service_server_port);
+    if (!r) {
+      Log::PrintErr("Could not start VM Service isolate %s",
+                    VmService::GetErrorMessage());
+    }
+  }
+
   // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   char* isolate_name = BuildIsolateName(script_name, "main");
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(script_name,
                                                      "main",
                                                      new IsolateData(),
                                                      &error);
   if (isolate == NULL) {
     Log::PrintErr("%s\n", error);
@@ skipping 98 matching lines @@
 
   return Process::GlobalExitCode();
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   return dart::bin::main(argc, argv);
 }