double JSObject::toNumber(ExecState* exec) const
{
JSValuePtr primitive = toPrimitive(exec, PreferNumber);
if (exec->hadException()) // should be picked up soon in Nodes.cpp
return 0.0;
return primitive->toNumber(exec);
}
double JSValueToNumber(JSContextRef ctx, JSValueRef value, JSValueRef* exception)
{
ExecState* exec = toJS(ctx);
exec->globalData().heap.registerThread();
JSLock lock(exec);
JSValuePtr jsValue = toJS(value);
double number = jsValue.toNumber(exec);
if (exec->hadException()) {
if (exception)
*exception = toRef(exec->exception());
exec->clearException();
number = NaN;
}
return number;
}
void JSHTMLOptionsCollection::setLength(ExecState* exec, JSValuePtr value)
{
HTMLOptionsCollection* imp = static_cast<HTMLOptionsCollection*>(impl());
ExceptionCode ec = 0;
unsigned newLength = 0;
double lengthValue = value->toNumber(exec);
if (!isnan(lengthValue) && !isinf(lengthValue)) {
if (lengthValue < 0.0)
ec = INDEX_SIZE_ERR;
else if (lengthValue > static_cast<double>(UINT_MAX))
newLength = UINT_MAX;
else
newLength = static_cast<unsigned>(lengthValue);
}
if (!ec)
imp->setLength(newLength, ec);
setDOMException(exec, ec);
}
// 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 JSObject::getPrimitiveNumber(ExecState* exec, double& number, JSValuePtr& result)
{
result = defaultValue(exec, PreferNumber);
number = result->toNumber(exec);
return !result->isString();
}
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;
}
static jobject convertArrayInstanceToJavaArray(ExecState* exec, JSArray* jsArray, const char* javaClassName)
{
JNIEnv *env = getJNIEnv();
// As JS Arrays can contain a mixture of objects, assume we can convert to
// the requested Java Array type requested, unless the array type is some object array
// other than a string.
unsigned length = jsArray->length();
jobjectArray jarray = 0;
// Build the correct array type
switch (JNITypeFromPrimitiveType(javaClassName[1])) {
case object_type: {
// Only support string object types
if (0 == strcmp("[Ljava.lang.String;", javaClassName)) {
jarray = (jobjectArray)env->NewObjectArray(length,
env->FindClass("java/lang/String"),
env->NewStringUTF(""));
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
UString stringValue = item->toString(exec);
env->SetObjectArrayElement(jarray,i,
env->functions->NewString(env, (const jchar *)stringValue.data(), stringValue.size()));
}
}
break;
}
case boolean_type: {
jarray = (jobjectArray)env->NewBooleanArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jboolean value = (jboolean)item->toNumber(exec);
env->SetBooleanArrayRegion((jbooleanArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case byte_type: {
jarray = (jobjectArray)env->NewByteArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jbyte value = (jbyte)item->toNumber(exec);
env->SetByteArrayRegion((jbyteArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case char_type: {
jarray = (jobjectArray)env->NewCharArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
UString stringValue = item->toString(exec);
jchar value = 0;
if (stringValue.size() > 0)
value = ((const jchar*)stringValue.data())[0];
env->SetCharArrayRegion((jcharArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case short_type: {
jarray = (jobjectArray)env->NewShortArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jshort value = (jshort)item->toNumber(exec);
env->SetShortArrayRegion((jshortArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case int_type: {
jarray = (jobjectArray)env->NewIntArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jint value = (jint)item->toNumber(exec);
env->SetIntArrayRegion((jintArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case long_type: {
jarray = (jobjectArray)env->NewLongArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jlong value = (jlong)item->toNumber(exec);
env->SetLongArrayRegion((jlongArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case float_type: {
jarray = (jobjectArray)env->NewFloatArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jfloat value = (jfloat)item->toNumber(exec);
env->SetFloatArrayRegion((jfloatArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case double_type: {
jarray = (jobjectArray)env->NewDoubleArray(length);
for(unsigned i = 0; i < length; i++) {
JSValuePtr item = jsArray->get(exec, i);
jdouble value = (jdouble)item->toNumber(exec);
env->SetDoubleArrayRegion((jdoubleArray)jarray, (jsize)i, (jsize)1, &value);
}
break;
}
case array_type: // don't handle embedded arrays
case void_type: // Don't expect arrays of void objects
case invalid_type: // Array of unknown objects
break;
}
// if it was not one of the cases handled, then null is returned
return jarray;
}