static JSBool
obj_valueOf(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
*rval = OBJECT_TO_JSVAL(obj);
return JS_TRUE;
}
JavaClass_getPropertyById(JSContext *cx, JSObject *obj, jsid id, jsval *vp)
{
jsval idval;
jclass java_class;
const char *member_name;
JavaClassDescriptor *class_descriptor;
JavaMemberDescriptor *member_descriptor;
JNIEnv *jEnv;
JSJavaThreadState *jsj_env;
JSBool result;
/* printf("In JavaClass_getProperty\n"); */
/* Get the Java per-thread environment pointer for this JSContext */
jsj_env = jsj_EnterJava(cx, &jEnv);
if (!jEnv)
return JS_FALSE;
if (!lookup_static_member_by_id(cx, jEnv, obj, &class_descriptor, id, &member_descriptor)) {
jsj_ExitJava(jsj_env);
return JS_FALSE;
}
if (!member_descriptor) {
*vp = JSVAL_VOID;
jsj_ExitJava(jsj_env);
return JS_TRUE;
}
java_class = class_descriptor->java_class;
if (member_descriptor->field) {
if (!member_descriptor->methods) {
result = jsj_GetJavaFieldValue(cx, jEnv, member_descriptor->field, java_class, vp);
jsj_ExitJava(jsj_env);
return result;
} else {
JS_ASSERT(0);
}
} else {
JSFunction *function;
/* TODO - eliminate JSFUN_BOUND_METHOD */
if (member_descriptor->methods->is_alias) {
/* If this is an explicit resolution of an overloaded method,
use the fully-qualified method name as the name of the
resulting JS function, i.e. "myMethod(int,long)" */
JS_IdToValue(cx, id, &idval);
member_name = JS_GetStringBytes(JSVAL_TO_STRING(idval));
} else {
/* Either not explicit resolution of overloaded method or
explicit resolution was unnecessary because method was
not overloaded. */
member_name = member_descriptor->name;
}
function = JS_NewFunction(cx, jsj_JavaStaticMethodWrapper, 0,
JSFUN_BOUND_METHOD, obj, member_name);
if (!function) {
jsj_ExitJava(jsj_env);
return JS_FALSE;
}
*vp = OBJECT_TO_JSVAL(JS_GetFunctionObject(function));
}
jsj_ExitJava(jsj_env);
return JS_TRUE;
}
static bool js_cocos2dx_CCTableView_create(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
if (argc == 3 || argc == 2)
{
JSB_TableViewDataSource* pNativeSource = new (std::nothrow) JSB_TableViewDataSource();
JS::RootedObject jsdata(cx, args.get(0).toObjectOrNull());
pNativeSource->setTableViewDataSource(jsdata);
cocos2d::Size arg1;
ok &= jsval_to_ccsize(cx, args.get(1), &arg1);
cocos2d::extension::TableView* ret = NULL;
ret = new (std::nothrow) TableView();
ret->autorelease();
ret->setDataSource(pNativeSource);
jsval jsret;
do {
if (ret)
{
JS::RootedObject jsobj(cx, js_get_or_create_jsobject<cocos2d::extension::TableView>(cx, ret));
jsret = OBJECT_TO_JSVAL(jsobj);
JS_SetProperty(cx, jsobj, "_dataSource", args.get(0));
}
else
{
jsret = JSVAL_NULL;
}
} while (0);
if (argc == 2)
{
ret->initWithViewSize(arg1);
}
else
{
cocos2d::Node* arg2;
do
{
js_proxy_t *proxy;
JS::RootedObject tmpObj(cx, args.get(2).toObjectOrNull());
proxy = jsb_get_js_proxy(tmpObj);
arg2 = (cocos2d::Node*)(proxy ? proxy->ptr : NULL);
JSB_PRECONDITION2( arg2, cx, false, "Invalid Native Object");
} while (0);
JSB_PRECONDITION2(ok, cx, false, "Error processing arguments");
ret->initWithViewSize(arg1, arg2);
}
ret->reloadData();
__Dictionary* userDict = new (std::nothrow) __Dictionary();
userDict->setObject(pNativeSource, KEY_TABLEVIEW_DATA_SOURCE);
ret->setUserObject(userDict);
userDict->release();
pNativeSource->release();
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "wrong number of arguments");
return false;
}
inline jsval object_to_jsval(JSObject *o) {
return OBJECT_TO_JSVAL(o);
}
static JSBool
JO(JSContext *cx, jsval *vp, StringifyContext *scx)
{
JSObject *obj = JSVAL_TO_OBJECT(*vp);
if (!scx->cb.append('{'))
return JS_FALSE;
jsval vec[3] = {JSVAL_NULL, JSVAL_NULL, JSVAL_NULL};
JSAutoTempValueRooter tvr(cx, 3, vec);
jsval& key = vec[0];
jsval& outputValue = vec[1];
JSObject *iterObj = NULL;
jsval *keySource = vp;
bool usingWhitelist = false;
// if the replacer is an array, we use the keys from it
if (scx->replacer && JS_IsArrayObject(cx, scx->replacer)) {
usingWhitelist = true;
vec[2] = OBJECT_TO_JSVAL(scx->replacer);
keySource = &vec[2];
}
if (!js_ValueToIterator(cx, JSITER_ENUMERATE, keySource))
return JS_FALSE;
iterObj = JSVAL_TO_OBJECT(*keySource);
JSBool memberWritten = JS_FALSE;
bool ok = false;
while (true) {
outputValue = JSVAL_VOID;
if (!js_CallIteratorNext(cx, iterObj, &key))
goto error_break;
if (key == JSVAL_HOLE)
break;
jsuint index = 0;
if (usingWhitelist) {
// skip non-index properties
if (!js_IdIsIndex(key, &index))
continue;
jsval newKey;
if (!scx->replacer->getProperty(cx, key, &newKey))
goto error_break;
key = newKey;
}
JSString *ks;
if (JSVAL_IS_STRING(key)) {
ks = JSVAL_TO_STRING(key);
} else {
ks = js_ValueToString(cx, key);
if (!ks)
goto error_break;
}
JSAutoTempValueRooter keyStringRoot(cx, ks);
// Don't include prototype properties, since this operation is
// supposed to be implemented as if by ES3.1 Object.keys()
jsid id;
jsval v = JS_FALSE;
if (!js_ValueToStringId(cx, STRING_TO_JSVAL(ks), &id) ||
!js_HasOwnProperty(cx, obj->map->ops->lookupProperty, obj, id, &v)) {
goto error_break;
}
if (v != JSVAL_TRUE)
continue;
if (!JS_GetPropertyById(cx, obj, id, &outputValue))
goto error_break;
if (JSVAL_IS_OBJECT(outputValue) && !js_TryJSON(cx, &outputValue))
goto error_break;
// call this here, so we don't write out keys if the replacer function
// wants to elide the value.
if (!CallReplacerFunction(cx, id, obj, scx, &outputValue))
goto error_break;
JSType type = JS_TypeOfValue(cx, outputValue);
// elide undefined values and functions and XML
if (outputValue == JSVAL_VOID || type == JSTYPE_FUNCTION || type == JSTYPE_XML)
continue;
// output a comma unless this is the first member to write
if (memberWritten && !scx->cb.append(','))
goto error_break;
memberWritten = JS_TRUE;
if (!WriteIndent(cx, scx, scx->depth))
goto error_break;
// Be careful below, this string is weakly rooted
JSString *s = js_ValueToString(cx, key);
if (!s)
goto error_break;
const jschar *chars;
size_t length;
s->getCharsAndLength(chars, length);
if (!write_string(cx, scx->cb, chars, length) ||
!scx->cb.append(':') ||
!Str(cx, id, obj, scx, &outputValue, false)) {
goto error_break;
}
}
ok = true;
error_break:
if (iterObj) {
// Always close the iterator, but make sure not to stomp on OK
JS_ASSERT(OBJECT_TO_JSVAL(iterObj) == *keySource);
ok &= js_CloseIterator(cx, *keySource);
}
if (!ok)
return JS_FALSE;
if (memberWritten && !WriteIndent(cx, scx, scx->depth - 1))
return JS_FALSE;
return scx->cb.append('}');
}
JSBool js_cocos2dx_CCBReader_createSceneWithNodeGraphFromFile(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
JSBool ok = JS_TRUE;
JSObject *obj;
cocos2d::extension::CCBReader* cobj;
obj = JS_THIS_OBJECT(cx, vp);
js_proxy_t *proxy = jsb_get_js_proxy(obj);
cobj = (cocos2d::extension::CCBReader *)(proxy ? proxy->ptr : NULL);
TEST_NATIVE_OBJECT(cx, cobj)
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();
cocos2d::CCObject* arg1;
do {
js_proxy_t *proxy;
JSObject *tmpObj = JSVAL_TO_OBJECT(argv[1]);
proxy = jsb_get_js_proxy(tmpObj);
arg1 = (cocos2d::CCObject*)(proxy ? proxy->ptr : NULL);
TEST_NATIVE_OBJECT(cx, arg1)
} while (0);
JSB_PRECONDITION2(ok, cx, JS_FALSE, "Error processing arguments");
cocos2d::CCScene* ret = cobj->createSceneWithNodeGraphFromFile(arg0, arg1);
jsval jsret; do {
if (ret) {
js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::CCScene>(cx, ret);
jsret = OBJECT_TO_JSVAL(proxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return JS_TRUE;
}
if (argc == 1) {
const char* arg0;
std::string arg0_tmp; ok &= jsval_to_std_string(cx, argv[0], &arg0_tmp); arg0 = arg0_tmp.c_str();
JSB_PRECONDITION2(ok, cx, JS_FALSE, "Error processing arguments");
cocos2d::CCScene* ret = cobj->createSceneWithNodeGraphFromFile(arg0);
jsval jsret; do {
if (ret) {
js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::CCScene>(cx, ret);
jsret = OBJECT_TO_JSVAL(proxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return JS_TRUE;
}
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();
cocos2d::CCObject* arg1;
do {
js_proxy_t *proxy;
JSObject *tmpObj = JSVAL_TO_OBJECT(argv[1]);
proxy = jsb_get_js_proxy(tmpObj);
arg1 = (cocos2d::CCObject*)(proxy ? proxy->ptr : NULL);
TEST_NATIVE_OBJECT(cx, arg1)
} while (0);
cocos2d::CCSize arg2;
ok &= jsval_to_ccsize(cx, argv[2], &arg2);
JSB_PRECONDITION2(ok, cx, JS_FALSE, "Error processing arguments");
cocos2d::CCScene* ret = cobj->createSceneWithNodeGraphFromFile(arg0, arg1, arg2);
jsval jsret; do {
if (ret) {
js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::CCScene>(cx, ret);
jsret = OBJECT_TO_JSVAL(proxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return JS_TRUE;
}
return JS_FALSE;
}
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;
}
static JSBool js_get(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
jsint tiny;
js_branch_t* branch;
if((branch=(js_branch_t*)JS_GetPrivate(cx,obj))==NULL)
return(JS_FALSE);
tiny = JSVAL_TO_INT(id);
switch(tiny) {
case PROP_VERSION:
*vp=STRING_TO_JSVAL(JS_NewStringCopyZ(cx,(char *)JS_GetImplementationVersion()));
break;
case PROP_TERMINATED:
if(branch->terminated==NULL)
*vp=JSVAL_FALSE;
else
*vp=BOOLEAN_TO_JSVAL(*branch->terminated);
break;
case PROP_AUTO_TERMINATE:
*vp=BOOLEAN_TO_JSVAL(branch->auto_terminate);
break;
case PROP_BRANCH_COUNTER:
JS_NewNumberValue(cx,branch->counter,vp);
break;
case PROP_BRANCH_LIMIT:
JS_NewNumberValue(cx,branch->limit,vp);
break;
case PROP_YIELD_INTERVAL:
JS_NewNumberValue(cx,branch->yield_interval,vp);
break;
case PROP_GC_INTERVAL:
JS_NewNumberValue(cx,branch->gc_interval,vp);
break;
case PROP_GC_ATTEMPTS:
JS_NewNumberValue(cx,branch->gc_attempts,vp);
break;
#ifdef jscntxt_h___
case PROP_GC_COUNTER:
JS_NewNumberValue(cx,cx->runtime->gcNumber,vp);
break;
case PROP_GC_LASTBYTES:
JS_NewNumberValue(cx,cx->runtime->gcLastBytes,vp);
break;
case PROP_BYTES:
JS_NewNumberValue(cx,cx->runtime->gcBytes,vp);
break;
case PROP_MAXBYTES:
JS_NewNumberValue(cx,cx->runtime->gcMaxBytes,vp);
break;
case PROP_GLOBAL:
*vp = OBJECT_TO_JSVAL(cx->globalObject);
break;
#else
case PROP_GLOBAL:
*vp = OBJECT_TO_JSVAL(JS_GetParent(cx,obj));
break;
#endif
}
return(JS_TRUE);
}
static JSObject *
load_module_init(JSContext *context,
JSObject *in_object,
const char *full_path)
{
char *script;
gsize script_len;
jsval script_retval;
JSObject *module_obj;
GError *error;
/* First we check if js module has already been loaded */
if (gjs_object_has_property(context, in_object, MODULE_INIT_PROPERTY)) {
jsval module_obj_val;
if (gjs_object_get_property(context,
in_object,
MODULE_INIT_PROPERTY,
&module_obj_val)) {
return JSVAL_TO_OBJECT(module_obj_val);
}
}
module_obj = JS_NewObject(context, NULL, NULL, NULL);
if (module_obj == NULL) {
return JS_FALSE;
}
/* https://bugzilla.mozilla.org/show_bug.cgi?id=599651 means we
* can't just pass in the global as the parent */
JS_SetParent(context, module_obj,
gjs_get_import_global (context));
/* Define module in importer for future use and to avoid module_obj
* object to be garbage collected during the evaluation of the script */
JS_DefineProperty(context, in_object,
MODULE_INIT_PROPERTY, OBJECT_TO_JSVAL(module_obj),
NULL, NULL,
GJS_MODULE_PROP_FLAGS & ~JSPROP_PERMANENT);
script_len = 0;
error = NULL;
if (!g_file_get_contents(full_path, &script, &script_len, &error)) {
if (!g_error_matches(error, G_FILE_ERROR, G_FILE_ERROR_ISDIR) &&
!g_error_matches(error, G_FILE_ERROR, G_FILE_ERROR_NOTDIR) &&
!g_error_matches(error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
gjs_throw_g_error(context, error);
else
g_error_free(error);
return NULL;
}
g_assert(script != NULL);
gjs_debug(GJS_DEBUG_IMPORTER, "Importing %s", full_path);
if (!JS_EvaluateScript(context,
module_obj,
script,
script_len,
full_path,
1, /* line number */
&script_retval)) {
g_free(script);
/* If JSOPTION_DONT_REPORT_UNCAUGHT is set then the exception
* would be left set after the evaluate and not go to the error
* reporter function.
*/
if (JS_IsExceptionPending(context)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"Module " MODULE_INIT_FILENAME " left an exception set");
gjs_log_and_keep_exception(context, NULL);
} else {
gjs_throw(context,
"JS_EvaluateScript() returned FALSE but did not set exception");
}
return NULL;
}
g_free(script);
return module_obj;
}
void SG_vc_hooks__execute(
SG_context* pCtx,
const char* psz_js,
SG_vhash* pvh_params,
SG_vhash** ppvh_result
)
{
jsval rval;
JSContext* cx = NULL;
JSObject* glob = NULL;
SG_vhash* pvh_result = NULL;
JSObject* jso_params = NULL;
SG_NULLARGCHECK_RETURN(psz_js);
SG_jscore__new_runtime(pCtx, NULL, global_functions, SG_FALSE, NULL);
SG_ERR_CHECK_CURRENT_DISREGARD(SG_ERR_ALREADY_INITIALIZED);
SG_ERR_CHECK( SG_jscore__new_context(pCtx, &cx, &glob, NULL) );
//This should tell the javascript engine how to report javascript errors to our jsglue.
JS_SetErrorReporter(cx,SG_jsglue__error_reporter);
if(!JS_EvaluateScript(cx, glob, psz_js, (uintN) strlen(psz_js), "hook_script", 1, &rval))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_UNSPECIFIED, (pCtx, "An error occurred evaluating hook"));
}
// note that we don't care about the rval from eval of the script
{
jsval params;
jsval rval;
if (pvh_params)
{
jso_params = JS_NewObject(cx, NULL, NULL, NULL);
if(!jso_params)
SG_ERR_THROW2(SG_ERR_MALLOCFAILED, (pCtx, "Failed to create new JS object for params to vc hook."));
params = OBJECT_TO_JSVAL(jso_params);
SG_ERR_CHECK( sg_jsglue__copy_vhash_into_jsobject(pCtx, cx, pvh_params, jso_params) );
}
else
{
params = JSVAL_NULL;
}
if(!JS_CallFunctionName(cx, glob, "hook", 1, ¶ms, &rval))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_UNSPECIFIED, (pCtx, "An error occurred calling JS hook"));
}
if (JSVAL_IS_OBJECT(rval))
{
SG_ERR_CHECK( sg_jsglue__jsobject_to_vhash(pCtx, cx, JSVAL_TO_OBJECT(rval), &pvh_result) );
}
}
if (ppvh_result)
{
*ppvh_result = pvh_result;
pvh_result = NULL;
}
fail:
if (cx)
{
SG_ERR_IGNORE( SG_jsglue__set_sg_context(NULL, cx) );
JS_EndRequest(cx);
JS_DestroyContext(cx);
}
SG_VHASH_NULLFREE(pCtx, pvh_result);
}
void
SmsRequest::NotifyThreadList(const InfallibleTArray<ThreadListItem>& aItems)
{
MOZ_ASSERT(!mParent);
MOZ_ASSERT(GetOwner());
nsresult rv;
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
NS_ENSURE_SUCCESS_VOID(rv);
NS_ENSURE_TRUE_VOID(sc);
JSContext* cx = sc->GetNativeContext();
MOZ_ASSERT(cx);
nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(GetOwner());
JSObject* ownerObj = sgo->GetGlobalJSObject();
NS_ENSURE_TRUE_VOID(ownerObj);
nsCxPusher pusher;
NS_ENSURE_TRUE_VOID(pusher.Push(cx, false));
JSAutoRequest ar(cx);
JSAutoCompartment ac(cx, ownerObj);
JSObject* array = JS_NewArrayObject(cx, aItems.Length(), nullptr);
NS_ENSURE_TRUE_VOID(array);
bool ok;
for (uint32_t i = 0; i < aItems.Length(); i++) {
const ThreadListItem& source = aItems[i];
nsString temp = source.senderOrReceiver();
jsval senderOrReceiver;
ok = xpc::StringToJsval(cx, temp, &senderOrReceiver);
NS_ENSURE_TRUE_VOID(ok);
JSObject* timestampObj = JS_NewDateObjectMsec(cx, source.timestamp());
NS_ENSURE_TRUE_VOID(timestampObj);
jsval timestamp = OBJECT_TO_JSVAL(timestampObj);
temp = source.body();
jsval body;
ok = xpc::StringToJsval(cx, temp, &body);
NS_ENSURE_TRUE_VOID(ok);
jsval unreadCount = JS_NumberValue(double(source.unreadCount()));
JSObject* elementObj = JS_NewObject(cx, nullptr, nullptr, nullptr);
NS_ENSURE_TRUE_VOID(elementObj);
ok = JS_SetProperty(cx, elementObj, "senderOrReceiver", &senderOrReceiver);
NS_ENSURE_TRUE_VOID(ok);
ok = JS_SetProperty(cx, elementObj, "timestamp", ×tamp);
NS_ENSURE_TRUE_VOID(ok);
ok = JS_SetProperty(cx, elementObj, "body", &body);
NS_ENSURE_TRUE_VOID(ok);
ok = JS_SetProperty(cx, elementObj, "unreadCount", &unreadCount);
NS_ENSURE_TRUE_VOID(ok);
jsval element = OBJECT_TO_JSVAL(elementObj);
ok = JS_SetElement(cx, array, i, &element);
NS_ENSURE_TRUE_VOID(ok);
}
NotifyThreadList(OBJECT_TO_JSVAL(array), cx);
}
/*
* This is a wrapper around JS_ReportError(), useful when an error condition
* is the result of a JVM failure or exception condition. It appends the
* message associated with the pending Java exception to the passed in
* printf-style format string and arguments.
*/
static void
vreport_java_error(JSContext *cx, JNIEnv *jEnv, const char *format, va_list ap)
{
jobject java_obj;
jclass java_class;
JavaClassDescriptor *class_descriptor;
jthrowable java_exception;
JSType wrapped_exception_type;
jsval js_exception;
java_obj = NULL;
class_descriptor = NULL;
/* Get the exception out of the java environment. */
java_exception = (*jEnv)->ExceptionOccurred(jEnv);
if (!java_exception) {
JSString *err_jsstr;
char *err = JS_vsmprintf(format, ap);
if (!err)
return;
err_jsstr = JS_NewString(cx, err, strlen(err));
if (!err_jsstr)
return;
JS_SetPendingException(cx, STRING_TO_JSVAL(err_jsstr));
return;
}
(*jEnv)->ExceptionClear(jEnv);
/* Check for JSException */
if (njJSException &&
(*jEnv)->IsInstanceOf(jEnv, java_exception, njJSException)) {
wrapped_exception_type =
(*jEnv)->GetIntField(jEnv, java_exception,
njJSException_wrappedExceptionType);
/* (int) to suppress warning */
if ((int)wrapped_exception_type != JSTYPE_EMPTY) {
java_obj =
(*jEnv)->GetObjectField(jEnv, java_exception,
njJSException_wrappedException);
if ((java_obj == NULL) &&
(wrapped_exception_type == JSTYPE_OBJECT)) {
js_exception = JSVAL_NULL;
} else {
java_class = (*jEnv)->GetObjectClass(jEnv, java_obj);
class_descriptor = jsj_GetJavaClassDescriptor(cx, jEnv, java_class);
/* OK to delete ref, since above call adds global ref */
(*jEnv)->DeleteLocalRef(jEnv, java_class);
/* Convert native JS values back to native types. */
switch(wrapped_exception_type) {
case JSTYPE_NUMBER:
if (!jsj_ConvertJavaObjectToJSNumber(cx, jEnv,
class_descriptor,
java_obj,
&js_exception))
goto error;
break;
case JSTYPE_BOOLEAN:
if (!jsj_ConvertJavaObjectToJSBoolean(cx, jEnv,
class_descriptor,
java_obj,
&js_exception))
goto error;
break;
case JSTYPE_STRING:
if (!jsj_ConvertJavaObjectToJSString(cx, jEnv,
class_descriptor,
java_obj,
&js_exception))
goto error;
break;
case JSTYPE_VOID:
js_exception = JSVAL_VOID;
break;
case JSTYPE_OBJECT:
case JSTYPE_FUNCTION:
default:
if ((*jEnv)->IsInstanceOf(jEnv, java_obj, njJSObject)) {
js_exception = OBJECT_TO_JSVAL(jsj_UnwrapJSObjectWrapper(jEnv, java_obj));
if (!js_exception)
goto error;
} else {
if (!jsj_ConvertJavaObjectToJSValue(cx, jEnv, java_obj,
&js_exception))
goto error;
}
}
}
}
/* Check for internal exception */
} else {
if (!JSJ_ConvertJavaObjectToJSValue(cx, java_exception,
&js_exception)) {
goto error;
}
}
/* Set pending JS exception and clear the java exception. */
JS_SetPendingException(cx, js_exception);
goto done;
error:
JS_ASSERT(0);
jsj_LogError("Out of memory while attempting to throw JSException\n");
done:
if (class_descriptor)
jsj_ReleaseJavaClassDescriptor(cx, jEnv, class_descriptor);
if (java_obj)
(*jEnv)->DeleteLocalRef(jEnv, java_obj);
if (java_exception)
(*jEnv)->DeleteLocalRef(jEnv, java_exception);
}
jsval as_jsval(JSContext *cx, cairo::JSSurface::OWNERPTR theOwner, cairo::JSSurface::NATIVE * theNative) {
JSObject * myReturnObject = cairo::JSSurface::Construct(cx, theOwner, theNative);
return OBJECT_TO_JSVAL(myReturnObject);
}
static JSBool
obj_watch(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSFunction *fun;
jsval userid, symid, propid, value;
JSAtom *atom;
JSRuntime *rt;
JSBool ok;
JSProperty *prop;
JSPropertyOp getter, setter;
JSClass *clasp;
fun = JS_ValueToFunction(cx, argv[1]);
if (!fun)
return JS_FALSE;
argv[1] = OBJECT_TO_JSVAL(fun->object);
/*
* Lock the world while we look in obj. Be sure to return via goto out
* on error, so we unlock.
*/
rt = cx->runtime;
JS_LOCK_RUNTIME(rt);
/* Compute the unique int/atom symbol id needed by js_LookupProperty. */
userid = argv[0];
if (JSVAL_IS_INT(userid)) {
symid = userid;
atom = NULL;
} else {
atom = js_ValueToStringAtom(cx, userid);
if (!atom) {
ok = JS_FALSE;
goto out;
}
symid = (jsval)atom;
}
ok = js_LookupProperty(cx, obj, symid, &obj, &prop);
if (atom)
js_DropAtom(cx, atom);
if (!ok)
goto out;
/* Set propid from the property, in case it has a tinyid. */
if (prop) {
propid = prop->id;
getter = prop->getter;
setter = prop->setter;
value = prop->object->slots[prop->slot];
} else {
propid = userid;
clasp = obj->map->clasp;
getter = clasp->getProperty;
setter = clasp->setProperty;
value = JSVAL_VOID;
}
/*
* Security policy is implemented in getters and setters, so we have to
* call get and set here to let the JS API client check for a watchpoint
* that crosses a trust boundary.
* XXX assumes get and set are idempotent, should use a clasp->watch hook
*/
ok = getter(cx, obj, propid, &value) && setter(cx, obj, propid, &value);
if (!ok)
goto out;
/* Finally, call into jsdbgapi.c to set the watchpoint on userid. */
ok = JS_SetWatchPoint(cx, obj, userid, obj_watch_handler, fun->object);
out:
JS_UNLOCK_RUNTIME(rt);
return ok;
}
JSBool XPCIDispatchExtension::DefineProperty(XPCCallContext & ccx,
JSObject *obj, jsval idval,
XPCWrappedNative* wrapperToReflectInterfaceNames,
uintN propFlags, JSBool* resolved)
{
if(!JSVAL_IS_STRING(idval))
return JS_FALSE;
// Look up the native interface for IDispatch and then find a tearoff
XPCNativeInterface* iface = XPCNativeInterface::GetNewOrUsed(ccx,
"IDispatch");
// The native interface isn't defined so just exit with an error
if(iface == nsnull)
return JS_FALSE;
XPCWrappedNativeTearOff* to =
wrapperToReflectInterfaceNames->LocateTearOff(ccx, iface);
// This object has no IDispatch interface so bail.
if(to == nsnull)
return JS_FALSE;
// Look up the member in the interface
const XPCDispInterface::Member * member = to->GetIDispatchInfo()->FindMember(idval);
if(!member)
{
// IDispatch is case insensitive, so if we don't find a case sensitive
// match, we'll try a more expensive case-insensisitive search
// TODO: We need to create cleaner solution that doesn't create
// multiple properties of different case on the JS Object
member = to->GetIDispatchInfo()->FindMemberCI(ccx, idval);
if(!member)
return JS_FALSE;
}
// Get the function object
jsval funval;
if(!member->GetValue(ccx, iface, &funval))
return JS_FALSE;
// Protect the jsval
AUTO_MARK_JSVAL(ccx, funval);
// clone a function we can use for this object
JSObject* funobj = xpc_CloneJSFunction(ccx, JSVAL_TO_OBJECT(funval), obj);
if(!funobj)
return JS_FALSE;
jsid id;
// If this is a function or a parameterized property
if(member->IsFunction() || member->IsParameterizedProperty())
{
// define the function on the object
AutoResolveName arn(ccx, idval);
if(resolved)
*resolved = JS_TRUE;
return JS_ValueToId(ccx, idval, &id) &&
OBJ_DEFINE_PROPERTY(ccx, obj, id, OBJECT_TO_JSVAL(funobj),
nsnull, nsnull, propFlags, nsnull);
}
// Define the property on the object
NS_ASSERTION(member->IsProperty(), "way broken!");
propFlags |= JSPROP_GETTER | JSPROP_SHARED;
if(member->IsSetter())
{
propFlags |= JSPROP_SETTER;
propFlags &= ~JSPROP_READONLY;
}
AutoResolveName arn(ccx, idval);
if(resolved)
*resolved = JS_TRUE;
return JS_ValueToId(ccx, idval, &id) &&
OBJ_DEFINE_PROPERTY(ccx, obj, id, JSVAL_VOID,
(JSPropertyOp) funobj,
(JSPropertyOp) funobj,
propFlags, nsnull);
}
jsval CStdDeserializer::ReadScriptVal(JSObject* appendParent)
{
JSContext* cx = m_ScriptInterface.GetContext();
uint8_t type;
NumberU8_Unbounded("type", type);
switch (type)
{
case SCRIPT_TYPE_VOID:
return JSVAL_VOID;
case SCRIPT_TYPE_NULL:
return JSVAL_NULL;
case SCRIPT_TYPE_ARRAY:
case SCRIPT_TYPE_OBJECT:
{
JSObject* obj;
if (appendParent)
obj = appendParent;
else if (type == SCRIPT_TYPE_ARRAY)
obj = JS_NewArrayObject(cx, 0, NULL);
else
obj = JS_NewObject(cx, NULL, NULL, NULL);
if (!obj)
throw PSERROR_Deserialize_ScriptError();
CScriptValRooted objRoot(cx, OBJECT_TO_JSVAL(obj));
AddScriptBackref(obj);
uint32_t numProps;
NumberU32_Unbounded("num props", numProps);
for (uint32_t i = 0; i < numProps; ++i)
{
utf16string propname;
ReadStringUTF16(propname);
jsval propval = ReadScriptVal(NULL);
CScriptValRooted propvalRoot(cx, propval);
if (!JS_SetUCProperty(cx, obj, (const jschar*)propname.data(), propname.length(), &propval))
throw PSERROR_Deserialize_ScriptError();
}
return OBJECT_TO_JSVAL(obj);
}
case SCRIPT_TYPE_STRING:
{
JSString* str;
ScriptString("string", str);
return STRING_TO_JSVAL(str);
}
case SCRIPT_TYPE_INT:
{
int32_t value;
NumberI32("value", value, JSVAL_INT_MIN, JSVAL_INT_MAX);
return INT_TO_JSVAL(value);
}
case SCRIPT_TYPE_DOUBLE:
{
double value;
NumberDouble_Unbounded("value", value);
jsval rval;
if (!JS_NewNumberValue(cx, value, &rval))
throw PSERROR_Deserialize_ScriptError("JS_NewNumberValue failed");
return rval;
}
case SCRIPT_TYPE_BOOLEAN:
{
uint8_t value;
NumberU8("value", value, 0, 1);
return BOOLEAN_TO_JSVAL(value ? JS_TRUE : JS_FALSE);
}
case SCRIPT_TYPE_BACKREF:
{
u32 tag;
NumberU32_Unbounded("tag", tag);
JSObject* obj = GetScriptBackref(tag);
if (!obj)
throw PSERROR_Deserialize_ScriptError("Invalid backref tag");
return OBJECT_TO_JSVAL(obj);
}
default:
throw PSERROR_Deserialize_OutOfBounds();
}
}
static JSBool
CommonConstructor(JSContext *cx, int name, JSObject *obj, uintN argc,
jsval *argv, jsval *rval, PRBool enforceSecurity)
{
XPCCallContext ccx(JS_CALLER, cx, JS_GetGlobalObject(cx));
// Check if IDispatch is enabled, fail if not
if(!nsXPConnect::IsIDispatchEnabled())
{
XPCThrower::Throw(NS_ERROR_XPC_IDISPATCH_NOT_ENABLED, ccx);
return JS_FALSE;
}
XPCJSRuntime *rt = ccx.GetRuntime();
if(!rt)
{
XPCThrower::Throw(NS_ERROR_UNEXPECTED, ccx);
return JS_FALSE;
}
nsIXPCSecurityManager* sm = ccx.GetXPCContext()
->GetAppropriateSecurityManager(nsIXPCSecurityManager::HOOK_CALL_METHOD);
XPCWrappedNative * wrapper = ccx.GetWrapper();
if(sm && NS_FAILED(sm->CanAccess(nsIXPCSecurityManager::ACCESS_CALL_METHOD,
&ccx, ccx, ccx.GetFlattenedJSObject(),
wrapper->GetIdentityObject(),
wrapper->GetClassInfo(),
rt->GetStringJSVal(name),
wrapper->GetSecurityInfoAddr())))
{
// Security manager will have set an exception
return JS_FALSE;
}
// Make sure we were called with one string parameter
if(argc != 1 || (argc == 1 && !JSVAL_IS_STRING(argv[0])))
{
XPCThrower::Throw(NS_ERROR_XPC_COM_INVALID_CLASS_ID, ccx);
return JS_FALSE;
}
JSString* str = JSVAL_TO_STRING(argv[0]);
PRUint32 len = JS_GetStringLength(str);
// Cap constructor argument length to keep from crashing in string
// code.
if(len > XPC_IDISPATCH_CTOR_MAX_ARG_LEN)
{
XPCThrower::Throw(NS_ERROR_XPC_COM_INVALID_CLASS_ID, ccx);
return JS_FALSE;
}
jschar * className = JS_GetStringChars(str);
CComBSTR bstrClassName(len, reinterpret_cast<const WCHAR *>(className));
if(!bstrClassName)
{
XPCThrower::Throw(NS_ERROR_XPC_COM_INVALID_CLASS_ID, ccx);
return JS_FALSE;
}
// Instantiate the desired COM object
CComPtr<IDispatch> pDispatch;
HRESULT rv = XPCDispObject::COMCreateInstance(ccx, bstrClassName,
enforceSecurity, &pDispatch);
if(FAILED(rv))
{
XPCThrower::ThrowCOMError(ccx, rv, NS_ERROR_XPC_COM_CREATE_FAILED);
return JS_FALSE;
}
// Get a wrapper for our object
nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
nsresult nsrv = ccx.GetXPConnect()->WrapNative(
ccx, ccx.GetOperandJSObject(), reinterpret_cast<nsISupports*>(pDispatch.p),
NSID_IDISPATCH, getter_AddRefs(holder));
if(NS_FAILED(nsrv))
{
XPCThrower::Throw(nsrv, ccx);
return JS_FALSE;
}
// get and return the JS object wrapper
JSObject * jsobj;
nsrv = holder->GetJSObject(&jsobj);
if(NS_FAILED(nsrv))
{
XPCThrower::Throw(nsrv, ccx);
return JS_FALSE;
}
*rval = OBJECT_TO_JSVAL(jsobj);
return JS_TRUE;
}
/*
* See:
* https://bugzilla.mozilla.org/show_bug.cgi?id=166436
* https://bugzilla.mozilla.org/show_bug.cgi?id=215173
*
* Very surprisingly, jsapi.h lacks any way to "throw new Error()"
*
* So here is an awful hack inspired by
* http://egachine.berlios.de/embedding-sm-best-practice/embedding-sm-best-practice.html#error-handling
*/
static void
gjs_throw_valist(JSContext *context,
const char *format,
va_list args)
{
char *s;
JSBool result;
jsval v_constructor, v_message;
JSObject *err_obj;
s = g_strdup_vprintf(format, args);
JS_BeginRequest(context);
if (JS_IsExceptionPending(context)) {
/* Often it's unclear whether a given jsapi.h function
* will throw an exception, so we will throw ourselves
* "just in case"; in those cases, we don't want to
* overwrite an exception that already exists.
* (Do log in case our second exception adds more info,
* but don't log as topic ERROR because if the exception is
* caught we don't want an ERROR in the logs.)
*/
gjs_debug(GJS_DEBUG_CONTEXT,
"Ignoring second exception: '%s'",
s);
g_free(s);
JS_EndRequest(context);
return;
}
result = JS_FALSE;
(void)JS_EnterLocalRootScope(context);
if (!gjs_string_from_utf8(context, s, -1, &v_message)) {
JS_ReportError(context, "Failed to copy exception string");
goto out;
}
if (!gjs_object_get_property(context, JS_GetGlobalObject(context),
"Error", &v_constructor)) {
JS_ReportError(context, "??? Missing Error constructor in global object?");
goto out;
}
/* throw new Error(message) */
err_obj = JS_New(context, JSVAL_TO_OBJECT(v_constructor), 1, &v_message);
JS_SetPendingException(context, OBJECT_TO_JSVAL(err_obj));
result = JS_TRUE;
out:
JS_LeaveLocalRootScope(context);
if (!result) {
/* try just reporting it to error handler? should not
* happen though pretty much
*/
JS_ReportError(context,
"Failed to throw exception '%s'",
s);
}
g_free(s);
JS_EndRequest(context);
}
bool js_cocos2dx_spine_SkeletonAnimation_createWithFile(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
bool ok = true;
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; }
spine::SkeletonAnimation* ret = spine::SkeletonAnimation::createWithFile(arg0, arg1);
jsval jsret = JSVAL_NULL;
do {
if (ret) {
js_proxy_t *jsProxy = js_get_or_create_proxy<spine::SkeletonAnimation>(cx, (spine::SkeletonAnimation*)ret);
jsret = OBJECT_TO_JSVAL(jsProxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return true;
}
} 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; }
spine::SkeletonAnimation* ret = spine::SkeletonAnimation::createWithFile(arg0, arg1, arg2);
jsval jsret = JSVAL_NULL;
do {
if (ret) {
js_proxy_t *jsProxy = js_get_or_create_proxy<spine::SkeletonAnimation>(cx, (spine::SkeletonAnimation*)ret);
jsret = OBJECT_TO_JSVAL(jsProxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return true;
}
} 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; }
spAtlas* arg1;
#pragma warning NO CONVERSION TO NATIVE FOR spAtlas*
ok = false;
if (!ok) { ok = true; break; }
spine::SkeletonAnimation* ret = spine::SkeletonAnimation::createWithFile(arg0, arg1);
jsval jsret = JSVAL_NULL;
do {
if (ret) {
js_proxy_t *jsProxy = js_get_or_create_proxy<spine::SkeletonAnimation>(cx, (spine::SkeletonAnimation*)ret);
jsret = OBJECT_TO_JSVAL(jsProxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return true;
}
} 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; }
spine::SkeletonAnimation* ret = spine::SkeletonAnimation::createWithFile(arg0, arg1, arg2);
jsval jsret = JSVAL_NULL;
do {
if (ret) {
js_proxy_t *jsProxy = js_get_or_create_proxy<spine::SkeletonAnimation>(cx, (spine::SkeletonAnimation*)ret);
jsret = OBJECT_TO_JSVAL(jsProxy->obj);
} else {
jsret = JSVAL_NULL;
}
} while (0);
JS_SET_RVAL(cx, vp, jsret);
return true;
}
} while (0);
JS_ReportError(cx, "js_cocos2dx_spine_SkeletonAnimation_createWithFile : wrong number of arguments");
return false;
}
NS_IMETHODIMP
TelemetryImpl::GetChromeHangs(JSContext *cx, jsval *ret)
{
MutexAutoLock hangReportMutex(mHangReportsMutex);
JSObject *reportArray = JS_NewArrayObject(cx, 0, nsnull);
if (!reportArray) {
return NS_ERROR_FAILURE;
}
*ret = OBJECT_TO_JSVAL(reportArray);
// Each hang report is an object in the 'chromeHangs' array
for (size_t i = 0; i < mHangReports.Length(); ++i) {
JSObject *reportObj = JS_NewObject(cx, NULL, NULL, NULL);
if (!reportObj) {
return NS_ERROR_FAILURE;
}
jsval reportObjVal = OBJECT_TO_JSVAL(reportObj);
if (!JS_SetElement(cx, reportArray, i, &reportObjVal)) {
return NS_ERROR_FAILURE;
}
// Record the hang duration (expressed in seconds)
JSBool ok = JS_DefineProperty(cx, reportObj, "duration",
INT_TO_JSVAL(mHangReports[i].duration),
NULL, NULL, JSPROP_ENUMERATE);
if (!ok) {
return NS_ERROR_FAILURE;
}
// Represent call stack PCs as strings
// (JS can't represent all 64-bit integer values)
JSObject *pcArray = JS_NewArrayObject(cx, 0, nsnull);
if (!pcArray) {
return NS_ERROR_FAILURE;
}
ok = JS_DefineProperty(cx, reportObj, "stack", OBJECT_TO_JSVAL(pcArray),
NULL, NULL, JSPROP_ENUMERATE);
if (!ok) {
return NS_ERROR_FAILURE;
}
const PRUint32 pcCount = mHangReports[i].callStack.Length();
for (size_t pcIndex = 0; pcIndex < pcCount; ++pcIndex) {
nsCAutoString pcString;
pcString.AppendPrintf("0x%p", mHangReports[i].callStack[pcIndex]);
JSString *str = JS_NewStringCopyZ(cx, pcString.get());
if (!str) {
return NS_ERROR_FAILURE;
}
jsval v = STRING_TO_JSVAL(str);
if (!JS_SetElement(cx, pcArray, pcIndex, &v)) {
return NS_ERROR_FAILURE;
}
}
// Record memory map info
JSObject *moduleArray = JS_NewArrayObject(cx, 0, nsnull);
if (!moduleArray) {
return NS_ERROR_FAILURE;
}
ok = JS_DefineProperty(cx, reportObj, "memoryMap",
OBJECT_TO_JSVAL(moduleArray),
NULL, NULL, JSPROP_ENUMERATE);
if (!ok) {
return NS_ERROR_FAILURE;
}
const PRUint32 moduleCount = mHangReports[i].moduleMap.GetSize();
for (size_t moduleIndex = 0; moduleIndex < moduleCount; ++moduleIndex) {
// Current module
const SharedLibrary &module =
mHangReports[i].moduleMap.GetEntry(moduleIndex);
JSObject *moduleInfoArray = JS_NewArrayObject(cx, 0, nsnull);
if (!moduleInfoArray) {
return NS_ERROR_FAILURE;
}
jsval val = OBJECT_TO_JSVAL(moduleInfoArray);
if (!JS_SetElement(cx, moduleArray, moduleIndex, &val)) {
return NS_ERROR_FAILURE;
}
// Start address
nsCAutoString addressString;
addressString.AppendPrintf("0x%p", module.GetStart());
JSString *str = JS_NewStringCopyZ(cx, addressString.get());
if (!str) {
return NS_ERROR_FAILURE;
}
val = STRING_TO_JSVAL(str);
if (!JS_SetElement(cx, moduleInfoArray, 0, &val)) {
return NS_ERROR_FAILURE;
}
// Module name
str = JS_NewStringCopyZ(cx, module.GetName());
if (!str) {
return NS_ERROR_FAILURE;
}
val = STRING_TO_JSVAL(str);
if (!JS_SetElement(cx, moduleInfoArray, 1, &val)) {
return NS_ERROR_FAILURE;
}
// Module size in memory
val = INT_TO_JSVAL(int32_t(module.GetEnd() - module.GetStart()));
if (!JS_SetElement(cx, moduleInfoArray, 2, &val)) {
return NS_ERROR_FAILURE;
}
// "PDB Age" identifier
val = INT_TO_JSVAL(0);
#if defined(MOZ_PROFILING) && defined(XP_WIN)
val = INT_TO_JSVAL(module.GetPdbAge());
#endif
if (!JS_SetElement(cx, moduleInfoArray, 3, &val)) {
return NS_ERROR_FAILURE;
}
// "PDB Signature" GUID
char guidString[NSID_LENGTH] = { 0 };
#if defined(MOZ_PROFILING) && defined(XP_WIN)
module.GetPdbSignature().ToProvidedString(guidString);
#endif
str = JS_NewStringCopyZ(cx, guidString);
if (!str) {
return NS_ERROR_FAILURE;
}
val = STRING_TO_JSVAL(str);
if (!JS_SetElement(cx, moduleInfoArray, 4, &val)) {
return NS_ERROR_FAILURE;
}
}
}
return NS_OK;
}
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;
}
static JSBool
Exception(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSBool ok;
jsval pval;
uint32 lineno;
JSString *message, *filename;
JSStackFrame *fp;
if (cx->creatingException)
return JS_FALSE;
cx->creatingException = JS_TRUE;
if (!(cx->fp->flags & JSFRAME_CONSTRUCTING)) {
/*
* ECMA ed. 3, 15.11.1 requires Error, etc., to construct even when
* called as functions, without operator new. But as we do not give
* each constructor a distinct JSClass, whose .name member is used by
* js_NewObject to find the class prototype, we must get the class
* prototype ourselves.
*/
ok = OBJ_GET_PROPERTY(cx, JSVAL_TO_OBJECT(argv[-2]),
ATOM_TO_JSID(cx->runtime->atomState
.classPrototypeAtom),
&pval);
if (!ok)
goto out;
obj = js_NewObject(cx, &ExceptionClass, JSVAL_TO_OBJECT(pval), NULL);
if (!obj) {
ok = JS_FALSE;
goto out;
}
*rval = OBJECT_TO_JSVAL(obj);
}
/*
* If it's a new object of class Exception, then null out the private
* data so that the finalizer doesn't attempt to free it.
*/
if (OBJ_GET_CLASS(cx, obj) == &ExceptionClass)
OBJ_SET_SLOT(cx, obj, JSSLOT_PRIVATE, JSVAL_VOID);
/* Set the 'message' property. */
if (argc != 0) {
message = js_ValueToString(cx, argv[0]);
if (!message) {
ok = JS_FALSE;
goto out;
}
argv[0] = STRING_TO_JSVAL(message);
} else {
message = cx->runtime->emptyString;
}
/* Set the 'fileName' property. */
if (argc > 1) {
filename = js_ValueToString(cx, argv[1]);
if (!filename) {
ok = JS_FALSE;
goto out;
}
argv[1] = STRING_TO_JSVAL(filename);
fp = NULL;
} else {
fp = JS_GetScriptedCaller(cx, NULL);
if (fp) {
filename = FilenameToString(cx, fp->script->filename);
if (!filename) {
ok = JS_FALSE;
goto out;
}
} else {
filename = cx->runtime->emptyString;
}
}
/* Set the 'lineNumber' property. */
if (argc > 2) {
ok = js_ValueToECMAUint32(cx, argv[2], &lineno);
if (!ok)
goto out;
} else {
if (!fp)
fp = JS_GetScriptedCaller(cx, NULL);
lineno = (fp && fp->pc) ? js_PCToLineNumber(cx, fp->script, fp->pc) : 0;
}
ok = InitExceptionObject(cx, obj, message, filename, lineno);
out:
cx->creatingException = JS_FALSE;
return ok;
}
JSBool
Library::Declare(JSContext* cx, uintN argc, jsval* vp)
{
JSObject* obj = JS_THIS_OBJECT(cx, vp);
if (!obj || !IsLibrary(cx, obj)) {
JS_ReportError(cx, "not a library");
return JS_FALSE;
}
PRLibrary* library = GetLibrary(cx, obj);
if (!library) {
JS_ReportError(cx, "library not open");
return JS_FALSE;
}
// We allow two API variants:
// 1) library.declare(name, abi, returnType, argType1, ...)
// declares a function with the given properties, and resolves the symbol
// address in the library.
// 2) library.declare(name, type)
// declares a symbol of 'type', and resolves it. The object that comes
// back will be of type 'type', and will point into the symbol data.
// This data will be both readable and writable via the usual CData
// accessors. If 'type' is a PointerType to a FunctionType, the result will
// be a function pointer, as with 1).
if (argc < 2) {
JS_ReportError(cx, "declare requires at least two arguments");
return JS_FALSE;
}
jsval* argv = JS_ARGV(cx, vp);
if (!JSVAL_IS_STRING(argv[0])) {
JS_ReportError(cx, "first argument must be a string");
return JS_FALSE;
}
JSObject* fnObj = NULL;
JSObject* typeObj;
js::AutoObjectRooter root(cx);
bool isFunction = argc > 2;
if (isFunction) {
// Case 1).
// Create a FunctionType representing the function.
fnObj = FunctionType::CreateInternal(cx,
argv[1], argv[2], &argv[3], argc - 3);
if (!fnObj)
return JS_FALSE;
root.setObject(fnObj);
// Make a function pointer type.
typeObj = PointerType::CreateInternal(cx, fnObj);
if (!typeObj)
return JS_FALSE;
root.setObject(typeObj);
} else {
// Case 2).
if (JSVAL_IS_PRIMITIVE(argv[1]) ||
!CType::IsCType(cx, JSVAL_TO_OBJECT(argv[1])) ||
!CType::IsSizeDefined(cx, JSVAL_TO_OBJECT(argv[1]))) {
JS_ReportError(cx, "second argument must be a type of defined size");
return JS_FALSE;
}
typeObj = JSVAL_TO_OBJECT(argv[1]);
if (CType::GetTypeCode(cx, typeObj) == TYPE_pointer) {
fnObj = PointerType::GetBaseType(cx, typeObj);
isFunction = fnObj && CType::GetTypeCode(cx, fnObj) == TYPE_function;
}
}
void* data;
PRFuncPtr fnptr;
JSString* nameStr = JSVAL_TO_STRING(argv[0]);
AutoCString symbol;
if (isFunction) {
// Build the symbol, with mangling if necessary.
FunctionType::BuildSymbolName(cx, nameStr, fnObj, symbol);
AppendString(symbol, "\0");
// Look up the function symbol.
fnptr = PR_FindFunctionSymbol(library, symbol.begin());
if (!fnptr) {
JS_ReportError(cx, "couldn't find function symbol in library");
return JS_FALSE;
}
data = &fnptr;
} else {
// 'typeObj' is another data type. Look up the data symbol.
AppendString(symbol, nameStr);
AppendString(symbol, "\0");
data = PR_FindSymbol(library, symbol.begin());
if (!data) {
JS_ReportError(cx, "couldn't find symbol in library");
return JS_FALSE;
}
}
JSObject* result = CData::Create(cx, typeObj, obj, data, isFunction);
if (!result)
return JS_FALSE;
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(result));
// Seal the CData object, to prevent modification of the function pointer.
// This permanently associates this object with the library, and avoids
// having to do things like reset SLOT_REFERENT when someone tries to
// change the pointer value.
// XXX This will need to change when bug 541212 is fixed -- CData::ValueSetter
// could be called on a sealed object.
if (isFunction && !JS_FreezeObject(cx, result))
return JS_FALSE;
return JS_TRUE;
}
JSBool
js_ErrorToException(JSContext *cx, const char *message, JSErrorReport *reportp)
{
JSErrNum errorNumber;
JSExnType exn;
JSBool ok;
JSObject *errProto, *errObject;
JSString *messageStr, *filenameStr;
uintN lineno;
JSExnPrivate *privateData;
const JSErrorFormatString *errorString;
/*
* Tell our caller to report immediately if cx has no active frames, or if
* this report is just a warning.
*/
JS_ASSERT(reportp);
if (!cx->fp || JSREPORT_IS_WARNING(reportp->flags))
return JS_FALSE;
/* Find the exception index associated with this error. */
errorNumber = (JSErrNum) reportp->errorNumber;
errorString = js_GetLocalizedErrorMessage(cx, NULL, NULL, errorNumber);
exn = errorString ? errorString->exnType : JSEXN_NONE;
JS_ASSERT(exn < JSEXN_LIMIT);
#if defined( DEBUG_mccabe ) && defined ( PRINTNAMES )
/* Print the error name and the associated exception name to stderr */
fprintf(stderr, "%s\t%s\n",
errortoexnname[errorNumber].name,
errortoexnname[errorNumber].exception);
#endif
/*
* Return false (no exception raised) if no exception is associated
* with the given error number.
*/
if (exn == JSEXN_NONE)
return JS_FALSE;
/*
* Prevent runaway recursion, just as the Exception native constructor
* must do, via cx->creatingException. If an out-of-memory error occurs,
* no exception object will be created, but we don't assume that OOM is
* the only kind of error that subroutines of this function called below
* might raise.
*/
if (cx->creatingException)
return JS_FALSE;
cx->creatingException = JS_TRUE;
/* Protect the newly-created strings below from nesting GCs. */
ok = js_EnterLocalRootScope(cx);
if (!ok)
goto out;
/*
* Try to get an appropriate prototype by looking up the corresponding
* exception constructor name in the scope chain of the current context's
* top stack frame, or in the global object if no frame is active.
*/
ok = js_GetClassPrototype(cx, exceptions[exn].name, &errProto);
if (!ok)
goto out;
errObject = js_NewObject(cx, &ExceptionClass, errProto, NULL);
if (!errObject) {
ok = JS_FALSE;
goto out;
}
/*
* Set the generated Exception object early, so it won't be GC'd by a last
* ditch attempt to collect garbage, or a GC that otherwise nests or races
* under any of the following calls. If one of the following calls fails,
* it will overwrite this exception object with one of its own (except in
* case of OOM errors, of course).
*/
JS_SetPendingException(cx, OBJECT_TO_JSVAL(errObject));
messageStr = JS_NewStringCopyZ(cx, message);
if (!messageStr) {
ok = JS_FALSE;
goto out;
}
if (reportp) {
filenameStr = JS_NewStringCopyZ(cx, reportp->filename);
if (!filenameStr) {
ok = JS_FALSE;
goto out;
}
lineno = reportp->lineno;
} else {
filenameStr = cx->runtime->emptyString;
lineno = 0;
}
ok = InitExceptionObject(cx, errObject, messageStr, filenameStr, lineno);
if (!ok)
goto out;
/*
* Construct a new copy of the error report struct, and store it in the
* exception object's private data. We can't use the error report struct
* that was passed in, because it's stack-allocated, and also because it
* may point to transient data in the JSTokenStream.
*/
privateData = exn_newPrivate(cx, reportp);
if (!privateData) {
ok = JS_FALSE;
goto out;
}
OBJ_SET_SLOT(cx, errObject, JSSLOT_PRIVATE, PRIVATE_TO_JSVAL(privateData));
/* Flag the error report passed in to indicate an exception was raised. */
reportp->flags |= JSREPORT_EXCEPTION;
out:
js_LeaveLocalRootScope(cx);
cx->creatingException = JS_FALSE;
return ok;
}
// static
nsresult
Key::DecodeJSValInternal(const unsigned char*& aPos, const unsigned char* aEnd,
JSContext* aCx, uint8_t aTypeOffset, jsval* aVal,
uint16_t aRecursionDepth)
{
NS_ENSURE_TRUE(aRecursionDepth < MaxRecursionDepth, NS_ERROR_DOM_INDEXEDDB_DATA_ERR);
if (*aPos - aTypeOffset >= eArray) {
JS::Rooted<JSObject*> array(aCx, JS_NewArrayObject(aCx, 0, nullptr));
if (!array) {
NS_WARNING("Failed to make array!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
aTypeOffset += eMaxType;
if (aTypeOffset == eMaxType * MaxArrayCollapse) {
++aPos;
aTypeOffset = 0;
}
uint32_t index = 0;
while (aPos < aEnd && *aPos - aTypeOffset != eTerminator) {
JS::Rooted<JS::Value> val(aCx);
nsresult rv = DecodeJSValInternal(aPos, aEnd, aCx, aTypeOffset,
val.address(), aRecursionDepth + 1);
NS_ENSURE_SUCCESS(rv, rv);
aTypeOffset = 0;
if (!JS_SetElement(aCx, array, index++, val.address())) {
NS_WARNING("Failed to set array element!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
}
NS_ASSERTION(aPos >= aEnd || (*aPos % eMaxType) == eTerminator,
"Should have found end-of-array marker");
++aPos;
*aVal = OBJECT_TO_JSVAL(array);
}
else if (*aPos - aTypeOffset == eString) {
nsString key;
DecodeString(aPos, aEnd, key);
if (!xpc::StringToJsval(aCx, key, aVal)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
}
else if (*aPos - aTypeOffset == eDate) {
double msec = static_cast<double>(DecodeNumber(aPos, aEnd));
JSObject* date = JS_NewDateObjectMsec(aCx, msec);
if (!date) {
NS_WARNING("Failed to make date!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
*aVal = OBJECT_TO_JSVAL(date);
}
else if (*aPos - aTypeOffset == eFloat) {
*aVal = DOUBLE_TO_JSVAL(DecodeNumber(aPos, aEnd));
}
else {
NS_NOTREACHED("Unknown key type!");
}
return NS_OK;
}
// any getUniform(WebGLProgram? program, WebGLUniformLocation? location);
bool JSB_glGetUniformfv(JSContext *cx, uint32_t argc, jsval *vp)
{
JSB_PRECONDITION2( argc == 2, cx, false, "JSB_glGetUniformfv: Invalid number of arguments" );
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
uint32_t arg0, arg1;
ok &= jsval_to_uint( cx, args.get(0), &arg0 );
ok &= jsval_to_uint( cx, args.get(1), &arg1 );
JSB_PRECONDITION2(ok, cx, false, "JSB_glGetUniformfv: Error processing arguments");
GLint activeUniforms;
glGetProgramiv(arg0, GL_ACTIVE_UNIFORMS, &activeUniforms);
GLsizei length;
glGetProgramiv(arg0, GL_ACTIVE_UNIFORM_MAX_LENGTH, &length);
GLchar* namebuffer = new GLchar[length+1];
GLint size = -1;
GLenum type = -1;
bool isLocationFound = false;
for(int i = 0; i < activeUniforms; ++i)
{
glGetActiveUniform(arg0, i, length, NULL, &size, &type, namebuffer);
if(arg1 == glGetUniformLocation(arg0, namebuffer))
{
isLocationFound = true;
break;
}
}
if(!isLocationFound)
{
size = -1;
type = -1;
}
CC_SAFE_DELETE_ARRAY(namebuffer);
int usize = 0;
int utype = 0;
switch(type) {
// float
case GL_FLOAT:
usize = 1;
utype = GL_FLOAT;
break;
case GL_FLOAT_MAT2:
usize = 2 * 2;
utype = GL_FLOAT;
break;
case GL_FLOAT_MAT3:
usize = 3 * 3;
utype = GL_FLOAT;
break;
case GL_FLOAT_MAT4:
usize = 4 * 4;
utype = GL_FLOAT;
break;
case GL_FLOAT_VEC2:
usize = 2;
utype = GL_FLOAT;
break;
case GL_FLOAT_VEC3:
usize = 3;
utype = GL_FLOAT;
break;
case GL_FLOAT_VEC4:
usize = 4;
utype = GL_FLOAT;
break;
// int
case GL_INT:
usize = 1;
utype = GL_INT;
break;
case GL_INT_VEC2:
usize = 1;
utype = GL_INT;
break;
case GL_INT_VEC3:
usize = 1;
utype = GL_INT;
break;
case GL_INT_VEC4:
usize = 1;
utype = GL_INT;
break;
default:
JSB_PRECONDITION2(false, cx, false, "JSB_glGetUniformfv: Uniform Type not supported");
}
JSObject *typedArray = NULL;
if( utype == GL_FLOAT) {
// FIXME: glew on windows will cause array overflow after invoking glGetUniformfv.
// It seems that glGetUniformfv re-assign the memeroy with a wrong size which is 4x than we pass in.
// For temporary solution, we allocate 4x array.
GLfloat* param = new GLfloat[usize*4];
glGetUniformfv(arg0, arg1, param);
typedArray = JS_NewFloat32Array(cx, usize);
float *buffer = (float*)JS_GetArrayBufferViewData(typedArray);
memcpy( buffer, param, sizeof(float) * usize);
CC_SAFE_DELETE_ARRAY(param);
} else if( utype == GL_INT ) {
// FIXME: glew on windows will cause array overflow after invoking glGetUniformfv.
// It seems that glGetUniformfv re-assign the memeroy with a wrong size which is 4x than we pass in.
// For temporary solution, we allocate 4x array.
GLint* param = new GLint[usize*4];
glGetUniformiv(arg0, arg1, param);
typedArray = JS_NewInt32Array(cx, usize);
GLint *buffer = (GLint*)JS_GetArrayBufferViewData(typedArray);
memcpy( buffer, param, sizeof(GLint) * usize);
CC_SAFE_DELETE_ARRAY(param);
}
args.rval().set(OBJECT_TO_JSVAL(typedArray));
return true;
}
jsval as_jsval(JSContext *cx, JSVButtonBox::OWNERPTR theOwner, JSVButtonBox::NATIVE * theNative) {
JSObject * myReturnObject = JSVButtonBox::Construct(cx, theOwner, theNative);
return OBJECT_TO_JSVAL(myReturnObject);
}
static void getJSTouchObject(JSContext *cx, Touch *x, jsval &jsret) {
js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::Touch>(cx, x);
jsret = OBJECT_TO_JSVAL(proxy->obj);
}
bool js_cocos2dx_extension_EventListenerAssetsManagerEx_create(JSContext *cx, uint32_t argc, jsval *vp)
{
JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
bool ok = true;
if (argc == 2) {
cocos2d::extension::AssetsManagerEx* arg0 = nullptr;
std::function<void (cocos2d::extension::EventAssetsManagerEx *)> arg1;
do {
if (args.get(0).isNull()) { arg0 = nullptr; break; }
if (!args.get(0).isObject()) { ok = false; break; }
js_proxy_t *jsProxy;
JS::RootedObject tmpObj(cx, args.get(0).toObjectOrNull());
jsProxy = jsb_get_js_proxy(tmpObj);
arg0 = (cocos2d::extension::AssetsManagerEx*)(jsProxy ? jsProxy->ptr : NULL);
JSB_PRECONDITION2( arg0, cx, false, "Invalid Native Object");
} while (0);
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)));
auto lambda = [=](cocos2d::extension::EventAssetsManagerEx* larg0) -> void {
JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET
jsval largv[1];
do {
if (larg0) {
js_type_class_t* typeClass = js_get_type_from_native<cocos2d::extension::EventAssetsManagerEx>(larg0);
largv[0] = OBJECT_TO_JSVAL(jsb_get_or_create_weak_jsobject(cx, larg0, typeClass, "cocos2d::extension::EventAssetsManagerEx"));
} else {
largv[0] = JSVAL_NULL;
}
} while (0);
JS::RootedValue rval(cx);
bool succeed = func->invoke(1, &largv[0], &rval);
if (!succeed && JS_IsExceptionPending(cx)) {
JS_ReportPendingException(cx);
}
removeJSObject(cx, larg0);
};
arg1 = lambda;
}
else
{
arg1 = nullptr;
}
} while(0)
;
JSB_PRECONDITION2(ok, cx, false, "js_cocos2dx_extension_EventListenerAssetsManagerEx_create : Error processing arguments");
cocos2d::extension::EventListenerAssetsManagerEx* ret = cocos2d::extension::EventListenerAssetsManagerEx::create(arg0, arg1);
jsval jsret = JSVAL_NULL;
if (ret) {
JS::RootedObject jsobj(cx, js_get_or_create_jsobject<cocos2d::extension::EventListenerAssetsManagerEx>(cx, ret));
jsret = OBJECT_TO_JSVAL(jsobj);
} else {
jsret = JSVAL_NULL;
}
args.rval().set(jsret);
return true;
}
JS_ReportError(cx, "js_cocos2dx_extension_EventListenerAssetsManagerEx_create : wrong number of arguments");
return false;
}
// any getUniform(WebGLProgram? program, WebGLUniformLocation? location);
JSBool JSB_glGetUniformfv(JSContext *cx, uint32_t argc, jsval *vp)
{
JSB_PRECONDITION2( argc == 2, cx, JS_FALSE, "JSB_glGetUniformfv: Invalid number of arguments" );
jsval *argvp = JS_ARGV(cx,vp);
JSBool ok = JS_TRUE;
uint32_t arg0, arg1;
ok &= jsval_to_uint( cx, *argvp++, &arg0 );
ok &= jsval_to_uint( cx, *argvp++, &arg1 );
JSB_PRECONDITION2(ok, cx, JS_FALSE, "JSB_glGetUniformfv: Error processing arguments");
GLsizei length;
glGetProgramiv(arg0, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &length);
GLchar* namebuffer = new GLchar[length];
GLint size = -1;
GLenum type = -1;
glGetActiveUniform(arg0, arg1, length, NULL, &size, &type, namebuffer);
CC_SAFE_DELETE_ARRAY(namebuffer);
int usize = 0;
int utype = 0;
switch(type) {
// float
case GL_FLOAT:
usize = 1;
utype = GL_FLOAT;
break;
case GL_FLOAT_MAT2:
usize = 2 * 2;
utype = GL_FLOAT;
break;
case GL_FLOAT_MAT3:
usize = 3 * 3;
utype = GL_FLOAT;
break;
case GL_FLOAT_MAT4:
usize = 4 * 4;
utype = GL_FLOAT;
break;
case GL_FLOAT_VEC2:
usize = 2;
utype = GL_FLOAT;
break;
case GL_FLOAT_VEC3:
usize = 3;
utype = GL_FLOAT;
break;
case GL_FLOAT_VEC4:
usize = 4;
utype = GL_FLOAT;
break;
// int
case GL_INT:
usize = 1;
utype = GL_INT;
break;
case GL_INT_VEC2:
usize = 1;
utype = GL_INT;
break;
case GL_INT_VEC3:
usize = 1;
utype = GL_INT;
break;
case GL_INT_VEC4:
usize = 1;
utype = GL_INT;
break;
default:
JSB_PRECONDITION2(false, cx, JS_FALSE, "JSB_glGetUniformfv: Uniform Type not supported");
}
JSObject *typedArray = NULL;
if( utype == GL_FLOAT) {
GLfloat* param = new GLfloat[usize];
glGetUniformfv(arg0, arg1, param);
typedArray = JS_NewFloat32Array(cx, usize);
float *buffer = (float*)JS_GetArrayBufferViewData(typedArray);
memcpy( buffer, param, sizeof(float) * usize);
CC_SAFE_DELETE_ARRAY(param);
} else if( utype == GL_INT ) {
GLint* param = new GLint[usize];
glGetUniformiv(arg0, arg1, param);
typedArray = JS_NewInt32Array(cx, usize);
GLint *buffer = (GLint*)JS_GetArrayBufferViewData(typedArray);
memcpy( buffer, param, sizeof(GLint) * usize);
CC_SAFE_DELETE_ARRAY(param);
}
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(typedArray));
return JS_TRUE;
}