js_compare_atom_keys(const void *k1, const void *k2) { jsval v1, v2; v1 = (jsval)k1, v2 = (jsval)k2; if (JSVAL_IS_STRING(v1) && JSVAL_IS_STRING(v2)) return !js_CompareStrings(JSVAL_TO_STRING(v1), JSVAL_TO_STRING(v2)); if (JSVAL_IS_DOUBLE(v1) && JSVAL_IS_DOUBLE(v2)) return *JSVAL_TO_DOUBLE(v1) == *JSVAL_TO_DOUBLE(v2); return v1 == v2; }
/* * This function is used to convert function arguments and return value (jsval) * into the following based on each value's type tag: * * jsval returned * ------------------- * STRING -> char * * INT -> int * DOUBLE -> double * * BOOLEAN -> int * OBJECT -> void * * * All are presented as void * for DTrace consumers to use, after shifting or * masking out the JavaScript type bits. This allows D scripts to use ints and * booleans directly and copyinstr() for string arguments, when types are known * beforehand. * * This is used by the function-args and function-rval probes, which also * provide raw (unmasked) jsvals should type info be useful from D scripts. */ void * jsdtrace_jsvaltovoid(JSContext *cx, jsval argval) { JSType type = TYPEOF(cx, argval); switch (type) { case JSTYPE_NULL: case JSTYPE_VOID: return JS_TYPE_STR(type); case JSTYPE_BOOLEAN: return (void *)JSVAL_TO_BOOLEAN(argval); case JSTYPE_STRING: return (void *)js_GetStringBytes(cx, JSVAL_TO_STRING(argval)); case JSTYPE_NUMBER: if (JSVAL_IS_INT(argval)) return (void *)JSVAL_TO_INT(argval); return JSVAL_TO_DOUBLE(argval); default: return JSVAL_TO_GCTHING(argval); } /* NOTREACHED */ }
char* DLLCALL js_sprintf(JSContext *cx, uint argn, uintN argc, jsval *argv) { char* p; JSString* str; if((p=js_ValueToStringBytes(cx, argv[argn++], NULL))==NULL) return(NULL); p=xp_asprintf_start(p); for(; argn<argc; argn++) { if(JSVAL_IS_DOUBLE(argv[argn])) p=xp_asprintf_next(p,XP_PRINTF_CONVERT|XP_PRINTF_TYPE_DOUBLE,*JSVAL_TO_DOUBLE(argv[argn])); else if(JSVAL_IS_INT(argv[argn])) p=xp_asprintf_next(p,XP_PRINTF_CONVERT|XP_PRINTF_TYPE_INT,JSVAL_TO_INT(argv[argn])); else if(JSVAL_IS_BOOLEAN(argv[argn]) && xp_printf_get_type(p)!=XP_PRINTF_TYPE_CHARP) p=xp_asprintf_next(p,XP_PRINTF_CONVERT|XP_PRINTF_TYPE_INT,JSVAL_TO_BOOLEAN(argv[argn])); else { if((str=JS_ValueToString(cx, argv[argn]))==NULL) return(NULL); p=xp_asprintf_next(p,XP_PRINTF_CONVERT|XP_PRINTF_TYPE_CHARP,JS_GetStringBytes(str)); } } return xp_asprintf_end(p, NULL); }
JSBool js_ValueToObject(JSContext *cx, jsval v, JSObject **objp) { JSObject *obj; if (JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v)) { obj = NULL; } else if (JSVAL_IS_OBJECT(v)) { obj = JSVAL_TO_OBJECT(v); if (!obj->map->clasp->convert(cx, obj, JSTYPE_OBJECT, &v)) return JS_FALSE; if (JSVAL_IS_OBJECT(v)) obj = JSVAL_TO_OBJECT(v); } else { if (JSVAL_IS_STRING(v)) { obj = js_StringToObject(cx, JSVAL_TO_STRING(v)); } else if (JSVAL_IS_INT(v)) { obj = js_NumberToObject(cx, (jsdouble)JSVAL_TO_INT(v)); } else if (JSVAL_IS_DOUBLE(v)) { obj = js_NumberToObject(cx, *JSVAL_TO_DOUBLE(v)); } else { PR_ASSERT(JSVAL_IS_BOOLEAN(v)); obj = js_BooleanToObject(cx, JSVAL_TO_BOOLEAN(v)); } if (!obj) return JS_FALSE; } *objp = obj; return JS_TRUE; }
static PyObject *to_python_object(JSContext *context, jsval value) { if (JSVAL_IS_PRIMITIVE(value)) { if (JSVAL_IS_STRING(value)) { return PyUnicode_FromString(JS_EncodeString(context, JSVAL_TO_STRING(value))); } else if (JSVAL_IS_BOOLEAN(value)) { return PyBool_FromLong(JSVAL_TO_BOOLEAN(value)); } else if (JSVAL_IS_INT(value)) { return PyLong_FromLong(JSVAL_TO_INT(value)); } else if (JSVAL_IS_DOUBLE(value)) { return PyFloat_FromDouble(JSVAL_TO_DOUBLE(value)); } else { Py_INCREF(Py_None); return Py_None; } } else { JSObject *obj = JSVAL_TO_OBJECT(value); if (JS_ObjectIsDate(context, obj)) { return to_python_datetime(context, obj); } else if (JS_IsArrayObject(context, obj)) { return to_python_list(context, obj); } else { return to_python_dict(context, obj); } } }
jsdouble jsd_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval) { if(!JSVAL_IS_DOUBLE(jsdval->val)) return 0; return JSVAL_TO_DOUBLE(jsdval->val); }
JSBool WvideoVol(JSContext *cx, uintN argc, jsval *vp){ JSObject *ob = NULL; ob = JSVAL_TO_OBJECT(JS_THIS(cx,vp)); if(ob){ video *vid = (video*)JS_GetPrivate(cx,ob); if(!vid) return JS_TRUE; if(argc = 0 || (!JSVAL_IS_DOUBLE(JS_ARGV(cx,vp)[0]) && !JSVAL_IS_INT(JS_ARGV(cx,vp)[0]))){ double vol; vol = vid->vb->getVideoVol(vid); //print("Got value %f\n",vol); JS_SET_RVAL(cx,vp,INT_TO_JSVAL((int) (vol*100))); } else { double vol; if(JSVAL_IS_DOUBLE(JS_ARGV(cx,vp)[0])) vol = JSVAL_TO_DOUBLE(JS_ARGV(cx,vp)[0])/100; else if (JSVAL_IS_INT(JS_ARGV(cx,vp)[0])) vol = ((double)JSVAL_TO_INT(JS_ARGV(cx,vp)[0]))/100; if(vol < 0) vol = 0; if(vol > 1) vol = 1; vid->vb->setVideoVol(vid,vol); JS_SET_RVAL(cx,vp,INT_TO_JSVAL((int)vol * 100)); } } return JS_TRUE; }
double Context::FromJSArg<double>(const JS::Value &val) const { if(!JSVAL_IS_NUMBER(val)) { return 0.0f; } return JSVAL_TO_DOUBLE(val); }
JSBool js_ValueToBoolean(JSContext *cx, jsval v, JSBool *bp) { JSBool b; jsdouble d; #if defined XP_PC && defined _MSC_VER && _MSC_VER <= 800 /* MSVC1.5 coredumps */ if (!bp) return JS_TRUE; /* This should be an if-else chain, but MSVC1.5 crashes if it is. */ #define ELSE #else #define ELSE else #endif if (JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v)) { /* Must return early to avoid falling thru to JSVAL_IS_OBJECT case. */ *bp = JS_FALSE; return JS_TRUE; } if (JSVAL_IS_OBJECT(v)) { if (!JSVERSION_IS_ECMA(cx->version)) { if (!OBJ_DEFAULT_VALUE(cx, JSVAL_TO_OBJECT(v), JSTYPE_BOOLEAN, &v)) return JS_FALSE; if (!JSVAL_IS_BOOLEAN(v)) v = JSVAL_TRUE; /* non-null object is true */ b = JSVAL_TO_BOOLEAN(v); } else { b = JS_TRUE; } } ELSE if (JSVAL_IS_STRING(v)) { b = JSSTRING_LENGTH(JSVAL_TO_STRING(v)) ? JS_TRUE : JS_FALSE; } ELSE if (JSVAL_IS_INT(v)) { b = JSVAL_TO_INT(v) ? JS_TRUE : JS_FALSE; } ELSE if (JSVAL_IS_DOUBLE(v)) { d = *JSVAL_TO_DOUBLE(v); b = (!JSDOUBLE_IS_NaN(d) && d != 0) ? JS_TRUE : JS_FALSE; } ELSE #if defined XP_PC && defined _MSC_VER && _MSC_VER <= 800 if (JSVAL_IS_BOOLEAN(v)) { b = JSVAL_TO_BOOLEAN(v); } #else { JS_ASSERT(JSVAL_IS_BOOLEAN(v)); b = JSVAL_TO_BOOLEAN(v); } #endif #undef ELSE *bp = b; return JS_TRUE; }
double TraceMonkeyValue::getFloat() { assert(isValid()); Logging::log(Logging::DEBUG, "TraceMonkeyValue::getFloat: \r\n"); printJSVAL(value); assert(JSVAL_IS_DOUBLE(value)); return *(JSVAL_TO_DOUBLE(value)); }
SEXP jsval_to_double(SEXP ptr) { jsval *p = R_ExternalPtrAddr(ptr); if(!JSVAL_IS_DOUBLE(*p)) { PROBLEM "jsval is not a double!" ERROR; } return(ScalarReal( * JSVAL_TO_DOUBLE(*p))); }
float CFBFunctionsJS::getSpeed(const CFBCard& co) { auto res = callJSFunc("GetSpeed", "j", createJsvalFromCard(co)); if (JSVAL_IS_DOUBLE(res)) { return (float)JSVAL_TO_DOUBLE(res); } return 0.f; }
JS_CLASS_METHOD(JsSceneBinding,Loop) { if (argc == 1) { jsval *args = JS_ARGV(context, vp); JSObject *thisObj = JS_THIS_OBJECT(context,vp); JsScene *pScene = static_cast<JsScene*>(JS_GetPrivate(context,thisObj)); if(pScene) { pScene->Loop(JSVAL_TO_DOUBLE(args[0]),thisObj); } } return JS_TRUE; }
js_compare_atom_keys(const void *k1, const void *k2) { jsval v1, v2; v1 = (jsval)k1, v2 = (jsval)k2; if (JSVAL_IS_STRING(v1) && JSVAL_IS_STRING(v2)) return !js_CompareStrings(JSVAL_TO_STRING(v1), JSVAL_TO_STRING(v2)); if (JSVAL_IS_DOUBLE(v1) && JSVAL_IS_DOUBLE(v2)) { double d1 = *JSVAL_TO_DOUBLE(v1); double d2 = *JSVAL_TO_DOUBLE(v2); if (JSDOUBLE_IS_NaN(d1)) return JSDOUBLE_IS_NaN(d2); #ifdef XP_PC /* XXX MSVC miscompiles such that (NaN == 0) */ if (JSDOUBLE_IS_NaN(d2)) return JS_FALSE; #endif return d1 == d2; } return v1 == v2; }
bool TraceMonkeyValue::compare(ScriptValuePtr other) { assert(isValid()); assert(other->isValid()); jsval otherValue = (dynamic_cast<TraceMonkeyValue*>(other.get()))->value; if (JSVAL_IS_INT(value)) return (JSVAL_IS_INT(otherValue) && JSVAL_TO_INT(value) == JSVAL_TO_INT(otherValue)); else if (JSVAL_IS_NULL(value)) return (JSVAL_IS_NULL(otherValue)); else if (JSVAL_IS_VOID(value)) return (JSVAL_IS_VOID(otherValue)); else if (JSVAL_IS_BOOLEAN(value)) return (JSVAL_IS_BOOLEAN(otherValue) && JSVAL_TO_BOOLEAN(value) == JSVAL_TO_BOOLEAN(otherValue)); else if (JSVAL_IS_DOUBLE(value)) return (JSVAL_IS_DOUBLE(otherValue) && *(JSVAL_TO_DOUBLE(value)) == *(JSVAL_TO_DOUBLE(otherValue))); else if (JSVAL_IS_STRING(value)) { if (!JSVAL_IS_STRING(otherValue)) return false; else assert(0 && "TODO: compare TM strings"); } else if (JSVAL_IS_OBJECT(value)) { if (JSVAL_IS_NULL(otherValue)) // NULLs are objects, in TraceMonkey return false; if (!JSVAL_IS_OBJECT(otherValue)) return false; else assert(0 && "TODO: compare TM objects"); } else { Logging::log(Logging::INFO, "Can't compare uncertain jsvals\r\n"); } assert(0); return false; }
// // Native method FileModDateChanged // JSBool PR_CALLBACK InstallFileOpFileModDateChanged(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { nsInstall *nativeThis = GetNativeThis(cx, obj, argv); if (!nativeThis) return JS_FALSE; PRInt32 nativeRet; JSObject *jsObj; nsInstallFolder *folder; *rval = BOOLEAN_TO_JSVAL(PR_FALSE); if(argc >= 2) { // public int FileModDateChanged (nsInstallFolder aSourceFolder, // Number aOldDate); jsdouble dval = *(JSVAL_TO_DOUBLE(argv[1])); if (argv[0] == JSVAL_NULL || !JSVAL_IS_OBJECT(argv[0])) //argv[0] MUST be a jsval { *rval = *rval = BOOLEAN_TO_JSVAL(PR_FALSE); return JS_TRUE; } jsObj = JSVAL_TO_OBJECT(argv[0]); if (!JS_InstanceOf(cx, jsObj, &FileSpecObjectClass, nsnull)) { *rval = BOOLEAN_TO_JSVAL(PR_FALSE); return JS_TRUE; } folder = (nsInstallFolder*)JS_GetPrivate(cx, jsObj); if(!folder || NS_OK != nativeThis->FileOpFileModDateChanged(*folder, dval, &nativeRet)) { return JS_TRUE; } *rval = BOOLEAN_TO_JSVAL(nativeRet); } else { JS_ReportError(cx, "Function FileModDateChanged requires 2 parameters"); return JS_TRUE; } return JS_TRUE; }
bool CoerceDouble(jsval v, double* d) { if (JSVAL_IS_DOUBLE(v)) { *d = JSVAL_TO_DOUBLE(v); } else if (JSVAL_IS_INT(v)) { *d = double(JSVAL_TO_INT(v)); } else if (JSVAL_IS_VOID(v)) { *d = 0.0; } else { return false; } return true; }
JSAtom * js_AtomizeValue(JSContext *cx, jsval value, uintN flags) { if (JSVAL_IS_STRING(value)) return js_AtomizeString(cx, JSVAL_TO_STRING(value), flags); if (JSVAL_IS_INT(value)) return js_AtomizeInt(cx, JSVAL_TO_INT(value), flags); if (JSVAL_IS_DOUBLE(value)) return js_AtomizeDouble(cx, *JSVAL_TO_DOUBLE(value), flags); if (JSVAL_IS_OBJECT(value)) return js_AtomizeObject(cx, JSVAL_TO_OBJECT(value), flags); if (JSVAL_IS_BOOLEAN(value)) return js_AtomizeBoolean(cx, JSVAL_TO_BOOLEAN(value), flags); return js_AtomizeHashedKey(cx, value, (JSHashNumber)value, flags); }
SEXP js_to_R(SEXP ptr) { jsval *p = R_ExternalPtrAddr(ptr); if(JSVAL_IS_INT(*p)) return(ScalarInteger(JSVAL_TO_INT(*p))); else if(JSVAL_IS_BOOLEAN(*p)) return(ScalarLogical(JSVAL_TO_BOOLEAN(*p))); else if(JSVAL_IS_DOUBLE(*p)) return(ScalarReal( * JSVAL_TO_DOUBLE(*p))); else if(JSVAL_IS_STRING(*p)) { return(jsval_to_string(ptr)); } else return(R_NilValue); }
VALUE convert_to_ruby(JohnsonRuntime* runtime, jsval js) { if (JSVAL_NULL == js) return Qnil; JSContext * context = johnson_get_current_context(runtime); PREPARE_RUBY_JROOTS(context, 1); JROOT(js); switch (JS_TypeOfValue(context, js)) { case JSTYPE_VOID: JRETURN_RUBY(Qnil); case JSTYPE_FUNCTION: case JSTYPE_OBJECT: if (OBJECT_TO_JSVAL(runtime->global) == js) // global gets special treatment, since the Prelude might not be loaded JRETURN_RUBY(make_ruby_land_proxy(runtime, js, "GlobalProxy")); // this conditional requires the Prelude if (js_value_is_symbol(runtime, js)) JRETURN_RUBY(ID2SYM(rb_intern(JS_GetStringBytes(JS_ValueToString(context, js))))); if (js_value_is_proxy(runtime, js)) JRETURN_RUBY(unwrap_js_land_proxy(runtime, js)); if (js_value_is_regexp(runtime, js)) JRETURN_RUBY(convert_regexp_to_ruby(runtime, js)); JRETURN_RUBY(make_ruby_land_proxy(runtime, js, "RubyLandProxy")); case JSTYPE_BOOLEAN: JRETURN_RUBY(JSVAL_TRUE == js ? Qtrue : Qfalse); case JSTYPE_STRING: JRETURN_RUBY(convert_js_string_to_ruby(runtime, JSVAL_TO_STRING(js))); case JSTYPE_NUMBER: if (JSVAL_IS_INT(js)) JRETURN_RUBY(INT2FIX(JSVAL_TO_INT(js))); else JRETURN_RUBY(rb_float_new(*JSVAL_TO_DOUBLE(js))); default: JERROR("unknown js type in switch"); } JRETURN_RUBY(Qnil); }
double TraceMonkeyValue::getPropertyFloat(std::string propertyName) { assert(isValid()); Logging::log(Logging::DEBUG, "TraceMonkeyValue::getPropertyFloat(%s): \r\n", propertyName.c_str()); printJSVAL(value); assert(JSVAL_IS_OBJECT(value)); jsval ret; bool success = JS_GetProperty(TraceMonkeyEngine::context, JSVAL_TO_OBJECT(value), propertyName.c_str(), &ret); assert(success); assert(JSVAL_IS_DOUBLE(ret)); Logging::log(Logging::DEBUG, "returning: \r\n"); printJSVAL(ret); return *(JSVAL_TO_DOUBLE(ret)); }
JSBool js_ValueToBoolean(JSContext *cx, jsval v, JSBool *bp) { JSBool b; jsdouble d; if (JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v)) { b = JS_FALSE; } else if (JSVAL_IS_OBJECT(v)) { if (!JS_VERSION_IS_ECMA(cx)) { if (!OBJ_DEFAULT_VALUE(cx, JSVAL_TO_OBJECT(v), JSTYPE_BOOLEAN, &v)) return JS_FALSE; if (!JSVAL_IS_BOOLEAN(v)) v = JSVAL_TRUE; /* non-null object is true */ b = JSVAL_TO_BOOLEAN(v); } else { b = JS_TRUE; } } else if (JSVAL_IS_STRING(v)) { b = JSSTRING_LENGTH(JSVAL_TO_STRING(v)) ? JS_TRUE : JS_FALSE; } else if (JSVAL_IS_INT(v)) { b = JSVAL_TO_INT(v) ? JS_TRUE : JS_FALSE; } else if (JSVAL_IS_DOUBLE(v)) { d = *JSVAL_TO_DOUBLE(v); b = (!JSDOUBLE_IS_NaN(d) && d != 0) ? JS_TRUE : JS_FALSE; } else { JS_ASSERT(JSVAL_IS_BOOLEAN(v)); b = JSVAL_TO_BOOLEAN(v); } *bp = b; return JS_TRUE; }
/* * Log a given jsval with a prefix. * cx - JSContext for the JS execution context to use * val - jsval to print * prefix - string to print before the value, defaults to empty string * * TODO(jat): this whole printf-style logging needs to be replaced, but we * run into library version issues if we use C++ iostreams so we would need * to implement our own equivalent. Given that this code is all likely to * be rewritten for out-of-process hosted mode, it seems unlikely to be worth * the effort until that is completed. */ void PrintJSValue(JSContext* cx, jsval val, char* prefix="") { JSType type = JS_TypeOfValue(cx, val); const char* typeString=JS_GetTypeName(cx, type); static const int BUF_SIZE = 256; char buf[BUF_SIZE]; const char *bufEnd = buf + BUF_SIZE; char* p = buf; p += append_sprintf(p, bufEnd, "%s%s", prefix, typeString); switch(type) { case JSTYPE_VOID: break; case JSTYPE_BOOLEAN: p += append_sprintf(p, bufEnd, ": %s", JSVAL_TO_BOOLEAN(val) ? "true" : "false"); break; case JSTYPE_NUMBER: if (JSVAL_IS_INT(val)) { p += append_sprintf(p, bufEnd, ": %d", JSVAL_TO_INT(val)); } else { p += append_sprintf(p, bufEnd, ": %lf", (double)*JSVAL_TO_DOUBLE(val)); } break; case JSTYPE_OBJECT: { JSObject* obj = JSVAL_TO_OBJECT(val); if (!JSVAL_IS_OBJECT(val)) break; JSClass* clazz = obj ? JS_GET_CLASS(cx, obj) : 0; p += append_sprintf(p, bufEnd, " @ %08x, class %s", (unsigned)obj, clazz ? clazz->name : "<null>"); break; } case JSTYPE_FUNCTION: case JSTYPE_LIMIT: break; case JSTYPE_STRING: { /* * TODO(jat): support JS strings with international characters */ JsStringWrap str(cx, JSVAL_TO_STRING(val)); p += append_sprintf(p, bufEnd, ": %.*s", str.length(), str.bytes()); break; } } Tracer::log("%s", buf); }
nsIVariant * convertJSValToVariant( JSContext *aCtx, jsval aValue) { if (JSVAL_IS_INT(aValue)) return new IntegerVariant(JSVAL_TO_INT(aValue)); if (JSVAL_IS_DOUBLE(aValue)) return new FloatVariant(JSVAL_TO_DOUBLE(aValue)); if (JSVAL_IS_STRING(aValue)) { JSString *str = JSVAL_TO_STRING(aValue); nsDependentJSString value; if (!value.init(aCtx, str)) return nsnull; return new TextVariant(value); } if (JSVAL_IS_BOOLEAN(aValue)) return new IntegerVariant((aValue == JSVAL_TRUE) ? 1 : 0); if (JSVAL_IS_NULL(aValue)) return new NullVariant(); if (JSVAL_IS_OBJECT(aValue)) { JSObject *obj = JSVAL_TO_OBJECT(aValue); // We only support Date instances, all others fail. if (!::js_DateIsValid(aCtx, obj)) return nsnull; double msecd = ::js_DateGetMsecSinceEpoch(aCtx, obj); msecd *= 1000.0; PRInt64 msec; LL_D2L(msec, msecd); return new IntegerVariant(msec); } return nsnull; }
static void ValueToString(JSContext *cx, jsval aJSValue, nsString& aString) { if (JSVAL_IS_VOID(aJSValue)) { aString.Assign(kUndefined, STRLEN_ARRAY(kUndefined)); } else if (JSVAL_IS_NULL(aJSValue)) { aString.Assign(kNull, STRLEN_ARRAY(kNull)); } else if (JSVAL_IS_INT(aJSValue)) { jsint i = JSVAL_TO_INT(aJSValue); char buf[20]; PR_snprintf(buf, sizeof(buf), "%d", i); aString.Assign(NS_ConvertASCIItoUTF16(buf)); } else if (JSVAL_IS_DOUBLE(aJSValue)) { jsdouble d = JSVAL_TO_DOUBLE(aJSValue); char buf[50]; PR_snprintf(buf, sizeof(buf), "%f", d); aString.Assign(NS_ConvertASCIItoUTF16(buf)); } else if (JSVAL_IS_BOOLEAN(aJSValue)) { JSBool b = JSVAL_TO_BOOLEAN(aJSValue); if (b) aString.Assign(kTrue, STRLEN_ARRAY(kTrue)); else aString.Assign(kFalse, STRLEN_ARRAY(kFalse)); } else if (JSVAL_IS_STRING(aJSValue)) { JSString *str = JSVAL_TO_STRING(aJSValue); size_t len; const jschar *chars = JS_GetStringCharsAndLength(cx, str, &len); NS_ASSERTION(chars, "out of memory"); if (chars) { NS_ASSERTION(sizeof(jschar) == sizeof(PRUnichar), "char size mismatch"); aString.Assign(reinterpret_cast<const PRUnichar*>(chars), len); } } else { JSObject *obj = JSVAL_TO_OBJECT(aJSValue); JSClass *clazz = JS_GetClass(cx, obj); aString.Assign(PRUnichar('[')); aString.Append(NS_ConvertASCIItoUTF16(clazz->name)); aString.Append(PRUnichar(']')); } }
JSBool js_AtomizePrimitiveValue(JSContext *cx, jsval v, JSAtom **atomp) { JSAtom *atom; if (JSVAL_IS_STRING(v)) { atom = js_AtomizeString(cx, JSVAL_TO_STRING(v), 0); if (!atom) return JS_FALSE; } else if (JSVAL_IS_DOUBLE(v)) { atom = js_AtomizeDouble(cx, *JSVAL_TO_DOUBLE(v)); if (!atom) return JS_FALSE; } else { JS_ASSERT(JSVAL_IS_INT(v) || JSVAL_IS_BOOLEAN(v) || JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v)); atom = (JSAtom *)v; } *atomp = atom; return JS_TRUE; }
js_hash_atom_key(const void *key) { jsval v; jsdouble *dp; /* Order JSVAL_IS_* tests by likelihood of success. */ v = (jsval)key; if (JSVAL_IS_STRING(v)) return js_HashString(JSVAL_TO_STRING(v)); if (JSVAL_IS_INT(v)) return HASH_INT(JSVAL_TO_INT(v)); if (JSVAL_IS_DOUBLE(v)) { dp = JSVAL_TO_DOUBLE(v); return HASH_DOUBLE(dp); } if (JSVAL_IS_OBJECT(v)) return HASH_OBJECT(JSVAL_TO_OBJECT(v)); if (JSVAL_IS_BOOLEAN(v)) return HASH_BOOLEAN(JSVAL_TO_BOOLEAN(v)); return (JSHashNumber)v; }
//--------------------------------------------------------------------------- void JS_TO_CONCEPT(void *member, jsval rval) { INVOKE_CALL InvokePtr = 0; CALL_BACK_VARIABLE_SET SetVariable = _SetVariable; void *HANDLER = CONCEPT_HANDLER; if (JSVAL_IS_DOUBLE(rval)) { SET_NUMBER_VARIABLE(member, *JSVAL_TO_DOUBLE(rval)); } else if (JSVAL_IS_INT(rval)) { SET_NUMBER_VARIABLE(member, JSVAL_TO_INT(rval)); } else if (JSVAL_IS_STRING(rval)) { struct JSString *str = JSVAL_TO_STRING(rval); SET_BUFFER_VARIABLE(member, JS_GetStringBytes(str), str->length); } else if (JSVAL_IS_BOOLEAN(rval)) { SET_NUMBER_VARIABLE(member, (NUMBER)JSVAL_TO_BOOLEAN(rval)); } else if ((JSVAL_IS_NULL(rval)) || (JSVAL_IS_VOID(rval))) { SET_NUMBER_VARIABLE(member, 0); } else SET_NUMBER_VARIABLE(member, 1); }
SV * PrimJSVALToSV( pTHX_ JSContext *cx, jsval v ) { SV *sv = NULL; if(JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v)) sv = newSV(0); else if(JSVAL_IS_BOOLEAN(v)) { sv = newSV(0); sv_setref_iv(sv, PJS_BOOLEAN, (IV)JSVAL_TO_BOOLEAN(v)); } else if(JSVAL_IS_INT(v)) sv = newSViv((IV)JSVAL_TO_INT(v)); else if(JSVAL_IS_DOUBLE(v)) sv = newSVnv(*JSVAL_TO_DOUBLE(v)); else if(JSVAL_IS_STRING(v)) sv = PJS_JSString2SV(aTHX_ JSVAL_TO_STRING(v)); else croak("PJS_Assert: Unknown primitive type"); return sv; }
void printJSVAL(jsval value) { if (JSVAL_IS_INT(value)) Logging::log(Logging::INFO, "INT: %d\r\n", JSVAL_TO_INT(value)); else if (JSVAL_IS_NULL(value)) Logging::log(Logging::INFO, "NULL (null)\r\n"); else if (JSVAL_IS_VOID(value)) Logging::log(Logging::INFO, "VOID (undefined)\r\n"); else if (JSVAL_IS_BOOLEAN(value)) Logging::log(Logging::INFO, "BOOLEAN: %d\r\n", JSVAL_TO_BOOLEAN(value)); else if (JSVAL_IS_NUMBER(value)) Logging::log(Logging::INFO, "NUMBER: %f\r\n", *JSVAL_TO_DOUBLE(value)); else if (JSVAL_IS_DOUBLE(value)) Logging::log(Logging::INFO, "DOUBLE: %f\r\n", *JSVAL_TO_DOUBLE(value)); else if (JSVAL_IS_STRING(value)) { JSString* str = JS_ValueToString(TraceMonkeyEngine::context, value); char* chr = JS_GetStringBytes(str); Logging::log(Logging::INFO, "STRING: %s\r\n", chr); /* INDENT_LOG(Logging::DEBUG); jsval func; bool success = JS_GetProperty(TraceMonkeyEngine::context, TraceMonkeyEngine::global, "log", &func); assert(success); assert(JSVAL_IS_OBJECT(func)); assert(!JSVAL_IS_NULL(func)); jsval jsArgs[2]; jsArgs[0] = INT_TO_JSVAL(Logging::DEBUG); jsArgs[1] = value; jsval ret; JS_CallFunctionValue(TraceMonkeyEngine::context, JSVAL_TO_OBJECT(value), func, 2, jsArgs, &ret); */ } else if (JSVAL_IS_OBJECT(value)) { Logging::log(Logging::INFO, "OBJECT (object)\r\n"); assert(!JSVAL_IS_NULL(value)); jsval ret; JS_GetProperty(TraceMonkeyEngine::context, JSVAL_TO_OBJECT(value), "uniqueId", &ret); if (JSVAL_IS_INT(ret)) Logging::log(Logging::INFO, "OBJECT (object) has uniqueId: %d\r\n", JSVAL_TO_INT(ret)); else Logging::log(Logging::INFO, "OBJECT (object) has no uniqueId\r\n"); /* if (TraceMonkeyEngine::global) { ScriptEngineManager::getGlobal()->call("log", ScriptValueArgs().append(Logging::DEBUG).append( // ScriptEngineManager::getGlobal()->call("serializeJSON", ScriptEngineManager::getGlobal()->call("keys", // Just print keys, to avoid recursions etc. ScriptValuePtr(new TraceMonkeyValue(true, value)) ) // ) ) ); } */ } else { Logging::log(Logging::INFO, "Uncertain jsval\r\n"); } }