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);
}
