void JSArmatureWrapper::addArmatureFileInfoAsyncCallbackFunc(float percent)
{
JSContext *cx = ScriptingCore::getInstance()->getGlobalContext();
JSObject *thisObj = JSVAL_IS_VOID(_jsThisObj) ? NULL : JSVAL_TO_OBJECT(_jsThisObj);
jsval retval;
if (_jsCallback != JSVAL_VOID)
{
jsval percentVal = DOUBLE_TO_JSVAL(percent);
JS_AddValueRoot(cx, &percentVal);
JSB_AUTOCOMPARTMENT_WITH_GLOBAL_OBJCET
JS_CallFunctionValue(cx, thisObj, _jsCallback, 1, &percentVal, &retval);
JS_RemoveValueRoot(cx, &percentVal);
}
}
/**
* Get a field of an object as an object.
*
* If the field does not exist, create it. If it exists but is not an
* object, throw a JS error.
*/
JSObject *GetOrCreateObjectProperty(JSContext *cx, JSObject *aObject,
const char *aProperty)
{
jsval val;
if (JS_GetProperty(cx, aObject, aProperty, &val)
&& !JSVAL_IS_VOID(val)) {
if (JSVAL_IS_OBJECT(val)) {
return JSVAL_TO_OBJECT(val);
}
else {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
JSMSG_UNEXPECTED_TYPE, aProperty, "not an object");
return NULL;
}
}
return JS_DefineObject(cx, aObject, aProperty, NULL, NULL, JSPROP_ENUMERATE);
}
void CConsole::ProcessBuffer(const wchar_t* szLine)
{
if (szLine == NULL) return;
if (wcslen(szLine) <= 0) return;
ENSURE(wcslen(szLine) < CONSOLE_BUFFER_SIZE);
m_deqBufHistory.push_front(szLine);
SaveHistory(); // Do this each line for the moment; if a script causes
// a crash it's a useful record.
// Process it as JavaScript
jsval rval = g_ScriptingHost.ExecuteScript(szLine, L"Console");
if (!JSVAL_IS_VOID(rval))
InsertMessage(L"%ls", g_ScriptingHost.GetScriptInterface().ToString(rval).c_str());
}
SV* PJS_GetPassport(
pTHX_
JSContext *cx,
JSObject *thing
) {
jsval temp;
SV *box;
SV *tref;
JSObject *inboxed;
if(!JS_LookupPropertyWithFlags(cx, thing, PJS_PASSPORT_PROP, 0, &temp)
|| JSVAL_IS_VOID(temp) || JSVAL_IS_NULL(temp))
croak("Can't get passport");
box = (SV *)JS_GetPrivate(cx, JSVAL_TO_OBJECT(temp));
tref = *av_fetch((AV *)SvRV(box), 0, 0);
inboxed = INT2PTR(JSObject *, SvIV((SV *)SvRV(tref)));
assert(inboxed == thing);
return box;
}
static JSBool
propertyOp(const char *name, JSContext *cx, JSObject *obj, jsval id,
jsval *vp)
{
if (resolverHasMethod(cx, obj, name)) {
jsval rval;
jsval args[2];
args[0] = id;
args[1] = *vp;
if (!delegateToResolver(cx, obj, name, 2, args, &rval))
return JS_FALSE;
if (!JSVAL_IS_VOID(rval))
*vp = rval;
return JS_TRUE;
}
return JS_PropertyStub(cx, obj, id, vp);
}
// static
nsresult
IDBKeyRange::FromJSVal(JSContext* aCx,
const jsval& aVal,
IDBKeyRange** aKeyRange)
{
nsresult rv;
nsRefPtr<IDBKeyRange> keyRange;
if (JSVAL_IS_VOID(aVal) || JSVAL_IS_NULL(aVal)) {
// undefined and null returns no IDBKeyRange.
}
else if (JSVAL_IS_PRIMITIVE(aVal) ||
JS_IsArrayObject(aCx, JSVAL_TO_OBJECT(aVal)) ||
JS_ObjectIsDate(aCx, JSVAL_TO_OBJECT(aVal))) {
// A valid key returns an 'only' IDBKeyRange.
keyRange = new IDBKeyRange(false, false, true);
rv = GetKeyFromJSVal(aCx, aVal, keyRange->Lower());
if (NS_FAILED(rv)) {
return rv;
}
}
else {
// An object is not permitted unless it's another IDBKeyRange.
nsIXPConnect* xpc = nsContentUtils::XPConnect();
NS_ASSERTION(xpc, "This should never be null!");
nsCOMPtr<nsIXPConnectWrappedNative> wrapper;
rv = xpc->GetWrappedNativeOfJSObject(aCx, JSVAL_TO_OBJECT(aVal),
getter_AddRefs(wrapper));
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
nsCOMPtr<nsIIDBKeyRange> iface;
if (!wrapper || !(iface = do_QueryInterface(wrapper->Native()))) {
// Some random JS object?
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
keyRange = static_cast<IDBKeyRange*>(iface.get());
}
keyRange.forget(aKeyRange);
return NS_OK;
}
NS_IMETHODIMP
LockedFile::GetMetadata(const jsval& aParameters,
JSContext* aCx,
nsIDOMFileRequest** _retval)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (!IsOpen()) {
return NS_ERROR_DOM_FILEHANDLE_LOCKEDFILE_INACTIVE_ERR;
}
// Do nothing if the window is closed
if (!GetOwner()) {
return NS_OK;
}
nsRefPtr<MetadataParameters> params = new MetadataParameters();
// Get optional arguments.
if (!JSVAL_IS_VOID(aParameters) && !JSVAL_IS_NULL(aParameters)) {
nsresult rv = params->Init(aCx, &aParameters);
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
if (!params->IsConfigured()) {
return NS_ERROR_TYPE_ERR;
}
}
else {
params->Init(true, true);
}
nsRefPtr<FileRequest> fileRequest = GenerateFileRequest();
NS_ENSURE_TRUE(fileRequest, NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
nsRefPtr<MetadataHelper> helper =
new MetadataHelper(this, fileRequest, params);
nsresult rv = helper->Enqueue();
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_FILEHANDLE_UNKNOWN_ERR);
fileRequest.forget(_retval);
return NS_OK;
}
void
IDBRequest::NotifyHelperSentResultsToChildProcess(nsresult aRv)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
NS_ASSERTION(!mHaveResultOrErrorCode, "Already called!");
NS_ASSERTION(JSVAL_IS_VOID(mResultVal), "Should be undefined!");
// See if our window is still valid. If not then we're going to pretend that
// we never completed.
if (NS_FAILED(CheckInnerWindowCorrectness())) {
return;
}
mHaveResultOrErrorCode = true;
if (NS_FAILED(aRv)) {
SetError(aRv);
}
}
void
js_prop_set_from_jsval(JSContext *cx, prop_t *p, jsval value)
{
JSBool b;
if(JSVAL_IS_INT(value)) {
prop_set_int(p, JSVAL_TO_INT(value));
} else if(JSVAL_IS_BOOLEAN(value)) {
prop_set_int(p, JSVAL_TO_BOOLEAN(value));
} else if(JSVAL_IS_NULL(value) || JSVAL_IS_VOID(value)) {
prop_set_void(p);
} else if(JSVAL_IS_DOUBLE(value)) {
double d;
if(JS_ValueToNumber(cx, value, &d))
prop_set_float(p, d);
} else if(JS_HasInstance(cx, RichText, value, &b) && b) {
JSObject *o = JSVAL_TO_OBJECT(value);
jsval v2;
if(!JS_EnterLocalRootScope(cx))
return;
if(!JS_GetProperty(cx, o, "text", &v2)) {
JS_LeaveLocalRootScope(cx);
return;
}
prop_set_string_ex(p, NULL, JS_GetStringBytes(JS_ValueToString(cx, v2)),
PROP_STR_RICH);
JS_LeaveLocalRootScope(cx);
} else if(JSVAL_IS_STRING(value)) {
js_prop_from_str(cx, p, value);
} else if(JSVAL_IS_OBJECT(value)) {
JSObject *obj = JSVAL_TO_OBJECT(value);
JSClass *c = JS_GetClass(cx, obj);
if(!strcmp(c->name, "XML")) // Treat some classes special
js_prop_from_str(cx, p, value);
else
js_prop_from_object(cx, obj, p);
} else {
prop_set_void(p);
}
}
GF_EXPORT
GF_Err gf_webvtt_js_addCue(GF_Node *node, const char *id,
const char *start, const char *end,
const char *settings,
const char *payload)
{
GF_Err e;
JSBool found;
JSContext *c = node->sgprivate->scenegraph->svg_js->js_ctx;
JSObject *global = node->sgprivate->scenegraph->svg_js->global;
jsval fun_val;
gf_sg_lock_javascript(c, GF_TRUE);
found = JS_LookupProperty(c, global, "addCue", &fun_val);
if (!found || JSVAL_IS_VOID(fun_val) || !JSVAL_IS_OBJECT(fun_val) ) {
e = GF_BAD_PARAM;
} else {
JSBool ret;
uintN attr;
ret = JS_GetPropertyAttributes(c, global, "addCue", &attr, &found);
if (ret == JS_TRUE && found == JS_TRUE) {
jsval rval;
jsval argv[5];
argv[0] = STRING_TO_JSVAL( JS_NewStringCopyZ(c, (id ? id : "")) );
argv[1] = STRING_TO_JSVAL( JS_NewStringCopyZ(c, (start ? start : "")) );
argv[2] = STRING_TO_JSVAL( JS_NewStringCopyZ(c, (end ? end : "")) );
argv[3] = STRING_TO_JSVAL( JS_NewStringCopyZ(c, (settings ? settings : "")) );
argv[4] = STRING_TO_JSVAL( JS_NewStringCopyZ(c, (payload ? payload : "")) );
ret = JS_CallFunctionValue(c, global, fun_val, 5, argv, &rval);
//ret = JS_CallFunctionName(c, global, "addCue", 5, argv, &rval);
if (ret == JS_TRUE) {
e = GF_OK;
} else {
e = GF_BAD_PARAM;
}
} else {
e = GF_BAD_PARAM;
}
}
gf_sg_lock_javascript(c, GF_FALSE);
return e;
}
int
js_prop_from_object(JSContext *cx, JSObject *obj, prop_t *p)
{
JSIdArray *ida;
int i, r = 0;
const char *n;
int array_zapped = 0;
if((ida = JS_Enumerate(cx, obj)) == NULL)
return -1;
for(i = 0; i < ida->length; i++) {
jsval name, value;
if(!JS_IdToValue(cx, ida->vector[i], &name))
continue;
if(JSVAL_IS_STRING(name)) {
n = JS_GetStringBytes(JSVAL_TO_STRING(name));
if(!JS_GetProperty(cx, obj, n, &value))
continue;
} else if(JSVAL_IS_INT(name)) {
if(!JS_GetElement(cx, obj, JSVAL_TO_INT(name), &value) ||
JSVAL_IS_VOID(value))
continue;
if(!array_zapped) {
array_zapped = 1;
prop_destroy_by_name(p, NULL);
}
n = NULL;
} else {
continue;
}
if(JSVAL_TO_OBJECT(value) == obj)
continue;
js_prop_set_from_jsval(cx, prop_create(p, n), value);
}
JS_DestroyIdArray(cx, ida);
return r;
}
void CancelLoad(const CStrW& message)
{
// Cancel loader
LDR_Cancel();
// Call the cancelOnError GUI function, defined in ..gui/common/functions_utility_error.js
// So all GUI pages that load games should include this script
if (g_GUI && g_GUI->HasPages())
{
JSContext* cx = g_ScriptingHost.getContext();
jsval fval, rval;
JSBool ok = JS_GetProperty(cx, g_GUI->GetScriptObject(), "cancelOnError", &fval);
ENSURE(ok);
jsval msgval = ToJSVal(message);
if (ok && !JSVAL_IS_VOID(fval))
JS_CallFunctionValue(cx, g_GUI->GetScriptObject(), fval, 1, &msgval, &rval);
}
}
static void
ValueToString(JSContext *cx, jsval aJSValue, nsString& aString)
{
if (JSVAL_IS_VOID(aJSValue)) {
aString.Assign(kUndefined, STRLEN_ARRAY(kUndefined));
} else if (JSVAL_IS_NULL(aJSValue)) {
aString.Assign(kNull, STRLEN_ARRAY(kNull));
} else if (JSVAL_IS_INT(aJSValue)) {
jsint i = JSVAL_TO_INT(aJSValue);
char buf[20];
PR_snprintf(buf, sizeof(buf), "%d", i);
aString.Assign(NS_ConvertASCIItoUTF16(buf));
} else if (JSVAL_IS_DOUBLE(aJSValue)) {
jsdouble d = JSVAL_TO_DOUBLE(aJSValue);
char buf[50];
PR_snprintf(buf, sizeof(buf), "%f", d);
aString.Assign(NS_ConvertASCIItoUTF16(buf));
} else if (JSVAL_IS_BOOLEAN(aJSValue)) {
JSBool b = JSVAL_TO_BOOLEAN(aJSValue);
if (b)
aString.Assign(kTrue, STRLEN_ARRAY(kTrue));
else
aString.Assign(kFalse, STRLEN_ARRAY(kFalse));
} else if (JSVAL_IS_STRING(aJSValue)) {
JSString *str = JSVAL_TO_STRING(aJSValue);
size_t len;
const jschar *chars = JS_GetStringCharsAndLength(cx, str, &len);
NS_ASSERTION(chars, "out of memory");
if (chars) {
NS_ASSERTION(sizeof(jschar) == sizeof(PRUnichar),
"char size mismatch");
aString.Assign(reinterpret_cast<const PRUnichar*>(chars), len);
}
} else {
JSObject *obj = JSVAL_TO_OBJECT(aJSValue);
JSClass *clazz = JS_GetClass(cx, obj);
aString.Assign(PRUnichar('['));
aString.Append(NS_ConvertASCIItoUTF16(clazz->name));
aString.Append(PRUnichar(']'));
}
}
JSBool
js_AtomizePrimitiveValue(JSContext *cx, jsval v, JSAtom **atomp)
{
JSAtom *atom;
if (JSVAL_IS_STRING(v)) {
atom = js_AtomizeString(cx, JSVAL_TO_STRING(v), 0);
if (!atom)
return JS_FALSE;
} else if (JSVAL_IS_DOUBLE(v)) {
atom = js_AtomizeDouble(cx, *JSVAL_TO_DOUBLE(v));
if (!atom)
return JS_FALSE;
} else {
JS_ASSERT(JSVAL_IS_INT(v) || JSVAL_IS_BOOLEAN(v) ||
JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v));
atom = (JSAtom *)v;
}
*atomp = atom;
return JS_TRUE;
}
JSBool
Library::Open(JSContext* cx, uintN argc, jsval *vp)
{
JSObject* ctypesObj = JS_THIS_OBJECT(cx, vp);
if (!ctypesObj || !IsCTypesGlobal(cx, ctypesObj)) {
JS_ReportError(cx, "not a ctypes object");
return JS_FALSE;
}
if (argc != 1 || JSVAL_IS_VOID(JS_ARGV(cx, vp)[0])) {
JS_ReportError(cx, "open requires a single argument");
return JS_FALSE;
}
JSObject* library = Create(cx, JS_ARGV(cx, vp)[0], GetCallbacks(cx, ctypesObj));
if (!library)
return JS_FALSE;
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(library));
return JS_TRUE;
}
int
spidermonkey_eval_boolback(struct ecmascript_interpreter *interpreter,
struct string *code)
{
JSContext *ctx;
JSFunction *fun;
jsval rval;
int ret;
assert(interpreter);
if (!js_module_init_ok) return 0;
ctx = interpreter->backend_data;
interpreter->ret = NULL;
fun = JS_CompileFunction(ctx, NULL, "", 0, NULL, code->source,
code->length, "", 0);
if (!fun)
return -1;
#if defined(CONFIG_ECMASCRIPT_SMJS_HEARTBEAT)
interpreter->heartbeat = add_heartbeat(interpreter);
#elif defined(HAVE_JS_SETBRANCHCALLBACK)
setup_safeguard(interpreter, ctx);
#endif
ret = JS_CallFunction(ctx, NULL, fun, 0, NULL, &rval);
#if defined(CONFIG_ECMASCRIPT_SMJS_HEARTBEAT)
done_heartbeat(interpreter->heartbeat);
#endif
if (ret == 2) { /* onClick="history.back()" */
return 0;
}
if (ret == JS_FALSE) {
return -1;
}
if (JSVAL_IS_VOID(rval)) {
/* Undefined value. */
return -1;
}
return jsval_to_boolean(ctx, &rval);
}
js::ValueRef wrap(JSContext *cx, jsval val) {
if ( JSVAL_IS_BOOLEAN(val)) {
return JSVAL_TO_BOOLEAN(val) ? true : false;
}
if ( JSVAL_IS_NULL(val)){
fprintf(stderr, "is null\n");
}
if ( JSVAL_IS_VOID(val)){
fprintf(stderr, "is void\n");
}
if ( JSVAL_IS_INT (val)){
fprintf(stderr, "is int\n");
}
if ( JSVAL_IS_STRING(val)) {
JSString *str = JSVAL_TO_STRING(val);
//todo: memory leak is my middle name
js::String *jsstr = new js::String((std::string)JS_EncodeString(cx, str));
return *jsstr;
}
if ( !JSVAL_IS_PRIMITIVE(val)) {
JSObject* obj=JSVAL_TO_OBJECT(val);
if (JS_IsArrayObject(cx, obj)){
std::vector<js::ValueRef> els;
jsuint length;
JS_GetArrayLength(cx, obj, &length);
for (int i = 0; i < length; i++){
jsval ret;
JS_GetElement(cx, obj, i, &ret);
els.push_back(wrap(cx, ret));
}
// leaking memory
js::Array *array=new js::Array(els);
return (*array);
}
}
return (std::string)"<unknown type>";
}
JSErrorReport *
js_ErrorFromException(JSContext *cx, jsval exn)
{
JSObject *obj;
JSExnPrivate *privateData;
jsval privateValue;
if (JSVAL_IS_PRIMITIVE(exn))
return NULL;
obj = JSVAL_TO_OBJECT(exn);
if (OBJ_GET_CLASS(cx, obj) != &ExceptionClass)
return NULL;
privateValue = OBJ_GET_SLOT(cx, obj, JSSLOT_PRIVATE);
if (JSVAL_IS_VOID(privateValue))
return NULL;
privateData = (JSExnPrivate*) JSVAL_TO_PRIVATE(privateValue);
if (!privateData)
return NULL;
JS_ASSERT(privateData->errorReport);
return privateData->errorReport;
}
static void
vfw_setval(void *opaque, prop_event_t event, ...)
{
wfv_t *wfv = opaque;
va_list ap;
rstr_t *r;
const char *s;
va_start(ap, event);
switch(event) {
case PROP_SET_VOID:
if(JSVAL_IS_NULL(wfv->value) || JSVAL_IS_VOID(wfv->value))
break;
return;
case PROP_SET_RSTRING:
if(!JSVAL_IS_STRING(wfv->value))
return;
r = va_arg(ap, rstr_t *);
if(strcmp(JS_GetStringBytes(JSVAL_TO_STRING(wfv->value)), rstr_get(r)))
return;
break;
case PROP_SET_CSTRING:
if(!JSVAL_IS_STRING(wfv->value))
return;
s = va_arg(ap, const char *);
if(strcmp(JS_GetStringBytes(JSVAL_TO_STRING(wfv->value)), s))
return;
break;
default:
return;
}
wfv->done = 1;
}
VARTYPE XPCDispConvert::JSTypeToCOMType(XPCCallContext& ccx, jsval val)
{
if(JSVAL_IS_PRIMITIVE(val))
{
if(JSVAL_IS_STRING(val))
{
return VT_BSTR;
}
if(JSVAL_IS_INT(val))
{
return VT_I4;
}
if(JSVAL_IS_DOUBLE(val))
{
return VT_R8;
}
if(JSVAL_IS_BOOLEAN(val))
{
return VT_BOOL;
}
if(JSVAL_IS_VOID(val))
{
return VT_EMPTY;
}
if(JSVAL_IS_NULL(val))
{
return VT_NULL;
}
}
else
{
if(JS_IsArrayObject(ccx, JSVAL_TO_OBJECT(val)))
return VT_ARRAY | VT_VARIANT;
return VT_DISPATCH;
}
NS_ERROR("XPCDispConvert::JSTypeToCOMType was unable to identify the type of the jsval");
return VT_EMPTY;
}
/* Returns whether the object had the property; if the object did
* not have the property, always sets an exception. Treats
* "the property's value is JSVAL_VOID" the same as "no such property,"
* while JS_GetProperty() treats only "no such property" as an error.
* Guarantees that *value_p is set to something, if only JSVAL_VOID,
* even if an exception is set and false is returned.
*/
gboolean
gjs_object_require_property(JSContext *context,
JSObject *obj,
const char *obj_description,
const char *property_name,
jsval *value_p)
{
jsval value;
JS_BeginRequest(context);
value = JSVAL_VOID;
JS_GetProperty(context, obj, property_name, &value);
if (value_p)
*value_p = value;
if (!JSVAL_IS_VOID(value)) {
JS_ClearPendingException(context); /* in case JS_GetProperty() was on crack */
JS_EndRequest(context);
return TRUE;
} else {
/* remember gjs_throw() is a no-op if JS_GetProperty()
* already set an exception
*/
if (obj_description)
gjs_throw(context,
"No property '%s' in %s (or its value was undefined)",
property_name, obj_description);
else
gjs_throw(context,
"No property '%s' in object %p (or its value was undefined)",
property_name, obj);
JS_EndRequest(context);
return FALSE;
}
}
xpc_qsAString::xpc_qsAString(JSContext *cx, jsval *pval)
{
// From the T_ASTRING case in XPCConvert::JSData2Native.
typedef implementation_type::char_traits traits;
jsval v;
JSString *s;
const PRUnichar *chars;
size_t len;
v = *pval;
if(JSVAL_IS_STRING(v))
{
s = JSVAL_TO_STRING(v);
}
else
{
if(JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v))
{
(new(mBuf) implementation_type(
traits::sEmptyBuffer, PRUint32(0)))->SetIsVoid(PR_TRUE);
mValid = JS_TRUE;
return;
}
s = JS_ValueToString(cx, v);
if(!s)
{
mValid = JS_FALSE;
return;
}
*pval = STRING_TO_JSVAL(s); // Root the new string.
}
len = JS_GetStringLength(s);
chars = (len == 0 ? traits::sEmptyBuffer : (const PRUnichar*)JS_GetStringChars(s));
new(mBuf) implementation_type(chars, len);
mValid = JS_TRUE;
}
void SG_jscore__check_module_dags(SG_context *pCtx, JSContext *cx, JSObject *glob, const char *reponame)
{
jsval args[2];
JSBool js_ok;
jsval rval;
JSString *pjs;
jsval fo = JSVAL_VOID;
if (gpJSCoreGlobalState->bSkipModules || (! gpJSCoreGlobalState->pPathToModules))
return;
SG_ERR_CHECK( _sg_jscore__install_modules(pCtx, cx, glob, NULL) );
SG_JS_NULL_CHECK( (pjs = JS_NewStringCopyZ(cx, reponame)) );
args[0] = STRING_TO_JSVAL(pjs);
SG_JS_NULL_CHECK( (pjs = JS_NewStringCopyZ(cx, SG_pathname__sz(gpJSCoreGlobalState->pPathToModules))) );
args[1] = STRING_TO_JSVAL(pjs);
if (! JS_LookupProperty(cx, glob, "checkModuleDags", &fo))
{
SG_ERR_CHECK_CURRENT;
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "lookup of checkModuleDags failed"));
}
if (!JSVAL_IS_VOID(fo))
{
js_ok = JS_CallFunctionName(cx, glob, "checkModuleDags", SG_NrElements(args), args, &rval);
SG_ERR_CHECK_CURRENT;
if(!js_ok)
SG_ERR_THROW2(SG_ERR_JS, (pCtx, "An error occurred initializing modules: call to JavaScript checkModuleDags() failed"));
}
fail:
;
}
/* Checks whether an object has a property; unlike JS_GetProperty(),
* never sets an exception. Treats a property with a value of JSVAL_VOID
* the same as an absent property and returns false in both cases.
* Always initializes *value_p, if only to JSVAL_VOID, even if it
* returns FALSE.
*/
gboolean
gjs_object_get_property(JSContext *context,
JSObject *obj,
const char *property_name,
jsval *value_p)
{
jsval value;
JSExceptionState *state;
JS_BeginRequest(context);
value = JSVAL_VOID;
state = JS_SaveExceptionState(context);
JS_GetProperty(context, obj, property_name, &value);
JS_RestoreExceptionState(context, state);
if (value_p)
*value_p = value;
JS_EndRequest(context);
return !JSVAL_IS_VOID(value);
}
SV *
PrimJSVALToSV(
pTHX_
JSContext *cx,
jsval v
) {
SV *sv = NULL;
if(JSVAL_IS_NULL(v) || JSVAL_IS_VOID(v))
sv = newSV(0);
else if(JSVAL_IS_BOOLEAN(v)) {
sv = newSV(0);
sv_setref_iv(sv, PJS_BOOLEAN, (IV)JSVAL_TO_BOOLEAN(v));
}
else if(JSVAL_IS_INT(v))
sv = newSViv((IV)JSVAL_TO_INT(v));
else if(JSVAL_IS_DOUBLE(v))
sv = newSVnv(*JSVAL_TO_DOUBLE(v));
else if(JSVAL_IS_STRING(v))
sv = PJS_JSString2SV(aTHX_ JSVAL_TO_STRING(v));
else croak("PJS_Assert: Unknown primitive type");
return sv;
}
ScriptValuePtr TraceMonkeyEngine::runScript(std::string script)
{
// printf("Running script: \r\n%s\r\n", script.c_str());
jsval ret;
JS_EvaluateScript(context, global, script.c_str(), script.length(), "TraceMonkeyEngine", 0, &ret);
bool success = JS_AddNamedRoot(context, &ret, "TraceMonkeyEngine::runScript temp val");; // Ensure our value won't be GCed
assert(success);
// printf("Script completed\r\n");
printJSVAL(ret);
ScriptValuePtr retValue;
if ( !JSVAL_IS_VOID(ret) )
retValue = ScriptValuePtr( new TraceMonkeyValue(this, true, ret) );
success = JS_RemoveRoot(context, &ret);
assert(success);
return retValue;
}
static JSBool
OnUpdateSettings(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval) {
try {
WMTouchPlugin* myPlugin = GetInstance();
if (argc != 1) {
JS_ReportError(cx, "WMTouchPlugin::onUpdateSettings(): Wrong number of arguments. One (ConfigNode) expected");
return JS_FALSE;
}
dom::NodePtr myConfigNode;
if (JSVAL_IS_VOID(argv[0]) || !jslib::convertFrom(cx, argv[0], myConfigNode)) {
JS_ReportError(cx, "WMTouchPlugin::onUpdateSettings(): Argument #1 must be a node");
return JS_FALSE;
}
myPlugin->onUpdateSettings(myConfigNode);
return JS_TRUE;
} HANDLE_CPP_EXCEPTION;
return JS_TRUE;
}
//---------------------------------------------------------------------------
void JS_TO_CONCEPT(void *member, jsval rval) {
INVOKE_CALL InvokePtr = 0;
CALL_BACK_VARIABLE_SET SetVariable = _SetVariable;
void *HANDLER = CONCEPT_HANDLER;
if (JSVAL_IS_DOUBLE(rval)) {
SET_NUMBER_VARIABLE(member, *JSVAL_TO_DOUBLE(rval));
} else
if (JSVAL_IS_INT(rval)) {
SET_NUMBER_VARIABLE(member, JSVAL_TO_INT(rval));
} else
if (JSVAL_IS_STRING(rval)) {
struct JSString *str = JSVAL_TO_STRING(rval);
SET_BUFFER_VARIABLE(member, JS_GetStringBytes(str), str->length);
} else
if (JSVAL_IS_BOOLEAN(rval)) {
SET_NUMBER_VARIABLE(member, (NUMBER)JSVAL_TO_BOOLEAN(rval));
} else
if ((JSVAL_IS_NULL(rval)) || (JSVAL_IS_VOID(rval))) {
SET_NUMBER_VARIABLE(member, 0);
} else
SET_NUMBER_VARIABLE(member, 1);
}
static JSBool xgg_label_propop_innertext_set(JSContext *pcxa, JSObject *pobja, jsval id, jsval *vp)
{
XGG_LABEL_PRIV* pv0 = JS_GetPrivate(pcxa, pobja);
//XJSEXADGELEM* pe0 = pv0->hdr.pxadgelem;
//XJSECTX* pjsectx = (XJSECTX*)JS_GetContextPrivate(pcxa);
if(JSVAL_IS_VOID(vp[0])) {
XJSE_TRACE("(X) assigning non-text to innerText prop. (%d)",
JS_TypeOfValue(pcxa, vp[0]));
goto cleanup;
}
char *psz1 = JS_GetStringBytes(JS_ValueToString(pcxa, vp[0]));
//XJSE_TRACE("(X) label.innerText: [%s]", psz1);
xjse_int_t n0 = xjse_strlen(0, psz1);
XJSE_SAFENNP(pv0->pszinnertext, free);
pv0->pszinnertext = (char*)malloc(n0 + 1);
memcpy(pv0->pszinnertext, psz1, n0);
pv0->pszinnertext[n0] = 0;
cleanup:
return JS_TRUE;
}
void
js_prop_set_from_jsval(JSContext *cx, prop_t *p, jsval value, int recurse)
{
JSBool b;
if(JSVAL_IS_INT(value)) {
prop_set_int(p, JSVAL_TO_INT(value));
} else if(JSVAL_IS_BOOLEAN(value)) {
prop_set_int(p, JSVAL_TO_BOOLEAN(value));
} else if(JSVAL_IS_DOUBLE(value)) {
double d;
if(JS_ValueToNumber(cx, value, &d))
prop_set_float(p, d);
} else if(JS_HasInstance(cx, RichText, value, &b) && b) {
JSObject *o = JSVAL_TO_OBJECT(value);
jsval v2;
if(!JS_EnterLocalRootScope(cx))
return;
if(!JS_GetProperty(cx, o, "text", &v2)) {
JS_LeaveLocalRootScope(cx);
return;
}
prop_set_string_ex(p, NULL, JS_GetStringBytes(JS_ValueToString(cx, v2)),
PROP_STR_RICH);
JS_LeaveLocalRootScope(cx);
} else if(JSVAL_IS_VOID(value) || JSVAL_IS_NULL(value)) {
prop_set_void(p);
} else if(recurse && JSVAL_IS_OBJECT(value)) {
js_prop_from_object(cx, JSVAL_TO_OBJECT(value), p, recurse);
} else {
prop_set_string(p, JS_GetStringBytes(JS_ValueToString(cx, value)));
}
}