PyObject* js2py_with_parent(Context* cx, jsval val, jsval parent) { JSType vtype = JS_TypeOfValue(cx->cx, val); PyObject* unwrapped; /* There's not JSType for null. Or rather, its reported as Object which causes segfaults. */ if(JSVAL_IS_NULL(val) || JSVAL_IS_VOID(val)) { Py_RETURN_NONE; } else if(vtype == JSTYPE_BOOLEAN) { if(JSVAL_TO_BOOLEAN(val)) { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; } } else if(vtype == JSTYPE_STRING) { return js2py_string(cx, val); } else if(vtype == JSTYPE_NUMBER) { if(JSVAL_IS_INT(val)) return js2py_integer(cx, val); else return js2py_double(cx, val); } /* Now try to unwrap any incoming object in so we don't rewrap our own objects being passed around. */ unwrapped = unwrap_pyobject(val); if (unwrapped != NULL) return unwrapped; if(vtype == JSTYPE_FUNCTION) { return js2py_function(cx, val, parent); } else if(vtype == JSTYPE_OBJECT) { JSObject* obj = JSVAL_TO_OBJECT(val); if(JS_IsArrayObject(cx->cx, obj)) { return js2py_array(cx, val); } return js2py_object(cx, val); } PyErr_SetString(PyExc_RuntimeError, "Unknown JSVAL type."); return NULL; }
/* * call-seq: * function_property?(name) * * Returns <code>true</code> if this JavaScript object's +name+ property * is a function. */ static VALUE function_property_p(VALUE self, VALUE name) { if (TYPE(name) == T_SYMBOL) name = rb_funcall(name, rb_intern("to_s"), 0); rb_string_value_cstr(&name); RubyLandProxy* proxy; Data_Get_Struct(self, RubyLandProxy, proxy); JSContext * context = johnson_get_current_context(proxy->runtime); PREPARE_RUBY_JROOTS(context, 2); jsval proxy_value; JCHECK(get_jsval_for_proxy(proxy, &proxy_value)); JROOT(proxy_value); jsval js_value; JCHECK(JS_GetProperty(context, JSVAL_TO_OBJECT(proxy_value), StringValueCStr(name), &js_value)); JROOT(js_value); JSType type = JS_TypeOfValue(context, js_value); JRETURN_RUBY(type == JSTYPE_FUNCTION ? Qtrue : Qfalse); }
void append( BSONObjBuilder& b , string name , jsval val , BSONType oldType = EOO , int depth=0 ) { //cout << "name: " << name << "\t" << typeString( val ) << " oldType: " << oldType << endl; switch ( JS_TypeOfValue( _context , val ) ) { case JSTYPE_VOID: b.appendUndefined( name.c_str() ); break; case JSTYPE_NULL: b.appendNull( name.c_str() ); break; case JSTYPE_NUMBER: { double d = toNumber( val ); if ( oldType == NumberInt && ((int)d) == d ) b.append( name.c_str() , (int)d ); else b.append( name.c_str() , d ); break; } case JSTYPE_STRING: b.append( name.c_str() , toString( val ) ); break; case JSTYPE_BOOLEAN: b.appendBool( name.c_str() , toBoolean( val ) ); break; case JSTYPE_OBJECT: { JSObject * o = JSVAL_TO_OBJECT( val ); if ( ! o || o == JSVAL_NULL ) { b.appendNull( name.c_str() ); } else if ( ! appendSpecialDBObject( this , b , name , val , o ) ) { BSONObj sub = toObject( o , depth ); if ( JS_IsArrayObject( _context , o ) ) { b.appendArray( name.c_str() , sub ); } else { b.append( name.c_str() , sub ); } } break; } case JSTYPE_FUNCTION: { string s = toString(val); if ( s[0] == '/' ) { appendRegex( b , name , s ); } else { b.appendCode( name.c_str() , getFunctionCode( val ).c_str() ); } break; } default: uassert( 10217 , (string)"can't append field. name:" + name + " type: " + typeString( val ) , 0 ); } }
nsresult nsJSON::EncodeInternal(JSContext* cx, const JS::Value& aValue, nsJSONWriter* writer) { JSAutoRequest ar(cx); // Backward compatibility: // nsIJSON does not allow to serialize anything other than objects if (!aValue.isObject()) { return NS_ERROR_INVALID_ARG; } JSObject* obj = &aValue.toObject(); JS::Value val = aValue; /* Backward compatibility: * Manually call toJSON if implemented by the object and check that * the result is still an object * Note: It is perfectly fine to not implement toJSON, so it is * perfectly fine for GetMethod to fail */ JS::Value toJSON; if (JS_GetMethod(cx, obj, "toJSON", NULL, &toJSON) && !JSVAL_IS_PRIMITIVE(toJSON) && JS_ObjectIsCallable(cx, JSVAL_TO_OBJECT(toJSON))) { // If toJSON is implemented, it must not throw if (!JS_CallFunctionValue(cx, obj, toJSON, 0, NULL, &val)) { if (JS_IsExceptionPending(cx)) // passing NS_OK will throw the pending exception return NS_OK; // No exception, but still failed return NS_ERROR_FAILURE; } // Backward compatibility: // nsIJSON does not allow to serialize anything other than objects if (JSVAL_IS_PRIMITIVE(val)) return NS_ERROR_INVALID_ARG; } // GetMethod may have thrown else if (JS_IsExceptionPending(cx)) // passing NS_OK will throw the pending exception return NS_OK; // Backward compatibility: // function shall not pass, just "plain" objects and arrays JSType type = JS_TypeOfValue(cx, val); if (type == JSTYPE_FUNCTION) return NS_ERROR_INVALID_ARG; // We're good now; try to stringify if (!JS_Stringify(cx, &val, NULL, JSVAL_NULL, WriteCallback, writer)) return NS_ERROR_FAILURE; return NS_OK; }
bool js_util_DirectoryUtils_walkFiles(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); js_proxy_t *proxy = jsb_get_js_proxy(obj); auto cobj = (Utils::DirectoryUtils *)(proxy ? proxy->ptr : NULL); JSB_PRECONDITION2( cobj, cx, false, "js_util_DirectoryUtils_walkFiles : Invalid Native Object"); if (argc == 4) { std::string arg0; bool arg1; std::string arg2; Utils::DirectoryUtils::walkCallback arg3; bool ok = true; do { ok = jsval_to_std_string(cx, args.get(0), &arg0); if (!ok) break; ok = jsval_to_bool(cx, args.get(1), &arg1); if (!ok) break; ok = jsval_to_std_string(cx, args.get(2), &arg2); if (!ok) break; ok = JS_TypeOfValue(cx, args.get(3)) == JSTYPE_FUNCTION; if (!ok) break; JSObject* thisObj = JS_THIS_OBJECT(cx, vp); // TODO 其它用法 std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, thisObj, args.get(3))); arg3 = [=](const char* arg0, const char* arg1, const char* arg2) -> void { JS::RootedValue rval(cx); JS::AutoValueVector args(cx); args.reserve(3); args.append(STRING_TO_JSVAL(c_str_to_js_str(cx, arg0))); args.append(STRING_TO_JSVAL(c_str_to_js_str(cx, arg1))); args.append(STRING_TO_JSVAL(c_str_to_js_str(cx, arg2))); bool ok = func->invoke(args, &rval); if (!ok && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }; cobj->walkFiles(arg0.c_str(), arg1, arg2.c_str(), arg3); } while (0); JSB_PRECONDITION2(ok, cx, false, "js_util_DirectoryUtils_walkFiles : Error processing arguments"); args.rval().setUndefined(); return true; } JS_ReportError(cx, "js_util_DirectoryUtils_walkFiles : wrong number of arguments"); return false; }
int to_erl_intern(ErlNifEnv* env, JSContext* cx, jsval val, ERL_NIF_TERM* term) { JSObject* obj = NULL; JSType type = JS_TypeOfValue(cx, val); if(val == JSVAL_NULL) { return to_erl_atom(env, "null", term); } else if(val == JSVAL_VOID) { // return ERROR; return to_erl_atom(env, "undefined", term); } else if(type == JSTYPE_BOOLEAN) { if(val == JSVAL_TRUE) return to_erl_atom(env, "true", term); else return to_erl_atom(env, "false", term); } else if(type == JSTYPE_STRING) { return to_erl_string(env, cx, val, term); } else if(type == JSTYPE_XML) { return to_erl_string(env, cx, val, term); } else if(type == JSTYPE_NUMBER) { if(JSVAL_IS_INT(val)) return to_erl_int(env, cx, val, term); else return to_erl_float(env, cx, val, term); } else if(type == JSTYPE_OBJECT) { obj = JSVAL_TO_OBJECT(val); if(OK == to_erl_convert(env, cx, obj, term)) { return OK; } if(JS_IsArrayObject(cx, obj)) { return to_erl_array(env, cx, obj, term); } return to_erl_object(env, cx, obj, term); } return ERROR; }
bool js_EventDispatcher_addCustomEventListener(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); bool ok = true; JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); js_proxy_t *proxy = jsb_get_js_proxy(obj); cocos2d::EventDispatcher* cobj = (cocos2d::EventDispatcher *)(proxy ? proxy->ptr : NULL); JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_EventDispatcher_addCustomEventListener : Invalid Native Object"); if (argc == 2) { std::string arg0; std::function<void (cocos2d::EventCustom *)> arg1; ok &= jsval_to_std_string(cx, args.get(0), &arg0); do { if(JS_TypeOfValue(cx, args.get(1)) == JSTYPE_FUNCTION) { JS::RootedObject jstarget(cx, args.thisv().toObjectOrNull()); std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, jstarget, args.get(1), args.thisv())); auto lambda = [=](cocos2d::EventCustom* event) -> void { JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET jsval largv[1]; if (event) { js_type_class_t *typeClassEvent = js_get_type_from_native<EventCustom>(event); largv[0] = OBJECT_TO_JSVAL(jsb_get_or_create_weak_jsobject(cx, event, typeClassEvent)); } else { largv[0] = JSVAL_NULL; }; JS::RootedValue rval(cx); bool succeed = func->invoke(JS::HandleValueArray::fromMarkedLocation(1, largv), &rval); if (!succeed && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }; arg1 = lambda; } else { arg1 = nullptr; } } while(0); JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_EventDispatcher_addCustomEventListener : Error processing arguments"); cocos2d::EventListenerCustom* ret = cobj->addCustomEventListener(arg0, arg1); JS::RootedValue jsret(cx); if (ret) { jsret = OBJECT_TO_JSVAL(js_get_or_create_jsobject<EventListenerCustom>(cx, ret)); args.rval().set(jsret); } else { jsret = JSVAL_NULL; }; args.rval().set(jsret); return true; } JS_ReportError(cx, "js_cocos2dx_EventDispatcher_addCustomEventListener : wrong number of arguments: %d, was expecting %d", argc, 2); return false; }
nsresult nsJSON::EncodeInternal(nsJSONWriter *writer) { nsresult rv; nsIXPConnect *xpc = nsContentUtils::XPConnect(); if (!xpc) return NS_ERROR_FAILURE; nsAXPCNativeCallContext *cc = nsnull; rv = xpc->GetCurrentNativeCallContext(&cc); NS_ENSURE_SUCCESS(rv, rv); JSContext *cx = nsnull; rv = cc->GetJSContext(&cx); NS_ENSURE_SUCCESS(rv, rv); JSAutoRequest ar(cx); PRUint32 argc = 0; rv = cc->GetArgc(&argc); NS_ENSURE_SUCCESS(rv, rv); // Now fish for the JS arguments. If it's a call to encode, we'll // want the first two arguments. If it's a call to encodeToStream, // we'll want the fourth and fifth; PRUint32 firstArg = writer->mStream ? 3 : 0; // Get the object we're going to serialize. JSObject *inputObj = nsnull; jsval *argv = nsnull; rv = cc->GetArgvPtr(&argv); NS_ENSURE_SUCCESS(rv, rv); if (argc <= firstArg || !(JSVAL_IS_OBJECT(argv[firstArg]) && (inputObj = JSVAL_TO_OBJECT(argv[firstArg])))) { // return if it's not something we can deal with return NS_ERROR_INVALID_ARG; } jsval *vp = &argv[firstArg]; JSBool ok = JS_TryJSON(cx, vp); JSType type; if (!(ok && !JSVAL_IS_PRIMITIVE(*vp) && (type = JS_TypeOfValue(cx, *vp)) != JSTYPE_FUNCTION && type != JSTYPE_XML)) { return NS_ERROR_INVALID_ARG; } ok = JS_Stringify(cx, vp, NULL, JSVAL_NULL, WriteCallback, writer); if (!ok) return NS_ERROR_FAILURE; return NS_OK; }
JSBool Core_print (JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) { JS_BeginRequest(cx); JS_EnterLocalRootScope(cx); char* separator = " "; char* end = "\n"; int fd = fileno(stdout); FILE* fp = NULL; jsval property; JSObject* options; if (argc > 1 && JS_TypeOfValue(cx, argv[argc-1]) == JSTYPE_OBJECT) { JS_ValueToObject(cx, argv[argc-1], &options); argc--; JS_GetProperty(cx, options, "separator", &property); if (JSVAL_IS_VOID(property) || JSVAL_IS_NULL(property)) { JS_GetProperty(cx, options, "sep", &property); } if (JSVAL_IS_STRING(property)) { separator = JS_GetStringBytes(JS_ValueToString(cx, property)); } JS_GetProperty(cx, options, "end", &property); if (JSVAL_IS_STRING(property)) { end = JS_GetStringBytes(JS_ValueToString(cx, property)); } JS_GetProperty(cx, options, "file", &property); if (JSVAL_IS_NUMBER(property)) { fd = JSVAL_TO_INT(property); } } fp = fdopen(fd, "a+"); uintN i; for (i = 0; i < argc; i++) { fprintf(fp, "%s", JS_GetStringBytes(JS_ValueToString(cx, argv[i]))); if (i != argc-1) { fprintf(fp, "%s", separator); } } fprintf(fp, "%s", end); JS_LeaveLocalRootScope(cx); JS_EndRequest(cx); return JS_TRUE; }
nsresult nsJSON::EncodeInternal(JSContext* cx, const JS::Value& aValue, nsJSONWriter* writer) { // Backward compatibility: // nsIJSON does not allow to serialize anything other than objects if (!aValue.isObject()) { return NS_ERROR_INVALID_ARG; } JS::Rooted<JSObject*> obj(cx, &aValue.toObject()); /* Backward compatibility: * Manually call toJSON if implemented by the object and check that * the result is still an object * Note: It is perfectly fine to not implement toJSON, so it is * perfectly fine for GetMethod to fail */ JS::Rooted<JS::Value> val(cx, aValue); JS::Rooted<JS::Value> toJSON(cx); if (JS_GetProperty(cx, obj, "toJSON", &toJSON) && toJSON.isObject() && JS_ObjectIsCallable(cx, &toJSON.toObject())) { // If toJSON is implemented, it must not throw if (!JS_CallFunctionValue(cx, obj, toJSON, 0, nullptr, val.address())) { if (JS_IsExceptionPending(cx)) // passing NS_OK will throw the pending exception return NS_OK; // No exception, but still failed return NS_ERROR_FAILURE; } // Backward compatibility: // nsIJSON does not allow to serialize anything other than objects if (val.isPrimitive()) return NS_ERROR_INVALID_ARG; } // GetMethod may have thrown else if (JS_IsExceptionPending(cx)) // passing NS_OK will throw the pending exception return NS_OK; // Backward compatibility: // function shall not pass, just "plain" objects and arrays JSType type = JS_TypeOfValue(cx, val); if (type == JSTYPE_FUNCTION) return NS_ERROR_INVALID_ARG; // We're good now; try to stringify if (!JS_Stringify(cx, &val, JS::NullPtr(), JS::NullHandleValue, WriteCallback, writer)) return NS_ERROR_FAILURE; return NS_OK; }
/* * call-seq: * function?() * * Returns <code>true</code> if this JavaScript object is a function. */ static VALUE function_p(VALUE self) { RubyLandProxy* proxy; Data_Get_Struct(self, RubyLandProxy, proxy); JSContext * context = johnson_get_current_context(proxy->runtime); PREPARE_RUBY_JROOTS(context, 1); jsval proxy_value; JCHECK(get_jsval_for_proxy(proxy, &proxy_value)); JROOT(proxy_value); JRETURN_RUBY(JS_TypeOfValue(context, proxy_value) == JSTYPE_FUNCTION ? Qtrue : Qfalse); }
int to_erl_intern(emonk_buf_t* buf, JSContext* cx, jsval val) { JSObject* obj = NULL; JSType type = JS_TypeOfValue(cx, val); int status = ERROR; if(val == JSVAL_NULL) { return to_erl_atom(buf, "null", 4); } else if(val == JSVAL_VOID) { JS_ReportError(cx, "Cannot encode 'undefined' value as JSON"); return ERROR; } else if(type == JSTYPE_BOOLEAN) { if(val == JSVAL_TRUE) return to_erl_atom(buf, "true", 4); else return to_erl_atom(buf, "false", 5); } else if(type == JSTYPE_STRING) { return to_erl_string(buf, cx, val); } else if(type == JSTYPE_XML) { return to_erl_string(buf, cx, val); } else if(type == JSTYPE_NUMBER) { if(JSVAL_IS_INT(val)) return to_erl_int(buf, cx, val); else return to_erl_float(buf, cx, val); } else if(type == JSTYPE_OBJECT) { obj = JSVAL_TO_OBJECT(val); status = to_erl_from_handler(buf, cx, obj); if(status != IGNORE) return status; if(JS_IsArrayObject(cx, obj)) { return to_erl_array(buf, cx, obj); } return to_erl_object(buf, cx, obj); } return ERROR; }
static JSBool xgg_label_propop_bold_set(JSContext *pcxa, JSObject *pobja, jsval id, jsval *vp) { //XGG_LABEL_PRIV* pv0 = JS_GetPrivate(pcxa, pobja); //XJSEXADGELEM* pe0 = pv0->hdr.pxadgelem; //XJSECTX* pjsectx = (XJSECTX*)JS_GetContextPrivate(pcxa); JSType type1 = JS_TypeOfValue(pcxa, vp[0]); if(type1 == JSTYPE_VOID) // "undefined" goto cleanup; cleanup: return JS_TRUE; }
bool js_cocos2dx_audioengine_AudioEngine_preload(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); bool ok = true; do { if (argc == 2) { std::string arg0; ok &= jsval_to_std_string(cx, args.get(0), &arg0); if (!ok) { ok = true; break; } std::function<void (bool)> arg1; do { if(JS_TypeOfValue(cx, args.get(1)) == JSTYPE_FUNCTION) { std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, args.thisv().toObjectOrNull(), args.get(1))); auto lambda = [=](bool larg0) -> void { JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET jsval largv[1]; largv[0] = BOOLEAN_TO_JSVAL(larg0); JS::RootedValue rval(cx); bool succeed = func->invoke(1, &largv[0], &rval); if (!succeed && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }; arg1 = lambda; } else { arg1 = nullptr; } } while(0) ; if (!ok) { ok = true; break; } cocos2d::experimental::AudioEngine::preload(arg0, arg1); return true; } } while (0); do { if (argc == 1) { std::string arg0; ok &= jsval_to_std_string(cx, args.get(0), &arg0); if (!ok) { ok = true; break; } cocos2d::experimental::AudioEngine::preload(arg0); return true; } } while (0); JS_ReportError(cx, "js_cocos2dx_audioengine_AudioEngine_preload : wrong number of arguments"); return false; }
bool js_EventListenerAcceleration_create(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); bool ok = true; if (argc == 1) { std::function<void (Acceleration *, Event *)> arg0; JSFunctionWrapper *wrapper = nullptr; do { if(JS_TypeOfValue(cx, args.get(0)) == JSTYPE_FUNCTION) { JS::RootedObject jstarget(cx, args.thisv().toObjectOrNull()); std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, jstarget, args.get(0))); wrapper = func.get(); auto lambda = [=](Acceleration* acc, Event* event) -> void { JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET jsval largv[2]; largv[0] = ccacceleration_to_jsval(cx, *acc); if (event) { js_type_class_t *typeClassEvent = js_get_type_from_native<Event>(event); largv[1] = OBJECT_TO_JSVAL(jsb_get_or_create_weak_jsobject(cx, event, typeClassEvent)); } else { largv[1] = JSVAL_NULL; }; JS::RootedValue rval(cx); bool succeed = func->invoke(2, &largv[0], &rval); if (!succeed && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }; arg0 = lambda; } else { arg0 = nullptr; } } while(0); JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_EventListenerAcceleration_create : Error processing arguments"); auto ret = EventListenerAcceleration::create(arg0); JS::RootedValue jsret(cx, OBJECT_TO_JSVAL(js_get_or_create_jsobject<EventListenerAcceleration>(cx, ret))); if (wrapper) { wrapper->setOwner(cx, jsret); } args.rval().set(jsret); return true; } JS_ReportError(cx, "js_cocos2dx_EventListenerAcceleration_create : wrong number of arguments"); return false; }
char *js_get_message(jsval v) { jsval messages, msg, rval; uint32_t messages_len; char *c_str; int i; struct string_buffer sb = STRING_BUFFER_INITIALIZER; if (!JS_GetProperty(js_context, JSVAL_TO_OBJECT(v), "messages", &messages)) { return NULL; } switch(JS_TypeOfValue(js_context, messages)) { case JSTYPE_STRING: c_str = JS_EncodeString(js_context, JSVAL_TO_STRING(messages)); return c_str; case JSTYPE_OBJECT: if (!JS_GetArrayLength(js_context, JSVAL_TO_OBJECT(messages), &messages_len)) { return NULL; } for (i = 0; i < (int) messages_len; i++) { if (!JS_GetElement(js_context, JSVAL_TO_OBJECT(messages), i, &msg)) { goto out_err; } c_str = JS_EncodeString(js_context, JSVAL_TO_STRING(msg)); if (string_buffer_append_string(&sb, c_str)) goto out_err; if (i < (int) messages_len - 1) { if (string_buffer_append_char(&sb, '\n')) goto out_err; } free(c_str); } return sb.s; default: break; } out_err: free(c_str); string_buffer_cleanup(&sb); return NULL; }
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); }
static JSBool jsOnWheel( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval ) { *rval = JSVAL_FALSE ; if( (1 == argc) && (JSTYPE_FUNCTION == JS_TypeOfValue(cx, argv[0]))){ if( JSVAL_VOID != onWheelCode_ ){ JS_RemoveRoot( cx, &onWheelCode_ ); } onWheelCode_ = argv[0]; JS_AddRoot( cx, &onWheelCode_ ); *rval = JSVAL_TRUE ; } else JS_ReportError(cx,"Usage: onWheel(function);\n" ); return JS_TRUE ; }
int add_header_properties(jsval *header, jsval *name, jsval *parts_recv) { int i; uint32_t arr_len; JSObject *parts_obj; jsval parts; // Set name property if (!JS_SetProperty(js_context, JSVAL_TO_OBJECT(*header), "hname", name)) { return -1; } // Add parts property switch(JS_TypeOfValue(js_context, *parts_recv)) { case JSTYPE_STRING: // Create the messages array property parts_obj = JS_NewArrayObject(js_context, 0, NULL); if (!parts_obj) { return -1; } // Add message to messages array if (!JS_SetElement(js_context, parts_obj, 0, parts_recv)) { return -1; } // Copy the messages to the property parts = OBJECT_TO_JSVAL(parts_obj); if (!JS_SetProperty(js_context, JSVAL_TO_OBJECT(*header), "parts", &parts)) { return -1; } break; case JSTYPE_OBJECT: // Copy the messages to the property if (!JS_SetProperty(js_context, JSVAL_TO_OBJECT(*header), "parts", parts_recv)) { return -1; } break; default: return -1; } return 0; }
void jsPort_t :: onChar( void ) { jsval handler ; if( JS_GetProperty( execContext_, scope_, "onChar", &handler ) && ( JSTYPE_FUNCTION == JS_TypeOfValue( execContext_, handler ) ) ) { executeCode( scope_, handler, "onChar", 0, 0 ); } // have handler else { printf( "no raw data handler\n" ); // clear input std::string sData ; read(sData); } // no handler defined }
bool js_cocos2dx_cocosAds_CocosAds_addInterstitialAdListener(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); bool ok = true; JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); js_proxy_t *proxy = jsb_get_js_proxy(obj); CocosAds* cobj = (CocosAds *)(proxy ? proxy->ptr : NULL); JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_cocosAds_CocosAds_addInterstitialAdListener : Invalid Native Object"); if (argc == 1) { std::function<void (int, std::basic_string<char>)> arg0; do { if(JS_TypeOfValue(cx, args.get(0)) == JSTYPE_FUNCTION) { std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, args.thisv().toObjectOrNull(), args.get(0))); auto lambda = [=](int larg0, std::basic_string<char> larg1) -> void { cocos2d::Director::getInstance()->getScheduler()->performFunctionInCocosThread([=]{ JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET jsval largv[2]; largv[0] = int32_to_jsval(cx, larg0); largv[1] = std_string_to_jsval(cx, larg1); JS::RootedValue rval(cx); bool succeed = func->invoke(2, &largv[0], &rval); if (!succeed && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }); }; arg0 = lambda; } else { arg0 = nullptr; } } while(0) ; JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_cocosAds_CocosAds_addInterstitialAdListener : Error processing arguments"); cobj->addInterstitialAdListener(arg0); args.rval().setUndefined(); return true; } JS_ReportError(cx, "js_cocos2dx_cocosAds_CocosAds_addInterstitialAdListener : wrong number of arguments: %d, was expecting %d", argc, 1); return false; }
void jsUsblpPoll_t::onDataIn( void ) { jsval handler ; if( JS_GetProperty( execContext_, obj_, "onDataIn", &handler ) && ( JSTYPE_FUNCTION == JS_TypeOfValue( execContext_, handler ) ) ) { executeCode( obj_, handler, "onDataIn", 0, 0 ); } // have handler else { printf( "no raw data handler\n" ); char temp[256]; unsigned numRead ; while( read( temp, sizeof(temp), numRead ) ) ; } // no handler defined }
void jsPort_t :: onLineIn( void ) { jsval handler ; if( JS_GetProperty( execContext_, scope_, "onLineIn", &handler ) && ( JSTYPE_FUNCTION == JS_TypeOfValue( execContext_, handler ) ) ) { executeCode( scope_, handler, "onLineIn", 0, 0 ); } // have handler else { printf( "no line input handler\n" ); // clear input std::string sData ; while( readln( sData ) ) ; } // no handler defined, purge input }
/* * 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); }
static JSBool ReceiverCommon(JSContext* cx, uintN argc, jsval* vp, const char* methodName, uintN arity, ReceiverResult* result) { if (argc != arity) { JS_ReportError(cx, "%s requires exactly %d arguments", methodName, arity); return JS_FALSE; } // Not currently possible, but think of the future. if (arity < 1) return JS_TRUE; jsval* argv = JS_ARGV(cx, vp); JSString* str = JS_ValueToString(cx, argv[0]); if (!str) { JS_ReportError(cx, "%s expects a stringifiable value as its first argument", methodName); return JS_FALSE; } size_t length; const jschar* chars = JS_GetStringCharsAndLength(cx, str, &length); if (!chars) return JS_FALSE; result->msgName.Assign(chars, length); if (arity < 2) return JS_TRUE; if (JS_TypeOfValue(cx, argv[1]) != JSTYPE_FUNCTION) { JS_ReportError(cx, "%s expects a function as its second argument", methodName); return JS_FALSE; } // GC-safe because argv is rooted. result->receiver = argv[1]; return JS_TRUE; }
ScriptArrayJsapiSource ScriptArrayJsapiSource::Create(const rs::jsapi::Value& obj) { ScriptArrayJsapiSource source; auto cx = obj.getContext(); JSAutoRequest ar{cx}; uint32_t length = 0; if (JS_GetArrayLength(cx, obj, &length) && length > 0) { source.stringValues_.resize(length); for (decltype(length) i = 0; i < length; ++i) { rs::jsapi::Value value{cx}; if (JS_GetElement(cx, obj, i, value)) { source.values_.emplace_back(value); switch (JS_TypeOfValue(cx, value)) { case JSTYPE_OBJECT: if (source.values_[i].isArray() || rs::jsapi::DynamicArray::IsDynamicArray(source.values_[i])) { source.types_.push_back(ScriptObjectType::Array); } else if (!source.values_[i].isNull()) { source.types_.push_back(ScriptObjectType::Object); } else { source.types_.push_back(ScriptObjectType::Null); } break; case JSTYPE_STRING: source.types_.push_back(ScriptObjectType::String); source.stringValues_[i] = source.values_[i].ToString(); break; case JSTYPE_NUMBER: source.types_.push_back(ScriptObjectType::Double); break; case JSTYPE_BOOLEAN: source.types_.push_back(ScriptObjectType::Boolean); break; default: source.types_.push_back(ScriptObjectType::Null); break; } } else { source.values_.emplace_back(cx); } } } return source; }
bool js_cocos2dx_nativehelper_NativeHelper_setPacketAssembler(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); bool ok = true; JS::RootedObject obj(cx, args.thisv().toObjectOrNull()); js_proxy_t *proxy = jsb_get_js_proxy(obj); cocos2d::NativeHelper* cobj = (cocos2d::NativeHelper *)(proxy ? proxy->ptr : NULL); JSB_PRECONDITION2( cobj, cx, false, "js_cocos2dx_nativehelper_NativeHelper_setPacketAssembler : Invalid Native Object"); if (argc == 1) { std::function<void (std::basic_string<char>, int)> arg0; do { if(JS_TypeOfValue(cx, args.get(0)) == JSTYPE_FUNCTION) { std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, args.thisv().toObjectOrNull(), args.get(0))); auto lambda = [=](std::basic_string<char> larg0, int larg1) -> void { JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET jsval largv[2]; largv[0] = std_string_to_jsval(cx, larg0); largv[1] = int32_to_jsval(cx, larg1); JS::RootedValue rval(cx); bool ok = func->invoke(2, &largv[0], &rval); if (!ok && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }; arg0 = lambda; } else { arg0 = nullptr; } } while(0) ; JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_nativehelper_NativeHelper_setPacketAssembler : Error processing arguments"); cobj->setPacketAssembler(arg0); args.rval().setUndefined(); return true; } JS_ReportError(cx, "js_cocos2dx_nativehelper_NativeHelper_setPacketAssembler : wrong number of arguments: %d, was expecting %d", argc, 1); return false; }
/** * Callback for functions * This callback is called by JS when a function on a JSObject proxying * for an IDispatch instance * @param cx A pointer to a JS context * @param obj JS object that the parameterized property is on * @param argc Number of arguments in this call * @param argv The parameters passed in if any * @param vp The return value * @return Returns JS_TRUE if the operation succeeded */ JSBool JS_DLL_CALLBACK XPC_IDispatch_CallMethod(JSContext* cx, JSObject* obj, uintN argc, jsval* argv, jsval* vp) { NS_ASSERTION(JS_TypeOfValue(cx, argv[-2]) == JSTYPE_FUNCTION, "bad function"); JSObject* funobj = JSVAL_TO_OBJECT(argv[-2]); XPCCallContext ccx(JS_CALLER, cx, obj, funobj, 0, argc, argv, vp); XPCWrappedNative* wrapper = ccx.GetWrapper(); THROW_AND_RETURN_IF_BAD_WRAPPER(cx, wrapper); ccx.SetArgsAndResultPtr(argc, argv, vp); XPCDispInterface::Member* member; XPCNativeInterface* iface; #ifdef DEBUG PRBool ok = #endif GetMember(ccx, funobj, iface, member); NS_ASSERTION(ok, "GetMember faild in XPC_IDispatch_CallMethod"); ccx.SetIDispatchInfo(iface, member); return XPCDispObject::Invoke(ccx, XPCDispObject::CALL_METHOD); }
bool js_cocos2dx_audioengine_AudioEngine_setFinishCallback(JSContext *cx, uint32_t argc, jsval *vp) { JS::CallArgs args = JS::CallArgsFromVp(argc, vp); bool ok = true; if (argc == 2) { int arg0; std::function<void (int, const std::basic_string<char> &)> arg1; ok &= jsval_to_int32(cx, args.get(0), (int32_t *)&arg0); do { if(JS_TypeOfValue(cx, args.get(1)) == JSTYPE_FUNCTION) { std::shared_ptr<JSFunctionWrapper> func(new JSFunctionWrapper(cx, args.thisv().toObjectOrNull(), args.get(1))); auto lambda = [=](int larg0, const std::basic_string<char> & larg1) -> void { JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET jsval largv[2]; largv[0] = int32_to_jsval(cx, larg0); largv[1] = std_string_to_jsval(cx, larg1); JS::RootedValue rval(cx); bool succeed = func->invoke(2, &largv[0], &rval); if (!succeed && JS_IsExceptionPending(cx)) { JS_ReportPendingException(cx); } }; arg1 = lambda; } else { arg1 = nullptr; } } while(0) ; JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_audioengine_AudioEngine_setFinishCallback : Error processing arguments"); cocos2d::experimental::AudioEngine::setFinishCallback(arg0, arg1); args.rval().setUndefined(); return true; } JS_ReportError(cx, "js_cocos2dx_audioengine_AudioEngine_setFinishCallback : wrong number of arguments"); return false; }
static JSBool at(JSContext *cx, uintN argc, jsval *vp) { if (argc < 2) { flm_log("'at' requires at least 2 arguments: <time> <function>"); return JS_FALSE; } jsval *arguments = JS_ARGV(cx, vp); uint32_t time; JS_ValueToECMAUint32(cx, arguments[0], &time); struct task *t = task_create(time); t->js_argc = 0; if (JS_TypeOfValue(cx, arguments[1]) == JSTYPE_FUNCTION) { t->js_function = arguments[1]; } else { flm_log("2nd argument of 'at' should be a function"); return JS_FALSE; } t->js_argc = (argc > 2 ? argc - 2 : 1); jsval *fn_args = malloc(t->js_argc * sizeof(jsval)); if (argc > 2) { int i; for (i = 2; i < argc; i++) { fn_args[i - 2] = arguments[i]; } } else { fn_args[0] = time; } t->js_args = fn_args; t->task_type = JS_FUNCTION; schedule_task(flim->scheduler, t); return JS_TRUE; }