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

runtime/lib/mirrors.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 "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "platform/json.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/message.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 
 namespace dart {
 
+inline Dart_Handle NewString(const char* str) {
+  return Dart_NewStringFromCString(str);
+}
+
+
 DEFINE_NATIVE_ENTRY(Mirrors_isLocalPort, 1) {
   GET_NATIVE_ARGUMENT(Instance, port, arguments->At(0));
 
   // Get the port id from the SendPort instance.
   const Object& id_obj = Object::Handle(DartLibraryCalls::PortGetId(port));
   if (id_obj.IsError()) {
     Exceptions::PropagateError(Error::Cast(id_obj));
     UNREACHABLE();
   }
   ASSERT(id_obj.IsSmi() || id_obj.IsMint());
   Integer& id = Integer::Handle();
   id ^= id_obj.raw();
   Dart_Port port_id = static_cast<Dart_Port>(id.AsInt64Value());
   return Bool::Get(PortMap::IsLocalPort(port_id));
 }
 
 
 // TODO(turnidge): Add Map support to the dart embedding api instead
 // of implementing it here.
 static Dart_Handle CoreLib() {
-  Dart_Handle core_lib_name = Dart_NewString("dart:core");
+  Dart_Handle core_lib_name = NewString("dart:core");
   return Dart_LookupLibrary(core_lib_name);
 }
 
 
 static Dart_Handle MapNew() {
   // TODO(turnidge): Switch to an order-preserving map type.
-  Dart_Handle cls = Dart_GetClass(CoreLib(), Dart_NewString("Map"));
+  Dart_Handle cls = Dart_GetClass(CoreLib(), NewString("Map"));
   if (Dart_IsError(cls)) {
     return cls;
   }
   return Dart_New(cls, Dart_Null(), 0, NULL);
 }
 
 
 static Dart_Handle MapAdd(Dart_Handle map, Dart_Handle key, Dart_Handle value) {
   Dart_Handle args[] = { key, value };
-  return Dart_Invoke(map, Dart_NewString("[]="), ARRAY_SIZE(args), args);
+  return Dart_Invoke(map, NewString("[]="), ARRAY_SIZE(args), args);
 }
 
 
 static Dart_Handle MirrorLib() {
-  Dart_Handle mirror_lib_name = Dart_NewString("dart:mirrors");
+  Dart_Handle mirror_lib_name = NewString("dart:mirrors");
   return Dart_LookupLibrary(mirror_lib_name);
 }
 
 
 static Dart_Handle IsMirror(Dart_Handle object, bool* is_mirror) {
-  Dart_Handle cls_name = Dart_NewString("Mirror");
+  Dart_Handle cls_name = NewString("Mirror");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle result = Dart_ObjectIsType(object, cls, is_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return Dart_True();  // Indicates success.  Result is in is_mirror.
 }
 
 
 static bool IsSimpleValue(Dart_Handle object) {
   return (Dart_IsNull(object) ||
           Dart_IsNumber(object) ||
           Dart_IsString(object) ||
           Dart_IsBoolean(object));
 }
 
 
 static void FreeVMReference(Dart_Handle weak_ref, void* data) {
   Dart_Handle perm_handle = reinterpret_cast<Dart_Handle>(data);
   Dart_DeletePersistentHandle(perm_handle);
   Dart_DeletePersistentHandle(weak_ref);
 }
 
 
 static Dart_Handle CreateVMReference(Dart_Handle handle) {
   // Create the VMReference object.
-  Dart_Handle cls_name = Dart_NewString("VMReference");
+  Dart_Handle cls_name = NewString("VMReference");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle vm_ref =  Dart_New(cls, Dart_Null(), 0, NULL);
   if (Dart_IsError(vm_ref)) {
     return vm_ref;
   }
 
   // Allocate a persistent handle.
@@ skipping 35 matching lines @@
   if (Dart_IsError(result)) {
     return result;
   }
   Dart_Handle perm_handle = reinterpret_cast<Dart_Handle>(perm_handle_value);
   ASSERT(!Dart_IsError(perm_handle));
   return perm_handle;
 }
 
 
 static Dart_Handle UnwrapMirror(Dart_Handle mirror) {
-  Dart_Handle field_name = Dart_NewString("_reference");
+  Dart_Handle field_name = NewString("_reference");
   Dart_Handle vm_ref = Dart_GetField(mirror, field_name);
   if (Dart_IsError(vm_ref)) {
     return vm_ref;
   }
   return UnwrapVMReference(vm_ref);
 }
 
 
 static Dart_Handle UnwrapArg(Dart_Handle arg) {
     if (Dart_IsError(arg)) {
@@ skipping 44 matching lines @@
   if (Dart_IsError(result)) {
     return result;
   }
 
   int64_t param_count = fixed_param_count + opt_param_count;
   Dart_Handle parameter_list = Dart_NewList(param_count);
   if (Dart_IsError(parameter_list)) {
     return result;
   }
 
-  Dart_Handle param_cls_name = Dart_NewString("_LocalParameterMirrorImpl");
+  Dart_Handle param_cls_name = NewString("_LocalParameterMirrorImpl");
   Dart_Handle param_cls = Dart_GetClass(MirrorLib(), param_cls_name);
   if (Dart_IsError(param_cls)) {
     return param_cls;
   }
 
   for (int64_t i = 0; i < param_count; i++) {
     Dart_Handle param_type = Dart_FunctionParameterType(func, i);
     if (Dart_IsError(param_type)) {
       return param_type;
     }
@@ skipping 14 matching lines @@
   return parameter_list;
 }
 
 
 static Dart_Handle CreateLazyMirror(Dart_Handle target) {
   if (Dart_IsNull(target) || Dart_IsError(target)) {
     return target;
   }
 
   if (Dart_IsLibrary(target)) {
-    Dart_Handle cls_name = Dart_NewString("_LazyLibraryMirror");
+    Dart_Handle cls_name = NewString("_LazyLibraryMirror");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
     Dart_Handle args[] = { Dart_LibraryName(target) };
     return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   }
 
   if (Dart_IsClass(target) || Dart_IsInterface(target)) {
     if (Dart_ClassIsFunctionType(target)) {
-      Dart_Handle cls_name = Dart_NewString("_LazyFunctionTypeMirror");
+      Dart_Handle cls_name = NewString("_LazyFunctionTypeMirror");
       Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
 
       Dart_Handle sig = Dart_ClassGetFunctionTypeSignature(target);
       Dart_Handle return_type = Dart_FunctionReturnType(sig);
       if (Dart_IsError(return_type)) {
         return return_type;
       }
 
       Dart_Handle args[] = {
         CreateLazyMirror(return_type),
         CreateParameterMirrorList(sig),
       };
       return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
     } else {
-      Dart_Handle cls_name = Dart_NewString("_LazyTypeMirror");
+      Dart_Handle cls_name = NewString("_LazyTypeMirror");
       Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
       Dart_Handle lib = Dart_ClassGetLibrary(target);
       Dart_Handle lib_name;
       if (Dart_IsNull(lib)) {
         lib_name = Dart_Null();
       } else {
         lib_name = Dart_LibraryName(lib);
       }
       Dart_Handle args[] = { lib_name, Dart_ClassName(target) };
       return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
     }
   }
 
   if (Dart_IsTypeVariable(target)) {
     Dart_Handle var_name = Dart_TypeVariableName(target);
     Dart_Handle owner = Dart_TypeVariableOwner(target);
     Dart_Handle owner_mirror = CreateLazyMirror(owner);
 
-    Dart_Handle cls_name = Dart_NewString("_LazyTypeVariableMirror");
+    Dart_Handle cls_name = NewString("_LazyTypeVariableMirror");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
 
     Dart_Handle args[] = { var_name, owner_mirror };
     return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   }
 
   UNREACHABLE();
   return Dart_Null();
 }
 
@@ skipping 25 matching lines @@
     }
   }
   return mirror_list;
 }
 
 
 static Dart_Handle CreateTypeVariableMirror(Dart_Handle type_var,
                                             Dart_Handle type_var_name,
                                             Dart_Handle owner_mirror) {
   ASSERT(Dart_IsTypeVariable(type_var));
-  Dart_Handle cls_name = Dart_NewString("_LocalTypeVariableMirrorImpl");
+  Dart_Handle cls_name = NewString("_LocalTypeVariableMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   Dart_Handle upper_bound = Dart_TypeVariableUpperBound(type_var);
   if (Dart_IsError(upper_bound)) {
     return upper_bound;
   }
 
@@ skipping 43 matching lines @@
     }
   }
   return map;
 }
 
 
 static Dart_Handle CreateTypedefMirror(Dart_Handle cls,
                                        Dart_Handle cls_name,
                                        Dart_Handle owner,
                                        Dart_Handle owner_mirror) {
-  Dart_Handle mirror_cls_name = Dart_NewString("_LocalTypedefMirrorImpl");
+  Dart_Handle mirror_cls_name = NewString("_LocalTypedefMirrorImpl");
   Dart_Handle mirror_cls = Dart_GetClass(MirrorLib(), mirror_cls_name);
   if (Dart_IsError(mirror_cls)) {
     return mirror_cls;
   }
 
   Dart_Handle referent = Dart_ClassGetTypedefReferent(cls);
   if (Dart_IsError(referent)) {
     return referent;
   }
 
@@ skipping 17 matching lines @@
                                      Dart_Handle intf_name,
                                      Dart_Handle lib,
                                      Dart_Handle lib_mirror) {
   ASSERT(Dart_IsClass(intf) || Dart_IsInterface(intf));
   if (Dart_ClassIsTypedef(intf)) {
     // This class is actually a typedef.  Represent it specially in
     // reflection.
     return CreateTypedefMirror(intf, intf_name, lib, lib_mirror);
   }
 
-  Dart_Handle cls_name = Dart_NewString("_LocalClassMirrorImpl");
+  Dart_Handle cls_name = NewString("_LocalClassMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   // TODO(turnidge): Why am I getting Null when I expect Object?
   Dart_Handle super_class = Dart_GetSuperclass(intf);
   if (Dart_IsNull(super_class)) {
-    super_class = Dart_GetClass(CoreLib(), Dart_NewString("Object"));
+    super_class = Dart_GetClass(CoreLib(), NewString("Object"));
   }
   Dart_Handle default_class = Dart_ClassGetDefault(intf);
 
   Dart_Handle intf_mirror = CreateLazyMirror(intf);
   if (Dart_IsError(intf_mirror)) {
     return intf_mirror;
   }
   Dart_Handle member_map = CreateMemberMap(intf, intf_mirror);
   if (Dart_IsError(member_map)) {
     return member_map;
@@ skipping 21 matching lines @@
   };
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateMethodMirror(Dart_Handle func,
                                       Dart_Handle func_name,
                                       Dart_Handle owner_mirror) {
   ASSERT(Dart_IsFunction(func));
-  Dart_Handle mirror_cls_name = Dart_NewString("_LocalMethodMirrorImpl");
+  Dart_Handle mirror_cls_name = NewString("_LocalMethodMirrorImpl");
   Dart_Handle mirror_cls = Dart_GetClass(MirrorLib(), mirror_cls_name);
   if (Dart_IsError(mirror_cls)) {
     return mirror_cls;
   }
 
   bool is_static = false;
   bool is_abstract = false;
   bool is_getter = false;
   bool is_setter = false;
   bool is_constructor = false;
@@ skipping 52 matching lines @@
   Dart_Handle mirror =
       Dart_New(mirror_cls, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateVariableMirror(Dart_Handle var,
                                         Dart_Handle var_name,
                                         Dart_Handle lib_mirror) {
   ASSERT(Dart_IsVariable(var));
-  Dart_Handle cls_name = Dart_NewString("_LocalVariableMirrorImpl");
+  Dart_Handle cls_name = NewString("_LocalVariableMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   bool is_static = false;
   bool is_final = false;
 
   Dart_Handle result = Dart_VariableIsStatic(var, &is_static);
   if (Dart_IsError(result)) {
@@ skipping 212 matching lines @@
   Dart_Handle map = MapNew();
   result = AddConstructors(map, owner, owner_mirror);
   if (Dart_IsError(result)) {
     return result;
   }
   return map;
 }
 
 
 static Dart_Handle CreateLibraryMirror(Dart_Handle lib) {
-  Dart_Handle cls_name = Dart_NewString("_LocalLibraryMirrorImpl");
+  Dart_Handle cls_name = NewString("_LocalLibraryMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle lazy_lib_mirror = CreateLazyMirror(lib);
   if (Dart_IsError(lazy_lib_mirror)) {
     return lazy_lib_mirror;
   }
   Dart_Handle member_map = CreateMemberMap(lib, lazy_lib_mirror);
   if (Dart_IsError(member_map)) {
@@ skipping 39 matching lines @@
       return lib_mirror;
     }
     // TODO(turnidge): Check for duplicate library names.
     result = MapAdd(map, lib_key, lib_mirror);
   }
   return map;
 }
 
 
 static Dart_Handle CreateIsolateMirror() {
-  Dart_Handle cls_name = Dart_NewString("_LocalIsolateMirrorImpl");
+  Dart_Handle cls_name = NewString("_LocalIsolateMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
   Dart_Handle args[] = {
     Dart_DebugName(),
     CreateLazyMirror(Dart_RootLibrary()),
   };
   return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
 }
 
 
 static Dart_Handle CreateMirrorSystem() {
-  Dart_Handle cls_name = Dart_NewString("_LocalMirrorSystemImpl");
+  Dart_Handle cls_name = NewString("_LocalMirrorSystemImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   Dart_Handle libraries = CreateLibrariesMap();
   if (Dart_IsError(libraries)) {
     return libraries;
   }
 
   Dart_Handle args[] = {
     libraries,
     CreateIsolateMirror(),
   };
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   if (Dart_IsError(mirror)) {
     return mirror;
   }
 
   return mirror;
 }
 
 
 static Dart_Handle CreateNullMirror() {
-  Dart_Handle cls_name = Dart_NewString("_LocalInstanceMirrorImpl");
+  Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
   Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
   if (Dart_IsError(cls)) {
     return cls;
   }
 
   // TODO(turnidge): This is wrong.  The Null class is distinct from object.
-  Dart_Handle object_class = Dart_GetClass(CoreLib(), Dart_NewString("Object"));
+  Dart_Handle object_class = Dart_GetClass(CoreLib(), NewString("Object"));
 
   Dart_Handle args[] = {
     CreateVMReference(Dart_Null()),
     CreateLazyMirror(object_class),
     Dart_Null(),
   };
   Dart_Handle mirror = Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
   return mirror;
 }
 
 
 static Dart_Handle CreateInstanceMirror(Dart_Handle instance) {
   if (Dart_IsNull(instance)) {
     return CreateNullMirror();
   }
   ASSERT(Dart_IsInstance(instance));
 
   Dart_Handle instance_cls = Dart_InstanceGetClass(instance);
   if (Dart_IsError(instance_cls)) {
     return instance_cls;
   }
 
   if (Dart_IsClosure(instance)) {
-    Dart_Handle cls_name = Dart_NewString("_LocalClosureMirrorImpl");
+    Dart_Handle cls_name = NewString("_LocalClosureMirrorImpl");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
     if (Dart_IsError(cls)) {
       return cls;
     }
     // We set the function field of ClosureMirrors outside of the constructor
     // to break the mutual recursion.
     Dart_Handle func = Dart_ClosureFunction(instance);
     if (Dart_IsError(func)) {
       return func;
     }
 
     // TODO(turnidge): Why not use the real function name here?
-    Dart_Handle func_name = Dart_NewString("call");
+    Dart_Handle func_name = NewString("call");
     Dart_Handle func_owner = Dart_FunctionOwner(func);
     if (Dart_IsError(func_owner)) {
       return func_owner;
     }
 
     // TODO(turnidge): Pass the function owner here.  This will require
     // us to support functions in CreateLazyMirror.
     Dart_Handle func_mirror =
         CreateMethodMirror(func, func_name, Dart_Null());
     if (Dart_IsError(func_mirror)) {
       return func_mirror;
     }
     Dart_Handle args[] = {
       CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
       func_mirror,
     };
     return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
 
   } else {
-    Dart_Handle cls_name = Dart_NewString("_LocalInstanceMirrorImpl");
+    Dart_Handle cls_name = NewString("_LocalInstanceMirrorImpl");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
     if (Dart_IsError(cls)) {
       return cls;
     }
     Dart_Handle args[] = {
       CreateVMReference(instance),
       CreateLazyMirror(instance_cls),
       instance,
     };
     return Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
@@ skipping 14 matching lines @@
       if (Dart_IsFatalError(exc_string)) {
         return exc_string;
       }
       exc_string = Dart_Null();
     }
 
     Dart_Handle stack = Dart_ErrorGetStacktrace(error);
     if (Dart_IsError(stack)) {
       return stack;
     }
-    Dart_Handle cls_name = Dart_NewString("MirroredUncaughtExceptionError");
+    Dart_Handle cls_name = NewString("MirroredUncaughtExceptionError");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
     Dart_Handle args[] = {
       CreateInstanceMirror(exc),
       exc_string,
       stack,
     };
     Dart_Handle mirrored_exc =
         Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
     return Dart_NewUnhandledExceptionError(mirrored_exc);
   } else if (Dart_IsApiError(error) ||
              Dart_IsCompilationError(error)) {
-    Dart_Handle cls_name = Dart_NewString("MirroredCompilationError");
+    Dart_Handle cls_name = NewString("MirroredCompilationError");
     Dart_Handle cls = Dart_GetClass(MirrorLib(), cls_name);
-    Dart_Handle args[] = { Dart_NewString(Dart_GetError(error)) };
+    Dart_Handle args[] = { NewString(Dart_GetError(error)) };
     Dart_Handle mirrored_exc =
         Dart_New(cls, Dart_Null(), ARRAY_SIZE(args), args);
     return Dart_NewUnhandledExceptionError(mirrored_exc);
   } else {
     ASSERT(Dart_IsFatalError(error));
     return error;
   }
 }
 
 
@@ skipping 168 matching lines @@
 }
 
 
 void HandleMirrorsMessage(Isolate* isolate,
                           Dart_Port reply_port,
                           const Instance& message) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart