JSBool SkJSDisplayable::SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp) {
if (JSVAL_IS_INT(id) == 0)
return JS_TRUE;
SkJSDisplayable *p = (SkJSDisplayable *) JS_GetPrivate(cx, obj);
SkDisplayable* displayable = p->fDisplayable;
SkDisplayTypes displayableType = displayable->getType();
int members;
const SkMemberInfo* info = SkDisplayType::GetMembers(NULL /* fMaker */, displayableType, &members);
int idIndex = JSVAL_TO_INT(id);
SkASSERT(idIndex >= 0 && idIndex < members);
info = &info[idIndex];
SkDisplayTypes infoType = info->getType();
SkScalar scalar = 0;
S32 s32 = 0;
SkString string;
JSString* str;
jsval value = *vp;
switch (infoType) {
case SkType_Boolean:
s32 = JSVAL_TO_BOOLEAN(value);
break;
case SkType_Color:
case SkType_S32:
s32 = JSVAL_TO_INT(value);
break;
case SkType_Scalar:
if (JSVAL_IS_INT(value))
scalar = SkIntToScalar(JSVAL_TO_INT(value));
else {
SkASSERT(JSVAL_IS_DOUBLE(value));
#ifdef SK_SCALAR_IS_FLOAT
scalar = (float) *(double*) JSVAL_TO_DOUBLE(value);
#else
scalar = (SkFixed) (*(double*)JSVAL_TO_DOUBLE(value) * 65536.0);
#endif
}
break;
case SkType_String:
str = JS_ValueToString(cx, value);
string.set(JS_GetStringBytes(str));
break;
default:
SkASSERT(0); // !!! unimplemented
}
if (info->fType == SkType_MemberProperty) {
switch (infoType) {
case SkType_Scalar: {
SkScriptValue scriptValue;
scriptValue.fType = SkType_Scalar;
scriptValue.fOperand.fScalar = scalar;
displayable->setProperty(-1 - (int) info->fOffset, scriptValue);
} break;
default:
SkASSERT(0); // !!! unimplemented
}
} else {
SkASSERT(info->fCount == 1);
switch (infoType) {
case SkType_Boolean:
case SkType_Color:
case SkType_S32:
s32 = *(S32*) ((const char*) displayable + info->fOffset);
break;
case SkType_String:
info->setString(displayable, &string);
break;
case SkType_Scalar:
SkOperand operand;
operand.fScalar = scalar;
info->setValue(displayable, &operand, 1);
break;
default:
SkASSERT(0); // !!! unimplemented
}
}
return JS_TRUE;
}
JSBool
js_Stringify(JSContext *cx, jsval *vp, JSObject *replacer,
JSONWriteCallback callback, void *data, uint32 depth)
{
if (depth > JSON_MAX_DEPTH)
return JS_FALSE; /* encoding error */
JSBool ok = JS_TRUE;
JSObject *obj = JSVAL_TO_OBJECT(*vp);
JSBool isArray = JS_IsArrayObject(cx, obj);
jschar output = jschar(isArray ? '[' : '{');
if (!callback(&output, 1, data))
return JS_FALSE;
JSObject *iterObj = NULL;
jsint i = 0;
jsuint length = 0;
if (isArray) {
if (!JS_GetArrayLength(cx, obj, &length))
return JS_FALSE;
} else {
if (!js_ValueToIterator(cx, JSITER_ENUMERATE, vp))
return JS_FALSE;
iterObj = JSVAL_TO_OBJECT(*vp);
}
jsval outputValue = JSVAL_VOID;
JSAutoTempValueRooter tvr(cx, 1, &outputValue);
jsval key;
JSBool memberWritten = JS_FALSE;
do {
outputValue = JSVAL_VOID;
if (isArray) {
if ((jsuint)i >= length)
break;
ok = JS_GetElement(cx, obj, i++, &outputValue);
} else {
ok = js_CallIteratorNext(cx, iterObj, &key);
if (!ok)
break;
if (key == JSVAL_HOLE)
break;
JSString *ks;
if (JSVAL_IS_STRING(key)) {
ks = JSVAL_TO_STRING(key);
} else {
ks = JS_ValueToString(cx, key);
if (!ks) {
ok = JS_FALSE;
break;
}
}
ok = JS_GetUCProperty(cx, obj, JS_GetStringChars(ks),
JS_GetStringLength(ks), &outputValue);
}
if (!ok)
break;
// if this is an array, holes are transmitted as null
if (isArray && outputValue == JSVAL_VOID) {
outputValue = JSVAL_NULL;
} else if (JSVAL_IS_OBJECT(outputValue)) {
ok = js_TryJSON(cx, &outputValue);
if (!ok)
break;
}
// elide undefined values
if (outputValue == JSVAL_VOID)
continue;
// output a comma unless this is the first member to write
if (memberWritten) {
output = jschar(',');
ok = callback(&output, 1, data);
if (!ok)
break;
}
memberWritten = JS_TRUE;
JSType type = JS_TypeOfValue(cx, outputValue);
// Can't encode these types, so drop them
if (type == JSTYPE_FUNCTION || type == JSTYPE_XML)
break;
// Be careful below, this string is weakly rooted.
JSString *s;
// If this isn't an array, we need to output a key
if (!isArray) {
s = JS_ValueToString(cx, key);
if (!s) {
ok = JS_FALSE;
break;
}
ok = write_string(cx, callback, data, JS_GetStringChars(s), JS_GetStringLength(s));
if (!ok)
break;
output = jschar(':');
ok = callback(&output, 1, data);
if (!ok)
break;
}
if (!JSVAL_IS_PRIMITIVE(outputValue)) {
// recurse
ok = js_Stringify(cx, &outputValue, replacer, callback, data, depth + 1);
} else {
JSString *outputString;
s = JS_ValueToString(cx, outputValue);
if (!s) {
ok = JS_FALSE;
break;
}
if (type == JSTYPE_STRING) {
ok = write_string(cx, callback, data, JS_GetStringChars(s), JS_GetStringLength(s));
if (!ok)
break;
continue;
}
if (type == JSTYPE_NUMBER) {
if (JSVAL_IS_DOUBLE(outputValue)) {
jsdouble d = *JSVAL_TO_DOUBLE(outputValue);
if (!JSDOUBLE_IS_FINITE(d))
outputString = JS_NewStringCopyN(cx, "null", 4);
else
outputString = s;
} else {
outputString = s;
}
} else if (type == JSTYPE_BOOLEAN) {
outputString = s;
} else if (JSVAL_IS_NULL(outputValue)) {
outputString = JS_NewStringCopyN(cx, "null", 4);
} else {
ok = JS_FALSE; // encoding error
break;
}
ok = callback(JS_GetStringChars(outputString), JS_GetStringLength(outputString), data);
}
} while (ok);
if (iterObj) {
// Always close the iterator, but make sure not to stomp on OK
js_CloseIteratorState(cx, iterObj);
// encoding error or propagate? FIXME: Bug 408838.
}
if (!ok) {
JS_ReportError(cx, "Error during JSON encoding.");
return JS_FALSE;
}
output = jschar(isArray ? ']' : '}');
ok = callback(&output, 1, data);
return ok;
}
JSBool ADM_JSAvidemux::JSSetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
if (JSVAL_IS_INT(id))
{
ADM_JSAvidemux *priv = (ADM_JSAvidemux *) JS_GetPrivate(cx, obj);
switch(JSVAL_TO_INT(id))
{
case markerA_prop:
if(JSVAL_IS_INT(*vp) == false)
break;
{
int f=JSVAL_TO_INT(*vp);
if (!avifileinfo)
{
return JS_FALSE;
}
if(f==-1)
f=avifileinfo->nb_frames-1;
if(f<0 || f>avifileinfo->nb_frames-1)
return JS_FALSE;
frameStart=f;
}
break;
case markerB_prop:
if(JSVAL_IS_INT(*vp) == false)
break;
{
int f=JSVAL_TO_INT(*vp);
if (!avifileinfo)
{
return JS_FALSE;
}
if(f==-1)
f=avifileinfo->nb_frames-1;
if(f<0 || f>avifileinfo->nb_frames-1)
return JS_FALSE;
frameEnd=f;
}
break;
case audio_prop:
return JS_FALSE;
break;
case video_prop:
return JS_FALSE;
break;
case container_prop:
if(JSVAL_IS_STRING(*vp) == false)
break;
{
priv->getObject()->m_pContainer = JSVAL_TO_STRING(*vp);
char *pContainer = JS_GetStringBytes(priv->getObject()->m_pContainer);
aprintf("Setting container format \"%s\"\n",pContainer);
if(A_setContainer(pContainer))
return JS_TRUE;
return JS_FALSE;
return JS_FALSE;
}
break;
case currentframe_prop:
if(JSVAL_IS_INT(*vp) == false)
break;
{
int frameno;
if (!avifileinfo)
return JS_FALSE;
frameno = JSVAL_TO_INT(*vp);
if( frameno<0)
{
aviInfo info;
video_body->getVideoInfo(&info);
frameno=-frameno;
if(frameno>info.nb_frames)
return JS_FALSE;
frameno = info.nb_frames-frameno;
}
enterLock();
if(GUI_GoToFrame( frameno ))
{
leaveLock();
return JS_TRUE;
}
leaveLock();
return JS_FALSE;
}
break;
case fps_prop:
if(JSVAL_IS_DOUBLE(*vp) == false)
break;
{
priv->getObject()->m_dFPS = *JSVAL_TO_DOUBLE(*vp);
aviInfo info;
if (avifileinfo)
{
video_body->getVideoInfo(&info);
info.fps1000 = (uint32_t)floor(priv->getObject()->m_dFPS*1000.f);
video_body->updateVideoInfo (&info);
video_body->getVideoInfo (avifileinfo);
return JS_TRUE;
} else
{
return JS_FALSE;
}
}
break;
}
}
return JS_TRUE;
}
JSBool
jsd_IsValueDouble(JSDContext* jsdc, JSDValue* jsdval)
{
return JSVAL_IS_DOUBLE(jsdval->val);
}
nsresult
Key::EncodeJSValInternal(JSContext* aCx, const jsval aVal,
uint8_t aTypeOffset, uint16_t aRecursionDepth)
{
NS_ENSURE_TRUE(aRecursionDepth < MaxRecursionDepth, NS_ERROR_DOM_INDEXEDDB_DATA_ERR);
MOZ_STATIC_ASSERT(eMaxType * MaxArrayCollapse < 256,
"Unable to encode jsvals.");
if (JSVAL_IS_STRING(aVal)) {
nsDependentJSString str;
if (!str.init(aCx, aVal)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
EncodeString(str, aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_INT(aVal)) {
EncodeNumber((double)JSVAL_TO_INT(aVal), eFloat + aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_DOUBLE(aVal)) {
double d = JSVAL_TO_DOUBLE(aVal);
if (MOZ_DOUBLE_IS_NaN(d)) {
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
EncodeNumber(d, eFloat + aTypeOffset);
return NS_OK;
}
if (!JSVAL_IS_PRIMITIVE(aVal)) {
JSObject* obj = JSVAL_TO_OBJECT(aVal);
if (JS_IsArrayObject(aCx, obj)) {
aTypeOffset += eMaxType;
if (aTypeOffset == eMaxType * MaxArrayCollapse) {
mBuffer.Append(aTypeOffset);
aTypeOffset = 0;
}
NS_ASSERTION((aTypeOffset % eMaxType) == 0 &&
aTypeOffset < (eMaxType * MaxArrayCollapse),
"Wrong typeoffset");
uint32_t length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
for (uint32_t index = 0; index < length; index++) {
jsval val;
if (!JS_GetElement(aCx, obj, index, &val)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
nsresult rv = EncodeJSValInternal(aCx, val, aTypeOffset,
aRecursionDepth + 1);
if (NS_FAILED(rv)) {
return rv;
}
aTypeOffset = 0;
}
mBuffer.Append(eTerminator + aTypeOffset);
return NS_OK;
}
if (JS_ObjectIsDate(aCx, obj)) {
if (!js_DateIsValid(obj)) {
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
EncodeNumber(js_DateGetMsecSinceEpoch(obj), eDate + aTypeOffset);
return NS_OK;
}
}
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
int
main(int argc, char **argv)
{
FILE *fl = NULL;
FILE *fl_out = NULL;
struct passwd *pw = NULL;
struct group *grp = NULL;
char *chroot = NULL;
char *directory;
const char *s;
Elixir_Runtime *er;
Elixir_Script *es;
JSObject *env;
JSObject *elx;
void *stack = NULL;
char **array = NULL;
jsval jsret;
int size;
int i;
int32_t ret = 0;
srandom(time(0));
#ifdef DEBUG
elixir_debug_print_switch(ELIXIR_DEBUG_STDERR, NULL);
#else
elixir_debug_print_switch(ELIXIR_DEBUG_NONE, NULL);
#endif
s = getenv("ELIXIR_DEBUG");
if (s)
{
if (!strcasecmp(s, "stderr"))
elixir_debug_print_switch(ELIXIR_DEBUG_STDERR, NULL);
else if (!strcasecmp(s, "stdout"))
elixir_debug_print_switch(ELIXIR_DEBUG_STDOUT, NULL);
else if (!strcasecmp(s, "console"))
elixir_debug_print_switch(ELIXIR_DEBUG_CONSOLE, NULL);
else if (!strcasecmp(s, "syslog"))
elixir_debug_print_switch(ELIXIR_DEBUG_SYSLOG, NULL);
else if ((!strcasecmp(s, "none")) || (!strcasecmp(s, "null")))
elixir_debug_print_switch(ELIXIR_DEBUG_NONE, NULL);
}
elixir_id_init();
elixir_class_init();
elixir_file_init();
elixir_modules_init();
er = elixir_init();
if (!er)
return 128;
elixir_loader_init(3, loaders);
elixir_security_init(1, security);
if (argc <= 1)
return 129;
while (1)
{
int option_index = 0;
int c;
c = getopt_long(argc, argv, "mc:t:l:hu:d:p:o:rs:e:g:i:a:", lopt, &option_index);
if (c == -1)
break ;
/* Long options. */
if (c == 0)
{
switch (option_index)
{
case 0: c = 'c'; break;
case 1: c = 't'; break;
case 2: c = 'l'; break;
case 3: c = 'm'; break;
case 4: c = 'h'; break;
case 5: c = 'u'; break;
case 6: c = 'd'; break;
case 7: c = 'p'; break;
case 8: c = 'o'; break;
case 9: c = 'r'; break;
case 10: c = 's'; break;
case 11: c = 'e'; break;
case 12: c = 'g'; break;
case 13: c = 'i'; break;
case 14: c = 'a'; break;
}
}
switch (c)
{
case 0:
case 'e':
case 's': /* Authorized security modules. */
array = malloc(sizeof (char*));
array[0] = optarg;
for (i = 0, size = 1; optarg[i] != '\0'; ++i)
{
if (optarg[i] == ',')
{
array[size++] = optarg + i + 1;
optarg[i] = '\0';
array = realloc(array, sizeof (char*) * size);
}
}
if (c == 's') elixir_security_init(size, (const char **)array);
else elixir_loader_init(size, (const char **)array);
free(array);
break;
case 'm': /* Activate monitoring. */
break;
case 'c': /* Call chroot. */
chroot = strdupa(optarg);
break;
case 't': /* Call virtual chroot. */
elixir_file_virtual_chroot_set(optarg);
break;
case 'l': /* Log file. */
if (fl)
fclose(fl);
fl = fopen(optarg, "a");
if (!fl)
{
fprintf(stderr, "Unable to open `%s'.\n\n", optarg);
elixir_help();
exit(0);
}
elixir_debug_print_switch(ELIXIR_DEBUG_FILE, fl);
break;
case 'u':
pw = getpwnam(optarg);
if (!pw)
{
fprintf(stderr, "Unable to get user `%s' information.\n\n", optarg);
elixir_help();
exit(0);
}
break;
case 'g':
grp = getgrnam(optarg);
if (!grp)
{
fprintf(stderr, "Unable to get group `%s' information.\n\n", optarg);
elixir_help();
exit(0);
}
break;
case 'd':
if (chdir(optarg))
{
fprintf(stderr, "Unable to chdir to %s.\n\n", optarg);
elixir_help();
exit(0);
};
break;
case 'p':
if (strlen(optarg) != 1)
{
fprintf(stderr, "`%s' is not a valid policy.\n\n", optarg);
elixir_help();
exit(0);
}
switch (*optarg)
{
case '0': elixir_file_virtual_chroot_directive_set(ELIXIR_VCHROOT_DATA_ONLY); break;
case '1': elixir_file_virtual_chroot_directive_set(ELIXIR_VCHROOT_NOEXEC); break;
case '2': elixir_file_virtual_chroot_directive_set(ELIXIR_VCHROOT_ALL); break;
default:
fprintf(stderr, "`%s' is not a valid policy.\n\n", optarg);
elixir_help();
exit(0);
}
break;
case 'o':
if (fl_out)
fclose(fl_out);
fl_out = fopen(optarg, "w");
break;
case 'r':
stack = alloca(random() & 0xFF);
break;
case 'i':
{
FILE *fid;
fid = fopen(optarg, "w");
if (fid)
{
pid_t pid;
pid = getpid();
fprintf(fid, "%i\n", pid);
fclose(fid);
}
break;
}
case 'a':
tracker = fopen(optarg, "w");
break;
case 'h': /* Help. */
case '?':
default:
elixir_help();
exit(0);
break;
}
}
if (optind >= argc)
return 129;
if (chroot)
{
if (!elixir_file_chroot_set(chroot))
return 133;
}
if (pw)
{
gid_t newgid;
uid_t newuid;
gid_t oldgid;
uid_t olduid;
oldgid = getegid();
olduid = geteuid();
newgid = grp ? grp->gr_gid : pw->pw_gid;
newuid = pw->pw_uid;
if (!olduid) setgroups(1, &newgid);
#if !defined(linux)
setegid(newgid);
if (setgid(newgid) == -1) abort();
#else
if (setregid(newgid, newgid) == -1) abort();
#endif
#if !defined(linux)
seteuid(newuid);
if (setuid(newuid) == -1) abort();
#else
if (setreuid(newuid, newuid) == -1) abort();
#endif
}
else
{
if (grp)
{
#if !defined(linux)
setegid(grp->gr_gid);
if (setgid(grp->gr_gid) == -1) abort();
#else
if (setregid(grp->gr_gid, grp->gr_gid) == -1) abort();
#endif
}
}
directory = dirname(strdupa(argv[optind]));
elixir_debug_print("chdir to `%s`.", directory);
chdir(directory);
es = elixir_script_file(er, argc - optind, (const char**) argv + optind);
elixir_script_set_out(es, fl_out ? fl_out : stdout);
elixir_lock_cx(er->cx);
elx = elixir_object_get_object(er->cx, er->root, "elx");
if (elx)
if (!elixir_object_register(er->cx, &elx, NULL))
return 130;
env = elixir_object_create(er, elx, "env", elixir_env, NULL);
if (!env)
return 131;
if (!elixir_script_run(es, &jsret))
return 132;
/* Useless I believe. */
if (JSVAL_IS_BOOLEAN(jsret)
|| JSVAL_IS_INT(jsret)
|| JSVAL_IS_DOUBLE(jsret)
|| JSVAL_IS_STRING(jsret))
if (JS_ValueToInt32(es->er->cx, jsret, &ret) != JS_TRUE)
ret = 0;
if (elx)
elixir_object_unregister(er->cx, &elx);
elixir_unlock_cx(er->cx);
elixir_script_free(es);
elixir_shutdown(er);
elixir_file_shutdown();
elixir_modules_shutdown();
elixir_class_shutdown();
elixir_id_shutdown();
if (stack) return 1;
return 0;
}
nsresult
Key::EncodeJSVal(JSContext* aCx, const jsval aVal, PRUint8 aTypeOffset)
{
PR_STATIC_ASSERT(eMaxType * MaxArrayCollapse < 256);
if (JSVAL_IS_STRING(aVal)) {
nsDependentJSString str;
if (!str.init(aCx, aVal)) {
return NS_ERROR_OUT_OF_MEMORY;
}
EncodeString(str, aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_INT(aVal)) {
EncodeNumber((double)JSVAL_TO_INT(aVal), eFloat + aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_DOUBLE(aVal)) {
double d = JSVAL_TO_DOUBLE(aVal);
if (DOUBLE_IS_NaN(d)) {
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
EncodeNumber(d, eFloat + aTypeOffset);
return NS_OK;
}
if (!JSVAL_IS_PRIMITIVE(aVal)) {
JSObject* obj = JSVAL_TO_OBJECT(aVal);
if (JS_IsArrayObject(aCx, obj)) {
aTypeOffset += eMaxType;
if (aTypeOffset == eMaxType * MaxArrayCollapse) {
mBuffer.Append(aTypeOffset);
aTypeOffset = 0;
}
NS_ASSERTION((aTypeOffset % eMaxType) == 0 &&
aTypeOffset < (eMaxType * MaxArrayCollapse),
"Wrong typeoffset");
jsuint length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
for (jsuint index = 0; index < length; index++) {
jsval val;
if (!JS_GetElement(aCx, obj, index, &val)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
nsresult rv = EncodeJSVal(aCx, val, aTypeOffset);
NS_ENSURE_SUCCESS(rv, rv);
aTypeOffset = 0;
}
mBuffer.Append(eTerminator + aTypeOffset);
return NS_OK;
}
if (JS_ObjectIsDate(aCx, obj)) {
EncodeNumber(js_DateGetMsecSinceEpoch(aCx, obj), eDate + aTypeOffset);
return NS_OK;
}
}
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
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(JS_HasInstance(cx, Link, value, &b) && b) {
JSObject *o = JSVAL_TO_OBJECT(value);
jsval v1;
jsval v2;
if(!JS_EnterLocalRootScope(cx))
return;
if(!JS_GetProperty(cx, o, "title", &v1)) {
JS_LeaveLocalRootScope(cx);
return;
}
if(!JS_GetProperty(cx, o, "url", &v2)) {
JS_LeaveLocalRootScope(cx);
return;
}
prop_set_link(p,
JS_GetStringBytes(JS_ValueToString(cx, v1)),
JS_GetStringBytes(JS_ValueToString(cx, v2)));
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);
}
}
/* void setScalarArgument (in uint32_t number, in jsval argument); */
NS_IMETHODIMP dpoCKernel::SetScalarArgument(uint32_t number, const jsval & argument,
const jsval & isInteger, const jsval & highPrecision)
{
cl_int err_code;
bool isIntegerB;
bool isHighPrecisionB;
/* skip internal arguments */
number = number + DPO_NUMBER_OF_ARTIFICIAL_ARGS;
if (!JSVAL_IS_BOOLEAN(isInteger)) {
DEBUG_LOG_STATUS("SetScalarArgument", "illegal isInteger argument.");
return NS_ERROR_INVALID_ARG;
}
isIntegerB = JSVAL_TO_BOOLEAN(isInteger);
if (!JSVAL_IS_BOOLEAN(highPrecision)) {
DEBUG_LOG_STATUS("SetScalarArgument", "illegal highPrecision argument.");
return NS_ERROR_INVALID_ARG;
}
isHighPrecisionB = JSVAL_TO_BOOLEAN(highPrecision);
if (!JSVAL_IS_NUMBER(argument)) {
DEBUG_LOG_STATUS("SetScalarArgument", "illegal number argument.");
return NS_ERROR_INVALID_ARG;
}
if (JSVAL_IS_INT(argument)) {
int value = JSVAL_TO_INT(argument);
DEBUG_LOG_STATUS("SetScalarArgument", "(JSVAL_IS_INT(argument)) isIntegerB: " << isIntegerB << " isHighPrecisionB " << isHighPrecisionB);
if (isIntegerB) {
DEBUG_LOG_STATUS("SetScalarArgument", "(JSVAL_IS_INT(argument)) setting integer argument " << number << " to integer value " << value);
cl_int intVal = (cl_int) value;
err_code = clSetKernelArg(kernel, number, sizeof(cl_int), &intVal);
} else if (isHighPrecisionB) {
DEBUG_LOG_STATUS("SetScalarArgument", "setting double argument " << number << " to integer value " << value);
cl_double doubleVal = (cl_double) value;
err_code = clSetKernelArg(kernel, number, sizeof(cl_double), &doubleVal);
} else {
DEBUG_LOG_STATUS("SetScalarArgument", "setting float argument " << number << " to integer value " << value);
cl_float floatVal = (cl_float) value;
err_code = clSetKernelArg(kernel, number, sizeof(cl_float), &floatVal);
}
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("SetScalarArgument", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
} else if (JSVAL_IS_DOUBLE(argument)) {
double value = JSVAL_TO_DOUBLE(argument);
DEBUG_LOG_STATUS("SetScalarArgument", "(JSVAL_IS_DOUBLE(argument)) isIntegerB: " << isIntegerB << " isHighPrecisionB " << isHighPrecisionB);
if (isIntegerB) {
DEBUG_LOG_STATUS("SetScalarArgument", "setting int formal argument " << number << " using double value " << value);
cl_int intVal = (cl_int) value;
err_code = clSetKernelArg(kernel, number, sizeof(cl_int), &intVal);
} else if (isHighPrecisionB) {
DEBUG_LOG_STATUS("SetScalarArgument", "setting double formal argument " << number << " using double value " << value);
cl_double doubleVal = (cl_double) value;
err_code = clSetKernelArg(kernel, number, sizeof(cl_double), &doubleVal);
} else {
DEBUG_LOG_STATUS("SetScalarArgument", "setting float formal argument " << number << " using double value " << value);
cl_float floatVal = (cl_float) value;
err_code = clSetKernelArg(kernel, number, sizeof(cl_float), &floatVal);
}
if (err_code != CL_SUCCESS) {
DEBUG_LOG_ERROR("SetScalarArgument", err_code);
return NS_ERROR_NOT_AVAILABLE;
}
} else {
DEBUG_LOG_STATUS("SetScalarArgument", "illegal number argument.");
return NS_ERROR_INVALID_ARG;
}
return NS_OK;
}
