Expose APIs for detecting boxed primitives, native errors and Math.

src/factory.cc

 // Copyright 2011 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 224 matching lines @@
 
 Handle<String> Factory::NewExternalStringFromTwoByte(
     ExternalTwoByteString::Resource* resource) {
   CALL_HEAP_FUNCTION(
       isolate(),
       isolate()->heap()->AllocateExternalStringFromTwoByte(resource),
       String);
 }
 
 
+static Handle<JSValue> AllocateJSValue(Isolate* isolate,
+                                       JSFunction* constructor) {
+  CALL_HEAP_FUNCTION(
+      isolate,
+      isolate->heap()->AllocateJSObject(constructor),

[Vyacheslav Egorov (Chromium), 2011/07/12 20:38:12]

constructor will be "dead variable" if GC happens.

you need to wrap constructor into Handle.

(constructor object can't die, but potentially can be relocated)

better still: there is already a Object::ToObject and Factory::ToObject methods
which do exactly what you need.

So I think you can use them to implement your API. so Factory::NewBoxedXXX are
unnecessary.

[zarko, 2011/07/12 21:42:06]

Done.

+      JSValue);
+}
+
+
+static Handle<Object> CreateJSValue(Isolate* isolate,
+                                    JSFunction* constructor,
+                                    Handle<Object> value) {
+  Handle<JSValue> raw_value = AllocateJSValue(isolate, constructor);
+  if (!raw_value.is_null()) {
+    raw_value->set_value(*value);
+  }
+  return raw_value;
+}
+
+
+Handle<Object> Factory::NewBoxedString(Handle<String> value) {
+  return CreateJSValue(isolate(),
+                       isolate()->global_context()->string_function(),
+                       value);
+}
+
+
+Handle<Object> Factory::NewBoxedBoolean(bool value) {
+  Handle<Object> boolean(value ? isolate()->heap()->true_value()
+                               : isolate()->heap()->false_value());
+  return CreateJSValue(isolate(),
+                       isolate()->global_context()->boolean_function(),
+                       boolean);
+}
+
+
+Handle<Object> Factory::NewBoxedNumber(double value) {
+  Handle<Object> number = NewNumber(value);
+  return CreateJSValue(isolate(),
+                       isolate()->global_context()->number_function(),
+                       number);
+}
+
+
 Handle<Context> Factory::NewGlobalContext() {
   CALL_HEAP_FUNCTION(
       isolate(),
       isolate()->heap()->AllocateGlobalContext(),
       Context);
 }
 
 
 Handle<Context> Factory::NewFunctionContext(int length,
                                             Handle<JSFunction> function) {
@@ skipping 992 matching lines @@
     Execution::ConfigureInstance(instance,
                                  instance_template,
                                  pending_exception);
   } else {
     *pending_exception = false;
   }
 }
 
 
 } }  // namespace v8::internal