UString JSImmediate::toString(JSValuePtr v)
{
ASSERT(isImmediate(v));
if (isIntegerNumber(v))
return UString::from(getTruncatedInt32(v));
#if USE(ALTERNATE_JSIMMEDIATE)
if (isNumber(v)) {
ASSERT(isDoubleNumber(v));
double value = doubleValue(v);
if (value == 0.0) // +0.0 or -0.0
return "0";
return UString::from(value);
}
#else
ASSERT(!isNumber(v));
#endif
if (jsBoolean(false) == v)
return "false";
if (jsBoolean(true) == v)
return "true";
if (v.isNull())
return "null";
ASSERT(v.isUndefined());
return "undefined";
}
// Variant value must be released with NPReleaseVariantValue()
void convertValueToNPVariant(ExecState* exec, JSValuePtr value, NPVariant* result)
{
JSLock lock(false);
VOID_TO_NPVARIANT(*result);
if (value.isString()) {
UString ustring = value.toString(exec);
CString cstring = ustring.UTF8String();
NPString string = { (const NPUTF8*)cstring.c_str(), static_cast<uint32_t>(cstring.size()) };
NPN_InitializeVariantWithStringCopy(result, &string);
} else if (value.isNumber()) {
DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result);
} else if (value.isBoolean()) {
BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result);
} else if (value.isNull()) {
NULL_TO_NPVARIANT(*result);
} else if (value.isObject()) {
JSObject* object = asObject(value);
if (object->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(object);
CInstance* instance = static_cast<CInstance*>(imp->getInternalInstance());
if (instance) {
NPObject* obj = instance->getObject();
_NPN_RetainObject(obj);
OBJECT_TO_NPVARIANT(obj, *result);
}
} else {
JSGlobalObject* globalObject = exec->dynamicGlobalObject();
RootObject* rootObject = findRootObject(globalObject);
if (rootObject) {
NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject);
OBJECT_TO_NPVARIANT(npObject, *result);
}
}
}
}
bool JSValueIsNull(JSContextRef, JSValueRef value)
{
JSValuePtr jsValue = toJS(value);
return jsValue.isNull();
}
UString valueToStringWithNullCheck(ExecState* exec, JSValuePtr value)
{
if (value.isNull())
return UString();
return value.toString(exec);
}
// ECMA 8.6.2.2
void JSObject::put(ExecState* exec, const Identifier& propertyName, JSValuePtr value, PutPropertySlot& slot)
{
ASSERT(value);
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
if (propertyName == exec->propertyNames().underscoreProto) {
// Setting __proto__ to a non-object, non-null value is silently ignored to match Mozilla.
if (!value->isObject() && !value->isNull())
return;
JSValuePtr nextPrototypeValue = value;
while (nextPrototypeValue && nextPrototypeValue->isObject()) {
JSObject* nextPrototype = asObject(nextPrototypeValue)->unwrappedObject();
if (nextPrototype == this) {
throwError(exec, GeneralError, "cyclic __proto__ value");
return;
}
nextPrototypeValue = nextPrototype->prototype();
}
setPrototype(value);
return;
}
// Check if there are any setters or getters in the prototype chain
JSValuePtr prototype;
for (JSObject* obj = this; !obj->structure()->hasGetterSetterProperties(); obj = asObject(prototype)) {
prototype = obj->prototype();
if (prototype->isNull()) {
putDirect(propertyName, value, 0, true, slot);
return;
}
}
unsigned attributes;
if ((m_structure->get(propertyName, attributes) != WTF::notFound) && attributes & ReadOnly)
return;
for (JSObject* obj = this; ; obj = asObject(prototype)) {
if (JSValuePtr gs = obj->getDirect(propertyName)) {
if (gs->isGetterSetter()) {
JSObject* setterFunc = asGetterSetter(gs)->setter();
if (!setterFunc) {
throwSetterError(exec);
return;
}
CallData callData;
CallType callType = setterFunc->getCallData(callData);
ArgList args;
args.append(value);
call(exec, setterFunc, callType, callData, this, args);
return;
}
// If there's an existing property on the object or one of its
// prototypes it should be replaced, so break here.
break;
}
prototype = obj->prototype();
if (prototype->isNull())
break;
}
putDirect(propertyName, value, 0, true, slot);
return;
}
jvalue convertValueToJValue(ExecState* exec, JSValuePtr value, JNIType _JNIType, const char* javaClassName)
{
JSLock lock(false);
jvalue result;
switch (_JNIType){
case array_type:
case object_type: {
result.l = (jobject)0;
// First see if we have a Java instance.
if (value->isObject()){
JSObject* objectImp = asObject(value);
if (objectImp->classInfo() == &RuntimeObjectImp::s_info) {
RuntimeObjectImp* imp = static_cast<RuntimeObjectImp*>(objectImp);
JavaInstance *instance = static_cast<JavaInstance*>(imp->getInternalInstance());
if (instance)
result.l = instance->javaInstance();
}
else if (objectImp->classInfo() == &RuntimeArray::s_info) {
// Input is a JavaScript Array that was originally created from a Java Array
RuntimeArray* imp = static_cast<RuntimeArray*>(objectImp);
JavaArray *array = static_cast<JavaArray*>(imp->getConcreteArray());
result.l = array->javaArray();
}
else if (objectImp->classInfo() == &JSArray::info) {
// Input is a Javascript Array. We need to create it to a Java Array.
result.l = convertArrayInstanceToJavaArray(exec, asArray(value), javaClassName);
}
}
// Now convert value to a string if the target type is a java.lang.string, and we're not
// converting from a Null.
if (result.l == 0 && strcmp(javaClassName, "java.lang.String") == 0) {
#ifdef CONVERT_NULL_TO_EMPTY_STRING
if (value->isNull()) {
JNIEnv *env = getJNIEnv();
jchar buf[2];
jobject javaString = env->functions->NewString (env, buf, 0);
result.l = javaString;
}
else
#else
if (!value->isNull())
#endif
{
UString stringValue = value->toString(exec);
JNIEnv *env = getJNIEnv();
jobject javaString = env->functions->NewString (env, (const jchar *)stringValue.data(), stringValue.size());
result.l = javaString;
}
} else if (result.l == 0)
bzero (&result, sizeof(jvalue)); // Handle it the same as a void case
}
break;
case boolean_type: {
result.z = (jboolean)value->toNumber(exec);
}
break;
case byte_type: {
result.b = (jbyte)value->toNumber(exec);
}
break;
case char_type: {
result.c = (jchar)value->toNumber(exec);
}
break;
case short_type: {
result.s = (jshort)value->toNumber(exec);
}
break;
case int_type: {
result.i = (jint)value->toNumber(exec);
}
break;
case long_type: {
result.j = (jlong)value->toNumber(exec);
}
break;
case float_type: {
result.f = (jfloat)value->toNumber(exec);
}
break;
case double_type: {
result.d = (jdouble)value->toNumber(exec);
}
break;
break;
case invalid_type:
default:
case void_type: {
bzero (&result, sizeof(jvalue));
}
break;
}
return result;
}