//FlashCS5extension.StartMakeObjectFile(생성할 오브젝트 파일패스, UV 파일패스들)
JSBool StartMakeObjectFile(JSContext *cx, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval) {
clearlog();
*rval = JS_BooleanToValue(JS_FALSE);
if(argc != 3)
return ReturnString(cx, "error: argument count", rval);
unsigned int filePathLen;
unsigned short* filePath = JS_ValueToString(cx, argv[0], &filePathLen);
if(filePath == NULL)
return ReturnString(cx, "error: obj file path", rval);
JSObject* uvObj;
if(JS_ValueToObject(cx, argv[1], &uvObj) == JS_FALSE)
return ReturnString(cx, "error: uv file array", rval);
long uvLen = JS_GetArrayLength(cx, uvObj);
if(uvLen == -1)
return ReturnString(cx, "error: image file array length", rval);
JSObject* slicePathObj;
if(JS_ValueToObject(cx, argv[2], &slicePathObj) == JS_FALSE)
return ReturnString(cx, "error: slicePaht file array", rval);
unsigned int uvPathLen[uvLen];
unsigned short* uvPath[uvLen];
char* slicePath = GetString(cx, slicePathObj, 0);
int i;
for(i = 0; i < uvLen; i++) {
jsval posUV;
if(JS_GetElement(cx, uvObj, i, &posUV) == JS_FALSE)
return ReturnString(cx, "error: uv file array element", rval);
uvPath[i] = JS_ValueToString(cx, posUV, &uvPathLen[i]);
if(uvPath[i] == NULL)
return ReturnString(cx, "error: uv file array element file path string", rval);
FILE* uvDataFile = OpenFileString(uvPath[i], uvPathLen[i], "r");
fread(&root_w, sizeof(long), 1, uvDataFile);
fread(&root_h, sizeof(long), 1, uvDataFile);
if(uvDataFile) {
fseek(uvDataFile, 0, SEEK_END);
long uvDataSize = ftell(uvDataFile);
fseek(uvDataFile, sizeof(long) + sizeof(long), SEEK_SET);
int result = sizeof(long) + sizeof(long);
while(result < uvDataSize)
result += ReadUVdata(uvDataFile, slicePath);
fclose(uvDataFile);
} else {
return ReturnString(cx, "error: uv data fopen", rval);
}
}
free(slicePath);
#define BreakStartMakeObjectFile(errorstr) \
fclose(pObjectFile); \
pObjectFile = NULL; \
return ReturnString(cx, errorstr, rval)
if(pObjectFile) {
fclose(pObjectFile);
pObjectFile = NULL;
}
if(pObjectFile == NULL) {
char* path = StringToAscii(filePath, filePathLen);
pObjectFile = fopen(path, "w+");
free(path);
if(pObjectFile) {
//fwrite(&imgLen, sizeof(long), 1, pObjectFile);FlashCS5extension.bundle
for(i = 0; i < uvLen; i++) {
// FILE* imgFile;
// path = StringToAscii(imgPath[i], imgPathLen[i]);
// if(path == NULL) {
// BreakStartMakeObjectFile("error: image file path");
// }
// imgFile = fopen(path, "r");
// free(path);
// if(imgFile) {
// WriteFileToFile(pObjectFile, imgFile);
// writelog("success write image");
// fclose(imgFile);
// } else {
// BreakStartMakeObjectFile("error: image file fopen");
// }
int i;
fwrite(&uv_data_len, sizeof(unsigned int), 1, pObjectFile);
writelog("uv data length = %d", uv_data_len);
for(i = 0; i < uv_data_len; i++) {
fwrite(&uv_data[i].libID, sizeof(unsigned int), 1, pObjectFile);
writelog("libid = %d", uv_data[i].libID);
fwrite(&uv_data[i].pathCount, sizeof(int), 1, pObjectFile);
writelog("path count = %d", uv_data[i].pathCount);
for(int j = 0; j < uv_data[i].pathCount; ++j) {
float uv_x = (float)uv_data[i].x[j];
float uv_y = (float)uv_data[i].y[j];
fwrite(&uv_x, sizeof(float), 1, pObjectFile);
fwrite(&uv_y, sizeof(float), 1, pObjectFile);
writelog("x = %.3f, y = %.3f", uv_data[i].x[j], uv_data[i].y[j]);
}
}
}
} else {
//return JS_FALSE;
return ReturnString(cx, "error : fail to make obj file", rval);
}
} else {
//return JS_FALSE;
return ReturnString(cx, "error : pObjectFile in use", rval);
}
#undef BreakStartMakeObjectFile
*rval = JS_BooleanToValue(JS_TRUE);
for(int i = 0; i < root_library_name_id_len; i++) {
writelog("??????????????????????????libname info length = %i data = %s??????????????????????????", strlen(root_library_name_id[i].name), root_library_name_id[i].name);
}
return JS_TRUE;
}
/*
* Like JSEnumerateOp, but enum provides contextual information as follows:
*
* JSENUMERATE_INIT: allocate private enum struct in state_p, return number
* of elements in *id_p
* JSENUMERATE_NEXT: return next property id in *id_p, and if no new property
* free state_p and set to JSVAL_NULL
* JSENUMERATE_DESTROY : destroy state_p
*
* Note that in a for ... in loop, this will be called first on the object,
* then on its prototype.
*
*/
static JSBool
importer_new_enumerate(JSContext *context,
JSObject **object,
JSIterateOp enum_op,
jsval *state_p,
jsid *id_p)
{
ImporterIterator *iter;
switch (enum_op) {
case JSENUMERATE_INIT_ALL:
case JSENUMERATE_INIT: {
Importer *priv;
JSObject *search_path;
jsval search_path_val;
guint32 search_path_len;
guint32 i;
jsid search_path_name;
if (state_p)
*state_p = JSVAL_NULL;
if (id_p)
*id_p = INT_TO_JSID(0);
priv = priv_from_js(context, *object);
if (!priv)
/* we are enumerating the prototype properties */
return JS_TRUE;
search_path_name = gjs_runtime_get_const_string(JS_GetRuntime(context),
GJS_STRING_SEARCH_PATH);
if (!gjs_object_require_property(context, *object, "importer", search_path_name, &search_path_val))
return JS_FALSE;
if (!JSVAL_IS_OBJECT(search_path_val)) {
gjs_throw(context, "searchPath property on importer is not an object");
return JS_FALSE;
}
search_path = JSVAL_TO_OBJECT(search_path_val);
if (!JS_IsArrayObject(context, search_path)) {
gjs_throw(context, "searchPath property on importer is not an array");
return JS_FALSE;
}
if (!JS_GetArrayLength(context, search_path, &search_path_len)) {
gjs_throw(context, "searchPath array has no length");
return JS_FALSE;
}
iter = importer_iterator_new();
for (i = 0; i < search_path_len; ++i) {
char *dirname = NULL;
char *init_path;
const char *filename;
jsval elem;
GDir *dir = NULL;
elem = JSVAL_VOID;
if (!JS_GetElement(context, search_path, i, &elem)) {
/* this means there was an exception, while elem == JSVAL_VOID
* means no element found
*/
importer_iterator_free(iter);
return JS_FALSE;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JSVAL_IS_STRING(elem)) {
gjs_throw(context, "importer searchPath contains non-string");
importer_iterator_free(iter);
return JS_FALSE;
}
if (!gjs_string_to_utf8(context, elem, &dirname)) {
importer_iterator_free(iter);
return JS_FALSE; /* Error message already set */
}
init_path = g_build_filename(dirname, MODULE_INIT_FILENAME,
NULL);
load_module_elements(context, *object, iter, init_path);
g_free(init_path);
dir = g_dir_open(dirname, 0, NULL);
if (!dir) {
g_free(dirname);
continue;
}
while ((filename = g_dir_read_name(dir))) {
char *full_path;
/* skip hidden files and directories (.svn, .git, ...) */
if (filename[0] == '.')
continue;
/* skip module init file */
if (strcmp(filename, MODULE_INIT_FILENAME) == 0)
continue;
full_path = g_build_filename(dirname, filename, NULL);
if (g_file_test(full_path, G_FILE_TEST_IS_DIR)) {
g_ptr_array_add(iter->elements, g_strdup(filename));
} else {
if (g_str_has_suffix(filename, "."G_MODULE_SUFFIX) ||
g_str_has_suffix(filename, ".js")) {
g_ptr_array_add(iter->elements,
g_strndup(filename, strlen(filename) - 3));
}
}
g_free(full_path);
}
g_dir_close(dir);
g_free(dirname);
}
if (state_p)
*state_p = PRIVATE_TO_JSVAL(iter);
if (id_p)
*id_p = INT_TO_JSID(iter->elements->len);
break;
}
case JSENUMERATE_NEXT: {
jsval element_val;
if (!state_p) {
gjs_throw(context, "Enumerate with no iterator set?");
return JS_FALSE;
}
if (JSVAL_IS_NULL(*state_p)) /* Iterating prototype */
return JS_TRUE;
iter = JSVAL_TO_PRIVATE(*state_p);
if (iter->index < iter->elements->len) {
if (!gjs_string_from_utf8(context,
g_ptr_array_index(iter->elements,
iter->index++),
-1,
&element_val))
return JS_FALSE;
if (!JS_ValueToId(context, element_val, id_p))
return JS_FALSE;
break;
}
/* else fall through to destroying the iterator */
}
case JSENUMERATE_DESTROY: {
if (state_p && !JSVAL_IS_NULL(*state_p)) {
iter = JSVAL_TO_PRIVATE(*state_p);
importer_iterator_free(iter);
*state_p = JSVAL_NULL;
}
}
}
return JS_TRUE;
}
static JSBool
js_conio_puttext(JSContext *cx, uintN argc, jsval *arglist)
{
jsval *argv=JS_ARGV(cx, arglist);
int32 args[4];
unsigned char *buffer;
jsuint i;
int32 j;
jsuint size;
jsval val;
JSObject *array;
jsrefcount rc;
JS_SET_RVAL(cx, arglist, JSVAL_VOID);
/* default values: */
args[0]=1;
args[1]=1;
args[2]=cio_textinfo.screenwidth;
args[3]=cio_textinfo.screenheight;
if(argc != 5)
return(JS_FALSE);
for(i=0; i<4; i++) {
if(!JSVAL_IS_NUMBER(argv[i]))
return(JS_FALSE);
if(!JS_ValueToInt32(cx, argv[i], &args[i]))
return(JS_FALSE);
}
if(args[0] < 1 || args[1] < 1 || args[2] < 1 || args[3] < 1
|| args[0] > args[2] || args[1] > args[3]
|| args[2] > cio_textinfo.screenwidth || args[3] > cio_textinfo.screenheight) {
JS_SET_RVAL(cx, arglist,JSVAL_FALSE);
return(JS_TRUE);
}
if(!JSVAL_IS_OBJECT(argv[4]))
return(JS_FALSE);
array=JSVAL_TO_OBJECT(argv[4]);
if(!JS_GetArrayLength(cx, array, &size))
return(JS_FALSE);
buffer=(unsigned char *)malloc(size);
if(buffer==NULL)
return(JS_FALSE);
for(i=0; i<size; i++) {
if(!JS_GetElement(cx, array, i, &val)) {
free(buffer);
return(JS_FALSE);
}
if(!JSVAL_IS_NUMBER(val)) {
free(buffer);
return(JS_FALSE);
}
if(!JS_ValueToInt32(cx, val, &j)) {
free(buffer);
return(JS_FALSE);
}
buffer[i]=(unsigned char)j;
}
rc=JS_SUSPENDREQUEST(cx);
JS_SET_RVAL(cx, arglist,BOOLEAN_TO_JSVAL(puttext(args[0], args[1], args[2], args[3], buffer)));
free(buffer);
JS_RESUMEREQUEST(cx, rc);
return(JS_TRUE);
}
static gboolean
peas_extension_gjs_call (PeasExtensionWrapper *exten,
GType exten_type,
GICallableInfo *func_info,
const gchar *method_name,
GIArgument *args,
GIArgument *retval)
{
PeasExtensionGjs *gexten = PEAS_EXTENSION_GJS (exten);
gboolean success = FALSE;
jsval js_method, js_retval;
jsval *js_args;
CachedArg *arg_cache;
gint i, n_args, nth_out_arg;
gint n_in_args = 0;
gint n_out_args = 0;
gint cached_args = 0;
/* Fetch the JS method we want to call */
if (!JS_GetProperty (gexten->js_context, gexten->js_object,
method_name, &js_method) ||
JSVAL_IS_VOID (js_method))
{
g_warning ("Method '%s.%s' was not found",
g_type_name (exten_type), method_name);
return FALSE;
}
if (JSVAL_IS_NULL (js_method) || !JSVAL_IS_OBJECT (js_method) ||
!JS_ObjectIsFunction (gexten->js_context, JSVAL_TO_OBJECT (js_method)))
{
g_warning ("Method '%s.%s' in not a function",
g_type_name (exten_type), method_name);
return FALSE;
}
n_args = g_callable_info_get_n_args (func_info);
if (n_args < 0)
{
g_warn_if_fail (n_args >= 0);
return FALSE;
}
js_args = g_newa (jsval, n_args);
arg_cache = g_newa (CachedArg, n_args + 1);
/* Return value is an out arg */
g_callable_info_load_return_type (func_info, &arg_cache[0].type_info);
if (g_type_info_get_tag (&arg_cache[0].type_info) != GI_TYPE_TAG_VOID)
{
++n_out_args;
arg_cache[cached_args++].ptr = &retval->v_pointer;
}
/* Handle the arguments */
for (i = 0; i < n_args; ++i, ++cached_args)
{
GIDirection direction;
g_callable_info_load_arg (func_info, i, &arg_cache[cached_args].arg_info);
direction = g_arg_info_get_direction (&arg_cache[cached_args].arg_info);
g_arg_info_load_type (&arg_cache[cached_args].arg_info,
&arg_cache[cached_args].type_info);
if (direction == GI_DIRECTION_IN &&
!gjs_value_from_g_argument (gexten->js_context, &js_args[n_in_args++],
&arg_cache[cached_args].type_info,
&args[i], TRUE))
{
g_warning ("Error failed to convert argument '%s'",
g_base_info_get_name (&arg_cache[cached_args].arg_info));
return FALSE;
}
if (direction == GI_DIRECTION_INOUT)
{
GIArgument arg;
peas_gi_pointer_to_argument (&arg_cache[cached_args].type_info,
args[i].v_pointer, &arg);
if (!gjs_value_from_g_argument (gexten->js_context, &js_args[n_in_args++],
&arg_cache[cached_args].type_info, &arg, TRUE))
{
g_warning ("Error failed to convert argument '%s'",
g_base_info_get_name (&arg_cache[cached_args].arg_info));
return FALSE;
}
}
if (direction == GI_DIRECTION_OUT || direction == GI_DIRECTION_INOUT)
{
++n_out_args;
arg_cache[cached_args].ptr = args[i].v_pointer;
}
}
success = JS_CallFunctionValue (gexten->js_context, gexten->js_object,
js_method, n_in_args, js_args, &js_retval);
if (!success)
{
if (!gjs_log_exception (gexten->js_context))
{
g_warning ("Error while calling '%s.%s'",
g_type_name (exten_type), method_name);
}
return FALSE;
}
/* First we need to release in argument */
for (i = 0; i < cached_args; ++i)
{
GIDirection direction;
/* First cached argument may be the return value */
if (i == 0 && cached_args > n_args)
continue;
direction = g_arg_info_get_direction (&arg_cache[i].arg_info);
if (direction == GI_DIRECTION_IN || direction == GI_DIRECTION_INOUT)
{
GITransfer transfer;
transfer = g_arg_info_get_ownership_transfer (&arg_cache[i].arg_info);
if (!gjs_g_argument_release_in_arg (gexten->js_context, transfer,
&arg_cache[i].type_info,
&args[i]))
{
g_warning ("Error failed to release IN argument '%s'",
g_base_info_get_name (&arg_cache[i].arg_info));
}
}
}
/* Check that we have a valid return value */
if (n_out_args > 1)
{
if (!JSVAL_IS_OBJECT (js_retval) ||
!JS_IsArrayObject (gexten->js_context, JSVAL_TO_OBJECT (js_retval)))
{
g_warning ("Error return value is not an array");
return FALSE;
}
}
/* Set out arguments */
for (i = 0, nth_out_arg = 0; i < cached_args && success; ++i)
{
gboolean is_return_value;
is_return_value = i == 0 && cached_args > n_args;
/* Return value does not have a GIArgInfo and is always out */
if (!is_return_value)
{
GIDirection direction;
direction = g_arg_info_get_direction (&arg_cache[i].arg_info);
if (direction == GI_DIRECTION_IN)
continue;
}
if (n_out_args == 1)
{
success = set_out_arg (gexten->js_context, func_info, is_return_value,
&arg_cache[i].arg_info, &arg_cache[i].type_info,
arg_cache[i].ptr, js_retval);
break;
}
else if (n_out_args > 1)
{
jsval js_value;
if (!JS_GetElement (gexten->js_context, JSVAL_TO_OBJECT (js_retval),
nth_out_arg++, &js_value) ||
JSVAL_IS_VOID (js_value))
{
g_warning ("Error failed to get out argument %i", nth_out_arg);
return FALSE;
}
else
{
success = set_out_arg (gexten->js_context, func_info,
is_return_value, &arg_cache[i].arg_info,
&arg_cache[i].type_info, arg_cache[i].ptr,
js_value);
}
}
}
return success;
}
/*
* Like JSEnumerateOp, but enum provides contextual information as follows:
*
* JSENUMERATE_INIT: allocate private enum struct in state_p, return number
* of elements in *id_p
* JSENUMERATE_NEXT: return next property id in *id_p, and if no new property
* free state_p and set to JSVAL_NULL
* JSENUMERATE_DESTROY : destroy state_p
*
* Note that in a for ... in loop, this will be called first on the object,
* then on its prototype.
*
*/
static JSBool
importer_new_enumerate(JSContext *context,
JS::HandleObject object,
JSIterateOp enum_op,
JS::MutableHandleValue statep,
JS::MutableHandleId idp)
{
ImporterIterator *iter;
switch (enum_op) {
case JSENUMERATE_INIT_ALL:
case JSENUMERATE_INIT: {
Importer *priv;
JSObject *search_path;
jsval search_path_val;
uint32_t search_path_len;
uint32_t i;
jsid search_path_name;
statep.set(JSVAL_NULL);
idp.set(INT_TO_JSID(0));
priv = priv_from_js(context, object);
if (!priv)
/* we are enumerating the prototype properties */
return JS_TRUE;
search_path_name = gjs_context_get_const_string(context, GJS_STRING_SEARCH_PATH);
if (!gjs_object_require_property(context, object, "importer", search_path_name, &search_path_val))
return JS_FALSE;
if (!search_path_val.isObject()) {
gjs_throw(context, "searchPath property on importer is not an object");
return JS_FALSE;
}
search_path = JSVAL_TO_OBJECT(search_path_val);
if (!JS_IsArrayObject(context, search_path)) {
gjs_throw(context, "searchPath property on importer is not an array");
return JS_FALSE;
}
if (!JS_GetArrayLength(context, search_path, &search_path_len)) {
gjs_throw(context, "searchPath array has no length");
return JS_FALSE;
}
iter = importer_iterator_new();
for (i = 0; i < search_path_len; ++i) {
std::string dirname;
std::string init_path;
const char *filename;
jsval elem;
std::vector<std::string> dir;
elem = JSVAL_VOID;
if (!JS_GetElement(context, search_path, i, &elem)) {
/* this means there was an exception, while elem == JSVAL_VOID
* means no element found
*/
importer_iterator_free(iter);
return JS_FALSE;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JSVAL_IS_STRING(elem)) {
gjs_throw(context, "importer searchPath contains non-string");
importer_iterator_free(iter);
return JS_FALSE;
}
if (!gjs_string_to_utf8(context, elem, dirname)) {
importer_iterator_free(iter);
return JS_FALSE; /* Error message already set */
}
init_path = pathCombine(dirname, MODULE_INIT_FILENAME);
load_module_elements(context, object, iter, init_path);
dir = enumerateFilesInDirectory(dirname);
if (dir.size() == 0) {
continue;
}
for(auto filename : dir) {
std::string full_path;
/* skip hidden files and directories (.svn, .git, ...) */
if (filename[0] == '.')
continue;
/* skip module init file */
if (filename == MODULE_INIT_FILENAME)
continue;
full_path = pathCombine(dirname, filename);
if (is_directory(full_path)) {
iter->elements.push_back(filename);
} else {
if (filename.rfind(MODULE_SUFFIX) != std::string::npos ||
filename.rfind(JS_SUFFIX) != std::string::npos) {
iter->elements.push_back(filename.substr(0, filename.size()-3));
}
}
}
}
statep.set(PRIVATE_TO_JSVAL(iter));
idp.set(INT_TO_JSID(iter->elements.size()));
break;
}
case JSENUMERATE_NEXT: {
jsval element_val;
if (JSVAL_IS_NULL(statep)) /* Iterating prototype */
return JS_TRUE;
iter = (ImporterIterator*) JSVAL_TO_PRIVATE(statep);
if (iter->index < iter->elements.size()) {
if (!gjs_string_from_utf8(context,
iter->elements.at(iter->index++),
&element_val))
return JS_FALSE;
jsid id;
if (!JS_ValueToId(context, element_val, &id))
return JS_FALSE;
idp.set(id);
break;
}
/* else fall through to destroying the iterator */
}
case JSENUMERATE_DESTROY: {
if (!JSVAL_IS_NULL(statep)) {
iter = (ImporterIterator*) JSVAL_TO_PRIVATE(statep);
importer_iterator_free(iter);
statep.set(JSVAL_NULL);
}
}
}
return JS_TRUE;
}
static JSBool
setDash_func(JSContext *context,
unsigned argc,
jsval *vp)
{
JS::CallArgs argv = JS::CallArgsFromVp (argc, vp);
JSObject *obj = JSVAL_TO_OBJECT(argv.thisv());
guint i;
cairo_t *cr;
JSObject *dashes;
double offset;
JSBool retval = JS_FALSE;
guint len;
GArray *dashes_c = NULL;
if (!gjs_parse_call_args(context, "setDash", "of", argv,
"dashes", &dashes, "offset", &offset))
return JS_FALSE;
JS_AddObjectRoot(context, &dashes);
if (!JS_IsArrayObject(context, dashes)) {
gjs_throw(context, "dashes must be an array");
goto out;
}
if (!JS_GetArrayLength(context, dashes, &len)) {
gjs_throw(context, "Can't get length of dashes");
goto out;
}
dashes_c = g_array_sized_new (FALSE, FALSE, sizeof(double), len);
for (i = 0; i < len; ++i) {
jsval elem;
double b;
elem = JSVAL_VOID;
if (!JS_GetElement(context, dashes, i, &elem)) {
goto out;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JS_ValueToNumber(context, elem, &b))
goto out;
if (b <= 0) {
gjs_throw(context, "Dash value must be positive");
goto out;
}
g_array_append_val(dashes_c, b);
}
cr = gjs_cairo_context_get_context(context, obj);
cairo_set_dash(cr, (double*)dashes_c->data, dashes_c->len, offset);
argv.rval().set(JSVAL_VOID);
retval = JS_TRUE;
out:
if (dashes_c != NULL)
g_array_free (dashes_c, TRUE);
JS_RemoveObjectRoot(context, &dashes);
return retval;
}
JSBool JSB_jsval_typedarray_to_dataptr( JSContext *cx, jsval vp, GLsizei *count, void **data, JSArrayBufferViewType t)
{
JSObject *jsobj;
JSBool ok = JS_ValueToObject( cx, vp, &jsobj );
JSB_PRECONDITION2( ok && jsobj, cx, JS_FALSE, "Error converting value to object");
// WebGL supports TypedArray and sequences for some of its APIs. So when converting a TypedArray, we should
// also check for a possible non-Typed Array JS object, like a JS Array.
if( JS_IsTypedArrayObject( jsobj ) ) {
*count = JS_GetTypedArrayLength(jsobj);
JSArrayBufferViewType type = JS_GetArrayBufferViewType(jsobj);
JSB_PRECONDITION2(t==type, cx, JS_FALSE, "TypedArray type different than expected type");
switch (t) {
case js::ArrayBufferView::TYPE_INT8:
case js::ArrayBufferView::TYPE_UINT8:
*data = JS_GetUint8ArrayData(jsobj);
break;
case js::ArrayBufferView::TYPE_INT16:
case js::ArrayBufferView::TYPE_UINT16:
*data = JS_GetUint16ArrayData(jsobj);
break;
case js::ArrayBufferView::TYPE_INT32:
case js::ArrayBufferView::TYPE_UINT32:
*data = JS_GetUint32ArrayData(jsobj);
break;
case js::ArrayBufferView::TYPE_FLOAT32:
*data = JS_GetFloat32ArrayData(jsobj);
break;
default:
JSB_PRECONDITION2(false, cx, JS_FALSE, "Unsupported typedarray type");
break;
}
} else if( JS_IsArrayObject(cx, jsobj)) {
// Slow... avoid it. Use TypedArray instead, but the spec says that it can receive
// Sequence<> as well.
uint32_t length;
JS_GetArrayLength(cx, jsobj, &length);
for( uint32_t i=0; i<length; i++ ) {
jsval valarg;
JS_GetElement(cx, jsobj, i, &valarg);
switch(t) {
case js::ArrayBufferView::TYPE_INT32:
case js::ArrayBufferView::TYPE_UINT32:
{
uint32_t e = JSVAL_TO_INT(valarg);
((uint32_t*)data)[i] = e;
break;
}
case js::ArrayBufferView::TYPE_FLOAT32:
{
double e = JSVAL_TO_DOUBLE(valarg);
((GLfloat*)data)[i] = (GLfloat)e;
break;
}
default:
JSB_PRECONDITION2(false, cx, JS_FALSE, "Unsupported typedarray type");
break;
}
}
} else
JSB_PRECONDITION2(false, cx, JS_FALSE, "Object shall be a TypedArray or Sequence");
return JS_TRUE;
}
static JSBool SMJS_FUNCTION(upnp_action_send_reply)
{
SMJS_OBJ
SMJS_ARGS
GPAC_GenericDevice *device = (GPAC_GenericDevice *)SMJS_GET_PRIVATE(c, obj);
if (!device) return JS_FALSE;
if (argc && JSVAL_IS_OBJECT(argv[0]) ) {
JSObject *list = JSVAL_TO_OBJECT(argv[0]);
u32 i, count;
JS_GetArrayLength(c, list, (jsuint*) &count);
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[UPnP] Calling response %s(", (char *) device->act_ref->GetActionDesc().GetName()));
i=0;
while (i+2<=count) {
jsval an_arg;
NPT_Result res;
char *param_val, *_param_val = NULL;
char szParamVal[1024];
JS_GetElement(c, list, (jsint) i, &an_arg);
char *param_name = SMJS_CHARS(c, an_arg);
JS_GetElement(c, list, (jsint) i+1, &an_arg);
param_val = (char*)"";
if (JSVAL_IS_STRING(an_arg)) {
param_val = _param_val = SMJS_CHARS(c, an_arg);
} else if (JSVAL_IS_BOOLEAN(an_arg)) {
param_val = (char *) ((JSVAL_TO_BOOLEAN(an_arg) == JS_TRUE) ? "true" : "false");
}
else if (JSVAL_IS_INT(argv[1])) {
sprintf(szParamVal, "%d", JSVAL_TO_INT(an_arg));
param_val = szParamVal;
}
else if (JSVAL_IS_NUMBER(an_arg)) {
jsdouble v;
JS_ValueToNumber(c, an_arg, &v);
sprintf(szParamVal, "%g", v);
param_val = szParamVal;
}
if (!param_name || !param_val) res = NPT_FAILURE;
else {
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" %s(%s)", param_name, param_val));
res = device->act_ref->SetArgumentValue(param_name, param_val);
}
SMJS_FREE(c, param_name);
SMJS_FREE(c, _param_val);
if (res != NPT_SUCCESS) return JS_FALSE;
i+=2;
}
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" )\n"));
}
//notify we are ready
if (device->m_pSema) {
gf_sema_notify(device->m_pSema, 1);
}
return JS_TRUE;
}
static void
format_frame(JSContext* cx, JSStackFrame* fp,
GString *buf, int num)
{
JSPropertyDescArray call_props = { 0, NULL };
JSObject* call_obj = NULL;
char* funname_str = NULL;
const char* filename = NULL;
guint32 lineno = 0;
guint32 named_arg_count = 0;
JSFunction* fun = NULL;
JSScript* script;
guchar* pc;
guint32 i;
gboolean is_string;
jsval val;
(void)JS_EnterLocalRootScope(cx);
if (!JS_IsScriptFrame(cx, fp)) {
g_string_append_printf(buf, "%d [native frame]\n", num);
goto out;
}
/* get the info for this stack frame */
script = JS_GetFrameScript(cx, fp);
pc = JS_GetFramePC(cx, fp);
if (script && pc) {
filename = JS_GetScriptFilename(cx, script);
lineno = (guint32) JS_PCToLineNumber(cx, script, pc);
fun = JS_GetFrameFunction(cx, fp);
if (fun) {
JSString* funname = JS_GetFunctionId(fun);
if (funname)
funname_str = gjs_string_get_ascii(cx, STRING_TO_JSVAL(funname));
}
call_obj = JS_GetFrameCallObject(cx, fp);
if (call_obj) {
if (!JS_GetPropertyDescArray(cx, call_obj, &call_props))
call_props.array = NULL;
}
}
/* print the frame number and function name */
if (funname_str) {
g_string_append_printf(buf, "%d %s(", num, funname_str);
g_free(funname_str);
}
else if (fun)
g_string_append_printf(buf, "%d anonymous(", num);
else
g_string_append_printf(buf, "%d <TOP LEVEL>", num);
for (i = 0; i < call_props.length; i++) {
char *name = NULL;
char *value = NULL;
JSPropertyDesc* desc = &call_props.array[i];
if(desc->flags & JSPD_ARGUMENT) {
name = jsvalue_to_string(cx, desc->id, &is_string);
if(!is_string) {
g_free(name);
name = NULL;
}
value = jsvalue_to_string(cx, desc->value, &is_string);
g_string_append_printf(buf, "%s%s%s%s%s%s",
named_arg_count ? ", " : "",
name ? name :"",
name ? " = " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
named_arg_count++;
}
g_free(name);
g_free(value);
}
/* print any unnamed trailing args (found in 'arguments' object) */
if (call_obj != NULL &&
JS_GetProperty(cx, call_obj, "arguments", &val) &&
JSVAL_IS_OBJECT(val)) {
guint32 k;
guint32 arg_count;
JSObject* args_obj = JSVAL_TO_OBJECT(val);
if (JS_GetArrayLength(cx, args_obj, &arg_count) &&
arg_count > named_arg_count) {
for (k = named_arg_count; k < arg_count; k++) {
if (JS_GetElement(cx, args_obj, k, &val)) {
char *value = jsvalue_to_string(cx, val, &is_string);
g_string_append_printf(buf, "%s%s%s%s",
k ? ", " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
g_free(value);
}
}
}
}
/* print filename and line number */
g_string_append_printf(buf, "%s@%s:%d\n",
fun ? ")" : "",
filename ? filename : "",
lineno);
out:
if (call_props.array)
JS_PutPropertyDescArray(cx, &call_props);
JS_LeaveLocalRootScope(cx);
}
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;
}
static JSBool SMJS_FUNCTION(upnp_service_call_action)
{
GPAC_ActionUDTA *act_udta = NULL;
char *action_name = NULL;
SMJS_OBJ
SMJS_ARGS
GPAC_ServiceItem *service = (GPAC_ServiceItem *)SMJS_GET_PRIVATE(c, obj);
if (!service || !argc || !JSVAL_IS_STRING(argv[0]) ) return JS_FALSE;
action_name = SMJS_CHARS(c, argv[0]);
PLT_ActionDesc* action_desc = service->m_service->FindActionDesc(action_name);
SMJS_FREE(c, action_name);
if (action_desc == NULL) return JS_FALSE;
PLT_ActionReference action;
NPT_CHECK_SEVERE(
service->m_device->m_pUPnP->m_pGenericController->m_CtrlPoint->CreateAction(
service->m_device->m_device,
service->m_service->GetServiceType(),
action_name,
action)
);
if ((argc>=2) && JSVAL_IS_OBJECT(argv[1])) {
JSObject *list = JSVAL_TO_OBJECT(argv[1]);
u32 i, count;
JS_GetArrayLength(c, list, (jsuint*) &count);
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[UPnP] Calling %s(", action_name));
i=0;
while (i+2<=count) {
NPT_Result res;
jsval an_arg;
char *param_val, *_param_val = NULL;
char szParamVal[1024];
JS_GetElement(c, list, (jsint) i, &an_arg);
char *param_name = SMJS_CHARS(c, an_arg);
JS_GetElement(c, list, (jsint) i+1, &an_arg);
param_val = (char*)"";
if (JSVAL_IS_STRING(an_arg)) {
param_val = _param_val = SMJS_CHARS(c, an_arg);
} else if (JSVAL_IS_BOOLEAN(an_arg)) {
param_val = (char *) ((JSVAL_TO_BOOLEAN(an_arg) == JS_TRUE) ? "true" : "false");
}
else if (JSVAL_IS_INT(argv[1])) {
sprintf(szParamVal, "%d", JSVAL_TO_INT(an_arg));
param_val = szParamVal;
}
else if (JSVAL_IS_NUMBER(an_arg)) {
jsdouble v;
JS_ValueToNumber(c, an_arg, &v);
sprintf(szParamVal, "%g", v);
param_val = szParamVal;
}
if (!param_name || !param_val) res = NPT_FAILURE;
else {
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" %s(%s)", param_name, param_val));
res = action->SetArgumentValue(param_name, param_val);
}
SMJS_FREE(c, param_name);
SMJS_FREE(c, _param_val);
if (res != NPT_SUCCESS) return JS_FALSE;
i+=2;
}
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" )\n"));
}
if ((argc==3) && JSVAL_IS_OBJECT(argv[2])) {
act_udta = new GPAC_ActionUDTA();
act_udta->udta = argv[2];
gf_js_add_root(c, &act_udta->udta, GF_JSGC_VAL);
}
service->m_device->m_pUPnP->m_pGenericController->m_CtrlPoint->InvokeAction(action, act_udta);
return JS_TRUE;
}
static JSBool
js_createMultiOpt(JSContext *cx, JSObject *obj, uintN argc,
jsval *argv, jsval *rval)
{
js_setting_group_t *jsg = JS_GetPrivate(cx, obj);
const char *id;
const char *title;
JSObject *func;
JSObject *optlist;
JSBool persistent = JS_FALSE;
if(!JS_ConvertArguments(cx, argc, argv, "ssoo/b",
&id, &title, &optlist, &func, &persistent))
return JS_FALSE;
js_setting_t *jss = jss_create(cx, obj, id, rval, func, jsg, persistent);
if(jss == NULL)
return JS_FALSE;
char **options = NULL;
JSIdArray *opts, *opt;
int i;
char *defvalue = NULL;
if((opts = JS_Enumerate(cx, optlist)) != NULL) {
for(i = 0; i < opts->length; i++) {
jsval name, value, id, title, def;
if(!JS_IdToValue(cx, opts->vector[i], &name) ||
!JSVAL_IS_INT(name) ||
!JS_GetElement(cx, optlist, JSVAL_TO_INT(name), &value) ||
!JSVAL_IS_OBJECT(value) ||
(opt = JS_Enumerate(cx, JSVAL_TO_OBJECT(value))) == NULL)
continue;
if(opt->length >= 2 &&
JS_GetElement(cx, JSVAL_TO_OBJECT(value), 0, &id) &&
JS_GetElement(cx, JSVAL_TO_OBJECT(value), 1, &title)) {
if(opt->length < 3 ||
!JS_GetElement(cx, JSVAL_TO_OBJECT(value), 2, &def))
def = JSVAL_FALSE;
const char *k = JS_GetStringBytes(JS_ValueToString(cx, id));
if(def == JSVAL_TRUE)
mystrset(&defvalue, k);
strvec_addp(&options, k);
strvec_addp(&options, JS_GetStringBytes(JS_ValueToString(cx, title)));
}
JS_DestroyIdArray(cx, opt);
}
JS_DestroyIdArray(cx, opts);
}
rstr_t *r = NULL;
if(persistent && jsg->jsg_kv_url)
r = kv_url_opt_get_rstr(jsg->jsg_kv_url, KVSTORE_DOMAIN_PLUGIN, id);
jss->jss_s =
setting_create(SETTING_MULTIOPT, jsg->jsg_root,
SETTINGS_INITIAL_UPDATE | jsg->jsg_settings_flags,
SETTING_TITLE_CSTR(title),
SETTING_COURIER(js_global_pc),
SETTING_CALLBACK(js_store_update_string, jss),
SETTING_VALUE(r ? rstr_get(r) : defvalue),
SETTING_OPTION_LIST(options),
SETTING_HTSMSG_CUSTOM_SAVER(id, jsg->jsg_store,
js_setting_group_save, jsg),
NULL);
strvec_free(options);
rstr_release(r);
jss->jss_cx = NULL;
return JS_TRUE;
}
JSBool XPCDispConvert::JSArrayToCOMArray(XPCCallContext& ccx, JSObject *obj,
VARIANT & var, nsresult& err)
{
err = NS_OK;
jsuint len;
if(!JS_GetArrayLength(ccx, obj, &len))
{
// TODO: I think we should create a specific error for this
err = NS_ERROR_XPC_NOT_ENOUGH_ELEMENTS_IN_ARRAY;
return PR_FALSE;
}
// Create the safe array of variants and populate it
SAFEARRAY * array = nsnull;
VARIANT* varArray = 0;
for(jsuint index = 0; index < len; ++index)
{
jsval val;
if(JS_GetElement(ccx, obj, index, &val))
{
if(!JSVAL_IS_VOID(val))
{
if(!array)
{
// Create an array that starts at index, and has len
// elements
array = SafeArrayCreateVector(VT_VARIANT, index, len - index);
if(!array)
{
err = NS_ERROR_OUT_OF_MEMORY;
return JS_FALSE;
}
if(FAILED(SafeArrayAccessData(array, reinterpret_cast<void**>(&varArray))))
{
err = NS_ERROR_FAILURE;
return JS_FALSE;
}
}
if(!JSToCOM(ccx, val, *varArray, err))
{
SafeArrayUnaccessData(array);
err = NS_ERROR_FAILURE;
// This cleans up the elements as well
SafeArrayDestroyData(array);
return JS_FALSE;
}
}
if(varArray)
++varArray;
}
}
if(!array)
{
array = SafeArrayCreateVector(VT_VARIANT, 0, 0);
if(!array)
{
err = NS_ERROR_OUT_OF_MEMORY;
return JS_FALSE;
}
}
else
{
SafeArrayUnaccessData(array);
}
var.vt = VT_ARRAY | VT_VARIANT;
var.parray = array;
return JS_TRUE;
}
//FlashCS5extension.WriteDynamic(라이브러리 다이나믹들)
JSBool WriteDynamic(JSContext *cx, JSObject *obj, unsigned int argc, jsval *argv, jsval *rval) {
writelog("begin");
if(argc != 1)
return JS_FALSE;
writelog("check arg count");
if(pObjectFile) {
JSObject* dynamicObjs;
if(JS_ValueToObject(cx, argv[0], &dynamicObjs) == JS_FALSE)
return ReturnString(cx, "q _ 1", rval);
writelog("get dynamic objects from argv[0]");
unsigned int dynamicLen = (unsigned int)JS_GetArrayLength(cx, dynamicObjs);
if(dynamicLen == -1)
return ReturnString(cx, "q _ 2", rval);
writelog("get dynamic length = %u", dynamicLen);
fwrite(&dynamicLen, sizeof(unsigned int), 1, pObjectFile);
for(int i = 0; i < dynamicLen; i++) {
jsval posDynamic;
if(JS_GetElement(cx, dynamicObjs, i, &posDynamic) == JS_FALSE)
return ReturnString(cx, "q _ 3", rval);
writelog("==================================");
writelog("get dynamic element %d", i);
JSObject* dynamicObj;
if(JS_ValueToObject(cx, posDynamic, &dynamicObj) == JS_FALSE)
return ReturnString(cx, "q _ 4", rval);
writelog("get dynamic object %d", i);
//라이브러리 네임
char *libName = GetString(cx, dynamicObj, 0);
if(libName == 0)
return ReturnString(cx, "q _ 5", rval);
//library ID
unsigned int libID = PushLibraryName(libName);
fwrite(&libID, sizeof(unsigned int), 1, pObjectFile);
writelog("libName = %s, libID = %u", libName, libID);
free(libName);
//library Type
long libType;
if(GetInteger(cx, dynamicObj, 4, &libType) == JS_FALSE)
return ReturnString(cx, "q _ 51", rval);
writelog("lib type = %d", libType);
fwrite(&libType, sizeof(long), 1, pObjectFile);
//frame Length
long frameLength;
if(GetInteger(cx, dynamicObj, 5, &frameLength) == JS_FALSE)
return ReturnString(cx, "q _ 51", rval);
writelog("frame length = %d", frameLength);
fwrite(&frameLength, sizeof(long), 1, pObjectFile);
// //인스턴스
// {
// JSObject* instanceObj;
// if(GetObject(cx, dynamicObj, 3, &instanceObj) == JS_FALSE)
// return ReturnString(cx, "instance _ 1", rval);
//
// //인스턴스 개수
// int insLen = (int)JS_GetArrayLength(cx, instanceObj);
// if(insLen == -1)
// return ReturnString(cx, "instance _ 2", rval);
//
// fwrite(&insLen, sizeof(int), 1, pObjectFile);
//
// writelog("instance length = %d", insLen);
//
// for(int m = 0; m < insLen; m++) {
// //instance obj
// JSObject* insObj;
// if(GetObject(cx, instanceObj, m, &insObj) == JS_FALSE)
// return ReturnString(cx, "instance _ 3", rval);
//
// //instance id
// long insid;
// if(GetInteger(cx, insObj, 1, &insid) == JS_FALSE)
// return ReturnString(cx, "instance _ 4", rval);
//
// //instance name
// char* insName = GetString(cx, insObj, 0);
// //instnace name length
// int insNameLen = strlen(insName);
//
// fwrite(&insNameLen, sizeof(int), 1, pObjectFile);
//
// writelog("instance name length = %d", insNameLen);
//
// fwrite(insName, sizeof(char), insNameLen, pObjectFile);
//
// writelog("instance name = %s", insName);
//
// fwrite(&insid, sizeof(int), 1, pObjectFile);
//
// writelog("instance id = %d", insid);
//
// free(insName);
// }
// }
//레퍼런스
{
JSObject* referenceObj;
if(GetObject(cx, dynamicObj, 1, &referenceObj) == JS_FALSE)
return ReturnString(cx, "q _ 6", rval);
writelog("--------------------------------");
writelog("get reference obj");
//reference count
int refLen = (int)JS_GetArrayLength(cx, referenceObj);
if(refLen == -1)
return ReturnString(cx, "q _ 7", rval);
writelog("reference length = %ld", refLen);
fwrite(&refLen, sizeof(int), 1, pObjectFile);
for(int j = 0; j < refLen; ++j) {
writelog("--------------------------------");
//ref info obj
JSObject* refObj;
if(GetObject(cx, referenceObj, j, &refObj) == JS_FALSE)
return ReturnString(cx, "q _ 71", rval);
int refMemberIndex = 0;
int refinfoLen = (int)JS_GetArrayLength(cx, refObj);
if(refinfoLen == -1)
return ReturnString(cx, "q _ 72", rval);
//reference ID
long refid;
if(GetInteger(cx, refObj, refMemberIndex++, &refid) == JS_FALSE)
return ReturnString(cx, "q _ 8", rval);
//type
long type;
if(GetInteger(cx, refObj, refMemberIndex++, &type) == JS_FALSE)
return ReturnString(cx, "q _ 11", rval);
writelog("type = %d", type);
fwrite(&type, sizeof(long), 1, pObjectFile);
//lib ID
char* libName = GetString(cx, refObj, refMemberIndex++);
//read Depth
//read StartFrame
long startFrame;
if(GetInteger(cx, refObj, refMemberIndex++, &startFrame) == JS_FALSE)
return ReturnString(cx, "q _ 11", rval);
//read End Frame
long endFrame;
if(GetInteger(cx, refObj, refMemberIndex++, &endFrame) == JS_FALSE)
return ReturnString(cx, "q _ 42", rval);
//read next reference ID
long nextrefid;
if(GetInteger(cx, refObj, refMemberIndex++, &nextrefid) == JS_FALSE)
return ReturnString(cx, "q _ 8", rval);
//read depth
long depth;
if(GetInteger(cx, refObj, refMemberIndex++, &depth) == JS_FALSE)
return ReturnString(cx, "q _ 8", rval);
if(type == _TYPE_BITMAP_) {
//lib Path
char* libPath = GetString(cx, refObj, refMemberIndex++);
unsigned int libID = PushLibraryName(libPath);
fwrite(&libID, sizeof(unsigned int), 1, pObjectFile);
writelog("lib path = %s, lib = %u", libPath, libID);
free(libPath);
} else if(type == _TYPE_GRAPHIC_) {
//get lib name
unsigned int libID = PushLibraryName(libName);
fwrite(&libID, sizeof(unsigned int), 1, pObjectFile);
writelog("lib name = %s, lib = %u", libName, libID);
free(libName);
} else {
//get lib name
unsigned int libID = PushLibraryName(libName);
fwrite(&libID, sizeof(unsigned int), 1, pObjectFile);
writelog("lib name = %s, lib = %u", libName, libID);
free(libName);
//instance ID
long insLen;
char* insName = GetString(cx, refObj, refMemberIndex++);
insLen = strlen(insName);
fwrite(&insLen, sizeof(long), 1, pObjectFile);
fwrite(insName, insLen, 1, pObjectFile);
writelog("instnace name = %s", insName);
}
//write depth
writelog("depth = %d", depth);
fwrite(&depth, sizeof(long), 1, pObjectFile);
//write Start Frame
writelog("startFrame = %d", startFrame);
fwrite(&startFrame, sizeof(long), 1, pObjectFile);
//write End Frame
writelog("end frame = %d", endFrame);
fwrite(&endFrame, sizeof(long), 1, pObjectFile);
if(type == _TYPE_BITMAP_ || type == _TYPE_GRAPHIC_ || type == _TYPE_MOVIECLIP_) {
writelog("ref id = %d", refid);
fwrite(&refid, sizeof(long), 1, pObjectFile);
//write next reference ID
writelog("next ref id = %d", nextrefid);
fwrite(&nextrefid, sizeof(long), 1, pObjectFile);
//Start Position
double startX;
double startY;
if(GetDouble(cx, refObj, refMemberIndex++, &startX) == JS_FALSE)
return ReturnString(cx, "q _ 12", rval);
if(GetDouble(cx, refObj, refMemberIndex++, &startY) == JS_FALSE)
return ReturnString(cx, "q _ 13", rval);
float startXf, startYf;
startXf = (float)startX;
startYf = (float)startY;
fwrite(&startXf, sizeof(float), 1, pObjectFile);
fwrite(&startYf, sizeof(float), 1, pObjectFile);
writelog("startX = %f, startY = %f", startX, startY);
//Anchor
double anchorX;
double anchorY;
if(GetDouble(cx, refObj, refMemberIndex++, &anchorX) == JS_FALSE)
return ReturnString(cx, "q _ 14", rval);
if(GetDouble(cx, refObj, refMemberIndex++, &anchorY) == JS_FALSE)
return ReturnString(cx, "q _ 15", rval);
float anchorXf, anchorYf;
anchorXf = (float)anchorX;
anchorYf = (float)anchorY;
fwrite(&anchorXf, sizeof(float), 1, pObjectFile);
fwrite(&anchorYf, sizeof(float), 1, pObjectFile);
writelog("anchorX = %f, anchorY = %f", anchorX, anchorY);
//Start Rotation
double startRotation;
if(GetDouble(cx, refObj, refMemberIndex++, &startRotation) == JS_FALSE)
return ReturnString(cx, "q _ 16", rval);
float rotf = (float)startRotation;
fwrite(&rotf, sizeof(float), 1, pObjectFile);
writelog("rotation = %f", startRotation);
//Start Scale
double scaleX;
double scaleY;
if(GetDouble(cx, refObj, refMemberIndex++, &scaleX) == JS_FALSE)
return ReturnString(cx, "q _ 17", rval);
if(GetDouble(cx, refObj, refMemberIndex++, &scaleY) == JS_FALSE)
return ReturnString(cx, "q _ 18", rval);
float scaleXf, scaleYf;
scaleXf = (float)scaleX;
scaleYf = (float)scaleY;
fwrite(&scaleXf, sizeof(float), 1, pObjectFile);
fwrite(&scaleYf, sizeof(float), 1, pObjectFile);
writelog("scale x = %f, y = %f", scaleX, scaleY);
//Start Skew
double startSkewX;
double startSkewY;
if(GetDouble(cx, refObj, refMemberIndex++, &startSkewX) == JS_FALSE)
return ReturnString(cx, "q _ 19", rval);
if(GetDouble(cx, refObj, refMemberIndex++, &startSkewY) == JS_FALSE)
return ReturnString(cx, "q _ 20", rval);
float skewXf, skewYf;
skewXf = (float)startSkewX;
skewYf = (float)startSkewY;
fwrite(&skewXf, sizeof(float), 1, pObjectFile);
fwrite(&skewYf, sizeof(float), 1, pObjectFile);
writelog("skew x = %f, y = %f", startSkewX, startSkewY);
if(type == _TYPE_GRAPHIC_ || type == _TYPE_MOVIECLIP_) {
//Start Color Style
long startColorAlphaPercent;
long startColorRedPercent;
long startColorGreenPercent;
long startColorBluePercent;
long startColorAlphaAmount;
long startColorRedAmount;
long startColorGreenAmount;
long startColorBlueAmount;
if(GetInteger(cx, refObj, refMemberIndex++, &startColorAlphaPercent) == JS_FALSE)
return ReturnString(cx, "q _ 22", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorRedPercent) == JS_FALSE)
return ReturnString(cx, "q _ 23", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorGreenPercent) == JS_FALSE)
return ReturnString(cx, "q _ 24", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorBluePercent) == JS_FALSE)
return ReturnString(cx, "q _ 25", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorAlphaAmount) == JS_FALSE)
return ReturnString(cx, "q _ 26", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorRedAmount) == JS_FALSE)
return ReturnString(cx, "q _ 27", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorGreenAmount) == JS_FALSE)
return ReturnString(cx, "q _ 28", rval);
if(GetInteger(cx, refObj, refMemberIndex++, &startColorBlueAmount) == JS_FALSE)
return ReturnString(cx, "q _ 29", rval);
char alphaPercent = (char)startColorAlphaPercent;
char redPercent = (char)startColorRedPercent;
char greenPercent = (char)startColorGreenPercent;
char bluePercent = (char)startColorBluePercent;
short alphaAmount = (short)startColorAlphaAmount;
short redAmount = (short)startColorRedAmount;
short greenAmount = (short)startColorGreenAmount;
short blueAmount = (short)startColorBlueAmount;
fwrite(&redPercent, sizeof(char), 1, pObjectFile);
fwrite(&greenPercent, sizeof(char), 1, pObjectFile);
fwrite(&bluePercent, sizeof(char), 1, pObjectFile);
fwrite(&alphaPercent, sizeof(char), 1, pObjectFile);
fwrite(&redAmount, sizeof(short), 1, pObjectFile);
fwrite(&greenAmount, sizeof(short), 1, pObjectFile);
fwrite(&blueAmount, sizeof(short), 1, pObjectFile);
fwrite(&alphaAmount, sizeof(short), 1, pObjectFile);
writelog("alpha percent = %d", startColorAlphaPercent);
writelog("red percent = %d", startColorRedPercent);
writelog("green percent = %d", startColorGreenPercent);
writelog("blue percent = %d", startColorBluePercent);
writelog("alpha amount = %d", startColorAlphaAmount);
writelog("red amount = %d", startColorRedAmount);
writelog("green amount = %d", startColorGreenAmount);
writelog("blue amount = %d", startColorBlueAmount);
}
if(type == _TYPE_GRAPHIC_ || type == _TYPE_MOVIECLIP_) {
long startColorBlendMode;
if(GetInteger(cx, refObj, refMemberIndex++, &startColorBlendMode) == JS_FALSE)
return ReturnString(cx, "q _ 30", rval);
unsigned char blendMode = (unsigned char)startColorBlendMode;
fwrite(&blendMode, sizeof(blendMode), 1, pObjectFile);
writelog("blend mode = %d", startColorBlendMode);
//Ease
long easeType;
if(GetInteger(cx, refObj, refMemberIndex++, &easeType) == JS_FALSE)
return ReturnString(cx, "q _ 31", rval);
writelog("ease type = %d", easeType);
unsigned char easeTypeuc = (unsigned char)easeType;
fwrite(&easeTypeuc, sizeof(easeTypeuc), 1, pObjectFile);
if(easeType == 2) { //멀티 타입일 경우(Position, Rotation, Scale, Color, Filters)
for(int l = 0; l < 4; ++l)
{
JSObject* easeObj;
if(GetObject(cx, refObj, refMemberIndex++, &easeObj) == JS_FALSE)
return ReturnString(cx, "q _ 32", rval);
writelog("get multi ease obj");
int easeCount = JS_GetArrayLength(cx, easeObj);
if(easeCount == -1)
return ReturnString(cx, "q _ 33", rval);
writelog("get ease length = %d", easeCount);
fwrite(&easeCount, sizeof(int), 1, pObjectFile);
for(int k = 0; k < easeCount; ++k) {
JSObject* posObj;
if(GetObject(cx, easeObj, k, &posObj) == JS_FALSE)
return ReturnString(cx, "q _ 34", rval);
writelog("get pos obj");
double x, y;
if(GetDouble(cx, posObj, 0, &x) == JS_FALSE)
return ReturnString(cx, "q _ 35", rval);
if(GetDouble(cx, posObj, 1, &y) == JS_FALSE)
return ReturnString(cx, "q _ 36", rval);
float fx, fy;
fx = (float)x;
fy = (float)y;
fwrite(&fx, sizeof(float), 1, pObjectFile);
fwrite(&fy, sizeof(float), 1, pObjectFile);
writelog("x = %f, y = %f", x, y);
}
}
} else if(easeType == 1) { //싱글이나 심플일 경우
JSObject* easeObj;
if(GetObject(cx, refObj, refMemberIndex++, &easeObj) == JS_FALSE)
return ReturnString(cx, "q _ 37", rval);
writelog("get ease obj");
int easeCount = JS_GetArrayLength(cx, easeObj);
if(easeCount == -1)
return ReturnString(cx, "q _ 38", rval);
writelog("get ease length = %d", easeCount);
fwrite(&easeCount, sizeof(int), 1, pObjectFile);
for(int k = 0; k < easeCount; ++k) {
JSObject* posObj;
if(GetObject(cx, easeObj, k, &posObj) == JS_FALSE)
return ReturnString(cx, "q _ 39", rval);
writelog("get pos obj");
double x, y;
if(GetDouble(cx, posObj, 0, &x) == JS_FALSE)
return ReturnString(cx, "q _ 40", rval);
if(GetDouble(cx, posObj, 1, &y) == JS_FALSE)
return ReturnString(cx, "q _ 41", rval);
float fx, fy;
fx = (float)x;
fy = (float)y;
fwrite(&fx, sizeof(float), 1, pObjectFile);
fwrite(&fy, sizeof(float), 1, pObjectFile);
writelog("x = %f, y = %f", x, y);
}
}
}
}
}
}
// //프레임
// {
// JSObject* frameObj;
// if(GetObject(cx, dynamicObj, 2, &frameObj) == JS_FALSE)
// return ReturnString(cx, "q _ 60", rval);
//
// writelog("get frame obj");
//
// //프레임 개수
// int frameCount;
// frameCount = JS_GetArrayLength(cx, frameObj);
// if(frameCount == -1)
// return ReturnString(cx, "q _ 61", rval);
//
// writelog("get frame count = %d", frameCount);
//
// fwrite(&frameCount, sizeof(int), 1, pObjectFile);
//
// for(int j = 0; j < frameCount; ++j) {
// //레퍼런스 아이디 배열
// JSObject* refObj;
// if(GetObject(cx, frameObj, j, &refObj) == JS_FALSE)
// return ReturnString(cx, "q _ 62", rval);
//
// fwrite(&j, sizeof(int), 1, pObjectFile);
//
// writelog("frame = %d", j);
//
// //레퍼런스 개수
// int refCount = JS_GetArrayLength(cx, refObj);
// if(refCount == -1)
// return ReturnString(cx, "q _ 63", rval);
//
// fwrite(&refCount, sizeof(int), 1, pObjectFile);
//
// writelog("ref count = %d", refCount);
//
// for(int k = 0; k < refCount; ++k) {
// //레퍼런스 번호
// long refid;
// if(GetInteger(cx, refObj, k, &refid) == JS_FALSE)
// return ReturnString(cx, "q _ 64", rval);
//
// fwrite(&refid, sizeof(long), 1, pObjectFile);
//
// writelog("ref id = %d", refid);
// }
// }
// }
}
*rval = JS_BooleanToValue(JS_TRUE);
return JS_TRUE;
} else {
return ReturnString(cx, "a _ 17", rval);
}
}
/**
* Load a JavaScript file then run the function corresponding to the service by
* passing the conf, inputs and outputs parameters by value as JavaScript
* Objects.
*
* @param main_conf the conf maps containing the main.cfg settings
* @param request the map containing the HTTP request
* @param s the service structure
* @param inputs the maps containing the inputs
* @param outputs the maps containing the outputs
* @return SERVICE_SUCCEEDED or SERVICE_FAILED if the service run, -1
* if the service failed to load or throw error at runtime.
*/
int zoo_js_support(maps** main_conf,map* request,service* s,maps **inputs,maps **outputs)
{
/*maps* main=*main_conf;
maps* _inputs=*inputs;
maps* _outputs=*outputs;*/
/* The class of the global object. */
JSClass global_class= {
"global", JSCLASS_GLOBAL_FLAGS,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
JSCLASS_NO_OPTIONAL_MEMBERS
};
/* JS variables. */
JSRuntime *rt;
JSContext *cx;
JSObject *global;
/* Create a JS runtime. */
rt = JS_NewRuntime(8L * 1024L * 1024L);
if (rt == NULL)
return 1;
/* Create a context. */
cx = JS_NewContext(rt,8192);
if (cx == NULL){
return 1;
}
JS_SetOptions(cx, JSOPTION_VAROBJFIX | JSOPTION_JIT | JSOPTION_METHODJIT);
JS_SetVersion(cx, JSVERSION_LATEST);
JS_SetErrorReporter(cx, reportError);
/* Create the global object. */
global = JS_NewCompartmentAndGlobalObject(cx, &global_class, NULL);
/* Populate the global object with the standard globals,
like Object and Array. */
if (!JS_InitStandardClasses(cx, global)){
return 1;
}
/* Define specific function and global variable to share with JS runtime
*/
jsval tmp=INT_TO_JSVAL(3);
if (!JS_SetProperty(cx, global, "SERVICE_SUCCEEDED", &tmp))
return 1;
tmp=INT_TO_JSVAL(4);
if (!JS_SetProperty(cx, global, "SERVICE_FAILED", &tmp))
return 1;
if (!JS_DefineFunction(cx, global, "ZOORequest", JSRequest, 4, 0))
return 1;
if (!JS_DefineFunction(cx, global, "ZOOTranslate", JSTranslate, 4, 0))
return 1;
if (!JS_DefineFunction(cx, global, "ZOOUpdateStatus", JSUpdateStatus, 2, 0))
return 1;
if (!JS_DefineFunction(cx, global, "alert", JSAlert, 2, 0))
return 1;
if (!JS_DefineFunction(cx, global, "importScripts", JSLoadScripts, 1, 0))
return 1;
/**
* Add private context object
*/
void* cxPrivate = request;
JS_SetContextPrivate(cx,cxPrivate);
map* tmpm1=getMap(request,"metapath");
char ntmp[1024];
map* cwdMap=getMapFromMaps(*main_conf,"main","servicePath");
if(cwdMap!=NULL)
sprintf(ntmp,"%s",cwdMap->value);
else
getcwd(ntmp,1024);
/**
* Load the first part of the ZOO-API
*/
char *api0=(char*)malloc((strlen(ntmp)+17)*sizeof(char));
sprintf(api0,"%s/ZOO-proj4js.js",ntmp);
#ifdef JS_DEBUG
fprintf(stderr,"Trying to load %s\n",api0);
#endif
JSObject *api_script1=loadZooApiFile(cx,global,api0);
free(api0);
fflush(stderr);
char *api1=(char*)malloc((strlen(ntmp)+13)*sizeof(char));
sprintf(api1,"%s/ZOO-api.js",ntmp);
#ifdef JS_DEBUG
fprintf(stderr,"Trying to load %s\n",api1);
#endif
JSObject *api_script2=loadZooApiFile(cx,global,api1);
free(api1);
fflush(stderr);
/* Your application code here. This may include JSAPI calls
to create your own custom JS objects and run scripts. */
//maps* out=*outputs;
int res=SERVICE_FAILED;
//maps* mc=*main_conf;
map* tmpm2=getMap(s->content,"serviceProvider");
char *filename=(char*)malloc(strlen(tmpm1->value)+strlen(tmpm2->value)+strlen(ntmp)+3);
sprintf(filename,"%s/%s/%s",ntmp,tmpm1->value,tmpm2->value);
filename[strlen(tmpm1->value)+strlen(tmpm2->value)+strlen(ntmp)+2]=0;
#ifdef JS_DEBUG
fprintf(stderr,"FILENAME %s\n",filename);
#endif
struct stat file_status;
stat(filename, &file_status);
//char *source=(char*)malloc(file_status.st_size);
//uint16 lineno;
jsval rval;
JSBool ok ;
JSObject *script = JS_CompileFile(cx, global, filename);
if(script!=NULL){
(void)JS_ExecuteScript(cx, global, script, &rval);
}
else{
char tmp1[1024];
sprintf(tmp1,"Unable to load JavaScript file %s",filename);
free(filename);
errorException(*main_conf,tmp1,"NoApplicableCode",NULL);
JS_MaybeGC(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
return -1;
}
/* Call a function in obj's scope. */
jsval argv[3];
JSObject *jsargv1=JSObject_FromMaps(cx,*main_conf);
argv[0] = OBJECT_TO_JSVAL(jsargv1);
JSObject *jsargv2=JSObject_FromMaps(cx,*inputs);
argv[1] = OBJECT_TO_JSVAL(jsargv2);
JSObject *jsargv3=JSObject_FromMaps(cx,*outputs);
argv[2] = OBJECT_TO_JSVAL(jsargv3);
jsval rval1=JSVAL_NULL;
#ifdef JS_DEBUG
fprintf(stderr, "object %p\n", (void *) argv[2]);
#endif
ok = JS_CallFunctionName(cx, global, s->name, 3, argv, &rval1);
#ifdef JS_DEBUG
fprintf(stderr, "object %p\n", (void *) argv[2]);
#endif
JSObject *d;
if (ok==JS_TRUE && JSVAL_IS_OBJECT(rval1)==JS_TRUE) {
#ifdef JS_DEBUG
fprintf(stderr,"Function run sucessfully !\n");
#endif
/* Should get a number back from the service function call. */
ok = JS_ValueToObject(cx, rval1, &d);
}else{
/* Unable to run JS function */
char tmp1[1024];
if(strlen(dbg)==0)
sprintf(dbg,"No result was found after the function call");
sprintf(tmp1,"Unable to run %s from the JavaScript file %s : \n %s",s->name,filename,dbg);
#ifdef JS_DEBUG
fprintf(stderr,"%s",tmp1);
#endif
errorException(*main_conf,tmp1,"NoApplicableCode",NULL);
free(filename);
JS_MaybeGC(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
// Should return -1 here but the unallocation won't work from zoo_service_loader.c line 1847
return -1;
}
//jsval t=OBJECT_TO_JSVAL(d);
if(JS_IsArrayObject(cx,d)){
#ifdef JS_DEBUG
fprintf(stderr,"An array was returned !\n");
#endif
jsuint len;
if((JS_GetArrayLength(cx, d, &len)==JS_FALSE)){
#ifdef JS_DEBUG
fprintf(stderr,"outputs array is empty\n");
#endif
}
jsval tmp1;
JSBool hasResult=JS_GetElement(cx,d,0,&tmp1);
res=JSVAL_TO_INT(tmp1);
#ifdef JS_DEBUG
fprintf(stderr," * %d * \n",res);
#endif
if(res==SERVICE_SUCCEEDED){
jsval tmp2;
JSBool hasElement=JS_GetElement(cx,d,1,&tmp2);
if(hasElement==JS_TRUE){
freeMaps(outputs);
free(*outputs);
*outputs=mapsFromJSObject(cx,tmp2);
}
}else{
jsval tmp3;
JSBool hasConf=JS_GetElement(cx,d,1,&tmp3);
if(hasConf==JS_TRUE){
freeMaps(main_conf);
free(*main_conf);
*main_conf=mapsFromJSObject(cx,tmp3);
}
}
}
else{
#ifdef JS_DEBUG
fprintf(stderr,"The service didn't return an array !\n");
#endif
/**
* Extract result
*/
jsval tmp1;
JSBool hasResult=JS_GetProperty(cx,d,"result",&tmp1);
res=JSVAL_TO_INT(tmp1);
#ifdef JS_DEBUG
fprintf(stderr," * %d * \n",res);
#endif
/**
* Extract outputs when available.
*/
jsval tmp2;
JSBool hasElement=JS_GetProperty(cx,d,"outputs",&tmp2);
if(!JSVAL_IS_VOID(tmp2) && hasElement==JS_TRUE){
freeMaps(outputs);
free(*outputs);
*outputs=mapsFromJSObject(cx,tmp2);
}
JS_MaybeGC(cx);
#ifdef JS_DEBUG
if(JSVAL_IS_VOID(tmp2))
fprintf(stderr,"No outputs property returned\n");
else{
if(JS_IsArrayObject(cx,JSVAL_TO_OBJECT(tmp2)))
fprintf(stderr,"outputs is an array as expected\n");
else
fprintf(stderr,"outputs is not an array as expected\n");
}
JS_MaybeGC(cx);
#endif
/**
* Extract conf when available.
*/
jsval tmp3;
JSBool hasConf=JS_GetProperty(cx,d,"conf",&tmp3);
if(!JSVAL_IS_VOID(tmp3) && hasConf==JS_TRUE){
freeMaps(main_conf);
free(*main_conf);
*main_conf=mapsFromJSObject(cx,tmp3);
}
JS_MaybeGC(cx);
#ifdef JS_DEBUG
dumpMaps(*outputs);
#endif
}
/* Cleanup. */
JS_MaybeGC(cx);
JS_DestroyContext(cx);
JS_DestroyRuntime(rt);
JS_ShutDown();
free(filename);
#ifdef JS_DEBUG
fprintf(stderr,"Returned value %d\n",res);
#endif
return res;
}
JSBool JSI_IGUIObject::setProperty(JSContext* cx, JSObject* obj, jsid id, JSBool UNUSED(strict), jsval* vp)
{
IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, obj, &JSI_IGUIObject::JSI_class, NULL);
if (!e)
return JS_FALSE;
jsval idval;
if (!JS_IdToValue(cx, id, &idval))
return JS_FALSE;
std::string propName;
if (!ScriptInterface::FromJSVal(cx, idval, propName))
return JS_FALSE;
if (propName == "name")
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
e->SetName(value);
return JS_TRUE;
}
// Use onWhatever to set event handlers
if (propName.substr(0, 2) == "on")
{
if (!JSVAL_IS_OBJECT(*vp) || !JS_ObjectIsFunction(cx, JSVAL_TO_OBJECT(*vp)))
{
JS_ReportError(cx, "on- event-handlers must be functions");
return JS_FALSE;
}
CStr eventName (CStr(propName.substr(2)).LowerCase());
e->SetScriptHandler(eventName, JSVAL_TO_OBJECT(*vp));
return JS_TRUE;
}
// Retrieve the setting's type (and make sure it actually exists)
EGUISettingType Type;
if (e->GetSettingType(propName, Type) != PSRETURN_OK)
{
JS_ReportError(cx, "Invalid setting '%s'", propName.c_str());
return JS_TRUE;
}
switch (Type)
{
case GUIST_CStr:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
GUI<CStr>::SetSetting(e, propName, value);
break;
}
case GUIST_CStrW:
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
GUI<CStrW>::SetSetting(e, propName, value);
break;
}
case GUIST_CGUISpriteInstance:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
GUI<CGUISpriteInstance>::SetSetting(e, propName, CGUISpriteInstance(value));
break;
}
case GUIST_CGUIString:
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
CGUIString str;
str.SetValue(value);
GUI<CGUIString>::SetSetting(e, propName, str);
break;
}
case GUIST_EAlign:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
EAlign a;
if (value == "left") a = EAlign_Left;
else if (value == "right") a = EAlign_Right;
else if (value == "center" || value == "centre") a = EAlign_Center;
else
{
JS_ReportError(cx, "Invalid alignment (should be 'left', 'right' or 'center')");
return JS_FALSE;
}
GUI<EAlign>::SetSetting(e, propName, a);
break;
}
case GUIST_EVAlign:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
EVAlign a;
if (value == "top") a = EVAlign_Top;
else if (value == "bottom") a = EVAlign_Bottom;
else if (value == "center" || value == "centre") a = EVAlign_Center;
else
{
JS_ReportError(cx, "Invalid alignment (should be 'top', 'bottom' or 'center')");
return JS_FALSE;
}
GUI<EVAlign>::SetSetting(e, propName, a);
break;
}
case GUIST_int:
{
int32 value;
if (JS_ValueToInt32(cx, *vp, &value) == JS_TRUE)
GUI<int>::SetSetting(e, propName, value);
else
{
JS_ReportError(cx, "Cannot convert value to int");
return JS_FALSE;
}
break;
}
case GUIST_float:
{
jsdouble value;
if (JS_ValueToNumber(cx, *vp, &value) == JS_TRUE)
GUI<float>::SetSetting(e, propName, (float)value);
else
{
JS_ReportError(cx, "Cannot convert value to float");
return JS_FALSE;
}
break;
}
case GUIST_bool:
{
JSBool value;
if (JS_ValueToBoolean(cx, *vp, &value) == JS_TRUE)
GUI<bool>::SetSetting(e, propName, value||0); // ||0 to avoid int-to-bool compiler warnings
else
{
JS_ReportError(cx, "Cannot convert value to bool");
return JS_FALSE;
}
break;
}
case GUIST_CClientArea:
{
if (JSVAL_IS_STRING(*vp))
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
if (e->SetSetting(propName, value) != PSRETURN_OK)
{
JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
return JS_FALSE;
}
}
else if (JSVAL_IS_OBJECT(*vp) && JS_InstanceOf(cx, JSVAL_TO_OBJECT(*vp), &JSI_GUISize::JSI_class, NULL))
{
CClientArea area;
GUI<CClientArea>::GetSetting(e, propName, area);
JSObject* obj = JSVAL_TO_OBJECT(*vp);
#define P(x, y, z) area.x.y = (float)g_ScriptingHost.GetObjectProperty_Double(obj, #z)
P(pixel, left, left);
P(pixel, top, top);
P(pixel, right, right);
P(pixel, bottom, bottom);
P(percent, left, rleft);
P(percent, top, rtop);
P(percent, right, rright);
P(percent, bottom, rbottom);
#undef P
GUI<CClientArea>::SetSetting(e, propName, area);
}
else
{
JS_ReportError(cx, "Size only accepts strings or GUISize objects");
return JS_FALSE;
}
break;
}
case GUIST_CColor:
{
if (JSVAL_IS_STRING(*vp))
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
if (e->SetSetting(propName, value) != PSRETURN_OK)
{
JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
return JS_FALSE;
}
}
else if (JSVAL_IS_OBJECT(*vp) && JS_InstanceOf(cx, JSVAL_TO_OBJECT(*vp), &JSI_GUIColor::JSI_class, NULL))
{
CColor colour;
JSObject* obj = JSVAL_TO_OBJECT(*vp);
jsval t; double s;
#define PROP(x) JS_GetProperty(cx, obj, #x, &t); \
JS_ValueToNumber(cx, t, &s); \
colour.x = (float)s
PROP(r); PROP(g); PROP(b); PROP(a);
#undef PROP
GUI<CColor>::SetSetting(e, propName, colour);
}
else
{
JS_ReportError(cx, "Color only accepts strings or GUIColor objects");
return JS_FALSE;
}
break;
}
case GUIST_CGUIList:
{
JSObject* obj = JSVAL_TO_OBJECT(*vp);
jsuint length;
if (JSVAL_IS_OBJECT(*vp) && JS_GetArrayLength(cx, obj, &length) == JS_TRUE)
{
CGUIList list;
for (int i=0; i<(int)length; ++i)
{
jsval element;
if (! JS_GetElement(cx, obj, i, &element))
{
JS_ReportError(cx, "Failed to get list element");
return JS_FALSE;
}
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, element, value))
return JS_FALSE;
CGUIString str;
str.SetValue(value);
list.m_Items.push_back(str);
}
GUI<CGUIList>::SetSetting(e, propName, list);
}
else
{
JS_ReportError(cx, "List only accepts a GUIList object");
return JS_FALSE;
}
break;
}
// TODO Gee: (2004-09-01) EAlign and EVAlign too.
default:
JS_ReportError(cx, "Setting '%s' uses an unimplemented type", propName.c_str());
break;
}
return !JS_IsExceptionPending(cx);
}
/**
* Convert a JavaScript Object to a maps
*
* @param cx the JavaScript context
* @param t the JavaScript Object to convert
* @return a new maps containing the JavaScript Object
*/
maps* mapsFromJSObject(JSContext *cx,jsval t){
maps *res=NULL;
maps *tres=NULL;
jsint oi=0;
JSObject* tt=JSVAL_TO_OBJECT(t);
if(JS_IsArrayObject(cx,tt)){
#ifdef JS_DEBUG
fprintf(stderr,"Is finally an array !\n");
#endif
}
else{
#ifdef JS_DEBUG
fprintf(stderr,"Is not an array !\n");
#endif
JSIdArray *idp=JS_Enumerate(cx,tt);
if(idp!=NULL) {
int index;
jsdouble argNum;
#ifdef JS_DEBUG
fprintf(stderr,"Properties length : %d \n",idp->length);
#endif
for (index=0,argNum=idp->length;index<argNum;index++) {
jsval id = idp->vector[index];
jsval vp;
JS_IdToValue(cx,id,&vp);
char *tmp;
JSString *jsmsg;
size_t len1;
jsmsg = JS_ValueToString(cx,vp);
len1 = JS_GetStringLength(jsmsg);
tmp=JS_EncodeString(cx,jsmsg);
tres=createMaps(tmp);
jsval nvp=JSVAL_NULL;
if((JS_GetProperty(cx, tt, tmp, &nvp)==JS_FALSE)){
#ifdef JS_DEBUG
fprintf(stderr,"Enumerate id : %d => %s => No more value\n",oi,tmp);
#endif
}
free(tmp);
JSObject *nvp1=JSVAL_TO_OBJECT(JSVAL_NULL);
JS_ValueToObject(cx,nvp,&nvp1);
jsval nvp1j=OBJECT_TO_JSVAL(nvp1);
if(JSVAL_IS_OBJECT(nvp1j)){
tres->content=mapFromJSObject(cx,nvp1j);
}
jsval nvp0=JSVAL_NULL;
JSObject *nvp01=JSVAL_TO_OBJECT(JSVAL_NULL);
if((JS_GetProperty(cx, nvp1, "child", &nvp0)==JS_FALSE)){
#ifdef JS_DEBUG
fprintf(stderr,"Enumerate id : %d => %s => No more value\n",oi,tmp);
#endif
}
JS_ValueToObject(cx,nvp0,&nvp01);
jsval nvp01j=OBJECT_TO_JSVAL(nvp01);
if(!JSVAL_IS_NULL(nvp01j)){
tres->child=mapsFromJSObject(cx,nvp01j);
}
if(res==NULL)
res=dupMaps(&tres);
else
addMapsToMaps(&res,tres);
freeMaps(&tres);
free(tres);
tres=NULL;
}
JS_DestroyIdArray(cx,idp);
}
}
jsuint len;
JSBool hasLen=JS_GetArrayLength(cx, tt, &len);
#ifdef JS_DEBUG
if(hasLen==JS_FALSE){
fprintf(stderr,"outputs array is empty\n");
}
fprintf(stderr,"outputs array length : %d\n",len);
#endif
for(oi=0;hasLen && oi < len;oi++){
#ifdef JS_DEBUG
fprintf(stderr,"outputs array length : %d step %d \n",len,oi);
#endif
jsval tmp1;
JSBool hasElement=JS_GetElement(cx,tt,oi,&tmp1);
JSObject *otmp1=JSVAL_TO_OBJECT(tmp1);
JSIdArray *idp=JS_Enumerate(cx,otmp1);
if(idp!=NULL) {
int index;
jsdouble argNum;
#ifdef JS_DEBUG
fprintf(stderr,"Properties length : %d \n",idp->length);
#endif
tres=(maps*)malloc(MAPS_SIZE);
tres->name=NULL;
tres->content=NULL;
tres->next=NULL;
for (index=0,argNum=idp->length;index<argNum;index++) {
jsval id = idp->vector[index];
jsval vp;
JS_IdToValue(cx,id,&vp);
char *tmp;
JSString *jsmsg;
size_t len1;
jsmsg = JS_ValueToString(cx,vp);
len1 = JS_GetStringLength(jsmsg);
tmp=JS_EncodeString(cx,jsmsg);
#ifdef JS_DEBUG
fprintf(stderr,"Enumerate id : %d => %s\n",oi,tmp);
#endif
jsval nvp=JSVAL_NULL;
if((JS_GetProperty(cx, JSVAL_TO_OBJECT(tmp1), tmp, &nvp)==JS_FALSE)){
#ifdef JS_DEBUG
fprintf(stderr,"Enumerate id : %d => %s => No more value\n",oi,tmp);
#endif
}
free(tmp);
if(JSVAL_IS_OBJECT(nvp)){
#ifdef JS_DEBUG
fprintf(stderr,"JSVAL NVP IS OBJECT\n");
#endif
}
JSObject *nvp1=JSVAL_TO_OBJECT(JSVAL_NULL);
JS_ValueToObject(cx,nvp,&nvp1);
jsval nvp1j=OBJECT_TO_JSVAL(nvp1);
if(JSVAL_IS_OBJECT(nvp1j)){
JSString *jsmsg1;
char *tmp1, *tmp2;
JSObject *nvp2=JSVAL_TO_OBJECT(JSVAL_NULL);
jsmsg1 = JS_ValueToString(cx,nvp1j);
len1 = JS_GetStringLength(jsmsg1);
tmp1=JS_EncodeString(cx,jsmsg1);
tmp2=JS_EncodeString(cx,jsmsg);
#ifdef JS_DEBUG
fprintf(stderr,"JSVAL NVP1J IS OBJECT %s = %s\n",JS_EncodeString(cx,jsmsg),tmp1);
#endif
if(strcasecmp(tmp1,"[object Object]")==0){
tres->name=zStrdup(tmp2);
tres->content=mapFromJSObject(cx,nvp1j);
}
else
if(strcasecmp(tmp2,"name")==0){
tres->name=zStrdup(tmp1);
}
else{
if(tres->content==NULL)
tres->content=createMap(tmp2,tmp1);
else
addToMap(tres->content,tmp2,tmp1);
}
free(tmp1);
free(tmp2);
}
#ifdef JS_DEBUG
else
fprintf(stderr,"JSVAL NVP1J IS NOT OBJECT !!\n");
#endif
}
#ifdef JS_DEBUG
dumpMaps(tres);
#endif
if(res==NULL)
res=dupMaps(&tres);
else
addMapsToMaps(&res,tres);
freeMaps(&tres);
free(tres);
tres=NULL;
JS_DestroyIdArray(cx,idp);
}
}
#ifdef JS_DEBUG
dumpMaps(res);
#endif
return res;
}
void Server::invokeCallback( const JSCallback & theCallback,
const request & theRequest,
reply & theReply)
{
std::string myResponseString;
try {
jsval argv[4], rval;
argv[0] = jslib::as_jsval(theCallback.context, theRequest.method);
argv[1] = jslib::as_jsval(theCallback.context, theRequest.body);
argv[2] = jslib::as_jsval(theCallback.context, theRequest.uri );
argv[3] = jslib::as_jsval(theCallback.context, theRequest.headers );
jslib::JSA_CallFunctionValue(theCallback.context, theCallback.object, theCallback.functionValue,
4, argv, &rval);
if (JSVAL_IS_VOID(rval)) {
theReply.status = reply::no_content;
return;
}
// changed to adhere to industry standard:
// the callback must return either:
// body
// [statuscode, body]
// [statucode, headers, body]
//
// where body is a string, statuscode an integer and headers a hash.
if (JSVAL_IS_OBJECT(rval)) {
JSObject * myJsObject;
jsuint arrayLength;
if(JS_ValueToObject(theCallback.context, rval, &myJsObject)) {
if (JS_IsArrayObject(theCallback.context, myJsObject) &&
JS_GetArrayLength(theCallback.context, myJsObject, &arrayLength))
{
jsval curElement;
// first element: status
JS_GetElement(theCallback.context, myJsObject, 0, &curElement);
if (!JSVAL_IS_VOID(curElement)) {
int myStatusCode;
jslib::convertFrom(theCallback.context, curElement, myStatusCode);
theReply.status = static_cast<reply::status_type>(myStatusCode);
} else {
theReply.status = reply::ok;
}
// 2nd element (if array has three elements) headers
if (arrayLength == 3) {
JS_GetElement(theCallback.context, myJsObject, 1, &curElement);
if (JSVAL_IS_OBJECT(curElement)) {
JSObject *headers = JSVAL_TO_OBJECT(curElement);
JSIdArray *props = JS_Enumerate(theCallback.context, headers);
for (int i = 0; props && i < props->length; ++i) {
jsid propid = props->vector[i];
jsval propname;
if (!JS_IdToValue(theCallback.context, propid, &propname)) {
AC_WARNING << "Weird case";
continue;
}
std::string header_name;
if (!jslib::convertFrom(theCallback.context, propname, header_name)) {
JS_ReportError(theCallback.context,
"Server::handleRequest: header_name is not a string!");
}
jsval propval;
if (!JS_GetProperty(theCallback.context, headers, header_name.c_str(), &propval)) {
AC_WARNING << "Weird case";
continue;
}
std::string header_value;
if (!jslib::convertFrom(theCallback.context, propval, header_value)) {
JS_ReportError(theCallback.context,
"Server::handleRequest: header_value is not a a string!");
}
theReply.headers.insert(make_pair(header_name, header_value));
}
}
}
// last element: Body
JS_GetElement(theCallback.context, myJsObject, arrayLength-1, &curElement);
if (!JSVAL_IS_VOID(curElement)) {
jslib::convertFrom(theCallback.context, curElement, theReply.content);
}
return;
}
}
}
// default (backwards-compatible): treat jsval as string...
if (!jslib::convertFrom(theCallback.context, rval, myResponseString)) {
JS_ReportError(theCallback.context,
"Server::handleRequest: Callback does not return a string!");
}
theReply.content = myResponseString;
theReply.status = reply::ok;
theReply.headers.insert(make_pair("Content-Type", theCallback.contentType));
return;
} catch (Exception e) {
theReply.status = reply::internal_server_error;
theReply.content = std::string("An internal error occured: ") + asl::compose_message(e);
AC_ERROR << e;
return;
};
}
// static
JSBool
XPCArrayHomogenizer::GetTypeForArray(XPCCallContext& ccx, JSObject* array,
jsuint length,
nsXPTType* resultType, nsID* resultID)
{
Type state = tUnk;
Type type;
for(jsuint i = 0; i < length; i++)
{
jsval val;
if(!JS_GetElement(ccx, array, i, &val))
return JS_FALSE;
if(JSVAL_IS_INT(val))
type = tInt;
else if(JSVAL_IS_DOUBLE(val))
type = tDbl;
else if(JSVAL_IS_BOOLEAN(val))
type = tBool;
else if(JSVAL_IS_VOID(val))
{
state = tVar;
break;
}
else if(JSVAL_IS_NULL(val))
type = tNull;
else if(JSVAL_IS_STRING(val))
type = tStr;
else
{
NS_ASSERTION(JSVAL_IS_OBJECT(val), "invalid type of jsval!");
JSObject* jsobj = JSVAL_TO_OBJECT(val);
if(JS_IsArrayObject(ccx, jsobj))
type = tArr;
else if(xpc_JSObjectIsID(ccx, jsobj))
type = tID;
else
type = tISup;
}
NS_ASSERTION(state != tErr, "bad state table!");
NS_ASSERTION(type != tErr, "bad type!");
NS_ASSERTION(type != tVar, "bad type!");
NS_ASSERTION(type != tUnk, "bad type!");
state = StateTable[state][type];
NS_ASSERTION(state != tErr, "bad state table!");
NS_ASSERTION(state != tUnk, "bad state table!");
if(state == tVar)
break;
}
switch(state)
{
case tInt :
*resultType = nsXPTType((uint8)TD_INT32);
break;
case tDbl :
*resultType = nsXPTType((uint8)TD_DOUBLE);
break;
case tBool:
*resultType = nsXPTType((uint8)TD_BOOL);
break;
case tStr :
*resultType = nsXPTType((uint8)(TD_PWSTRING | XPT_TDP_POINTER));
break;
case tID :
*resultType = nsXPTType((uint8)(TD_PNSIID | XPT_TDP_POINTER));
break;
case tISup:
*resultType = nsXPTType((uint8)(TD_INTERFACE_IS_TYPE | XPT_TDP_POINTER));
*resultID = NS_GET_IID(nsISupports);
break;
case tNull:
// FALL THROUGH
case tVar :
*resultType = nsXPTType((uint8)(TD_INTERFACE_IS_TYPE | XPT_TDP_POINTER));
*resultID = NS_GET_IID(nsIVariant);
break;
case tArr :
// FALL THROUGH
case tUnk :
// FALL THROUGH
case tErr :
// FALL THROUGH
default:
NS_ERROR("bad state");
return JS_FALSE;
}
return JS_TRUE;
}
JSBool systemExecute(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{// begin systemExecute
// default return value
*rval = INT_TO_JSVAL(-1);
if(argc != 3)
return JS_FALSE;
if(JSVAL_IS_STRING(argv[0]) == false || JSVAL_IS_OBJECT(argv[1]) == false || JSVAL_IS_BOOLEAN(argv[2]) == false)
return JS_FALSE;
char *pExecutable = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
JSObject *pArgs = JSVAL_TO_OBJECT(argv[1]);
bool bWait = JSVAL_TO_BOOLEAN(argv[2]);
int status = 0;
jsuint nArgsLength = 0;
jsval jsValue;
struct stat sbFileInfo;
if(JS_IsArrayObject(cx, pArgs) == false)
return JS_FALSE;
JS_GetArrayLength(cx,pArgs,&nArgsLength);
char **args = new char *[JSVAL_TO_INT(nArgsLength)+2];
args[0] = pExecutable;
args[JSVAL_TO_INT(nArgsLength)+1] = NULL;
for(jsuint i = 1;i <= nArgsLength;i++)
{
if(JS_GetElement(cx, pArgs, i, &jsValue) == JS_FALSE)
{// begin failure to get item
JS_ReportError(cx, "exec() JS_GetElement failed to get an array item.");
return JS_FALSE;
}// end failure to get item
args[JSVAL_TO_INT(i)] = JS_GetStringBytes(JSVAL_TO_STRING(jsValue));
}
if(getuid() == 0)
{// begin running as root
JS_ReportError(cx, "exec() disallowed while running as root.");
return JS_FALSE;
}// end running as root
if(stat(pExecutable , &sbFileInfo) != 0)
{// begin can't stat file
JS_ReportError(cx, "exec() Can't stat \"%s\" errno(%i).", pExecutable, errno);
return JS_FALSE;
}// end can't stat file
if((sbFileInfo.st_mode & S_ISUID) == S_ISUID || (sbFileInfo.st_mode & S_ISGID) == S_ISGID)
{// begin setuid/setgid files disallowed
JS_ReportError(cx, "exec() disallowed execution of \"%s\" since it is a setuid/setgid file.", pExecutable);
return JS_FALSE;
}// end setuid/setgid files disallowed
enterLock();
// clear file descriptor table of forked process and fork
#ifdef __linux__
pid_t pidRtn = fork();
#elif __FreeBSD__
pid_t pidRtn = rfork(RFPROC|RFCFDG);
#endif
if(pidRtn == 0)
{// begin child process
#ifdef __linux__
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
#endif
char **pEnv = environ;
//char *pEnv[] = {NULL};
execve(pExecutable,args,pEnv);
printf("Error: execve failure errno(%d)\n",errno);
_exit(errno);
}// end child process
else if(bWait && pidRtn != -1)
{// begin wait for execution to finish
printf("Waiting on pid %d...",pidRtn);
do
{// begin wait for child
waitpid(pidRtn,&status,WUNTRACED);
}// end wait for child
while(WIFEXITED(status) == false && WIFSIGNALED(status) == false);
printf("Done...\n");
}// end wait for execution to finish
else if(pidRtn == -1)
{// begin rfork failure
printf("Error: execve failure errno(%d)\n",errno);
}// end rfork failure
leaveLock();
// cleanup
delete []args;
if(pidRtn != -1)
*rval = INT_TO_JSVAL(WEXITSTATUS(status)); // success return child's exit status
else
*rval = INT_TO_JSVAL(-1); // failure
return JS_TRUE;
}// end systemExecute
JSBool openfiledlg(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{
JSObject * filterArray = NULL;
LPWSTR initialDirectory = NULL;
LPWSTR dlgTitle = NULL;
LPWSTR defaultExtension = NULL;
JSBool save = JS_FALSE;
JS_BeginRequest(cx);
if(!JS_ConvertArguments(cx, argc, argv, "W W W o/ b", &initialDirectory, &defaultExtension, &dlgTitle, &filterArray, &save))
{
JS_ReportError(cx, "Error parsing arguments in OpenFileDialog");
JS_EndRequest(cx);
return JS_FALSE;
}
jsuint nFilters;
JS_GetArrayLength(cx, filterArray, &nFilters);
LPWSTR filterBuffer = (LPWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (50 * nFilters) * sizeof(WCHAR));
long filterBufferUsed = 0, filterBufferSize = (50 * nFilters);
for(jsuint i = 0; i < nFilters; i++)
{
jsval curFilter;
JS_GetElement(cx, filterArray, i, &curFilter);
JSString * curFilterString = JS_ValueToString(cx, curFilter);
LPWSTR curFilterRaw = (LPWSTR)JS_GetStringChars(curFilterString);
int delta = wcslen(curFilterRaw);
if(filterBufferSize - ( 2 + JS_GetStringLength(curFilterString) + filterBufferUsed) <= 0)
{
filterBufferSize += 50;
HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, filterBuffer, filterBufferSize * sizeof(WCHAR));
}
wcscpy_s(filterBuffer + filterBufferUsed, filterBufferSize - filterBufferUsed, (LPWSTR)JS_GetStringChars(curFilterString));
filterBufferUsed += JS_GetStringLength(curFilterString) + 1;
}
filterBuffer[filterBufferUsed] = TEXT('\0');
OPENFILENAME ofn;
memset(&ofn, 0, sizeof(OPENFILENAME));
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.lpstrFilter = filterBuffer;
ofn.nFilterIndex = 0;
ofn.lpstrFile = (LPWSTR)JS_malloc(cx, 260 * sizeof(WCHAR));
memset(ofn.lpstrFile, 0, sizeof(WCHAR) * 260);
ofn.nMaxFile = 260;
ofn.lpstrFileTitle = (LPWSTR)JS_malloc(cx, 260 * sizeof(WCHAR));
memset(ofn.lpstrFileTitle, 0, sizeof(WCHAR) * 260);
ofn.nMaxFileTitle = 260;
ofn.lpstrInitialDir = initialDirectory;
ofn.lpstrTitle = dlgTitle;
ofn.lpstrDefExt = defaultExtension;
ofn.lpfnHook = OFN_Hook;
ofn.Flags = OFN_ENABLEHOOK | OFN_EXPLORER;
jsrefcount rCount = JS_SuspendRequest(cx);
BOOL ok;
if(save)
ok = GetSaveFileName(&ofn);
else
ok = GetOpenFileName(&ofn);
DWORD errorCode = CommDlgExtendedError();
HeapFree(GetProcessHeap(), 0, filterBuffer);
JS_ResumeRequest(cx, rCount);
if(!ok)
{
JS_free(cx, ofn.lpstrFile);
JS_free(cx, ofn.lpstrFileTitle);
*rval = JSVAL_FALSE;
return JS_TRUE;
}
JSObject * retObj = JS_NewObject(cx, NULL, NULL, obj);
*rval = OBJECT_TO_JSVAL(retObj);
jsval filePathVal = STRING_TO_JSVAL(JS_NewUCString(cx, (jschar*)ofn.lpstrFile, wcslen(ofn.lpstrFile)));
JS_DefineProperty(cx, retObj, "filePath", filePathVal, NULL, NULL, JSPROP_PERMANENT | JSPROP_ENUMERATE);
jsval fileTitleVal = STRING_TO_JSVAL(JS_NewUCString(cx, (jschar*)ofn.lpstrFileTitle, wcslen(ofn.lpstrFileTitle)));
JS_DefineProperty(cx, retObj, "fileTitle", fileTitleVal, NULL, NULL, JSPROP_PERMANENT | JSPROP_ENUMERATE);
JS_EndRequest(cx);
return JS_TRUE;
}
NS_IMETHODIMP
IDBDatabase::CreateObjectStore(const nsAString& aName,
const jsval& aOptions,
JSContext* aCx,
nsIIDBObjectStore** _retval)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
IDBTransaction* transaction = AsyncConnectionHelper::GetCurrentTransaction();
if (!transaction ||
transaction->Mode() != nsIIDBTransaction::VERSION_CHANGE) {
return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
}
DatabaseInfo* databaseInfo = transaction->DBInfo();
mozilla::dom::IDBObjectStoreParameters params;
nsString keyPath;
keyPath.SetIsVoid(true);
nsTArray<nsString> keyPathArray;
if (!JSVAL_IS_VOID(aOptions) && !JSVAL_IS_NULL(aOptions)) {
nsresult rv = params.Init(aCx, &aOptions);
NS_ENSURE_SUCCESS(rv, rv);
// Get keyPath
jsval val = params.keyPath;
if (!JSVAL_IS_VOID(val) && !JSVAL_IS_NULL(val)) {
if (!JSVAL_IS_PRIMITIVE(val) &&
JS_IsArrayObject(aCx, JSVAL_TO_OBJECT(val))) {
JSObject* obj = JSVAL_TO_OBJECT(val);
jsuint length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!length) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
keyPathArray.SetCapacity(length);
for (jsuint index = 0; index < length; index++) {
jsval val;
JSString* jsstr;
nsDependentJSString str;
if (!JS_GetElement(aCx, obj, index, &val) ||
!(jsstr = JS_ValueToString(aCx, val)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!IDBObjectStore::IsValidKeyPath(aCx, str)) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
keyPathArray.AppendElement(str);
}
NS_ASSERTION(!keyPathArray.IsEmpty(), "This shouldn't have happened!");
}
else {
JSString* jsstr;
nsDependentJSString str;
if (!(jsstr = JS_ValueToString(aCx, val)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!IDBObjectStore::IsValidKeyPath(aCx, str)) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
keyPath = str;
}
}
}
if (databaseInfo->ContainsStoreName(aName)) {
return NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR;
}
if (params.autoIncrement &&
((!keyPath.IsVoid() && keyPath.IsEmpty()) || !keyPathArray.IsEmpty())) {
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
}
nsRefPtr<ObjectStoreInfo> newInfo(new ObjectStoreInfo());
newInfo->name = aName;
newInfo->id = databaseInfo->nextObjectStoreId++;
newInfo->keyPath = keyPath;
newInfo->keyPathArray = keyPathArray;
newInfo->nextAutoIncrementId = params.autoIncrement ? 1 : 0;
newInfo->comittedAutoIncrementId = newInfo->nextAutoIncrementId;
if (!databaseInfo->PutObjectStore(newInfo)) {
NS_WARNING("Put failed!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
// Don't leave this in the hash if we fail below!
AutoRemoveObjectStore autoRemove(databaseInfo, aName);
nsRefPtr<IDBObjectStore> objectStore =
transaction->GetOrCreateObjectStore(aName, newInfo);
NS_ENSURE_TRUE(objectStore, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
nsRefPtr<CreateObjectStoreHelper> helper =
new CreateObjectStoreHelper(transaction, objectStore);
nsresult rv = helper->DispatchToTransactionPool();
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
autoRemove.forget();
objectStore.forget(_retval);
return NS_OK;
}
static JSBool
do_import(JSContext *context,
JSObject *obj,
Importer *priv,
std::string &name)
{
std::string filename;
std::string full_path;
std::string dirname;
jsval search_path_val;
JSObject *search_path;
JSObject *module_obj = NULL;
uint32_t search_path_len;
uint32_t i;
JSBool result;
std::vector<std::string> directories;
jsid search_path_name;
bool exists;
search_path_name = gjs_context_get_const_string(context, GJS_STRING_SEARCH_PATH);
if (!gjs_object_require_property(context, obj, "importer", search_path_name, &search_path_val)) {
return JS_FALSE;
}
if (!search_path_val.isObject()) {
gjs_throw(context, "searchPath property on importer is not an object");
return JS_FALSE;
}
search_path = JSVAL_TO_OBJECT(search_path_val);
if (!JS_IsArrayObject(context, search_path)) {
gjs_throw(context, "searchPath property on importer is not an array");
return JS_FALSE;
}
if (!JS_GetArrayLength(context, search_path, &search_path_len)) {
gjs_throw(context, "searchPath array has no length");
return JS_FALSE;
}
result = JS_FALSE;
filename = std::string(name) + ".js";
/* First try importing an internal module like byteArray */
if (priv->is_root &&
gjs_is_registered_native_module(context, obj, name) &&
import_native_file(context, obj, name)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
goto out;
}
for (i = 0; i < search_path_len; ++i) {
jsval elem;
elem = JSVAL_VOID;
if (!JS_GetElement(context, search_path, i, &elem)) {
/* this means there was an exception, while elem == JSVAL_VOID
* means no element found
*/
goto out;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JSVAL_IS_STRING(elem)) {
gjs_throw(context, "importer searchPath contains non-string");
goto out;
}
if (!gjs_string_to_utf8(context, elem, dirname))
goto out; /* Error message already set */
/* Ignore empty path elements */
if (dirname[0] == '\0')
continue;
/* Try importing __init__.js and loading the symbol from it */
full_path = pathCombine(dirname, MODULE_INIT_FILENAME);
module_obj = load_module_init(context, obj, full_path);
if (module_obj != NULL) {
jsval obj_val;
if (JS_GetProperty(context,
module_obj,
name.c_str(),
&obj_val)) {
if (!JSVAL_IS_VOID(obj_val) &&
JS_DefineProperty(context, obj,
name.c_str(), obj_val,
NULL, NULL,
GJS_MODULE_PROP_FLAGS & ~JSPROP_PERMANENT)) {
result = JS_TRUE;
goto out;
}
}
}
/* Second try importing a directory (a sub-importer) */
full_path = pathCombine(dirname, name);
if (is_directory(full_path)) {
std::cout << "Adding directory '" << full_path << "' to child importer '" << name << "'\n",
directories.push_back(full_path);
}
/* If we just added to directories, we know we don't need to
* check for a file. If we added to directories on an earlier
* iteration, we want to ignore any files later in the
* path. So, always skip the rest of the loop block if we have
* directories.
*/
if (directories.size() > 0) {
continue;
}
/* Third, if it's not a directory, try importing a file */
full_path = pathCombine(dirname, filename);
std::cout << "full path: " << full_path << "\n";
exists = is_regular(full_path);
if (!exists) {
std::cout << "JS import '" << name << "' not found in " << dirname << "\n";
continue;
}
if (import_file_on_module (context, obj, name, full_path)) {
std::cout << "successfully imported module '" << name << "'\n";
result = JS_TRUE;
}
/* Don't keep searching path if we fail to load the file for
* reasons other than it doesn't exist... i.e. broken files
* block searching for nonbroken ones
*/
goto out;
}
if (directories.size() > 0) {
/* NULL-terminate the char** */
if (import_directory(context, obj, name, directories)) {
std::cout << "successfully imported directory '" << name << "'\n";
result = JS_TRUE;
}
}
out:
if (!result &&
!JS_IsExceptionPending(context)) {
/* If no exception occurred, the problem is just that we got to the
* end of the path. Be sure an exception is set.
*/
gjs_throw(context, "No JS module '%s' found in search path", name.c_str());
}
return result;
}
NS_IMETHODIMP
IDBDatabase::Transaction(const jsval& aStoreNames,
PRUint16 aMode,
JSContext* aCx,
PRUint8 aOptionalArgCount,
nsIIDBTransaction** _retval)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (IndexedDatabaseManager::IsShuttingDown()) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (mClosed) {
return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
}
if (mRunningVersionChange) {
return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
}
if (aOptionalArgCount) {
if (aMode != nsIIDBTransaction::READ_WRITE &&
aMode != nsIIDBTransaction::READ_ONLY) {
return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
}
}
else {
aMode = nsIIDBTransaction::READ_ONLY;
}
nsresult rv;
nsTArray<nsString> storesToOpen;
if (!JSVAL_IS_PRIMITIVE(aStoreNames)) {
JSObject* obj = JSVAL_TO_OBJECT(aStoreNames);
// See if this is a JS array.
if (JS_IsArrayObject(aCx, obj)) {
jsuint length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!length) {
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
}
storesToOpen.SetCapacity(length);
for (jsuint index = 0; index < length; index++) {
jsval val;
JSString* jsstr;
nsDependentJSString str;
if (!JS_GetElement(aCx, obj, index, &val) ||
!(jsstr = JS_ValueToString(aCx, val)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
storesToOpen.AppendElement(str);
}
NS_ASSERTION(!storesToOpen.IsEmpty(),
"Must have something here or else code below will "
"misbehave!");
}
else {
// Perhaps some kind of wrapped object?
nsIXPConnect* xpc = nsContentUtils::XPConnect();
NS_ASSERTION(xpc, "This should never be null!");
nsCOMPtr<nsIXPConnectWrappedNative> wrapper;
rv = xpc->GetWrappedNativeOfJSObject(aCx, obj, getter_AddRefs(wrapper));
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
if (wrapper) {
nsISupports* wrappedObject = wrapper->Native();
NS_ENSURE_TRUE(wrappedObject, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
// We only accept DOMStringList.
nsCOMPtr<nsIDOMDOMStringList> list = do_QueryInterface(wrappedObject);
if (list) {
PRUint32 length;
rv = list->GetLength(&length);
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
if (!length) {
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
}
storesToOpen.SetCapacity(length);
for (PRUint32 index = 0; index < length; index++) {
nsString* item = storesToOpen.AppendElement();
NS_ASSERTION(item, "This should never fail!");
rv = list->Item(index, *item);
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
}
NS_ASSERTION(!storesToOpen.IsEmpty(),
"Must have something here or else code below will "
"misbehave!");
}
}
}
}
// If our list is empty here then the argument must have been an object that
// we don't support or a primitive. Either way we convert to a string.
if (storesToOpen.IsEmpty()) {
JSString* jsstr;
nsDependentJSString str;
if (!(jsstr = JS_ValueToString(aCx, aStoreNames)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
storesToOpen.AppendElement(str);
}
// Now check to make sure the object store names we collected actually exist.
DatabaseInfo* info = Info();
for (PRUint32 index = 0; index < storesToOpen.Length(); index++) {
if (!info->ContainsStoreName(storesToOpen[index])) {
return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
}
}
nsRefPtr<IDBTransaction> transaction =
IDBTransaction::Create(this, storesToOpen, aMode, false);
NS_ENSURE_TRUE(transaction, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
transaction.forget(_retval);
return NS_OK;
}
static JSBool
do_import(JSContext *context,
JSObject *obj,
Importer *priv,
const char *name)
{
char *filename;
char *full_path;
char *dirname = NULL;
jsval search_path_val;
JSObject *search_path;
JSObject *module_obj = NULL;
guint32 search_path_len;
guint32 i;
JSBool result;
GPtrArray *directories;
jsid search_path_name;
search_path_name = gjs_runtime_get_const_string(JS_GetRuntime(context),
GJS_STRING_SEARCH_PATH);
if (!gjs_object_require_property(context, obj, "importer", search_path_name, &search_path_val)) {
return JS_FALSE;
}
if (!JSVAL_IS_OBJECT(search_path_val)) {
gjs_throw(context, "searchPath property on importer is not an object");
return JS_FALSE;
}
search_path = JSVAL_TO_OBJECT(search_path_val);
if (!JS_IsArrayObject(context, search_path)) {
gjs_throw(context, "searchPath property on importer is not an array");
return JS_FALSE;
}
if (!JS_GetArrayLength(context, search_path, &search_path_len)) {
gjs_throw(context, "searchPath array has no length");
return JS_FALSE;
}
result = JS_FALSE;
filename = g_strdup_printf("%s.js", name);
full_path = NULL;
directories = NULL;
/* First try importing an internal module like byteArray */
if (priv->is_root &&
gjs_is_registered_native_module(context, obj, name) &&
import_native_file(context, obj, name)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
goto out;
}
for (i = 0; i < search_path_len; ++i) {
jsval elem;
elem = JSVAL_VOID;
if (!JS_GetElement(context, search_path, i, &elem)) {
/* this means there was an exception, while elem == JSVAL_VOID
* means no element found
*/
goto out;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JSVAL_IS_STRING(elem)) {
gjs_throw(context, "importer searchPath contains non-string");
goto out;
}
g_free(dirname);
dirname = NULL;
if (!gjs_string_to_utf8(context, elem, &dirname))
goto out; /* Error message already set */
/* Ignore empty path elements */
if (dirname[0] == '\0')
continue;
/* Try importing __init__.js and loading the symbol from it */
if (full_path)
g_free(full_path);
full_path = g_build_filename(dirname, MODULE_INIT_FILENAME,
NULL);
module_obj = load_module_init(context, obj, full_path);
if (module_obj != NULL) {
jsval obj_val;
if (JS_GetProperty(context,
module_obj,
name,
&obj_val)) {
if (!JSVAL_IS_VOID(obj_val) &&
JS_DefineProperty(context, obj,
name, obj_val,
NULL, NULL,
GJS_MODULE_PROP_FLAGS & ~JSPROP_PERMANENT)) {
result = JS_TRUE;
goto out;
}
}
}
/* Second try importing a directory (a sub-importer) */
if (full_path)
g_free(full_path);
full_path = g_build_filename(dirname, name,
NULL);
if (g_file_test(full_path, G_FILE_TEST_IS_DIR)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"Adding directory '%s' to child importer '%s'",
full_path, name);
if (directories == NULL) {
directories = g_ptr_array_new();
}
g_ptr_array_add(directories, full_path);
/* don't free it twice - pass ownership to ptr array */
full_path = NULL;
}
/* If we just added to directories, we know we don't need to
* check for a file. If we added to directories on an earlier
* iteration, we want to ignore any files later in the
* path. So, always skip the rest of the loop block if we have
* directories.
*/
if (directories != NULL) {
continue;
}
/* Third, if it's not a directory, try importing a file */
g_free(full_path);
full_path = g_build_filename(dirname, filename,
NULL);
if (g_file_test(full_path, G_FILE_TEST_EXISTS)) {
if (import_file(context, obj, name, full_path)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
}
/* Don't keep searching path if we fail to load the file for
* reasons other than it doesn't exist... i.e. broken files
* block searching for nonbroken ones
*/
goto out;
}
gjs_debug(GJS_DEBUG_IMPORTER,
"JS import '%s' not found in %s",
name, dirname);
}
if (directories != NULL) {
/* NULL-terminate the char** */
g_ptr_array_add(directories, NULL);
if (import_directory(context, obj, name,
(const char**) directories->pdata)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported directory '%s'", name);
result = JS_TRUE;
}
}
out:
if (directories != NULL) {
char **str_array;
/* NULL-terminate the char**
* (maybe for a second time, but doesn't matter)
*/
g_ptr_array_add(directories, NULL);
str_array = (char**) directories->pdata;
g_ptr_array_free(directories, FALSE);
g_strfreev(str_array);
}
g_free(full_path);
g_free(filename);
g_free(dirname);
if (!result &&
!JS_IsExceptionPending(context)) {
/* If no exception occurred, the problem is just that we got to the
* end of the path. Be sure an exception is set.
*/
gjs_throw(context, "No JS module '%s' found in search path", name);
}
return result;
}
static JSBool
array_join_sub(JSContext *cx, JSObject *obj, JSString *sep, JSBool literalize,
jsval *rval, JSBool localeString)
{
JSBool ok;
jsval v;
jsuint length, index;
jschar *chars, *ochars;
size_t nchars, growth, seplen, tmplen;
const jschar *sepstr;
JSString *str;
JSHashEntry *he;
JSObject *obj2;
ok = js_GetLengthProperty(cx, obj, &length);
if (!ok)
return JS_FALSE;
he = js_EnterSharpObject(cx, obj, NULL, &chars);
if (!he)
return JS_FALSE;
if (literalize) {
if (IS_SHARP(he)) {
#if JS_HAS_SHARP_VARS
nchars = js_strlen(chars);
#else
chars[0] = '[';
chars[1] = ']';
chars[2] = 0;
nchars = 2;
#endif
goto make_string;
}
/*
* Allocate 1 + 3 + 1 for "[", the worst-case closing ", ]", and the
* terminating 0.
*/
growth = (1 + 3 + 1) * sizeof(jschar);
if (!chars) {
nchars = 0;
chars = (jschar *) malloc(growth);
if (!chars)
goto done;
} else {
MAKE_SHARP(he);
nchars = js_strlen(chars);
chars = (jschar *)
realloc((ochars = chars), nchars * sizeof(jschar) + growth);
if (!chars) {
free(ochars);
goto done;
}
}
chars[nchars++] = '[';
} else {
/*
* Free any sharp variable definition in chars. Normally, we would
* MAKE_SHARP(he) so that only the first sharp variable annotation is
* a definition, and all the rest are references, but in the current
* case of (!literalize), we don't need chars at all.
*/
if (chars)
JS_free(cx, chars);
chars = NULL;
nchars = 0;
/* Return the empty string on a cycle as well as on empty join. */
if (IS_BUSY(he) || length == 0) {
js_LeaveSharpObject(cx, NULL);
*rval = JS_GetEmptyStringValue(cx);
return ok;
}
/* Flag he as BUSY so we can distinguish a cycle from a join-point. */
MAKE_BUSY(he);
}
sepstr = NULL;
seplen = JSSTRING_LENGTH(sep);
v = JSVAL_NULL;
for (index = 0; index < length; index++) {
ok = JS_GetElement(cx, obj, index, &v);
if (!ok)
goto done;
if (!literalize && (JSVAL_IS_VOID(v) || JSVAL_IS_NULL(v))) {
str = cx->runtime->emptyString;
} else {
if (localeString) {
if (!js_ValueToObject(cx, v, &obj2) ||
!js_TryMethod(cx, obj2,
cx->runtime->atomState.toLocaleStringAtom,
0, NULL, &v)) {
str = NULL;
} else {
str = js_ValueToString(cx, v);
}
} else {
str = (literalize ? js_ValueToSource : js_ValueToString)(cx, v);
}
if (!str) {
ok = JS_FALSE;
goto done;
}
}
/* Allocate 3 + 1 at end for ", ", closing bracket, and zero. */
growth = (nchars + (sepstr ? seplen : 0) +
JSSTRING_LENGTH(str) +
3 + 1) * sizeof(jschar);
if (!chars) {
chars = (jschar *) malloc(growth);
if (!chars)
goto done;
} else {
chars = (jschar *) realloc((ochars = chars), growth);
if (!chars) {
free(ochars);
goto done;
}
}
if (sepstr) {
js_strncpy(&chars[nchars], sepstr, seplen);
nchars += seplen;
}
sepstr = JSSTRING_CHARS(sep);
tmplen = JSSTRING_LENGTH(str);
js_strncpy(&chars[nchars], JSSTRING_CHARS(str), tmplen);
nchars += tmplen;
}
done:
if (literalize) {
if (chars) {
if (JSVAL_IS_VOID(v)) {
chars[nchars++] = ',';
chars[nchars++] = ' ';
}
chars[nchars++] = ']';
}
} else {
CLEAR_BUSY(he);
}
js_LeaveSharpObject(cx, NULL);
if (!ok) {
if (chars)
free(chars);
return ok;
}
make_string:
if (!chars) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
chars[nchars] = 0;
str = js_NewString(cx, chars, nchars, 0);
if (!str) {
free(chars);
return JS_FALSE;
}
*rval = STRING_TO_JSVAL(str);
return JS_TRUE;
}
static int
json_encode_from_object(JSContext *cx, JSObject *obj, htsbuf_queue_t *out)
{
int objtype = 0;
JSIdArray *ida;
int i;
const char *n;
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)) {
JSString *str = JSVAL_TO_STRING(name);
n = JS_GetStringBytes(str);
if(!JS_GetProperty(cx, obj, n, &value))
continue;
if(objtype == 0) {
htsbuf_append(out, "{", 1);
objtype = OBJTYPE_MAP;
} else if(objtype != OBJTYPE_MAP)
continue;
else
htsbuf_append(out, ",", 1);
htsbuf_append_and_escape_jsonstr(out, n);
htsbuf_append(out, ":", 1);
} else if(JSVAL_IS_INT(name)) {
if(!JS_GetElement(cx, obj, JSVAL_TO_INT(name), &value) ||
JSVAL_IS_VOID(value))
continue;
if(objtype == 0) {
htsbuf_append(out, "[", 1);
objtype = OBJTYPE_LIST;
} else if(objtype != OBJTYPE_LIST)
continue;
else
htsbuf_append(out, ",", 1);
} else {
continue;
}
js_json_emit_jsval(cx, value, out);
}
JS_DestroyIdArray(cx, ida);
switch(objtype) {
case OBJTYPE_LIST:
htsbuf_append(out, "]", 1);
break;
case OBJTYPE_MAP:
htsbuf_append(out, "}", 1);
break;
default:
return -1;
}
return 0;
}
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;
}
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;
}
std::vector<std::string> CTemplateLoader::FindPlaceableTemplates(const std::string& path, bool includeSubdirectories, ETemplatesType templatesType, ScriptInterface& scriptInterface)
{
JSContext* cx = scriptInterface.GetContext();
JSAutoRequest rq(cx);
std::vector<std::string> templates;
Status ok;
VfsPath templatePath;
if (templatesType == SIMULATION_TEMPLATES || templatesType == ALL_TEMPLATES)
{
JS::RootedValue placeablesFilter(cx);
scriptInterface.ReadJSONFile("simulation/data/placeablesFilter.json", &placeablesFilter);
JS::RootedObject folders(cx);
if (scriptInterface.GetProperty(placeablesFilter, "templates", &folders))
{
if (!(JS_IsArrayObject(cx, folders)))
{
LOGERROR("FindPlaceableTemplates: Argument must be an array!");
return templates;
}
u32 length;
if (!JS_GetArrayLength(cx, folders, &length))
{
LOGERROR("FindPlaceableTemplates: Failed to get array length!");
return templates;
}
templatePath = VfsPath(TEMPLATE_ROOT) / path;
//I have every object inside, just run for each
for (u32 i=0; i<length; ++i)
{
JS::RootedValue val(cx);
if (!JS_GetElement(cx, folders, i, &val))
{
LOGERROR("FindPlaceableTemplates: Failed to read array element!");
return templates;
}
std::string directoryPath;
std::wstring fileFilter;
scriptInterface.GetProperty(val, "directory", directoryPath);
scriptInterface.GetProperty(val, "file", fileFilter);
VfsPaths filenames;
if (vfs::GetPathnames(g_VFS, templatePath / (directoryPath + "/"), fileFilter.c_str(), filenames) != INFO::OK)
continue;
for (const VfsPath& filename : filenames)
{
// Strip the .xml extension
VfsPath pathstem = filename.ChangeExtension(L"");
// Strip the root from the path
std::wstring name = pathstem.string().substr(ARRAY_SIZE(TEMPLATE_ROOT) - 1);
templates.emplace_back(name.begin(), name.end());
}
}
}
}
if (templatesType == ACTOR_TEMPLATES || templatesType == ALL_TEMPLATES)
{
templatePath = VfsPath(ACTOR_ROOT) / path;
if (includeSubdirectories)
ok = vfs::ForEachFile(g_VFS, templatePath, AddActorToTemplates, (uintptr_t)&templates, L"*.xml", vfs::DIR_RECURSIVE);
else
ok = vfs::ForEachFile(g_VFS, templatePath, AddActorToTemplates, (uintptr_t)&templates, L"*.xml");
WARN_IF_ERR(ok);
}
if (templatesType != SIMULATION_TEMPLATES && templatesType != ACTOR_TEMPLATES && templatesType != ALL_TEMPLATES)
LOGERROR("Undefined template type (valid: all, simulation, actor)");
return templates;
}
