- Represent strings internally in UTF-16 format, this makes it

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 282 matching lines @@
   }
 
   return 0;
 }
 
 
 static Dart_Handle SetupRuntimeOptions(CommandLineOptions* options,
                                        const char* executable_name,
                                        const char* script_name) {
   int options_count = options->count();
-  Dart_Handle dart_executable = Dart_NewString(executable_name);
+  Dart_Handle dart_executable = DartUtils::NewString(executable_name);
   if (Dart_IsError(dart_executable)) {
     return dart_executable;
   }
-  Dart_Handle dart_script = Dart_NewString(script_name);
+  Dart_Handle dart_script = DartUtils::NewString(script_name);
   if (Dart_IsError(dart_script)) {
     return dart_script;
   }
   Dart_Handle dart_arguments = Dart_NewList(options_count);
   if (Dart_IsError(dart_arguments)) {
     return dart_arguments;
   }
   for (int i = 0; i < options_count; i++) {
-    Dart_Handle argument_value = Dart_NewString(options->GetArgument(i));
+    Dart_Handle argument_value =
+        DartUtils::NewString(options->GetArgument(i));
     if (Dart_IsError(argument_value)) {
       return argument_value;
     }
     Dart_Handle result = Dart_ListSetAt(dart_arguments, i, argument_value);
     if (Dart_IsError(result)) {
       return result;
     }
   }
-  Dart_Handle core_lib_url = Dart_NewString("dart:core");
+  Dart_Handle core_lib_url = DartUtils::NewString("dart:core");
   if (Dart_IsError(core_lib_url)) {
     return core_lib_url;
   }
   Dart_Handle core_lib = Dart_LookupLibrary(core_lib_url);
   if (Dart_IsError(core_lib)) {
     return core_lib;
   }
-  Dart_Handle runtime_options_class_name = Dart_NewString("_OptionsImpl");
+  Dart_Handle runtime_options_class_name =
+      DartUtils::NewString("_OptionsImpl");
   if (Dart_IsError(runtime_options_class_name)) {
     return runtime_options_class_name;
   }
   Dart_Handle runtime_options_class = Dart_GetClass(
       core_lib, runtime_options_class_name);
   if (Dart_IsError(runtime_options_class)) {
     return runtime_options_class;
   }
-  Dart_Handle executable_name_name = Dart_NewString("_nativeExecutable");
+  Dart_Handle executable_name_name =
+      DartUtils::NewString("_nativeExecutable");
   if (Dart_IsError(executable_name_name)) {
     return executable_name_name;
   }
   Dart_Handle set_executable_name =
       Dart_SetField(runtime_options_class,
                     executable_name_name,
                     dart_executable);
   if (Dart_IsError(set_executable_name)) {
     return set_executable_name;
   }
-  Dart_Handle script_name_name = Dart_NewString("_nativeScript");
+  Dart_Handle script_name_name = DartUtils::NewString("_nativeScript");
   if (Dart_IsError(script_name_name)) {
     return script_name_name;
   }
   Dart_Handle set_script_name =
       Dart_SetField(runtime_options_class, script_name_name, dart_script);
   if (Dart_IsError(set_script_name)) {
     return set_script_name;
   }
-  Dart_Handle native_name = Dart_NewString("_nativeArguments");
+  Dart_Handle native_name = DartUtils::NewString("_nativeArguments");
   if (Dart_IsError(native_name)) {
     return native_name;
   }
 
   return Dart_SetField(runtime_options_class, native_name, dart_arguments);
 }
 
 
 static void DumpPprofSymbolInfo() {
   if (generate_pprof_symbols_filename != NULL) {
@@ skipping 174 matching lines @@
 
 
 static Dart_Handle SetBreakpoint(const char* breakpoint_at,
                                  Dart_Handle library) {
   Dart_Handle result;
   if (strchr(breakpoint_at, ':')) {
     char* bpt_line = strdup(breakpoint_at);
     char* colon = strchr(bpt_line, ':');
     ASSERT(colon != NULL);
     *colon = '\0';
-    Dart_Handle url = Dart_NewString(bpt_line);
+    Dart_Handle url = DartUtils::NewString(bpt_line);
     Dart_Handle line_number = Dart_NewInteger(atoi(colon + 1));
     free(bpt_line);
     Dart_Breakpoint bpt;
     result = Dart_SetBreakpointAtLine(url, line_number, &bpt);
   } else {
     char* bpt_function = strdup(breakpoint_at);
     Dart_Handle class_name;
     Dart_Handle function_name;
     char* dot = strchr(bpt_function, '.');
     if (dot == NULL) {
-      class_name = Dart_NewString("");
-      function_name = Dart_NewString(breakpoint_at);
+      class_name = DartUtils::NewString("");
+      function_name = DartUtils::NewString(breakpoint_at);
     } else {
       *dot = '\0';
-      class_name = Dart_NewString(bpt_function);
-      function_name = Dart_NewString(dot + 1);
+      class_name = DartUtils::NewString(bpt_function);
+      function_name = DartUtils::NewString(dot + 1);
     }
     free(bpt_function);
     Dart_Breakpoint bpt;
     result = Dart_SetBreakpointAtEntry(
                  library, class_name, function_name, &bpt);
   }
   return result;
 }
 
 
@@ skipping 136 matching lines @@
   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));
     }
   }
 
   // Lookup and invoke the top level main function.
-  result = Dart_Invoke(library, Dart_NewString("main"), 0, NULL);
+  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();
   // Dump symbol information for the profiler.
   DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   return 0;
 }