JSBool js_cocos2dx_CCControl_addTargetWithActionForControlEvents(JSContext *cx, uint32_t argc, jsval *vp) {
return JS_TRUE;
if(argc == 3) {
jsval *argv = JS_ARGV(cx, vp);
JSObject *obj = JS_THIS_OBJECT(cx, vp);
js_proxy_t *proxy;
JS_GET_NATIVE_PROXY(proxy, obj);
cocos2d::extension::CCControl* item = (cocos2d::extension::CCControl*)(proxy ? proxy->ptr : NULL);
TEST_NATIVE_OBJECT(cx, item)
JSObject* jsTargetObj = JSVAL_TO_OBJECT(argv[0]);
JSObject* jsFuncObj = JSVAL_TO_OBJECT(argv[1]);
int event = JSVAL_TO_INT(argv[2]);
js_callback_proxy_t* found = NULL;
if (is_target_function_exist(jsTargetObj, jsFuncObj, (void*)item, (void*)event, &found))
{
item->removeTargetWithActionForControlEvents(found->nativeTargetObj, cccontrol_selector(JSCallbackTarget::onControlEventReceived), event);
JS_CALLBACK_REMOVE_PROXY(found);
CCLOG("In add Target: target exists, remove it!");
}
JSCallbackTarget* pTarget = new JSCallbackTarget();
item->addTargetWithActionForControlEvents(pTarget, cccontrol_selector(JSCallbackTarget::onControlEventReceived), event);
js_callback_proxy_t* p;
JS_CALLBACK_NEW_PROXY(p, pTarget, jsTargetObj, jsFuncObj, item, event);
JS_AddNamedObjectRoot(cx, &jsTargetObj, "cccontrol target object");
JS_AddNamedObjectRoot(cx, &jsFuncObj, "cccontrol jsFuncObj object");
pTarget->setJSProxy(p);
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 3);
return JS_FALSE;
}
JSBool js_cocos2dx_extension_HttpRequest_constructor(JSContext *cx, uint32_t argc, jsval *vp){
if(argc == 0){
HttpRequest* cobj = new HttpRequest();
cocos2d::CCObject *_ccobj = dynamic_cast<cocos2d::CCObject *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<cocos2d::extension::CCHttpRequest> t;
js_type_class_t *typeClass;
uint32_t typeId = t.s_id();
HASH_FIND_INT(_js_global_type_ht, &typeId, typeClass);
assert(typeClass);
JSObject *obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
// link the native object with the javascript object
js_proxy_t *p;
JS_NEW_PROXY(p, cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "HttpRequest");
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return JS_FALSE;
}
bool js_cocos2dx_GLNode_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
if (argc == 0) {
GLNode* cobj = new GLNode();
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<GLNode> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
JSObject *obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
// link the native object with the javascript object
js_proxy_t *p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "cocos2d::GLNode");
return true;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return false;
}
void setJSAction(JSObject* jsFunc)
{
_jsFunc = jsFunc;
JSContext* cx = ScriptingCore::getInstance()->getGlobalContext();
JS_AddNamedObjectRoot(cx, &_jsFunc, "JSB_ControlButtonTarget, func");
}
JSBool js_cocos2dx_GLNode_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
if (argc == 0) {
GLNode* cobj = new GLNode();
#ifdef COCOS2D_JAVASCRIPT
cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
#endif
TypeTest<GLNode> t;
js_type_class_t *typeClass;
uint32_t typeId = t.s_id();
HASH_FIND_INT(_js_global_type_ht, &typeId, typeClass);
assert(typeClass);
JSObject *obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
// link the native object with the javascript object
js_proxy_t *p = jsb_new_proxy(cobj, obj);
#ifdef COCOS2D_JAVASCRIPT
JS_AddNamedObjectRoot(cx, &p->obj, "cocos2d::GLNode");
#endif
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return JS_FALSE;
}
inline js_proxy_t *js_get_or_create_proxy(JSContext *cx, T *native_obj) {
js_proxy_t *proxy;
HASH_FIND_PTR(_native_js_global_ht, &native_obj, proxy);
if (!proxy) {
js_type_class_t *typeProxy = js_get_type_from_native<T>(native_obj);
// Return NULL if can't find its type rather than making an assert.
// assert(typeProxy);
if (!typeProxy) {
CCLOGINFO("Could not find the type of native object.");
return NULL;
}
JSObject* js_obj = JS_NewObject(cx, typeProxy->jsclass, typeProxy->proto, typeProxy->parentProto);
proxy = jsb_new_proxy(native_obj, js_obj);
#ifdef DEBUG
JS_AddNamedObjectRoot(cx, &proxy->obj, typeid(*native_obj).name());
#else
JS_AddObjectRoot(cx, &proxy->obj);
#endif
return proxy;
} else {
return proxy;
}
return NULL;
}
// JSFunctionWrapper
JSFunctionWrapper::JSFunctionWrapper(JSContext* cx, JSObject *jsthis, jsval fval)
: _cx(cx)
, _jsthis(jsthis)
, _fval(fval)
{
JS_AddNamedValueRoot(cx, &this->_fval, "JSFunctionWrapper");
JS_AddNamedObjectRoot(cx, &this->_jsthis, "JSFunctionWrapper");
}
static bool js_cocos2dx_GLNode_ctor(JSContext *cx, uint32_t argc, jsval *vp)
{
JSObject *obj = JS_THIS_OBJECT(cx, vp);
GLNode *nobj = new GLNode();
js_proxy_t* p = jsb_new_proxy(nobj, obj);
nobj->autorelease();
JS_AddNamedObjectRoot(cx, &p->obj, "GLNode");
JS_SET_RVAL(cx, vp, JSVAL_VOID);
return true;
}
static JSBool js_fygui_FYPropCell_ctor(JSContext *cx, uint32_t argc, jsval *vp)
{
JSObject *obj = JS_THIS_OBJECT(cx, vp);
FYPropCell *nobj = new FYPropCell();
js_proxy_t* p;
JS_NEW_PROXY(p, nobj, obj);
nobj->autorelease();
JS_AddNamedObjectRoot(cx, &p->obj, "FYPropCell");
JS_SET_RVAL(cx, vp, JSVAL_VOID);
return JS_TRUE;
}
void setJSTarget(JSObject* pJSTarget)
{
_jsTarget = pJSTarget;
js_proxy_t* p = jsb_get_js_proxy(_jsTarget);
if (!p)
{
JSContext* cx = ScriptingCore::getInstance()->getGlobalContext();
JS_AddNamedObjectRoot(cx, &_jsTarget, "JSB_ControlButtonTarget, target");
_needUnroot = true;
}
}
void setJSDelegate(JSObject* pJSDelegate)
{
_JSDelegate = pJSDelegate;
// Check whether the js delegate is a pure js object.
js_proxy_t* p = jsb_get_js_proxy(_JSDelegate);
if (!p)
{
_needUnroot = true;
JSContext* cx = ScriptingCore::getInstance()->getGlobalContext();
JS_AddNamedObjectRoot(cx, &_JSDelegate, "TableViewDelegate");
}
}
static void getJSTouchObject(JSContext *cx, CCTouch *x, jsval &jsret) {
js_type_class_t *classType;
TypeTest<cocos2d::CCTouch> t;
uint32_t typeId = t.s_id();
HASH_FIND_INT(_js_global_type_ht, &typeId, classType);
assert(classType);
JSObject *_tmp = JS_NewObject(cx, classType->jsclass, classType->proto, classType->parentProto);
js_proxy_t *proxy, *nproxy;
JS_NEW_PROXY(proxy, x, _tmp);
void *ptr = x;
JS_GET_PROXY(nproxy, ptr);
JS_AddNamedObjectRoot(cx, &nproxy->obj, "CCTouch");
jsret = OBJECT_TO_JSVAL(_tmp);
}
static bool js_es_Button_ctor(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
JSObject *obj = JS_THIS_OBJECT(cx, vp);
es::Button *nobj = new es::Button();
if (nobj) {
nobj->autorelease();
}
js_proxy_t* p = jsb_new_proxy(nobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "es::Button");
bool isFound = false;
if (JS_HasProperty(cx, obj, "_ctor", &isFound))
ScriptingCore::getInstance()->executeFunctionWithOwner(OBJECT_TO_JSVAL(obj), "_ctor", argc, argv);
JS_SET_RVAL(cx, vp, JSVAL_VOID);
return true;
}
JSObject * JSAPITest::createGlobal(JSPrincipals *principals)
{
/* Create the global object. */
global = JS_NewGlobalObject(cx, getGlobalClass(), principals);
if (!global)
return NULL;
JS_AddNamedObjectRoot(cx, &global, "test-global");
JS::HandleObject globalHandle = JS::HandleObject::fromMarkedLocation(&global);
JSAutoCompartment ac(cx, globalHandle);
/* Populate the global object with the standard globals, like Object and
Array. */
if (!JS_InitStandardClasses(cx, globalHandle))
return NULL;
return global;
}
inline js_proxy_t *js_get_or_create_proxy(JSContext *cx, T *native_obj) {
js_proxy_t *proxy;
HASH_FIND_PTR(_native_js_global_ht, &native_obj, proxy);
if (!proxy) {
js_type_class_t *typeProxy = js_get_type_from_native<T>(native_obj);
assert(typeProxy);
JSObject* js_obj = JS_NewObject(cx, typeProxy->jsclass, typeProxy->proto, typeProxy->parentProto);
JS_NEW_PROXY(proxy, native_obj, js_obj);
#ifdef DEBUG
JS_AddNamedObjectRoot(cx, &proxy->obj, typeid(*native_obj).name());
#else
JS_AddObjectRoot(cx, &proxy->obj);
#endif
return proxy;
} else {
return proxy;
}
return NULL;
}
JSObject* bind_menu_item(JSContext *cx, T* nativeObj, jsval callback, jsval thisObj) {
js_proxy_t *p;
JS_GET_PROXY(p, nativeObj);
if (p) {
addCallBackAndThis(p->obj, callback, thisObj);
return p->obj;
} else {
js_type_class_t *classType = js_get_type_from_native<T>(nativeObj);
assert(classType);
JSObject *tmp = JS_NewObject(cx, classType->jsclass, classType->proto, classType->parentProto);
// bind nativeObj <-> JSObject
js_proxy_t *proxy;
JS_NEW_PROXY(proxy, nativeObj, tmp);
JS_AddNamedObjectRoot(cx, &proxy->obj, "MenuItem");
addCallBackAndThis(tmp, callback, thisObj);
return tmp;
}
}
FFSessionHandler::FFSessionHandler(HostChannel* channel)
: SessionData(channel, this, getJSContext()), jsObjectId(0),
jsObjectsById(NULL), stringObjectClass(NULL) {
Debug::log(Debug::Debugging) << "FFSessionHandler::FFSessionHandler(this="
<< this << ")" << Debug::flush;
// TODO(jat): is there a way to avoid calling this twice, without keeping
// JSContext in an instance field?
JSContext* ctx = getJSContext();
if (!JS_AddNamedObjectRoot(ctx, &jsObjectsById, "jsObjectsById")) {
Debug::log(Debug::Error) << "Error rooting jsObjectsById" << Debug::flush;
}
jsObjectsById = JS_NewArrayObject(ctx, 0, NULL);
if (!jsObjectsById) {
Debug::log(Debug::Error) << "Error rooting jsObjectsById" << Debug::flush;
}
if (!JS_AddNamedValueRoot(ctx, &toStringTearOff, "toStringTearOff")) {
Debug::log(Debug::Error) << "Error rooting toStringTearOff" << Debug::flush;
}
getStringObjectClass(ctx);
getToStringTearOff(ctx);
}
void __JSDownloaderDelegator::onSuccess(const std::string &srcUrl, const std::string &storagePath, const std::string &customId)
{
Image *image = new Image();
jsval valArr[2];
JSContext *cx = ScriptingCore::getInstance()->getGlobalContext();
JSObject *global = ScriptingCore::getInstance()->getGlobalObject();
JSAutoCompartment ac(_cx, _obj);
if(image->initWithImageData(_buffer, _size))
{
Texture2D *tex = Director::getInstance()->getTextureCache()->addImage(image, srcUrl);
valArr[0] = BOOLEAN_TO_JSVAL(true);
js_type_class_t *classType = js_get_type_from_native<cocos2d::Texture2D>(tex);
assert(classType);
JSObject *obj = JS_NewObject(cx, classType->jsclass, classType->proto, classType->parentProto);
// link the native object with the javascript object
js_proxy_t* p = jsb_new_proxy(tex, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "cocos2d::Texture2D");
valArr[1] = OBJECT_TO_JSVAL(p->obj);
}
else
{
valArr[0] = BOOLEAN_TO_JSVAL(false);
valArr[1] = JSVAL_NULL;
}
image->release();
if (!JSVAL_IS_NULL(_jsCallback)) {
jsval retval;
JS_AddValueRoot(cx, valArr);
JS_CallFunctionValue(cx, global, _jsCallback, 2, valArr, &retval);
JS_RemoveValueRoot(cx, valArr);
JS_RemoveValueRoot(cx, &_jsCallback);
}
this->release();
}
JSBool js_skeleton_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
cocos2d::CCLog("js skeletonanimation constructor ..");
if (argc == 2) {
jsval *argvp = JS_ARGV(cx,vp);
JSBool ok = JS_TRUE;
const char* arg1; const char* arg2;
ok &= jsval_to_charptr(cx, *argvp++, &arg1);
ok &= jsval_to_charptr(cx, *argvp++, &arg2);
JSB_PRECONDITION(ok, "Error processing arguments");
// 调用 C++ 构造函数
cocos2d::extension::CCSkeletonAnimation* cobj =
new cocos2d::extension::CCSkeletonAnimation(arg1, arg2);
cocos2d::CCObject* _ccobj = dynamic_cast<cocos2d::CCObject*>(cobj);
// 默认使用原有的内存管理方式
if (_ccobj){
_ccobj->autorelease();
}
TypeTest<cocos2d::extension::CCSkeletonAnimation> t;
js_type_class_t *typeClass;
uint32_t typeId = t.s_id();
HASH_FIND_INT(_js_global_type_ht, &typeId, typeClass);
assert(typeClass);
JSObject *obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
// 构造 js 端对象，将 cobj 实际对象存入
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "cocos2d::extension::CCSkeletonAnimation");
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return JS_FALSE;
}
JSBool js_cocos2dx_CCSet_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
JSObject *obj;
cocos2d::CCSet* cobj;
if (argc == 0) {
cobj = new cocos2d::CCSet();
cobj->autorelease();
TypeTest<cocos2d::CCSet> t;
js_type_class_t *typeClass;
uint32_t typeId = t.s_id();
HASH_FIND_INT(_js_global_type_ht, &typeId, typeClass);
assert(typeClass);
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t *proxy;
JS_NEW_PROXY(proxy, cobj, obj);
JS_AddNamedObjectRoot(cx, &proxy->obj, typeid(cobj).name());
}
if (cobj) {
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
return JS_TRUE;
}
return JS_FALSE;
}
PRIntn prmain(PRIntn argc, char **argv)
{
void *stackBasePtr;
gpsee_interpreter_t *jsi; /* Handle describing a GPSEE/JavaScript Interpreter */
gpsee_realm_t *realm; /* Interpreter's primordial realm */
JSContext *cx; /* A context in realm */
const char *scriptCode = NULL; /* String with JavaScript program in it */
const char *scriptFilename = NULL; /* Filename with JavaScript program in it */
char * const *script_argv; /* Becomes arguments array in JS program */
char * const *script_environ = NULL; /* Environment to pass to script */
char *flags = malloc(8); /* Flags found on command line */
int noRunScript = 0; /* !0 = compile but do not run */
int fiArg = 0;
int skipSheBang = 0;
int exitCode;
int verbosity; /* Verbosity to use before flags are processed */
#ifdef GPSEE_DEBUGGER
JSDContext *jsdc;
#endif
#if defined(__SURELYNX__)
permanent_pool = apr_initRuntime();
#endif
gpsee_setVerbosity(isatty(STDERR_FILENO) ? GSR_PREPROGRAM_TTY_VERBOSITY : GSR_PREPROGRAM_NOTTY_VERBOSITY);
gpsee_openlog(gpsee_basename(argv[0]));
/* Print usage and exit if no arguments were given */
if (argc < 2)
usage(argv[0]);
flags[0] = (char)0;
fiArg = findFileToInterpret(argc, argv);
if (fiArg == 0) /* Not a script file interpreter (shebang) */
{
int c;
char *flag_p = flags;
while ((c = getopt(argc, argv, whenSureLynx("D:r:","") "v:c:hHnf:F:aCRxSUWdeJz")) != -1)
{
switch(c)
{
#if defined(__SURELYNX__)
case 'D':
redirect_output(permanent_pool, optarg);
break;
case 'r': /* handled by cfg_openfile() */
break;
#endif
case 'c':
scriptCode = optarg;
break;
case 'h':
usage(argv[0]);
break;
case 'H':
moreHelp(argv[0]);
break;
case 'n':
noRunScript = 1;
break;
case 'F':
skipSheBang = 1;
case 'f':
scriptFilename = optarg;
break;
case 'a':
case 'C':
case 'd':
case 'e':
case 'J':
case 'S':
case 'R':
case 'U':
case 'W':
case 'x':
case 'z':
{
char *flags_storage = realloc(flags, (flag_p - flags) + 1 + 1);
if (flags_storage != flags)
{
flag_p = (flag_p - flags) + flags_storage;
flags = flags_storage;
}
*flag_p++ = c;
*flag_p = '\0';
}
break;
case '?':
{
char buf[32];
snprintf(buf, sizeof(buf), "Invalid option: %c\n", optopt);
fatal(buf);
}
case ':':
{
char buf[32];
snprintf(buf, sizeof(buf), "Missing parameter to option '%c'\n", optopt);
fatal(buf);
}
}
} /* getopt wend */
/* Create the script's argument vector with the script name as arguments[0] */
{
char **nc_script_argv = malloc(sizeof(argv[0]) * (2 + (argc - optind)));
nc_script_argv[0] = (char *)scriptFilename;
memcpy(nc_script_argv + 1, argv + optind, sizeof(argv[0]) * ((1 + argc) - optind));
script_argv = nc_script_argv;
}
*flag_p = (char)0;
}
else
{
scriptFilename = argv[fiArg];
if (fiArg == 2)
{
if (argv[1][0] != '-')
fatal("Invalid syntax for file-interpreter flags! (Must begin with '-')");
flags = realloc(flags, strlen(argv[1]) + 1);
strcpy(flags, argv[1] + 1);
}
/* This is a file interpreter; script_argv is correct at offset fiArg. */
script_argv = argv + fiArg;
}
if (strchr(flags, 'a'))
{
#if defined(GPSEE_DARWIN_SYSTEM)
script_environ = (char * const *)_NSGetEnviron();
#else
extern char **environ;
script_environ = (char * const *)environ;
#endif
}
loadRuntimeConfig(scriptFilename, flags, argc, argv);
if (strchr(flags, 'U') || (cfg_bool_value(cfg, "gpsee_force_no_utf8_c_strings") == cfg_true) || getenv("GPSEE_NO_UTF8_C_STRINGS"))
{
JS_DestroyRuntime(JS_NewRuntime(1024));
putenv((char *)"GPSEE_NO_UTF8_C_STRINGS=1");
}
jsi = gpsee_createInterpreter();
realm = jsi->realm;
cx = jsi->cx;
#if defined(GPSEE_DEBUGGER)
jsdc = gpsee_initDebugger(cx, realm, DEBUGGER_JS);
#endif
gpsee_setThreadStackLimit(cx, &stackBasePtr, strtol(cfg_default_value(cfg, "gpsee_thread_stack_limit_bytes", "0x80000"), NULL, 0));
processFlags(cx, flags, &verbosity);
free(flags);
#if defined(__SURELYNX__)
sl_set_debugLevel(gpsee_verbosity(0));
/* enableTerminalLogs(permanent_pool, gpsee_verbosity(0) > 0, NULL); */
#else
if (verbosity < GSR_MIN_TTY_VERBOSITY && isatty(STDERR_FILENO))
verbosity = GSR_MIN_TTY_VERBOSITY;
#endif
if (gpsee_verbosity(0) < verbosity)
gpsee_setVerbosity(verbosity);
/* Run JavaScript specified with -c */
if (scriptCode)
{
jsval v;
if (JS_EvaluateScript(cx, realm->globalObject, scriptCode, strlen(scriptCode), "command_line", 1, &v) == JS_FALSE)
{
v = JSVAL_NULL;
goto out;
}
v = JSVAL_NULL;
}
if ((argv[0][0] == '/')
#if defined(SYSTEM_GSR)
&& (strcmp(argv[0], SYSTEM_GSR) != 0)
#endif
&& cfg_bool_value(cfg, "no_gsr_preload_script") != cfg_true)
{
char preloadScriptFilename[FILENAME_MAX];
char mydir[FILENAME_MAX];
int i;
jsi->grt->exitType = et_unknown;
i = snprintf(preloadScriptFilename, sizeof(preloadScriptFilename), "%s/.%s_preload", gpsee_dirname(argv[0], mydir, sizeof(mydir)),
gpsee_basename(argv[0]));
if ((i == 0) || (i == (sizeof(preloadScriptFilename) -1)))
gpsee_log(cx, GLOG_EMERG, PRODUCT_SHORTNAME ": Unable to create preload script filename!");
else
errno = 0;
if (access(preloadScriptFilename, F_OK) == 0)
{
jsval v;
JSScript *script;
JSObject *scrobj;
if (!gpsee_compileScript(cx, preloadScriptFilename, NULL, NULL, &script, realm->globalObject, &scrobj))
{
jsi->grt->exitType = et_compileFailure;
gpsee_log(cx, GLOG_EMERG, PRODUCT_SHORTNAME ": Unable to compile preload script '%s'", preloadScriptFilename);
goto out;
}
if (!script || !scrobj)
goto out;
if (!noRunScript)
{
JS_AddNamedObjectRoot(cx, &scrobj, "preload_scrobj");
jsi->grt->exitType = et_execFailure;
if (JS_ExecuteScript(cx, realm->globalObject, script, &v) == JS_TRUE)
jsi->grt->exitType = et_finished;
else
jsi->grt->exitType = et_exception;
JS_RemoveObjectRoot(cx, &scrobj);
v = JSVAL_NULL;
}
}
if (jsi->grt->exitType & et_errorMask)
goto out;
}
/* Setup for main-script running -- cancel preprogram verbosity and use our own error reporting system in gsr that does not use error reporter */
gpsee_setVerbosity(verbosity);
JS_SetOptions(cx, JS_GetOptions(cx) | JSOPTION_DONT_REPORT_UNCAUGHT);
if (!scriptFilename)
{
if (!scriptCode) /* Command-line options did not include code to run */
usage(argv[0]);
if (jsi->grt->exitType == et_unknown)
jsi->grt->exitType = et_finished;
}
else
{
FILE *scriptFile = openScriptFile(cx, scriptFilename, skipSheBang || (fiArg != 0));
if (!scriptFile)
{
gpsee_log(cx, GLOG_NOTICE, PRODUCT_SHORTNAME ": Unable to open' script '%s'! (%m)", scriptFilename);
jsi->grt->exitType = et_compileFailure;
goto out;
}
processInlineFlags(cx, scriptFile, &verbosity);
gpsee_setVerbosity(verbosity);
/* Just compile and exit? */
if (noRunScript)
{
JSScript *script;
JSObject *scrobj;
if (!gpsee_compileScript(cx, scriptFilename, scriptFile, NULL, &script, realm->globalObject, &scrobj))
{
jsi->grt->exitType = et_exception;
gpsee_reportUncaughtException(cx, JSVAL_NULL,
(gpsee_verbosity(0) >= GSR_FORCE_STACK_DUMP_VERBOSITY) ||
((gpsee_verbosity(0) >= GPSEE_ERROR_OUTPUT_VERBOSITY) && isatty(STDERR_FILENO)));
}
else
{
jsi->grt->exitType = et_finished;
}
}
else /* noRunScript is false; run the program */
{
jsi->grt->exitType = et_execFailure;
if (gpsee_runProgramModule(cx, scriptFilename, NULL, scriptFile, script_argv, script_environ) == JS_TRUE)
{
jsi->grt->exitType = et_finished;
}
else
{
int code;
code = gpsee_getExceptionExitCode(cx);
if (code >= 0) /** e.g. throw 6 */
{
jsi->grt->exitType = et_requested;
jsi->grt->exitCode = code;
}
else
{
if (JS_IsExceptionPending(cx))
{
jsi->grt->exitType = et_exception;
gpsee_reportUncaughtException(cx, JSVAL_NULL,
(gpsee_verbosity(0) >= GSR_FORCE_STACK_DUMP_VERBOSITY) ||
((gpsee_verbosity(0) >= GPSEE_ERROR_OUTPUT_VERBOSITY) && isatty(STDERR_FILENO)));
}
}
}
}
fclose(scriptFile);
goto out;
}
out:
#ifdef GPSEE_DEBUGGER
gpsee_finiDebugger(jsdc);
#endif
if (jsi->grt->exitType & et_successMask)
{
exitCode = jsi->grt->exitCode;
}
else
{
const char *reason;
exitCode = 1;
switch(jsi->grt->exitType)
{
case et_successMask:
case et_errorMask:
case et_requested:
case et_finished:
case et_dummy:
default:
GPSEE_NOT_REACHED("impossible");
reason = NULL; /* quell compiler warning below */
break;
case et_execFailure:
reason = "execFailure - probable native module error, returning JS_FALSE without setting exception";
break;
case et_compileFailure:
reason = "script could not be compiled";
break;
case et_unknown:
reason = "unknown - probable native module error, returning JS_FALSE without setting exception";
break;
case et_exception:
reason = NULL;
break;
}
if (reason)
{
gpsee_log(cx, GLOG_NOTICE, "Unexpected interpreter shutdown: %s (%m)", reason);
if (gpsee_verbosity(0) == 0)
{
/* not gpsee_ */ fprintf(stderr, "*** Unexpected interpreter shutdown: %s", reason);
if (errno)
fprintf(stderr, " (%s)\n", strerror(errno));
else
fputs("\n", stderr);
}
}
}
gpsee_destroyInterpreter(jsi);
JS_ShutDown();
return exitCode;
}
JSBool js_cocos2dx_extension_WebSocket_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
if (argc == 1 || argc == 2)
{
std::string url;
do {
JSBool ok = jsval_to_std_string(cx, argv[0], &url);
JSB_PRECONDITION2( ok, cx, JS_FALSE, "Error processing arguments");
} while (0);
JSObject *obj = JS_NewObject(cx, js_cocos2dx_websocket_class, js_cocos2dx_websocket_prototype, NULL);
cocos2d::extension::WebSocket* cobj = new cocos2d::extension::WebSocket();
JSB_WebSocketDelegate* delegate = new JSB_WebSocketDelegate();
delegate->setJSDelegate(obj);
if (argc == 2)
{
std::vector<std::string> protocols;
if (JSVAL_IS_STRING(argv[1]))
{
std::string protocol;
do {
JSBool ok = jsval_to_std_string(cx, argv[1], &protocol);
JSB_PRECONDITION2( ok, cx, JS_FALSE, "Error processing arguments");
} while (0);
protocols.push_back(protocol);
}
else if (argv[1].isObject())
{
JSBool ok = JS_TRUE;
JSObject* arg2 = JSVAL_TO_OBJECT(argv[1]);
JSB_PRECONDITION(JS_IsArrayObject( cx, arg2 ), "Object must be an array");
uint32_t len = 0;
JS_GetArrayLength(cx, arg2, &len);
for( uint32_t i=0; i< len;i++ )
{
jsval valarg;
JS_GetElement(cx, arg2, i, &valarg);
std::string protocol;
do {
ok = jsval_to_std_string(cx, valarg, &protocol);
JSB_PRECONDITION2( ok, cx, JS_FALSE, "Error processing arguments");
} while (0);
protocols.push_back(protocol);
}
}
cobj->init(*delegate, url, &protocols);
}
else
{
cobj->init(*delegate, url);
}
JS_DefineProperty(cx, obj, "URL", argv[0]
, NULL, NULL, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
//protocol not support yet (always return "")
JS_DefineProperty(cx, obj, "protocol", c_string_to_jsval(cx, "")
, NULL, NULL, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
// link the native object with the javascript object
js_proxy_t *p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "WebSocket");
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return JS_FALSE;
}
JSBool js_cocos2dx_spine_SkeletonAnimation_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
JSBool ok = JS_TRUE;
JSObject *obj = NULL;
spine::SkeletonAnimation* cobj = NULL;
do {
if (argc == 2) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = JS_TRUE; break; }
spAtlas* arg1;
#pragma warning NO CONVERSION TO NATIVE FOR spAtlas*;
if (!ok) { ok = JS_TRUE; break; }
cobj = new spine::SkeletonAnimation(arg0, arg1);
cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* proxy = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &proxy->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 3) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = JS_TRUE; break; }
spAtlas* arg1;
#pragma warning NO CONVERSION TO NATIVE FOR spAtlas*;
if (!ok) { ok = JS_TRUE; break; }
double arg2;
ok &= JS_ValueToNumber(cx, argv[2], &arg2);
if (!ok) { ok = JS_TRUE; break; }
cobj = new spine::SkeletonAnimation(arg0, arg1, arg2);
cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* proxy = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &proxy->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 1) {
spSkeletonData* arg0;
#pragma warning NO CONVERSION TO NATIVE FOR spSkeletonData*;
if (!ok) { ok = JS_TRUE; break; }
cobj = new spine::SkeletonAnimation(arg0);
cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* proxy = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &proxy->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 2) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = JS_TRUE; break; }
const char* arg1;
std::string arg1_tmp; ok &= jsval_to_std_string(cx, argv[1], &arg1_tmp); arg1 = arg1_tmp.c_str();
if (!ok) { ok = JS_TRUE; break; }
cobj = new spine::SkeletonAnimation(arg0, arg1);
cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* proxy = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &proxy->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 3) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = JS_TRUE; break; }
const char* arg1;
std::string arg1_tmp; ok &= jsval_to_std_string(cx, argv[1], &arg1_tmp); arg1 = arg1_tmp.c_str();
if (!ok) { ok = JS_TRUE; break; }
double arg2;
ok &= JS_ValueToNumber(cx, argv[2], &arg2);
if (!ok) { ok = JS_TRUE; break; }
cobj = new spine::SkeletonAnimation(arg0, arg1, arg2);
cocos2d::Object *_ccobj = dynamic_cast<cocos2d::Object *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* proxy = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &proxy->obj, "spine::SkeletonAnimation");
}
} while(0);
if (cobj) {
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
return JS_TRUE;
}
JS_ReportError(cx, "js_cocos2dx_spine_SkeletonAnimation_constructor : wrong number of arguments");
return JS_FALSE;
}
/**
* Create a new GPSEE Realm. New realm will be initialized to have all members NULL, except
* - the context and name provided (name only present in debug build)
* - an initialized module system (and hence module data store)
* - an initialized I/O hooks data store
* - an initialized global object
* - a prototype for the module object
*
* @param grt The GPSEE runtime to which the new realm will belong
* @param name A symbolic name, for use in debugging, to describe this realm. Does not need to be unique.
*
* @returns The new realm, or NULL if we threw an exception.
*/
gpsee_realm_t *gpsee_createRealm(gpsee_runtime_t *grt, const char *name)
{
gpsee_realm_t *realm = NULL;
JSContext *cx;
cx = JS_NewContext(grt->rt, 8192);
if (!cx)
return NULL;
JS_BeginRequest(cx);
JS_SetOptions(cx, JS_GetOptions(grt->coreCx));
gpsee_enterAutoMonitor(cx, &grt->monitors.realms);
realm = JS_malloc(cx, sizeof(*realm));
if (!realm)
goto err_out;
memset(realm, 0, sizeof(*realm));
realm->grt = grt;
#ifdef GPSEE_DEBUG_BUILD
realm->name = JS_strdup(cx, name);
if (!realm->name)
goto err_out;
#endif
realm->user_io_pendingWrites = gpsee_ds_create(grt, GPSEE_DS_OTM_KEYS, 0);
if (!realm->user_io_pendingWrites)
return JS_FALSE;
#if defined(JSRESERVED_GLOBAL_COMPARTMENT)
realm->globalObject = JS_NewCompartmentAndGlobalObject(cx, gpsee_getGlobalClass(), NULL);
#else
realm->globalObject = JS_NewGlobalObject(cx, gpsee_getGlobalClass());
#endif
if (!realm->globalObject)
goto err_out;
{
static JSClass moduleObjectClass =
{
GPSEE_GLOBAL_NAMESPACE_NAME ".Module", 0,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub
};
#undef JS_InitClass
moduleObjectClass.name += sizeof(GPSEE_GLOBAL_NAMESPACE_NAME);
realm->moduleObjectProto = JS_InitClass(cx, realm->globalObject, NULL, &moduleObjectClass,
ModuleObject, 0, NULL, NULL, NULL, NULL);
moduleObjectClass.name -= sizeof(GPSEE_GLOBAL_NAMESPACE_NAME);
realm->moduleObjectClass = &moduleObjectClass;
#define JS_InitClass poison
}
if (!realm->moduleObjectProto)
goto err_out;
JS_AddNamedObjectRoot(cx, &realm->globalObject, "super-global");
if (gpsee_ds_put(grt->realms, realm, NULL) == JS_FALSE)
goto err_out;
if (gpsee_initializeModuleSystem(cx, realm) == JS_FALSE)
panic("Unable to initialize module system");
if (gpsee_initGlobalObject(cx, realm, realm->globalObject) == JS_FALSE)
goto err_out;
realm->cachedCx = cx;
goto out;
err_out:
if (realm)
{
JS_free(cx, realm);
#ifdef GPSEE_DEBUG_BUILD
if (realm->name)
JS_free(cx, (char *)realm->name);
#endif
realm = NULL;
}
if (cx) {
JS_DestroyContext(cx);
cx = NULL;
}
out:
gpsee_leaveAutoMonitor(grt->monitors.realms);
if (cx)
JS_EndRequest(cx);
return realm;
}
static void rootObject(JSContext *cx, JSObject *obj) {
JS_AddNamedObjectRoot(cx, &obj, "unnamed");
}
static JSDContext*
_newJSDContext(JSRuntime* jsrt,
JSD_UserCallbacks* callbacks,
void* user,
JSObject* scopeobj)
{
JSDContext* jsdc = NULL;
JSCrossCompartmentCall *call = NULL;
JSBool ok;
if( ! jsrt )
return NULL;
if( ! _validateUserCallbacks(callbacks) )
return NULL;
jsdc = (JSDContext*) calloc(1, sizeof(JSDContext));
if( ! jsdc )
goto label_newJSDContext_failure;
if( ! JSD_INIT_LOCKS(jsdc) )
goto label_newJSDContext_failure;
JS_INIT_CLIST(&jsdc->links);
jsdc->jsrt = jsrt;
if( callbacks )
memcpy(&jsdc->userCallbacks, callbacks, callbacks->size);
jsdc->user = user;
#ifdef JSD_HAS_DANGEROUS_THREAD
jsdc->dangerousThread = _dangerousThread;
#endif
JS_INIT_CLIST(&jsdc->threadsStates);
JS_INIT_CLIST(&jsdc->sources);
JS_INIT_CLIST(&jsdc->removedSources);
jsdc->sourceAlterCount = 1;
if( ! jsd_CreateAtomTable(jsdc) )
goto label_newJSDContext_failure;
if( ! jsd_InitObjectManager(jsdc) )
goto label_newJSDContext_failure;
if( ! jsd_InitScriptManager(jsdc) )
goto label_newJSDContext_failure;
jsdc->dumbContext = JS_NewContext(jsdc->jsrt, 256);
if( ! jsdc->dumbContext )
goto label_newJSDContext_failure;
JS_BeginRequest(jsdc->dumbContext);
JS_SetOptions(jsdc->dumbContext, JS_GetOptions(jsdc->dumbContext) | JSOPTION_ALLOW_XML);
jsdc->glob = JS_NewCompartmentAndGlobalObject(jsdc->dumbContext, &global_class, NULL);
if( ! jsdc->glob )
goto label_newJSDContext_failure;
call = JS_EnterCrossCompartmentCall(jsdc->dumbContext, jsdc->glob);
if( ! call )
goto label_newJSDContext_failure;
if ( ! JS_AddNamedObjectRoot(jsdc->dumbContext, &jsdc->glob, "JSD context global") )
goto label_newJSDContext_failure;
ok = JS_InitStandardClasses(jsdc->dumbContext, jsdc->glob);
JS_LeaveCrossCompartmentCall(call);
if( ! ok )
goto label_newJSDContext_failure;
JS_EndRequest(jsdc->dumbContext);
jsdc->data = NULL;
jsdc->inited = JS_TRUE;
JSD_LOCK();
JS_INSERT_LINK(&jsdc->links, &_jsd_context_list);
JSD_UNLOCK();
return jsdc;
label_newJSDContext_failure:
if( jsdc ) {
if ( jsdc->dumbContext && jsdc->glob )
JS_RemoveObjectRootRT(JS_GetRuntime(jsdc->dumbContext), &jsdc->glob);
jsd_DestroyObjectManager(jsdc);
jsd_DestroyAtomTable(jsdc);
if( jsdc->dumbContext )
JS_EndRequest(jsdc->dumbContext);
free(jsdc);
}
return NULL;
}
bool js_cocos2dx_spine_SkeletonAnimation_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
bool ok = true;
JSObject *obj = NULL;
spine::SkeletonAnimation* cobj = NULL;
do {
if (argc == 2) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = true; break; }
spAtlas* arg1;
#pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
ok = false;
if (!ok) { ok = true; break; }
cobj = new (std::nothrow) spine::SkeletonAnimation(arg0, arg1);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 3) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = true; break; }
spAtlas* arg1;
#pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
ok = false;
if (!ok) { ok = true; break; }
double arg2;
ok &= JS::ToNumber( cx, JS::RootedValue(cx, argv[2]), &arg2);
if (!ok) { ok = true; break; }
cobj = new (std::nothrow) spine::SkeletonAnimation(arg0, arg1, arg2);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 1) {
spSkeletonData* arg0;
#pragma warning NO CONVERSION TO NATIVE FOR spSkeletonData*
ok = false;
if (!ok) { ok = true; break; }
cobj = new (std::nothrow) spine::SkeletonAnimation(arg0);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 2) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = true; break; }
const char* arg1;
std::string arg1_tmp; ok &= jsval_to_std_string(cx, argv[1], &arg1_tmp); arg1 = arg1_tmp.c_str();
if (!ok) { ok = true; break; }
cobj = new (std::nothrow) spine::SkeletonAnimation(arg0, arg1);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "spine::SkeletonAnimation");
}
} while(0);
do {
if (argc == 3) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
if (!ok) { ok = true; break; }
const char* arg1;
std::string arg1_tmp; ok &= jsval_to_std_string(cx, argv[1], &arg1_tmp); arg1 = arg1_tmp.c_str();
if (!ok) { ok = true; break; }
double arg2;
ok &= JS::ToNumber( cx, JS::RootedValue(cx, argv[2]), &arg2);
if (!ok) { ok = true; break; }
cobj = new (std::nothrow) spine::SkeletonAnimation(arg0, arg1, arg2);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<spine::SkeletonAnimation> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "spine::SkeletonAnimation");
}
} while(0);
if (cobj) {
if (JS_HasProperty(cx, obj, "_ctor", &ok))
ScriptingCore::getInstance()->executeFunctionWithOwner(OBJECT_TO_JSVAL(obj), "_ctor", argc, argv);
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
return true;
}
JS_ReportError(cx, "js_cocos2dx_spine_SkeletonAnimation_constructor : wrong number of arguments");
return false;
}
bool js_autogentestbindings_SimpleNativeClass_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
bool ok = true;
JSObject *obj = NULL;
SimpleNativeClass* cobj = NULL;
do {
if (argc == 1) {
int arg0;
ok &= jsval_to_int32(cx, argv[0], (int32_t *)&arg0);
if (!ok) { ok = true; break; }
cobj = new SimpleNativeClass(arg0);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<SimpleNativeClass> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "SimpleNativeClass");
}
} while(0);
do {
if (argc == 0) {
cobj = new SimpleNativeClass();
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<SimpleNativeClass> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "SimpleNativeClass");
}
} while(0);
do {
if (argc == 2) {
int arg0;
ok &= jsval_to_int32(cx, argv[0], (int32_t *)&arg0);
if (!ok) { ok = true; break; }
int arg1;
ok &= jsval_to_int32(cx, argv[1], (int32_t *)&arg1);
if (!ok) { ok = true; break; }
cobj = new SimpleNativeClass(arg0, arg1);
cocos2d::Ref *_ccobj = dynamic_cast<cocos2d::Ref *>(cobj);
if (_ccobj) {
_ccobj->autorelease();
}
TypeTest<SimpleNativeClass> t;
js_type_class_t *typeClass = nullptr;
std::string typeName = t.s_name();
auto typeMapIter = _js_global_type_map.find(typeName);
CCASSERT(typeMapIter != _js_global_type_map.end(), "Can't find the class type!");
typeClass = typeMapIter->second;
CCASSERT(typeClass, "The value is null.");
obj = JS_NewObject(cx, typeClass->jsclass, typeClass->proto, typeClass->parentProto);
js_proxy_t* p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "SimpleNativeClass");
}
} while(0);
if (cobj) {
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
return true;
}
JS_ReportError(cx, "js_autogentestbindings_SimpleNativeClass_constructor : wrong number of arguments");
return false;
}
