static JSValueRef columnIndexRangeCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { JSRetainPtr<JSStringRef> columnIndexRange(Adopt, toAXElement(thisObject)->columnIndexRange()); return JSValueMakeString(context, columnIndexRange.get()); }
JSValueRef function_load(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argc, const JSValueRef args[], JSValueRef* exception) { // TODO: implement fully if (argc == 1 && JSValueGetType(ctx, args[0]) == kJSTypeString) { char path[100]; JSStringRef path_str = JSValueToStringCopy(ctx, args[0], NULL); assert(JSStringGetLength(path_str) < 100); JSStringGetUTF8CString(path_str, path, 100); JSStringRelease(path_str); // debug_print_value("load", ctx, args[0]); time_t last_modified = 0; char *contents = NULL; bool developing = (num_src_paths == 1 && strcmp(src_paths[0].type, "src") == 0 && str_has_suffix(src_paths[0].path, "/planck-cljs/src/") == 0); if (!developing) { contents = bundle_get_contents(path); last_modified = 0; } // load from classpath if (contents == NULL) { for (int i = 0; i < num_src_paths; i++) { char *type = src_paths[i].type; char *location = src_paths[i].path; if (strcmp(type, "src") == 0) { char *full_path = str_concat(location, path); contents = get_contents(full_path, &last_modified); free(full_path); } else if (strcmp(type, "jar") == 0) { contents = get_contents_zip(location, path, &last_modified); } if (contents != NULL) { break; } } } // load from out/ if (contents == NULL) { if (out_path != NULL) { char *full_path = str_concat(out_path, path); contents = get_contents(full_path, &last_modified); free(full_path); } } if (developing && contents == NULL) { contents = bundle_get_contents(path); last_modified = 0; } if (contents != NULL) { JSStringRef contents_str = JSStringCreateWithUTF8CString(contents); free(contents); JSValueRef res[2]; res[0] = JSValueMakeString(ctx, contents_str); res[1] = JSValueMakeNumber(ctx, last_modified); return JSObjectMakeArray(ctx, 2, res, NULL); } } return JSValueMakeNull(ctx); }
int main(int argc, char **argv) { struct option long_options[] = { {"help", no_argument, NULL, 'h'}, {"legal", no_argument, NULL, 'l'}, {"verbose", no_argument, NULL, 'v'}, {"quiet", no_argument, NULL, 'q'}, {"repl", no_argument, NULL, 'r'}, {"static-fns", no_argument, NULL, 's'}, {"elide-asserts", no_argument, NULL, 'a'}, {"cache", required_argument, NULL, 'k'}, {"eval", required_argument, NULL, 'e'}, {"theme", required_argument, NULL, 't'}, {"classpath", required_argument, NULL, 'c'}, {"auto-cache", no_argument, NULL, 'K'}, {"init", required_argument, NULL, 'i'}, {"main", required_argument, NULL, 'm'}, // development options {"javascript", no_argument, NULL, 'j'}, {"out", required_argument, NULL, 'o'}, {0, 0, 0, 0} }; int opt, option_index; while ((opt = getopt_long(argc, argv, "h?lvrsak:je:t:c:o:Ki:qm:", long_options, &option_index)) != -1) { switch (opt) { case 'h': usage(argv[0]); exit(0); case 'l': legal(); return 0; case 'v': verbose = true; break; case 'q': quiet = true; break; case 'r': repl = true; break; case 's': static_fns = true; break; case 'a': elide_asserts = true; break; case 'k': cache_path = argv[optind - 1]; break; case 'K': cache_path = ".planck_cache"; { char *path_copy = strdup(cache_path); char *dir = dirname(path_copy); if (mkdir_p(dir) < 0) { fprintf(stderr, "Could not create %s: %s\n", cache_path, strerror(errno)); } free(path_copy); } break; case 'j': javascript = true; break; case 'e': num_scripts += 1; scripts = realloc(scripts, num_scripts * sizeof(struct script)); scripts[num_scripts - 1].type = "text"; scripts[num_scripts - 1].expression = true; scripts[num_scripts - 1].source = argv[optind - 1]; break; case 'i': num_scripts += 1; scripts = realloc(scripts, num_scripts * sizeof(struct script)); scripts[num_scripts - 1].type = "path"; scripts[num_scripts - 1].expression = false; scripts[num_scripts - 1].source = argv[optind - 1]; break; case 'm': main_ns_name = argv[optind - 1]; case 't': theme = argv[optind - 1]; break; case 'c': { char *classpath = argv[optind - 1]; char *source = strtok(classpath, ":"); while (source != NULL) { char *type = "src"; if (str_has_suffix(source, ".jar") == 0) { type = "jar"; } num_src_paths += 1; src_paths = realloc(src_paths, num_src_paths * sizeof(struct src_path)); src_paths[num_src_paths - 1].type = type; src_paths[num_src_paths - 1].path = strdup(source); source = strtok(NULL, ":"); } break; } case 'o': out_path = argv[optind - 1]; break; case '?': usage(argv[0]); exit(1); default: printf("unhandled argument: %c\n", opt); } } int num_rest_args = 0; char **rest_args = NULL; if (optind < argc) { num_rest_args = argc - optind; rest_args = malloc((argc - optind) * sizeof(char*)); int i = 0; while (optind < argc) { rest_args[i++] = argv[optind++]; } } if (num_scripts == 0 && main_ns_name == NULL && num_rest_args == 0) { repl = true; } if (main_ns_name != NULL && repl) { printf("Only one main-opt can be specified."); } JSGlobalContextRef ctx = JSGlobalContextCreate(NULL); JSStringRef nameRef = JSStringCreateWithUTF8CString("planck"); JSGlobalContextSetName(ctx, nameRef); evaluate_script(ctx, "var global = this;", "<init>"); register_global_function(ctx, "AMBLY_IMPORT_SCRIPT", function_import_script); bootstrap(ctx, out_path); register_global_function(ctx, "PLANCK_CONSOLE_LOG", function_console_log); register_global_function(ctx, "PLANCK_CONSOLE_ERROR", function_console_error); evaluate_script(ctx, "var console = {};"\ "console.log = PLANCK_CONSOLE_LOG;"\ "console.error = PLANCK_CONSOLE_ERROR;", "<init>"); evaluate_script(ctx, "var PLANCK_VERSION = \"" PLANCK_VERSION "\";", "<init>"); // require app namespaces evaluate_script(ctx, "goog.require('planck.repl');", "<init>"); // without this things won't work evaluate_script(ctx, "var window = global;", "<init>"); register_global_function(ctx, "PLANCK_READ_FILE", function_read_file); register_global_function(ctx, "PLANCK_LOAD", function_load); register_global_function(ctx, "PLANCK_LOAD_DEPS_CLJS_FILES", function_load_deps_cljs_files); register_global_function(ctx, "PLANCK_CACHE", function_cache); register_global_function(ctx, "PLANCK_EVAL", function_eval); register_global_function(ctx, "PLANCK_GET_TERM_SIZE", function_get_term_size); register_global_function(ctx, "PLANCK_PRINT_FN", function_print_fn); register_global_function(ctx, "PLANCK_PRINT_ERR_FN", function_print_err_fn); register_global_function(ctx, "PLANCK_SET_EXIT_VALUE", function_set_exit_value); is_tty = isatty(STDIN_FILENO) == 1; register_global_function(ctx, "PLANCK_RAW_READ_STDIN", function_raw_read_stdin); register_global_function(ctx, "PLANCK_RAW_WRITE_STDOUT", function_raw_write_stdout); register_global_function(ctx, "PLANCK_RAW_FLUSH_STDOUT", function_raw_flush_stdout); register_global_function(ctx, "PLANCK_RAW_WRITE_STDERR", function_raw_write_stderr); register_global_function(ctx, "PLANCK_RAW_FLUSH_STDERR", function_raw_flush_stderr); { JSValueRef arguments[num_rest_args]; for (int i = 0; i < num_rest_args; i++) { arguments[i] = c_string_to_value(ctx, rest_args[i]); } JSValueRef args_ref = JSObjectMakeArray(ctx, num_rest_args, arguments, NULL); JSValueRef global_obj = JSContextGetGlobalObject(ctx); JSStringRef prop = JSStringCreateWithUTF8CString("PLANCK_INITIAL_COMMAND_LINE_ARGS"); JSObjectSetProperty(ctx, JSValueToObject(ctx, global_obj, NULL), prop, args_ref, kJSPropertyAttributeNone, NULL); JSStringRelease(prop); } evaluate_script(ctx, "cljs.core.set_print_fn_BANG_.call(null,PLANCK_PRINT_FN);", "<init>"); evaluate_script(ctx, "cljs.core.set_print_err_fn_BANG_.call(null,PLANCK_PRINT_ERR_FN);", "<init>"); char *elide_script = str_concat("cljs.core._STAR_assert_STAR_ = ", elide_asserts ? "false" : "true"); evaluate_script(ctx, elide_script, "<init>"); free(elide_script); { JSValueRef arguments[4]; arguments[0] = JSValueMakeBoolean(ctx, repl); arguments[1] = JSValueMakeBoolean(ctx, verbose); JSValueRef cache_path_ref = NULL; if (cache_path != NULL) { JSStringRef cache_path_str = JSStringCreateWithUTF8CString(cache_path); cache_path_ref = JSValueMakeString(ctx, cache_path_str); } arguments[2] = cache_path_ref; arguments[3] = JSValueMakeBoolean(ctx, static_fns); JSValueRef ex = NULL; JSObjectCallAsFunction(ctx, get_function(ctx, "planck.repl", "init"), JSContextGetGlobalObject(ctx), 4, arguments, &ex); debug_print_value("planck.repl/init", ctx, ex); } if (repl) { evaluate_source(ctx, "text", "(require '[planck.repl :refer-macros [apropos dir find-doc doc source pst]])", true, false, "cljs.user", "dumb"); } evaluate_script(ctx, "goog.provide('cljs.user');", "<init>"); evaluate_script(ctx, "goog.require('cljs.core');", "<init>"); evaluate_script(ctx, "cljs.core._STAR_assert_STAR_ = true;", "<init>"); // Process init arguments for (int i = 0; i < num_scripts; i++) { // TODO: exit if not successfull evaluate_source(ctx, scripts[i].type, scripts[i].source, scripts[i].expression, false, NULL, theme); } // Process main arguments if (main_ns_name != NULL) { run_main_in_ns(ctx, main_ns_name, num_rest_args, rest_args); } else if (!repl && num_rest_args > 0) { char *path = rest_args[0]; struct script script; if (strcmp(path, "-") == 0) { char *source = read_all(stdin); script.type = "text"; script.source = source; script.expression = false; } else { script.type = "path"; script.source = path; script.expression = false; } evaluate_source(ctx, script.type, script.source, script.expression, false, NULL, theme); } else if (repl) { if (!quiet) { banner(); } char *home = getenv("HOME"); char *history_path = NULL; if (home != NULL) { char history_name[] = ".planck_history"; int len = strlen(home) + strlen(history_name) + 2; history_path = malloc(len * sizeof(char)); snprintf(history_path, len, "%s/%s", home, history_name); linenoiseHistoryLoad(history_path); } char *prompt = javascript ? " > " : " => "; char *line; while ((line = linenoise(prompt)) != NULL) { if (javascript) { JSValueRef res = evaluate_script(ctx, line, "<stdin>"); print_value("", ctx, res); } else { evaluate_source(ctx, "text", line, true, true, "cljs.user", theme); } linenoiseHistoryAdd(line); if (history_path != NULL) { linenoiseHistorySave(history_path); } free(line); } } return exit_value; }
static JSValueRef createErrorString(JSContextRef ctx, const char *msg) { return JSValueMakeString(ctx, String(msg)); }
jsc::Value::Value(Context &context, const String &string) : context(context) { value = JSValueMakeString(context, string); JSValueProtect(context, value); }
static JSValueRef getTitleCallback(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception) { JSRetainPtr<JSStringRef> title(Adopt, toAXElement(thisObject)->title()); return JSValueMakeString(context, title.get()); }
GVariant* js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue, const GVariantType* sig, JSValueRef *exception) { if (g_variant_type_is_array(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); if (g_variant_type_is_dict_entry(child_sig)) { const GVariantType* key_sig = g_variant_type_first(child_sig); const GVariantType* value_sig = g_variant_type_next(key_sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_function_child(ctx, jsvalue, i)) { continue; } g_variant_builder_open(&builder, child_sig); JSValueRef key = JSValueMakeString(ctx, JSPropertyNameArrayGetNameAtIndex(array, i)); JSValueRef value = JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL); g_variant_builder_add_value(&builder, js_to_dbus(ctx, key, key_sig, exception)); g_variant_builder_add_value(&builder, js_to_dbus(ctx, value, value_sig, exception)); g_variant_builder_close(&builder); } return g_variant_builder_end(&builder); } else { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* child_sig = g_variant_type_element(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) { continue; } g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), child_sig, exception)); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } } else if (g_variant_type_is_tuple(sig)) { GVariantBuilder builder; g_variant_builder_init(&builder, sig); JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue); const GVariantType* current_sig = g_variant_type_first(sig); for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) { if (filter_array_child(ctx, array, i)) { continue; } g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), current_sig, exception)); current_sig = g_variant_type_next(current_sig); } JSPropertyNameArrayRelease(array); return g_variant_builder_end(&builder); } else { switch (g_variant_type_peek_string(sig)[0]) { case 'y': return g_variant_new_byte(JSValueToNumber(ctx, jsvalue, exception)); case 'n': return g_variant_new_int16(JSValueToNumber(ctx, jsvalue, exception)); case 'q': return g_variant_new_uint16(JSValueToNumber(ctx, jsvalue, exception)); case 'i': return g_variant_new_int32(JSValueToNumber(ctx, jsvalue, exception)); case 'u': return g_variant_new_uint32(JSValueToNumber(ctx, jsvalue, exception)); case 'x': return g_variant_new_int64(JSValueToNumber(ctx, jsvalue, exception)); case 't': return g_variant_new_uint64(JSValueToNumber(ctx, jsvalue, exception)); case 'd': return g_variant_new_double(JSValueToNumber(ctx, jsvalue, exception)); case 'h': return g_variant_new_handle(JSValueToNumber(ctx, jsvalue, exception)); case 'b': return g_variant_new_boolean(JSValueToBoolean(ctx, jsvalue)); case 's': { char* v = jsvalue_to_cstr(ctx, jsvalue); GVariant* r = g_variant_new_string(v); g_free(v); return r; } case 'v': { //TODO: /*g_variant_new_variant()*/ g_assert_not_reached(); } } } g_assert_not_reached(); }
static JSValueRef speakCallback(JSContextRef context, JSObjectRef thisObject, JSStringRef, JSValueRef*) { JSRetainPtr<JSStringRef> speakString(Adopt, toAXElement(thisObject)->speak()); return JSValueMakeString(context, speakString.get()); }
NX::Value::Value (JSContextRef context, JSStringRef strRef): myContext(context), myVal(nullptr) { myVal = JSValueMakeString(myContext, strRef); JSValueProtect(context, myVal); JSStringRelease(strRef); }
static JSValueRef getHelpTextCallback(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception) { JSRetainPtr<JSStringRef> language(Adopt, toAXElement(thisObject)->helpText()); return JSValueMakeString(context, language.get()); }
static JSValueRef attributesOfChildrenCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { JSRetainPtr<JSStringRef> childrenDescription(Adopt, toAXElement(thisObject)->attributesOfChildren()); return JSValueMakeString(context, childrenDescription.get()); }
static gboolean axObjectEventListener(GSignalInvocationHint *signalHint, guint numParamValues, const GValue *paramValues, gpointer data) { // At least we should receive the instance emitting the signal. if (numParamValues < 1) return true; AtkObject* accessible = ATK_OBJECT(g_value_get_object(¶mValues[0])); if (!accessible || !ATK_IS_OBJECT(accessible)) return true; GSignalQuery signalQuery; GUniquePtr<gchar> signalName; GUniquePtr<gchar> signalValue; String notificationName; g_signal_query(signalHint->signal_id, &signalQuery); if (!g_strcmp0(signalQuery.signal_name, "state-change")) { signalName.reset(g_strdup_printf("state-change:%s", g_value_get_string(¶mValues[1]))); signalValue.reset(g_strdup_printf("%d", g_value_get_boolean(¶mValues[2]))); if (!g_strcmp0(g_value_get_string(¶mValues[1]), "checked")) notificationName = "CheckedStateChanged"; else if (!g_strcmp0(g_value_get_string(¶mValues[1]), "invalid-entry")) notificationName = "AXInvalidStatusChanged"; } else if (!g_strcmp0(signalQuery.signal_name, "focus-event")) { signalName.reset(g_strdup("focus-event")); signalValue.reset(g_strdup_printf("%d", g_value_get_boolean(¶mValues[1]))); if (g_value_get_boolean(¶mValues[1])) notificationName = "AXFocusedUIElementChanged"; } else if (!g_strcmp0(signalQuery.signal_name, "children-changed")) { const gchar* childrenChangedDetail = g_quark_to_string(signalHint->detail); signalName.reset(g_strdup_printf("children-changed:%s", childrenChangedDetail)); signalValue.reset(g_strdup_printf("%d", g_value_get_uint(¶mValues[1]))); notificationName = !g_strcmp0(childrenChangedDetail, "add") ? "AXChildrenAdded" : "AXChildrenRemoved"; } else if (!g_strcmp0(signalQuery.signal_name, "property-change")) { signalName.reset(g_strdup_printf("property-change:%s", g_quark_to_string(signalHint->detail))); if (!g_strcmp0(g_quark_to_string(signalHint->detail), "accessible-value")) notificationName = "AXValueChanged"; } else if (!g_strcmp0(signalQuery.signal_name, "load-complete")) notificationName = "AXLoadComplete"; else signalName.reset(g_strdup(signalQuery.signal_name)); if (loggingAccessibilityEvents) printAccessibilityEvent(accessible, signalName.get(), signalValue.get()); #if PLATFORM(GTK) JSGlobalContextRef jsContext = webkit_web_frame_get_global_context(mainFrame); #elif PLATFORM(EFL) JSGlobalContextRef jsContext = DumpRenderTreeSupportEfl::globalContextRefForFrame(browser->mainFrame()); #else JSContextRef jsContext = 0; #endif if (!jsContext) return true; if (notificationName.length()) { JSRetainPtr<JSStringRef> jsNotificationEventName(Adopt, JSStringCreateWithUTF8CString(notificationName.utf8().data())); JSValueRef notificationNameArgument = JSValueMakeString(jsContext, jsNotificationEventName.get()); NotificationHandlersMap::iterator elementNotificationHandler = notificationHandlers.find(accessible); if (elementNotificationHandler != notificationHandlers.end()) { // Listener for one element just gets one argument, the notification name. JSObjectCallAsFunction(jsContext, elementNotificationHandler->value->notificationFunctionCallback(), 0, 1, ¬ificationNameArgument, 0); } if (globalNotificationHandler) { // A global listener gets the element and the notification name as arguments. JSValueRef arguments[2]; arguments[0] = AccessibilityUIElement::makeJSAccessibilityUIElement(jsContext, AccessibilityUIElement(accessible)); arguments[1] = notificationNameArgument; JSObjectCallAsFunction(jsContext, globalNotificationHandler->notificationFunctionCallback(), 0, 2, arguments, 0); } } return true; }
int main(int argc, char* argv[]) { UNUSED_PARAM(argc); UNUSED_PARAM(argv); // Test garbage collection with a fresh context context = JSGlobalContextCreate(NULL); TestInitializeFinalize = true; testInitializeFinalize(); JSGlobalContextRelease(context); JSGarbageCollect(context); TestInitializeFinalize = false; assert(Base_didFinalize); JSClassDefinition globalObjectClassDefinition = kJSClassDefinitionEmpty; globalObjectClassDefinition.initialize = testInitializeOfGlobalObjectClassHasNonNullContext; JSClassRef globalObjectClass = JSClassCreate(&globalObjectClassDefinition); context = JSGlobalContextCreate(globalObjectClass); JSObjectRef globalObject = JSContextGetGlobalObject(context); assert(JSValueIsObject(context, globalObject)); JSValueRef jsUndefined = JSValueMakeUndefined(context); JSValueRef jsNull = JSValueMakeNull(context); JSValueRef jsTrue = JSValueMakeBoolean(context, true); JSValueRef jsFalse = JSValueMakeBoolean(context, false); JSValueRef jsZero = JSValueMakeNumber(context, 0); JSValueRef jsOne = JSValueMakeNumber(context, 1); JSValueRef jsOneThird = JSValueMakeNumber(context, 1.0 / 3.0); JSObjectRef jsObjectNoProto = JSObjectMake(context, NULL, NULL); JSObjectSetPrototype(context, jsObjectNoProto, JSValueMakeNull(context)); // FIXME: test funny utf8 characters JSStringRef jsEmptyIString = JSStringCreateWithUTF8CString(""); JSValueRef jsEmptyString = JSValueMakeString(context, jsEmptyIString); JSStringRef jsOneIString = JSStringCreateWithUTF8CString("1"); JSValueRef jsOneString = JSValueMakeString(context, jsOneIString); UniChar singleUniChar = 65; // Capital A CFMutableStringRef cfString = CFStringCreateMutableWithExternalCharactersNoCopy(kCFAllocatorDefault, &singleUniChar, 1, 1, kCFAllocatorNull); JSStringRef jsCFIString = JSStringCreateWithCFString(cfString); JSValueRef jsCFString = JSValueMakeString(context, jsCFIString); CFStringRef cfEmptyString = CFStringCreateWithCString(kCFAllocatorDefault, "", kCFStringEncodingUTF8); JSStringRef jsCFEmptyIString = JSStringCreateWithCFString(cfEmptyString); JSValueRef jsCFEmptyString = JSValueMakeString(context, jsCFEmptyIString); CFIndex cfStringLength = CFStringGetLength(cfString); UniChar buffer[cfStringLength]; CFStringGetCharacters(cfString, CFRangeMake(0, cfStringLength), buffer); JSStringRef jsCFIStringWithCharacters = JSStringCreateWithCharacters(buffer, cfStringLength); JSValueRef jsCFStringWithCharacters = JSValueMakeString(context, jsCFIStringWithCharacters); JSStringRef jsCFEmptyIStringWithCharacters = JSStringCreateWithCharacters(buffer, CFStringGetLength(cfEmptyString)); JSValueRef jsCFEmptyStringWithCharacters = JSValueMakeString(context, jsCFEmptyIStringWithCharacters); assert(JSValueGetType(context, jsUndefined) == kJSTypeUndefined); assert(JSValueGetType(context, jsNull) == kJSTypeNull); assert(JSValueGetType(context, jsTrue) == kJSTypeBoolean); assert(JSValueGetType(context, jsFalse) == kJSTypeBoolean); assert(JSValueGetType(context, jsZero) == kJSTypeNumber); assert(JSValueGetType(context, jsOne) == kJSTypeNumber); assert(JSValueGetType(context, jsOneThird) == kJSTypeNumber); assert(JSValueGetType(context, jsEmptyString) == kJSTypeString); assert(JSValueGetType(context, jsOneString) == kJSTypeString); assert(JSValueGetType(context, jsCFString) == kJSTypeString); assert(JSValueGetType(context, jsCFStringWithCharacters) == kJSTypeString); assert(JSValueGetType(context, jsCFEmptyString) == kJSTypeString); assert(JSValueGetType(context, jsCFEmptyStringWithCharacters) == kJSTypeString); JSObjectRef myObject = JSObjectMake(context, MyObject_class(context), NULL); JSStringRef myObjectIString = JSStringCreateWithUTF8CString("MyObject"); JSObjectSetProperty(context, globalObject, myObjectIString, myObject, kJSPropertyAttributeNone, NULL); JSStringRelease(myObjectIString); JSValueRef exception; // Conversions that throw exceptions exception = NULL; assert(NULL == JSValueToObject(context, jsNull, &exception)); assert(exception); exception = NULL; // FIXME <rdar://4668451> - On i386 the isnan(double) macro tries to map to the isnan(float) function, // causing a build break with -Wshorten-64-to-32 enabled. The issue is known by the appropriate team. // After that's resolved, we can remove these casts assert(isnan((float)JSValueToNumber(context, jsObjectNoProto, &exception))); assert(exception); exception = NULL; assert(!JSValueToStringCopy(context, jsObjectNoProto, &exception)); assert(exception); assert(JSValueToBoolean(context, myObject)); exception = NULL; assert(!JSValueIsEqual(context, jsObjectNoProto, JSValueMakeNumber(context, 1), &exception)); assert(exception); exception = NULL; JSObjectGetPropertyAtIndex(context, myObject, 0, &exception); assert(1 == JSValueToNumber(context, exception, NULL)); assertEqualsAsBoolean(jsUndefined, false); assertEqualsAsBoolean(jsNull, false); assertEqualsAsBoolean(jsTrue, true); assertEqualsAsBoolean(jsFalse, false); assertEqualsAsBoolean(jsZero, false); assertEqualsAsBoolean(jsOne, true); assertEqualsAsBoolean(jsOneThird, true); assertEqualsAsBoolean(jsEmptyString, false); assertEqualsAsBoolean(jsOneString, true); assertEqualsAsBoolean(jsCFString, true); assertEqualsAsBoolean(jsCFStringWithCharacters, true); assertEqualsAsBoolean(jsCFEmptyString, false); assertEqualsAsBoolean(jsCFEmptyStringWithCharacters, false); assertEqualsAsNumber(jsUndefined, nan("")); assertEqualsAsNumber(jsNull, 0); assertEqualsAsNumber(jsTrue, 1); assertEqualsAsNumber(jsFalse, 0); assertEqualsAsNumber(jsZero, 0); assertEqualsAsNumber(jsOne, 1); assertEqualsAsNumber(jsOneThird, 1.0 / 3.0); assertEqualsAsNumber(jsEmptyString, 0); assertEqualsAsNumber(jsOneString, 1); assertEqualsAsNumber(jsCFString, nan("")); assertEqualsAsNumber(jsCFStringWithCharacters, nan("")); assertEqualsAsNumber(jsCFEmptyString, 0); assertEqualsAsNumber(jsCFEmptyStringWithCharacters, 0); assert(sizeof(JSChar) == sizeof(UniChar)); assertEqualsAsCharactersPtr(jsUndefined, "undefined"); assertEqualsAsCharactersPtr(jsNull, "null"); assertEqualsAsCharactersPtr(jsTrue, "true"); assertEqualsAsCharactersPtr(jsFalse, "false"); assertEqualsAsCharactersPtr(jsZero, "0"); assertEqualsAsCharactersPtr(jsOne, "1"); assertEqualsAsCharactersPtr(jsOneThird, "0.3333333333333333"); assertEqualsAsCharactersPtr(jsEmptyString, ""); assertEqualsAsCharactersPtr(jsOneString, "1"); assertEqualsAsCharactersPtr(jsCFString, "A"); assertEqualsAsCharactersPtr(jsCFStringWithCharacters, "A"); assertEqualsAsCharactersPtr(jsCFEmptyString, ""); assertEqualsAsCharactersPtr(jsCFEmptyStringWithCharacters, ""); assertEqualsAsUTF8String(jsUndefined, "undefined"); assertEqualsAsUTF8String(jsNull, "null"); assertEqualsAsUTF8String(jsTrue, "true"); assertEqualsAsUTF8String(jsFalse, "false"); assertEqualsAsUTF8String(jsZero, "0"); assertEqualsAsUTF8String(jsOne, "1"); assertEqualsAsUTF8String(jsOneThird, "0.3333333333333333"); assertEqualsAsUTF8String(jsEmptyString, ""); assertEqualsAsUTF8String(jsOneString, "1"); assertEqualsAsUTF8String(jsCFString, "A"); assertEqualsAsUTF8String(jsCFStringWithCharacters, "A"); assertEqualsAsUTF8String(jsCFEmptyString, ""); assertEqualsAsUTF8String(jsCFEmptyStringWithCharacters, ""); assert(JSValueIsStrictEqual(context, jsTrue, jsTrue)); assert(!JSValueIsStrictEqual(context, jsOne, jsOneString)); assert(JSValueIsEqual(context, jsOne, jsOneString, NULL)); assert(!JSValueIsEqual(context, jsTrue, jsFalse, NULL)); CFStringRef cfJSString = JSStringCopyCFString(kCFAllocatorDefault, jsCFIString); CFStringRef cfJSEmptyString = JSStringCopyCFString(kCFAllocatorDefault, jsCFEmptyIString); assert(CFEqual(cfJSString, cfString)); assert(CFEqual(cfJSEmptyString, cfEmptyString)); CFRelease(cfJSString); CFRelease(cfJSEmptyString); CFRelease(cfString); CFRelease(cfEmptyString); jsGlobalValue = JSObjectMake(context, NULL, NULL); JSValueProtect(context, jsGlobalValue); JSGarbageCollect(context); assert(JSValueIsObject(context, jsGlobalValue)); JSValueUnprotect(context, jsGlobalValue); JSStringRef goodSyntax = JSStringCreateWithUTF8CString("x = 1;"); JSStringRef badSyntax = JSStringCreateWithUTF8CString("x := 1;"); assert(JSCheckScriptSyntax(context, goodSyntax, NULL, 0, NULL)); assert(!JSCheckScriptSyntax(context, badSyntax, NULL, 0, NULL)); JSValueRef result; JSValueRef v; JSObjectRef o; JSStringRef string; result = JSEvaluateScript(context, goodSyntax, NULL, NULL, 1, NULL); assert(result); assert(JSValueIsEqual(context, result, jsOne, NULL)); exception = NULL; result = JSEvaluateScript(context, badSyntax, NULL, NULL, 1, &exception); assert(!result); assert(JSValueIsObject(context, exception)); JSStringRef array = JSStringCreateWithUTF8CString("Array"); JSObjectRef arrayConstructor = JSValueToObject(context, JSObjectGetProperty(context, globalObject, array, NULL), NULL); JSStringRelease(array); result = JSObjectCallAsConstructor(context, arrayConstructor, 0, NULL, NULL); assert(result); assert(JSValueIsObject(context, result)); assert(JSValueIsInstanceOfConstructor(context, result, arrayConstructor, NULL)); assert(!JSValueIsInstanceOfConstructor(context, JSValueMakeNull(context), arrayConstructor, NULL)); o = JSValueToObject(context, result, NULL); exception = NULL; assert(JSValueIsUndefined(context, JSObjectGetPropertyAtIndex(context, o, 0, &exception))); assert(!exception); JSObjectSetPropertyAtIndex(context, o, 0, JSValueMakeNumber(context, 1), &exception); assert(!exception); exception = NULL; assert(1 == JSValueToNumber(context, JSObjectGetPropertyAtIndex(context, o, 0, &exception), &exception)); assert(!exception); JSStringRef functionBody; JSObjectRef function; exception = NULL; functionBody = JSStringCreateWithUTF8CString("rreturn Array;"); JSStringRef line = JSStringCreateWithUTF8CString("line"); assert(!JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, &exception)); assert(JSValueIsObject(context, exception)); v = JSObjectGetProperty(context, JSValueToObject(context, exception, NULL), line, NULL); assertEqualsAsNumber(v, 2); // FIXME: Lexer::setCode bumps startingLineNumber by 1 -- we need to change internal callers so that it doesn't have to (saying '0' to mean '1' in the API would be really confusing -- it's really confusing internally, in fact) JSStringRelease(functionBody); JSStringRelease(line); exception = NULL; functionBody = JSStringCreateWithUTF8CString("return Array;"); function = JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, &exception); JSStringRelease(functionBody); assert(!exception); assert(JSObjectIsFunction(context, function)); v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, NULL); assert(v); assert(JSValueIsEqual(context, v, arrayConstructor, NULL)); exception = NULL; function = JSObjectMakeFunction(context, NULL, 0, NULL, jsEmptyIString, NULL, 0, &exception); assert(!exception); v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, &exception); assert(v && !exception); assert(JSValueIsUndefined(context, v)); exception = NULL; v = NULL; JSStringRef foo = JSStringCreateWithUTF8CString("foo"); JSStringRef argumentNames[] = { foo }; functionBody = JSStringCreateWithUTF8CString("return foo;"); function = JSObjectMakeFunction(context, foo, 1, argumentNames, functionBody, NULL, 1, &exception); assert(function && !exception); JSValueRef arguments[] = { JSValueMakeNumber(context, 2) }; v = JSObjectCallAsFunction(context, function, NULL, 1, arguments, &exception); JSStringRelease(foo); JSStringRelease(functionBody); string = JSValueToStringCopy(context, function, NULL); assertEqualsAsUTF8String(JSValueMakeString(context, string), "function foo(foo) \n{\n return foo;\n}"); JSStringRelease(string); JSStringRef print = JSStringCreateWithUTF8CString("print"); JSObjectRef printFunction = JSObjectMakeFunctionWithCallback(context, print, print_callAsFunction); JSObjectSetProperty(context, globalObject, print, printFunction, kJSPropertyAttributeNone, NULL); JSStringRelease(print); assert(!JSObjectSetPrivate(printFunction, (void*)1)); assert(!JSObjectGetPrivate(printFunction)); JSStringRef myConstructorIString = JSStringCreateWithUTF8CString("MyConstructor"); JSObjectRef myConstructor = JSObjectMakeConstructor(context, NULL, myConstructor_callAsConstructor); JSObjectSetProperty(context, globalObject, myConstructorIString, myConstructor, kJSPropertyAttributeNone, NULL); JSStringRelease(myConstructorIString); assert(!JSObjectSetPrivate(myConstructor, (void*)1)); assert(!JSObjectGetPrivate(myConstructor)); string = JSStringCreateWithUTF8CString("Derived"); JSObjectRef derivedConstructor = JSObjectMakeConstructor(context, Derived_class(context), NULL); JSObjectSetProperty(context, globalObject, string, derivedConstructor, kJSPropertyAttributeNone, NULL); JSStringRelease(string); o = JSObjectMake(context, NULL, NULL); JSObjectSetProperty(context, o, jsOneIString, JSValueMakeNumber(context, 1), kJSPropertyAttributeNone, NULL); JSObjectSetProperty(context, o, jsCFIString, JSValueMakeNumber(context, 1), kJSPropertyAttributeDontEnum, NULL); JSPropertyNameArrayRef nameArray = JSObjectCopyPropertyNames(context, o); size_t expectedCount = JSPropertyNameArrayGetCount(nameArray); size_t count; for (count = 0; count < expectedCount; ++count) JSPropertyNameArrayGetNameAtIndex(nameArray, count); JSPropertyNameArrayRelease(nameArray); assert(count == 1); // jsCFString should not be enumerated JSClassDefinition nullDefinition = kJSClassDefinitionEmpty; nullDefinition.attributes = kJSClassAttributeNoAutomaticPrototype; JSClassRef nullClass = JSClassCreate(&nullDefinition); JSClassRelease(nullClass); nullDefinition = kJSClassDefinitionEmpty; nullClass = JSClassCreate(&nullDefinition); JSClassRelease(nullClass); functionBody = JSStringCreateWithUTF8CString("return this;"); function = JSObjectMakeFunction(context, NULL, 0, NULL, functionBody, NULL, 1, NULL); JSStringRelease(functionBody); v = JSObjectCallAsFunction(context, function, NULL, 0, NULL, NULL); assert(JSValueIsEqual(context, v, globalObject, NULL)); v = JSObjectCallAsFunction(context, function, o, 0, NULL, NULL); assert(JSValueIsEqual(context, v, o, NULL)); char* scriptUTF8 = createStringWithContentsOfFile("testapi.js"); JSStringRef script = JSStringCreateWithUTF8CString(scriptUTF8); result = JSEvaluateScript(context, script, NULL, NULL, 1, &exception); if (JSValueIsUndefined(context, result)) printf("PASS: Test script executed successfully.\n"); else { printf("FAIL: Test script returned unexcpected value:\n"); JSStringRef exceptionIString = JSValueToStringCopy(context, exception, NULL); CFStringRef exceptionCF = JSStringCopyCFString(kCFAllocatorDefault, exceptionIString); CFShow(exceptionCF); CFRelease(exceptionCF); JSStringRelease(exceptionIString); } JSStringRelease(script); free(scriptUTF8); JSStringRelease(jsEmptyIString); JSStringRelease(jsOneIString); JSStringRelease(jsCFIString); JSStringRelease(jsCFEmptyIString); JSStringRelease(jsCFIStringWithCharacters); JSStringRelease(jsCFEmptyIStringWithCharacters); JSStringRelease(goodSyntax); JSStringRelease(badSyntax); JSGlobalContextRelease(context); JSGarbageCollect(context); JSClassRelease(globalObjectClass); printf("PASS: Program exited normally.\n"); return 0; }
static void injectJSExtensions(JSGlobalContextRef context) { static JSValueRef s_value1 = JSValueMakeNumber(context, 15); static JSValueRef s_value2 = JSValueMakeNumber(context, 16); static JSStaticValue s_staticValues[] = { { "value1", // name // getProperty [](JSContextRef context, JSObjectRef, JSStringRef, JSValueRef*) -> JSValueRef { fprintf(stderr, "[WPE-EXT] getProperty for 'value1' invoked.\n"); return s_value1; }, nullptr, // setProperty kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete, // attributes }, { "value2", // name // getProperty [](JSContextRef context, JSObjectRef, JSStringRef, JSValueRef*) -> JSValueRef { fprintf(stderr, "[WPE-EXT] getProperty for 'value2' invoked.\n"); return s_value2; }, // setProperty [](JSContextRef, JSObjectRef, JSStringRef, JSValueRef value, JSValueRef*) -> bool { fprintf(stderr, "[WPE-EXT] setProperty for 'value2' invoked.\n"); s_value2 = value; return true; }, kJSPropertyAttributeNone, // attributes }, { nullptr, nullptr, nullptr, 0 } }; static JSStaticFunction s_staticFunctions[] = { { "function1", // name // callAsFunction [](JSContextRef context, JSObjectRef, JSObjectRef, size_t argumentCount, const JSValueRef arguments[], JSValueRef*) -> JSValueRef { fprintf(stderr, "[WPE-EXT] callAsFunction for 'function1' invoked.\n"); JSStringRef returnString = JSStringCreateWithUTF8CString("function1 return value"); JSValueRef returnValue = JSValueMakeString(context, returnString); JSStringRelease(returnString); return returnValue; }, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete, // attributes }, { nullptr, nullptr, 0 } }; static JSClassDefinition s_classDefinition = { 0, // version kJSClassAttributeNone, //attributes "WPE", // className 0, // parentClass s_staticValues, // staticValues s_staticFunctions, // staticFunctions nullptr, //initialize nullptr, //finalize nullptr, //hasProperty nullptr, //getProperty nullptr, //setProperty nullptr, //deleteProperty nullptr, //getPropertyNames nullptr, //callAsFunction nullptr, //callAsConstructor nullptr, //hasInstance nullptr, //convertToType }; JSClassRef wpeClass = JSClassCreate(&s_classDefinition); JSValueRef wpeObject = JSObjectMake(context, wpeClass, nullptr); JSClassRelease(wpeClass); JSStringRef extensionString = JSStringCreateWithUTF8CString("wpe"); JSObjectSetProperty(context, JSContextGetGlobalObject(context), extensionString, wpeObject, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete, nullptr); JSStringRelease(extensionString); }
static JSValueRef getARIADropEffectsCallback(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception) { JSRetainPtr<JSStringRef> dropEffects(Adopt, toAXElement(thisObject)->ariaDropEffects()); return JSValueMakeString(context, dropEffects.get()); }
NX::Value::Value (JSContextRef context, const std::string & str): myContext(context), myVal(nullptr) { NX::ScopedString strRef(str); myVal = JSValueMakeString(myContext, strRef); JSValueProtect(context, myVal); }
static JSValueRef allAttributesCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { JSRetainPtr<JSStringRef> attributes(Adopt, toAXElement(thisObject)->allAttributes()); return JSValueMakeString(context, attributes.get()); }
JSValueRef JSCDocument::evaluateCustomCallback(JSContextRef ctx, JSObjectRef function, JSObjectRef object, size_t argumentCount, const JSValueRef* arguments, JSValueRef* exception) { struct JSCDocumentPrivate* privData = (struct JSCDocumentPrivate*)JSObjectGetPrivate(object); if (!privData->dom || !privData->dom->xpath) return JSValueMakeUndefined(ctx); if (argumentCount < 1) { std::string errorMsg = "Wrong number of arguments in evaluate"; JSStringRef string = JSStringCreateWithUTF8CString(errorMsg.c_str()); JSValueRef exceptionString = JSValueMakeString(ctx, string); JSStringRelease(string); *exception = JSValueToObject(ctx, exceptionString, NULL); return JSValueMakeUndefined(ctx); } // make sure first argument is a string if (!JSValueIsString(ctx, arguments[0])) { std::string errorMsg = "Expected xpath expression as first argument"; JSStringRef string = JSStringCreateWithUTF8CString(errorMsg.c_str()); JSValueRef exceptionString = JSValueMakeString(ctx, string); JSStringRelease(string); *exception = JSValueToObject(ctx, exceptionString, NULL); return JSValueMakeUndefined(ctx); } JSStringRef stringReflocalXPath = JSValueToStringCopy(ctx, arguments[0], NULL); size_t localXPathMaxSize = JSStringGetMaximumUTF8CStringSize(stringReflocalXPath); char* localXPathBuffer = new char[localXPathMaxSize]; JSStringGetUTF8CString(stringReflocalXPath, localXPathBuffer, localXPathMaxSize); std::string localXPath(localXPathBuffer); JSStringRelease(stringReflocalXPath); free(localXPathBuffer); JSClassRef arbaicaRetClass = JSCXPathResult::getTmpl(); XPath::XPathValue<std::string>* retVal; try { if (argumentCount > 1) { // make sure second argument is a node if (!JSValueIsObject(ctx, arguments[1])) { std::string errorMsg = "Second argument is not of type node"; JSStringRef string = JSStringCreateWithUTF8CString(errorMsg.c_str()); JSValueRef exceptionString = JSValueMakeString(ctx, string); JSStringRelease(string); *exception = JSValueToObject(ctx, exceptionString, NULL); return JSValueMakeUndefined(ctx); } Arabica::DOM::Node<std::string>* localContextNode = (Arabica::DOM::Node<std::string>*)JSObjectGetPrivate(JSValueToObject(ctx, arguments[1], NULL)); retVal = new XPath::XPathValue<std::string>(privData->dom->xpath->evaluate(localXPath, *localContextNode)); } else { retVal = new XPath::XPathValue<std::string>(privData->dom->xpath->evaluate(localXPath, *privData->nativeObj)); } } catch (std::runtime_error e) { std::cout << e.what() << std::endl; return JSValueMakeUndefined(ctx); } struct JSCXPathResult::JSCXPathResultPrivate* retPrivData = new JSCXPathResult::JSCXPathResultPrivate(); retPrivData->dom = privData->dom; retPrivData->nativeObj = retVal; JSObjectRef arbaicaRetObj = JSObjectMake(ctx, arbaicaRetClass, retPrivData); return arbaicaRetObj; #if 0 if (args.Length() < 1) throw V8Exception("Wrong number of arguments in evaluate"); // if (!((V8Node::hasInstance(args[1])) && (V8XPathResult::hasInstance(args[3])))) // throw V8Exception("Parameter mismatch while calling evaluate"); v8::Local<v8::Object> self = args.Holder(); V8DocumentPrivate* privData = V8DOM::toClassPtr<V8DocumentPrivate >(self->GetInternalField(0)); v8::String::AsciiValue localExpression(args[0]); XPath::XPathValue<std::string>* retVal; if (args.Length() > 1) { Arabica::DOM::Node<std::string>* localContextNode = V8DOM::toClassPtr<Arabica::DOM::Node<std::string> >(args[1]->ToObject()->GetInternalField(0)); retVal = new XPath::XPathValue<std::string>(privData->dom->xpath->evaluate(*localExpression, *localContextNode)); } else { retVal = new XPath::XPathValue<std::string>(privData->dom->xpath->evaluate(*localExpression, *privData->nativeObj)); } v8::Handle<v8::Function> retCtor = V8XPathResult::getTmpl()->GetFunction(); v8::Persistent<v8::Object> retObj = v8::Persistent<v8::Object>::New(retCtor->NewInstance()); V8XPathResult::V8XPathResultPrivate* retPrivData = new V8XPathResult::V8XPathResultPrivate(); retPrivData->dom = privData->dom; retPrivData->nativeObj = retVal; retObj->SetInternalField(0, V8DOM::toExternal(retPrivData)); retObj.MakeWeak(0, V8XPathResult::jsDestructor); return retObj; #endif }
static JSValueRef getDescriptionCallback(JSContextRef context, JSObjectRef thisObject, JSStringRef propertyName, JSValueRef* exception) { JSRetainPtr<JSStringRef> description(Adopt, toAXElement(thisObject)->description()); return JSValueMakeString(context, description.get()); }
JSValueRef dbus_to_js(JSContextRef ctx, GVariant *dbus) { JSValueRef jsvalue = NULL; GVariantClass type = g_variant_classify(dbus); switch (type) { case G_VARIANT_CLASS_STRING: case G_VARIANT_CLASS_OBJECT_PATH: case G_VARIANT_CLASS_SIGNATURE: { JSStringRef js_string = JSStringCreateWithUTF8CString( g_variant_get_string(dbus, NULL)); jsvalue = JSValueMakeString(ctx, js_string); JSStringRelease(js_string); return jsvalue; } case G_VARIANT_CLASS_BYTE: return JSValueMakeNumber(ctx, g_variant_get_byte(dbus)); case G_VARIANT_CLASS_DOUBLE: return JSValueMakeNumber(ctx, g_variant_get_double(dbus)); case G_VARIANT_CLASS_INT16: return JSValueMakeNumber(ctx, g_variant_get_int16(dbus)); case G_VARIANT_CLASS_UINT16: return JSValueMakeNumber(ctx, g_variant_get_uint16(dbus)); case G_VARIANT_CLASS_INT32: return JSValueMakeNumber(ctx, g_variant_get_int32(dbus)); case G_VARIANT_CLASS_UINT32: return JSValueMakeNumber(ctx, g_variant_get_uint32(dbus)); case G_VARIANT_CLASS_INT64: return JSValueMakeNumber(ctx, g_variant_get_int64(dbus)); case G_VARIANT_CLASS_UINT64: return JSValueMakeNumber(ctx, g_variant_get_uint64(dbus)); case G_VARIANT_CLASS_BOOLEAN: return JSValueMakeBoolean(ctx, g_variant_get_boolean(dbus)); case G_VARIANT_CLASS_HANDLE: g_warning("[%s] does not support FD type\n", __func__); return JSValueMakeNumber(ctx, g_variant_get_uint32(dbus)); case G_VARIANT_CLASS_VARIANT: { GVariant* v = g_variant_get_variant(dbus); jsvalue = dbus_to_js(ctx, v); g_variant_unref(v); return jsvalue; } case G_VARIANT_CLASS_DICT_ENTRY: /*g_assert_not_reached();*/ break; case G_VARIANT_CLASS_ARRAY: { if (g_variant_type_is_dict_entry( g_variant_type_element(g_variant_get_type(dbus)))) { jsvalue = JSObjectMake(ctx, NULL, NULL); for (size_t i=0; i<g_variant_n_children(dbus); i++) { GVariant *dic = g_variant_get_child_value(dbus, i); GVariant *key= g_variant_get_child_value (dic, 0); GVariant *value = g_variant_get_child_value (dic, 1); JSValueRef js_key = dbus_to_js(ctx, key); JSValueRef js_value = dbus_to_js(ctx, value); JSStringRef key_str = JSValueToStringCopy(ctx, js_key, NULL); JSObjectSetProperty(ctx, (JSObjectRef)jsvalue, key_str, js_value, 0, NULL); JSStringRelease(key_str); g_variant_unref(key); g_variant_unref(value); g_variant_unref(dic); } return jsvalue; } else { int n = g_variant_n_children(dbus); JSValueRef *args = g_new(JSValueRef, n); for (int i=0; i < n; i++) { GVariant* v = g_variant_get_child_value(dbus, i); args[i] = dbus_to_js(ctx, v); g_variant_unref(v); } jsvalue = JSObjectMakeArray(ctx, n, args, NULL); g_free(args); return jsvalue; } } case G_VARIANT_CLASS_TUPLE: { int n = g_variant_n_children(dbus); jsvalue = JSObjectMakeArray(ctx, 0, NULL, NULL); for (int i=0; i < n; i++) { GVariant* v = g_variant_get_child_value(dbus, i); JSObjectSetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, dbus_to_js(ctx, v), NULL); g_variant_unref(v); } return jsvalue; } case G_VARIANT_CLASS_MAYBE: g_assert_not_reached(); } g_warning("[%s] does not support signature type:%c\n", __func__, type); return JSValueMakeUndefined(ctx); }