void duk_fileio_register(duk_context *ctx) { duk_push_global_object(ctx); duk_push_string(ctx, "fileio"); duk_push_object(ctx); duk_push_string(ctx, "readfile"); duk_push_c_function(ctx, duk_fileio_readfile, 1); duk_put_prop(ctx, -3); duk_put_prop(ctx, -3); duk_pop(ctx); }
/* strict: error * (non-strict: return 0) */ static duk_ret_t test_new_not_extensible(duk_context *ctx) { const char *src; duk_ret_t rc; printf("strict: %d\n", (int) duk_is_strict_call(ctx)); src = "(function () { var o = { foo: 1 }; Object.preventExtensions(o); return o; })()"; duk_set_top(ctx, 0); duk_push_string(ctx, src); printf("eval:\n%s\n", duk_get_string(ctx, -1)); duk_eval(ctx); printf("top after eval: %ld\n", (long) duk_get_top(ctx)); duk_push_string(ctx, "bar"); duk_push_string(ctx, "quux"); rc = duk_put_prop(ctx, -3); printf("put rc=%d\n", (int) rc); duk_json_encode(ctx, 0); printf("result: %s\n", duk_to_string(ctx, 0)); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
int duk_bi_array_prototype_push(duk_context *ctx) { /* Note: 'this' is not necessarily an Array object. The push() * algorithm is supposed to work for other kinds of objects too, * so the algorithm has e.g. an explicit update for the 'length' * property which is normally "magical" in arrays. */ double len; int i, n; n = duk_get_top(ctx); len = (double) duk__push_this_obj_len_u32(ctx); /* [ arg1 ... argN obj length ] */ /* Note: we keep track of length with a double instead of a 32-bit * (unsigned) int because the length can go beyond 32 bits and the * final length value is NOT wrapped to 32 bits on this call. */ for (i = 0; i < n; i++) { duk_push_number(ctx, len); duk_dup(ctx, i); duk_put_prop(ctx, -4); /* FIXME: "Throw" */ len += 1.0; } duk_push_number(ctx, len); duk_dup_top(ctx); duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH); /* [ arg1 ... argN obj length new_length ] */ return 1; }
void ncurses_register(duk_context *ctx) { duk_push_global_object(ctx); duk_push_string(ctx, "Ncurses"); duk_push_object(ctx); duk_push_c_function(ctx, ncurses_initscr, 0); duk_put_prop_string(ctx, -2, "initscr"); duk_push_c_function(ctx, ncurses_endwin, 0); duk_put_prop_string(ctx, -2, "endwin"); duk_push_c_function(ctx, ncurses_delscreen, 0); duk_put_prop_string(ctx, -2, "delscreen"); duk_push_c_function(ctx, ncurses_getmaxyx, 0); duk_put_prop_string(ctx, -2, "getmaxyx"); duk_push_c_function(ctx, ncurses_printw, 1); duk_put_prop_string(ctx, -2, "printw"); duk_push_c_function(ctx, ncurses_mvprintw, 3); duk_put_prop_string(ctx, -2, "mvprintw"); duk_push_c_function(ctx, ncurses_refresh, 0); duk_put_prop_string(ctx, -2, "refresh"); duk_push_c_function(ctx, ncurses_getch, 0); duk_put_prop_string(ctx, -2, "getch"); duk_put_prop(ctx, -3); duk_pop(ctx); }
/* strict: error * (non-strict: return 0) */ static duk_ret_t test_ex_nonwritable(duk_context *ctx) { duk_ret_t rc; printf("strict: %d\n", (int) duk_is_strict_call(ctx)); /* Math.PI is not writable */ duk_set_top(ctx, 0); duk_push_global_object(ctx); rc = duk_get_prop_string(ctx, -1, "Math"); /* -> [ global Math ] */ printf("get Math -> rc=%d\n", (int) rc); rc = duk_get_prop_string(ctx, -1, "PI"); printf("Math.PI=%s\n", duk_to_string(ctx, -1)); duk_pop(ctx); duk_push_string(ctx, "PI"); duk_push_string(ctx, "bar"); rc = duk_put_prop(ctx, -3); printf("put rc=%d\n", (int) rc); rc = duk_get_prop_string(ctx, -1, "PI"); printf("Math.PI=%s\n", duk_to_string(ctx, -1)); duk_pop(ctx); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
static duk_ret_t Component_SetProperty(duk_context* ctx) { /* 'this' binding: handler * [0]: target * [1]: key * [2]: val * [3]: receiver (proxy) */ const char* attrName = duk_to_string(ctx, 1); if (attrName && attrName[0] >= 'a' && attrName[0] <= 'z') { IComponent* comp = GetWeakObject<IComponent>(ctx, 0); if (comp) { IAttribute* attr = comp->AttributeById(String(attrName)); AssignAttributeValue(ctx, 2, attr, AttributeChange::Default); return 1; } } // Fallthrough to ordinary properties duk_dup(ctx, 1); duk_dup(ctx, 2); duk_put_prop(ctx, 0); duk_push_true(ctx); return 1; }
/* * An AllJoyn dictionary entry maps cleanly to a JavaScript object property */ static AJ_Status PushDictionaryArg(duk_context* ctx, AJ_Message* msg) { AJ_Arg arg; AJ_Status status = AJ_UnmarshalContainer(msg, &arg, AJ_ARG_ARRAY); if (status == AJ_OK) { int objIndex = duk_push_object(ctx); while (status == AJ_OK) { AJ_Arg entry; status = AJ_UnmarshalContainer(msg, &entry, AJ_ARG_DICT_ENTRY); if (status == AJ_OK) { status = PushArg(ctx, msg); // key if (status == AJ_OK) { status = PushArg(ctx, msg); // value } if (status == AJ_OK) { duk_put_prop(ctx, objIndex); } AJ_UnmarshalCloseContainer(msg, &entry); } } if (status == AJ_ERR_NO_MORE) { status = AJ_OK; } AJ_UnmarshalCloseContainer(msg, &arg); } return status; }
/* strict: error * (non-strict: return 0) */ static duk_ret_t test_ex_accessor_wo_setter(duk_context *ctx) { const char *src; duk_ret_t rc; printf("strict: %d\n", (int) duk_is_strict_call(ctx)); src = "(function () {\n" " var o = {};\n" " Object.defineProperty(o, 'foo', {\n" " configurable: true,\n" " extensible: true,\n" " get: function() { print('getter'); }\n" " // no setter\n" " });\n" " return o;\n" "})()"; duk_set_top(ctx, 0); duk_push_string(ctx, src); printf("eval:\n%s\n", duk_get_string(ctx, -1)); duk_eval(ctx); printf("top after eval: %ld\n", (long) duk_get_top(ctx)); duk_push_string(ctx, "foo"); duk_push_string(ctx, "bar"); rc = duk_put_prop(ctx, -3); printf("put rc=%d\n", (int) rc); duk_json_encode(ctx, 0); printf("result: %s\n", duk_to_string(ctx, 0)); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_assign(duk_hthread *thr) { duk_idx_t nargs; duk_int_t idx; nargs = duk_get_top_require_min(thr, 1 /*min_top*/); duk_to_object(thr, 0); for (idx = 1; idx < nargs; idx++) { /* E7 19.1.2.1 (step 4a) */ if (duk_is_null_or_undefined(thr, idx)) { continue; } /* duk_enum() respects ES2015+ [[OwnPropertyKeys]] ordering, which is * convenient here. */ duk_to_object(thr, idx); duk_enum(thr, idx, DUK_ENUM_OWN_PROPERTIES_ONLY); while (duk_next(thr, -1, 1 /*get_value*/)) { /* [ target ... enum key value ] */ duk_put_prop(thr, 0); /* [ target ... enum ] */ } /* Could pop enumerator, but unnecessary because of duk_set_top() * below. */ } duk_set_top(thr, 1); return 1; }
void JSEventDispatcher::EndSendEvent(Context* context, Object* sender, StringHash eventType, VariantMap& eventData) { if (!jsEvents_.Contains(eventType)) return; JSVM* vm = JSVM::GetJSVM(NULL); if (!vm) return; duk_context* ctx = vm->GetJSContext(); duk_push_global_stash(ctx); duk_get_prop_index(ctx, -1, JS_GLOBALSTASH_VARIANTMAP_CACHE); duk_push_pointer(ctx, (void*) &eventData); duk_get_prop(ctx, -2); // If this issue is addressed, revisit this to simply remove // the variantmap object from the cache, if the user explicitly // keeps the event object alive in a local closure, that is allowed // (though, will keep object properties from being GC'd) // https://github.com/svaarala/duktape/issues/229 // Ok, this is unfortunate, in an event callback it is possible // to capture the Proxy object which represents the event VariantMap // in a function() {} closure, which will keep the event data alive // until the function happens to be gc'd (it is a member of the eventhandler) // which will leave things like scenes up if there was a P_SCENE event data // member, etc // So, we need to check if we have an object in the variant map cache // and thense call it's delete property method on the Proxy, which will clear // all the data (the proxy can still be alive as a captured local, though // the members won't be held // This all makes it that much more important that the pointer to eventData // is consistent across entire event, otherwise references may be held // see note above about: https://github.com/svaarala/duktape/issues/229 if (duk_is_object(ctx, -1)) { // deletes all properties, thus freeing references, even if // the variant map object is held onto by script (it will be invalid, post // event send) // see JSAPI.cpp variantmap_property_deleteproperty duk_del_prop_index(ctx, -1, 0); duk_push_pointer(ctx, (void*) &eventData); duk_push_undefined(ctx); // clear the variant map object from the cache duk_put_prop(ctx, -4); } duk_pop_3(ctx); }
DUK_EXTERNAL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) { DUK_ASSERT_CTX_VALID(ctx); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_uarridx(ctx, arr_index); duk_swap_top(ctx, -2); /* [val key] -> [key val] */ return duk_put_prop(ctx, obj_index); }
DUK_EXTERNAL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) { DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT(key != NULL); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_string(ctx, key); duk_swap_top(ctx, -2); /* [val key] -> [key val] */ return duk_put_prop(ctx, obj_index); }
void StyleContext::parseSceneGlobals(const YAML::Node& node, const std::string& key, int seqIndex, duk_idx_t dukObject) { switch(node.Type()) { case YAML::NodeType::Scalar: if (key.size() == 0) { duk_push_string(m_ctx, node.Scalar().c_str()); duk_put_prop_index(m_ctx, dukObject, seqIndex); } else { auto nodeValue = node.Scalar(); if (nodeValue.compare(0, 8, "function") == 0) { duk_push_string(m_ctx, key.c_str()); // push property key duk_push_string(m_ctx, nodeValue.c_str()); // push function string duk_push_string(m_ctx, ""); if (duk_pcompile(m_ctx, DUK_COMPILE_FUNCTION) == 0) { // compile function duk_put_prop(m_ctx, -3); // put {key: function()} } else { LOGW("Compile failed in global function: %s\n%s\n---", duk_safe_to_string(m_ctx, -1), nodeValue.c_str()); duk_pop(m_ctx); //pop error duk_pop(m_ctx); //pop key // push property as a string duk_push_string(m_ctx, nodeValue.c_str()); duk_put_prop_string(m_ctx, dukObject, key.c_str()); } } else { duk_push_string(m_ctx, nodeValue.c_str()); duk_put_prop_string(m_ctx, dukObject, key.c_str()); } } break; case YAML::NodeType::Sequence: { auto seqObj = duk_push_array(m_ctx); for (int i = 0; i < node.size(); i++) { parseSceneGlobals(node[i], "", i, seqObj); } duk_put_prop_string(m_ctx, seqObj-1, key.c_str()); break; } case YAML::NodeType::Map: { //duk_push_string(m_ctx, key.c_str()); auto mapObj = duk_push_object(m_ctx); for (auto& mapNode : node) { auto itemKey = mapNode.first.Scalar(); parseSceneGlobals(mapNode.second, itemKey, 0, mapObj); } duk_put_prop_string(m_ctx, mapObj-1, key.c_str()); } default: break; } return; }
int duk_bi_array_prototype_unshift(duk_context *ctx) { unsigned int nargs; unsigned int len; unsigned int i; double final_len; /* FIXME: duk_get_top return type */ nargs = (unsigned int) duk_get_top(ctx); len = duk__push_this_obj_len_u32(ctx); /* stack[0...nargs-1] = unshift args (vararg) * stack[nargs] = ToObject(this) * stack[nargs+1] = ToUint32(length) */ DUK_ASSERT_TOP(ctx, nargs + 2); /* Note: unshift() may operate on indices above unsigned 32-bit range * and the final length may be >= 2**32. Hence we use 'double' vars * here, when appropriate. */ i = len; while (i > 0) { DUK_ASSERT_TOP(ctx, nargs + 2); i--; duk_push_number(ctx, ((double) i) + ((double) nargs)); /* k+argCount-1; note that may be above 32-bit range */ if (duk_get_prop_index(ctx, -3, i)) { /* fromPresent = true */ /* [ ... ToObject(this) ToUint32(length) to val ] */ duk_put_prop(ctx, -4); /* -> [ ... ToObject(this) ToUint32(length) ] */ /* FIXME: Throw */ } else { /* fromPresent = false */ /* [ ... ToObject(this) ToUint32(length) to val ] */ duk_pop(ctx); duk_del_prop(ctx, -3); /* -> [ ... ToObject(this) ToUint32(length) ] */ /* FIXME: Throw */ } DUK_ASSERT_TOP(ctx, nargs + 2); } for (i = 0; i < nargs; i++) { DUK_ASSERT_TOP(ctx, nargs + 2); duk_dup(ctx, i); /* -> [ ... ToObject(this) ToUint32(length) arg[i] ] */ duk_put_prop_index(ctx, -3, i); /* FIXME: Throw */ DUK_ASSERT_TOP(ctx, nargs + 2); } DUK_ASSERT_TOP(ctx, nargs + 2); final_len = ((double) len) + ((double) nargs); duk_push_number(ctx, final_len); duk_dup_top(ctx); /* -> [ ... ToObject(this) ToUint32(length) final_len final_len ] */ duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH); /* FIXME: Throw */ return 1; }
DUK_INTERNAL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) { duk_hthread *thr = (duk_hthread *) ctx; DUK_ASSERT_CTX_VALID(ctx); DUK_ASSERT_DISABLE(stridx >= 0); DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS); obj_index = duk_require_normalize_index(ctx, obj_index); duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx)); duk_swap_top(ctx, -2); /* [val key] -> [key val] */ return duk_put_prop(ctx, obj_index); }
/*----------------------------------------------------------------------------*/ void kbjs_register_built_ins(duk_context *context) { /* STACK: [..., global] */ duk_push_global_object(context); /* STACK: [..., global, "sleep"] */ duk_push_string(context, SLEEP_FUNC_NAME); /* STACK: [..., global, "sleep", function] */ duk_push_c_function(context, kbjs_sleep, (duk_idx_t)1); /* STACK: [..., global] */ duk_put_prop(context, (duk_idx_t)-3); /* STACK: [...] */ duk_pop(context); }
/* Place a `module` object on the top of the value stack into the require cache * based on its `.id` property. As a convenience to the caller, leave the * object on top of the value stack afterwards. */ static void duk__put_cached_module(duk_context *ctx) { /* [ ... module ] */ duk_push_global_stash(ctx); (void) duk_get_prop_string(ctx, -1, "\xff" "requireCache"); duk_dup(ctx, -3); /* [ ... module stash req_cache module ] */ (void) duk_get_prop_string(ctx, -1, "id"); duk_dup(ctx, -2); duk_put_prop(ctx, -4); duk_pop_3(ctx); /* [ ... module ] */ }
// Duktape.modSearch function, needed for loading modules with require() duk_ret_t module_search(duk_context *ctx) { const char *id = duk_require_string(ctx, 0); // C modules: add functions to exports variable (3rd argument) and return undefined for (int i = 0; i < c_module_count; i++) { if (!strcmp(c_module_list[i].name, id)) { duk_push_c_function(ctx, c_module_list[i].init_func, 0); duk_call(ctx, 0); duk_enum(ctx, -1, 0); while(duk_next(ctx, -1, 1)) { duk_put_prop(ctx, 2); } duk_pop_2(ctx); return 0; } } // JS modules: return source code as a string // Read from file "modname.js.tns" int module_filename_len = strlen(id) + strlen(".js.tns") + 1; char *module_filename = malloc(module_filename_len); if (!module_filename) goto error; snprintf(module_filename, module_filename_len, "%s.js.tns", id); FILE *module_file = fopen(module_filename, "r"); free(module_filename); if (!module_file) goto error; if (fseek(module_file, 0, SEEK_END) != 0) goto error; long module_file_size = ftell(module_file); if (module_file_size == -1) goto error; rewind(module_file); char *src = malloc(module_file_size); if (!src) goto error; fread(src, 1, module_file_size, module_file); if (ferror(module_file)) goto error; fclose(module_file); duk_push_lstring(ctx, src, module_file_size); free(src); return 1; error: duk_push_error_object(ctx, DUK_ERR_ERROR, "module %s not found: %s", id, strerror(errno)); duk_throw(ctx); }
int test_put(duk_context *ctx) { int rc; /* In Ecmascript, '(0).foo = "bar"' should work and evaluate to "bar" * in non-strict mode, but cause an error to be thrown in strict mode * (E5.1, Section 8.7.2, special [[Put]] variant, step 7. */ duk_push_int(ctx, 0); duk_push_string(ctx, "foo"); duk_push_string(ctx, "bar"); rc = duk_put_prop(ctx, -3); printf("put rc=%d\n", rc); printf("final top: %d\n", rc); return 0; }
static int ctx_push_hash_element(VALUE key, VALUE val, VALUE extra) { struct state *state = (struct state*) extra; duk_context *ctx = state->ctx; switch (TYPE(key)) { case T_SYMBOL: case T_STRING: ctx_push_ruby_object(state, key); break; default: clean_raise(ctx, rb_eTypeError, "invalid key type %s", rb_obj_classname(key)); } ctx_push_ruby_object(state, val); duk_put_prop(ctx, -3); return ST_CONTINUE; }
void init_env(duk_context *ctx) { // TODO: It might be cleaner to make this a property on some Process object // that can also have some other metadata (e.g. command line args) duk_push_global_object(ctx); duk_push_object(ctx); for (char **env=environ ; *env!=NULL ; env++) { char *kv = *env; char *val = strchr(kv, '='); duk_push_lstring(ctx, kv, val-kv); // Skip the = duk_push_string(ctx, val+1); duk_put_prop(ctx, -3); } duk_put_prop_string(ctx, -2, "environ"); duk_pop(ctx); }
/* success */ static duk_ret_t test_new_extensible(duk_context *ctx) { duk_ret_t rc; printf("strict: %d\n", (int) duk_is_strict_call(ctx)); duk_set_top(ctx, 0); duk_push_string(ctx, "{ \"foo\": 1 }"); duk_json_decode(ctx, 0); duk_push_string(ctx, "bar"); duk_push_string(ctx, "quux"); rc = duk_put_prop(ctx, -3); printf("put rc=%d\n", (int) rc); duk_json_encode(ctx, 0); printf("result: %s\n", duk_to_string(ctx, 0)); printf("final top: %ld\n", (long) duk_get_top(ctx)); return 0; }
static duk_ret_t js_ByteArray_setProp(duk_context* ctx) { bytearray_t* array; int index; int size; duk_get_prop_string(ctx, 0, "\xFF" "ptr"); array = duk_get_pointer(ctx, -1); duk_pop(ctx); if (duk_is_number(ctx, 1)) { index = duk_to_int(ctx, 1); size = get_bytearray_size(array); if (index < 0 || index >= size) duk_error_ni(ctx, -1, DUK_ERR_RANGE_ERROR, "ByteArray[]: Index is out of bounds (%i - size: %i)", index, size); set_byte(array, index, duk_require_uint(ctx, 2)); return 0; } else { duk_dup(ctx, 1); duk_dup(ctx, 2); duk_put_prop(ctx, 0); return 0; } }
static duk_ret_t duk__require(duk_context *ctx) { const char *str_req_id; /* requested identifier */ const char *str_mod_id; /* require.id of current module */ duk_int_t pcall_rc; /* NOTE: we try to minimize code size by avoiding unnecessary pops, * so the stack looks a bit cluttered in this function. DUK__ASSERT_TOP() * assertions are used to ensure stack configuration is correct at each * step. */ /* * Resolve module identifier into canonical absolute form. */ str_req_id = duk_require_string(ctx, DUK__IDX_REQUESTED_ID); duk_push_current_function(ctx); duk_get_prop_string(ctx, -1, "id"); str_mod_id = duk_get_string(ctx, DUK__IDX_REQUIRE_ID); /* ignore non-strings */ duk__resolve_module_id(ctx, str_req_id, str_mod_id); str_req_id = NULL; str_mod_id = NULL; /* [ requested_id require require.id resolved_id last_comp ] */ DUK__ASSERT_TOP(ctx, DUK__IDX_LASTCOMP + 1); /* * Cached module check. * * If module has been loaded or its loading has already begun without * finishing, return the same cached value (module.exports). The * value is registered when module load starts so that circular * references can be supported to some extent. */ duk_push_global_stash(ctx); duk_get_prop_string(ctx, -1, "\xff" "module:Duktape"); duk_remove(ctx, -2); /* Lookup stashed, original 'Duktape' object. */ duk_get_prop_string(ctx, DUK__IDX_DUKTAPE, "modLoaded"); /* Duktape.modLoaded */ duk_require_type_mask(ctx, DUK__IDX_MODLOADED, DUK_TYPE_MASK_OBJECT); DUK__ASSERT_TOP(ctx, DUK__IDX_MODLOADED + 1); duk_dup(ctx, DUK__IDX_RESOLVED_ID); if (duk_get_prop(ctx, DUK__IDX_MODLOADED)) { /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded Duktape.modLoaded[id] ] */ duk_get_prop_string(ctx, -1, "exports"); /* return module.exports */ return 1; } DUK__ASSERT_TOP(ctx, DUK__IDX_UNDEFINED + 1); /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined ] */ /* * Module not loaded (and loading not started previously). * * Create a new require() function with 'id' set to resolved ID * of module being loaded. Also create 'exports' and 'module' * tables but don't register exports to the loaded table yet. * We don't want to do that unless the user module search callbacks * succeeds in finding the module. */ /* Fresh require: require.id is left configurable (but not writable) * so that is not easy to accidentally tweak it, but it can still be * done with Object.defineProperty(). * * XXX: require.id could also be just made non-configurable, as there * is no practical reason to touch it (at least from Ecmascript code). */ duk_push_c_function(ctx, duk__require, 1 /*nargs*/); duk_push_string(ctx, "name"); duk_push_string(ctx, "require"); duk_def_prop(ctx, DUK__IDX_FRESH_REQUIRE, DUK_DEFPROP_HAVE_VALUE); /* not writable, not enumerable, not configurable */ duk_push_string(ctx, "id"); duk_dup(ctx, DUK__IDX_RESOLVED_ID); duk_def_prop(ctx, DUK__IDX_FRESH_REQUIRE, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_CONFIGURABLE); /* a fresh require() with require.id = resolved target module id */ /* Module table: * - module.exports: initial exports table (may be replaced by user) * - module.id is non-writable and non-configurable, as the CommonJS * spec suggests this if possible * - module.filename: not set, defaults to resolved ID if not explicitly * set by modSearch() (note capitalization, not .fileName, matches Node.js) * - module.name: not set, defaults to last component of resolved ID if * not explicitly set by modSearch() */ duk_push_object(ctx); /* exports */ duk_push_object(ctx); /* module */ duk_push_string(ctx, "exports"); duk_dup(ctx, DUK__IDX_EXPORTS); duk_def_prop(ctx, DUK__IDX_MODULE, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_SET_WRITABLE | DUK_DEFPROP_SET_CONFIGURABLE); /* module.exports = exports */ duk_push_string(ctx, "id"); duk_dup(ctx, DUK__IDX_RESOLVED_ID); /* resolved id: require(id) must return this same module */ duk_def_prop(ctx, DUK__IDX_MODULE, DUK_DEFPROP_HAVE_VALUE); /* module.id = resolved_id; not writable, not enumerable, not configurable */ duk_compact(ctx, DUK__IDX_MODULE); /* module table remains registered to modLoaded, minimize its size */ DUK__ASSERT_TOP(ctx, DUK__IDX_MODULE + 1); /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module ] */ /* Register the module table early to modLoaded[] so that we can * support circular references even in modSearch(). If an error * is thrown, we'll delete the reference. */ duk_dup(ctx, DUK__IDX_RESOLVED_ID); duk_dup(ctx, DUK__IDX_MODULE); duk_put_prop(ctx, DUK__IDX_MODLOADED); /* Duktape.modLoaded[resolved_id] = module */ /* * Call user provided module search function and build the wrapped * module source code (if necessary). The module search function * can be used to implement pure Ecmacsript, pure C, and mixed * Ecmascript/C modules. * * The module search function can operate on the exports table directly * (e.g. DLL code can register values to it). It can also return a * string which is interpreted as module source code (if a non-string * is returned the module is assumed to be a pure C one). If a module * cannot be found, an error must be thrown by the user callback. * * Because Duktape.modLoaded[] already contains the module being * loaded, circular references for C modules should also work * (although expected to be quite rare). */ duk_push_string(ctx, "(function(require,exports,module){"); /* Duktape.modSearch(resolved_id, fresh_require, exports, module). */ duk_get_prop_string(ctx, DUK__IDX_DUKTAPE, "modSearch"); /* Duktape.modSearch */ duk_dup(ctx, DUK__IDX_RESOLVED_ID); duk_dup(ctx, DUK__IDX_FRESH_REQUIRE); duk_dup(ctx, DUK__IDX_EXPORTS); duk_dup(ctx, DUK__IDX_MODULE); /* [ ... Duktape.modSearch resolved_id last_comp fresh_require exports module ] */ pcall_rc = duk_pcall(ctx, 4 /*nargs*/); /* -> [ ... source ] */ DUK__ASSERT_TOP(ctx, DUK__IDX_MODULE + 3); if (pcall_rc != DUK_EXEC_SUCCESS) { /* Delete entry in Duktape.modLoaded[] and rethrow. */ goto delete_rethrow; } /* If user callback did not return source code, module loading * is finished (user callback initialized exports table directly). */ if (!duk_is_string(ctx, -1)) { /* User callback did not return source code, so module loading * is finished: just update modLoaded with final module.exports * and we're done. */ goto return_exports; } /* Finish the wrapped module source. Force module.filename as the * function .fileName so it gets set for functions defined within a * module. This also ensures loggers created within the module get * the module ID (or overridden filename) as their default logger name. * (Note capitalization: .filename matches Node.js while .fileName is * used elsewhere in Duktape.) */ duk_push_string(ctx, "})"); duk_concat(ctx, 3); if (!duk_get_prop_string(ctx, DUK__IDX_MODULE, "filename")) { /* module.filename for .fileName, default to resolved ID if * not present. */ duk_pop(ctx); duk_dup(ctx, DUK__IDX_RESOLVED_ID); } pcall_rc = duk_pcompile(ctx, DUK_COMPILE_EVAL); if (pcall_rc != DUK_EXEC_SUCCESS) { goto delete_rethrow; } pcall_rc = duk_pcall(ctx, 0); /* -> eval'd function wrapper (not called yet) */ if (pcall_rc != DUK_EXEC_SUCCESS) { goto delete_rethrow; } /* Module has now evaluated to a wrapped module function. Force its * .name to match module.name (defaults to last component of resolved * ID) so that it is shown in stack traces too. Note that we must not * introduce an actual name binding into the function scope (which is * usually the case with a named function) because it would affect the * scope seen by the module and shadow accesses to globals of the same name. * This is now done by compiling the function as anonymous and then forcing * its .name without setting a "has name binding" flag. */ duk_push_string(ctx, "name"); if (!duk_get_prop_string(ctx, DUK__IDX_MODULE, "name")) { /* module.name for .name, default to last component if * not present. */ duk_pop(ctx); duk_dup(ctx, DUK__IDX_LASTCOMP); } duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_FORCE); /* * Call the wrapped module function. * * Use a protected call so that we can update Duktape.modLoaded[resolved_id] * even if the module throws an error. */ /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module mod_func ] */ DUK__ASSERT_TOP(ctx, DUK__IDX_MODULE + 2); duk_dup(ctx, DUK__IDX_EXPORTS); /* exports (this binding) */ duk_dup(ctx, DUK__IDX_FRESH_REQUIRE); /* fresh require (argument) */ duk_get_prop_string(ctx, DUK__IDX_MODULE, "exports"); /* relookup exports from module.exports in case it was changed by modSearch */ duk_dup(ctx, DUK__IDX_MODULE); /* module (argument) */ DUK__ASSERT_TOP(ctx, DUK__IDX_MODULE + 6); /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module mod_func exports fresh_require exports module ] */ pcall_rc = duk_pcall_method(ctx, 3 /*nargs*/); if (pcall_rc != DUK_EXEC_SUCCESS) { /* Module loading failed. Node.js will forget the module * registration so that another require() will try to load * the module again. Mimic that behavior. */ goto delete_rethrow; } /* [ requested_id require require.id resolved_id last_comp Duktape Duktape.modLoaded undefined fresh_require exports module result(ignored) ] */ DUK__ASSERT_TOP(ctx, DUK__IDX_MODULE + 2); /* fall through */ return_exports: duk_get_prop_string(ctx, DUK__IDX_MODULE, "exports"); duk_compact(ctx, -1); /* compact the exports table */ return 1; /* return module.exports */ delete_rethrow: duk_dup(ctx, DUK__IDX_RESOLVED_ID); duk_del_prop(ctx, DUK__IDX_MODLOADED); /* delete Duktape.modLoaded[resolved_id] */ duk_throw(ctx); /* rethrow original error */ return 0; /* not reachable */ }
void duk_hobject_enumerator_create(duk_context *ctx, int enum_flags) { duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *target; duk_hobject *curr; duk_hobject *res; DUK_ASSERT(ctx != NULL); DUK_DDDPRINT("create enumerator, stack top: %d", duk_get_top(ctx)); target = duk_require_hobject(ctx, -1); DUK_ASSERT(target != NULL); duk_push_object_internal(ctx); DUK_DDDPRINT("created internal object"); /* [target res] */ duk_push_hstring_stridx(ctx, DUK_STRIDX_INT_TARGET); duk_push_hobject(ctx, target); duk_put_prop(ctx, -3); /* initialize index so that we skip internal control keys */ duk_push_hstring_stridx(ctx, DUK_STRIDX_INT_NEXT); duk_push_int(ctx, ENUM_START_INDEX); duk_put_prop(ctx, -3); curr = target; while (curr) { duk_uint32_t i; /* * Virtual properties. * * String indices are virtual and always enumerable. String 'length' * is virtual and non-enumerable. Array and arguments object props * have special behavior but are concrete. */ if (DUK_HOBJECT_HAS_SPECIAL_STRINGOBJ(curr)) { duk_hstring *h_val; h_val = duk_hobject_get_internal_value_string(thr->heap, curr); DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */ /* FIXME: type for 'i' to match string max len (duk_uint32_t) */ for (i = 0; i < DUK_HSTRING_GET_CHARLEN(h_val); i++) { duk_hstring *k; k = duk_heap_string_intern_u32_checked(thr, i); DUK_ASSERT(k); duk_push_hstring(ctx, k); duk_push_true(ctx); /* [target res key true] */ duk_put_prop(ctx, -3); /* [target res] */ } /* 'length' property is not enumerable, but is included if * non-enumerable properties are requested. */ if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); duk_push_true(ctx); duk_put_prop(ctx, -3); } } /* * Array part * * Note: ordering between array and entry part must match 'abandon array' * behavior in duk_hobject_props.c: key order after an array is abandoned * must be the same. */ for (i = 0; i < curr->a_size; i++) { duk_hstring *k; duk_tval *tv; tv = DUK_HOBJECT_A_GET_VALUE_PTR(curr, i); if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { continue; } k = duk_heap_string_intern_u32_checked(thr, i); DUK_ASSERT(k); duk_push_hstring(ctx, k); duk_push_true(ctx); /* [target res key true] */ duk_put_prop(ctx, -3); /* [target res] */ } /* * Entries part */ for (i = 0; i < curr->e_used; i++) { duk_hstring *k; k = DUK_HOBJECT_E_GET_KEY(curr, i); if (!k) { continue; } if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(curr, i) && !(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) { continue; } if (DUK_HSTRING_HAS_INTERNAL(k) && !(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) { continue; } if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) && (DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) { continue; } DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(curr, i) || !DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(curr, i)->v)); duk_push_hstring(ctx, k); duk_push_true(ctx); /* [target res key true] */ duk_put_prop(ctx, -3); /* [target res] */ } if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) { break; } curr = curr->prototype; } /* [target res] */ duk_remove(ctx, -2); res = duk_require_hobject(ctx, -1); /* [res] */ if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) == (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) { /* * Some E5/E5.1 algorithms require that array indices are iterated * in a strictly ascending order. This is the case for e.g. * Array.prototype.forEach() and JSON.stringify() PropertyList * handling. * * To ensure this property for arrays with an array part (and * arbitrary objects too, since e.g. forEach() can be applied * to an array), the caller can request that we sort the keys * here. */ /* FIXME: avoid this at least when target is an Array, it has an * array part, and no ancestor properties were included? Not worth * it for JSON, but maybe worth it for forEach(). */ /* FIXME: may need a 'length' filter for forEach() */ DUK_DDDPRINT("sort array indices by caller request"); sort_array_indices(res); } /* compact; no need to seal because object is internal */ duk_hobject_compact_props(thr, res); DUK_DDDPRINT("created enumerator object: %!iT", duk_get_tval(ctx, -1)); }
//duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index); duk_bool_t aperl_duk_put_prop(duk_context *ctx, duk_idx_t obj_index) { duk_bool_t ret = duk_put_prop(ctx, obj_index); return ret; }
void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags) { duk_hthread *thr = (duk_hthread *) ctx; duk_hobject *enum_target; duk_hobject *curr; duk_hobject *res; #if defined(DUK_USE_ES6_PROXY) duk_hobject *h_proxy_target; duk_hobject *h_proxy_handler; duk_hobject *h_trap_result; #endif duk_uint_fast32_t i, len; /* used for array, stack, and entry indices */ DUK_ASSERT(ctx != NULL); DUK_DDD(DUK_DDDPRINT("create enumerator, stack top: %ld", (long) duk_get_top(ctx))); enum_target = duk_require_hobject(ctx, -1); DUK_ASSERT(enum_target != NULL); duk_push_object_internal(ctx); res = duk_require_hobject(ctx, -1); DUK_DDD(DUK_DDDPRINT("created internal object")); /* [enum_target res] */ /* Target must be stored so that we can recheck whether or not * keys still exist when we enumerate. This is not done if the * enumeration result comes from a proxy trap as there is no * real object to check against. */ duk_push_hobject(ctx, enum_target); duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET); /* Initialize index so that we skip internal control keys. */ duk_push_int(ctx, DUK__ENUM_START_INDEX); duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT); /* * Proxy object handling */ #if defined(DUK_USE_ES6_PROXY) if (DUK_LIKELY((enum_flags & DUK_ENUM_NO_PROXY_BEHAVIOR) != 0)) { goto skip_proxy; } if (DUK_LIKELY(!duk_hobject_proxy_check(thr, enum_target, &h_proxy_target, &h_proxy_handler))) { goto skip_proxy; } DUK_DDD(DUK_DDDPRINT("proxy enumeration")); duk_push_hobject(ctx, h_proxy_handler); if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ENUMERATE)) { /* No need to replace the 'enum_target' value in stack, only the * enum_target reference. This also ensures that the original * enum target is reachable, which keeps the proxy and the proxy * target reachable. We do need to replace the internal _target. */ DUK_DDD(DUK_DDDPRINT("no enumerate trap, enumerate proxy target instead")); DUK_DDD(DUK_DDDPRINT("h_proxy_target=%!O", (duk_heaphdr *) h_proxy_target)); enum_target = h_proxy_target; duk_push_hobject(ctx, enum_target); /* -> [ ... enum_target res handler undefined target ] */ duk_put_prop_stridx(ctx, -4, DUK_STRIDX_INT_TARGET); duk_pop_2(ctx); /* -> [ ... enum_target res ] */ goto skip_proxy; } /* [ ... enum_target res handler trap ] */ duk_insert(ctx, -2); duk_push_hobject(ctx, h_proxy_target); /* -> [ ... enum_target res trap handler target ] */ duk_call_method(ctx, 1 /*nargs*/); /* -> [ ... enum_target res trap_result ] */ h_trap_result = duk_require_hobject(ctx, -1); DUK_UNREF(h_trap_result); /* Copy trap result keys into the enumerator object. */ len = (duk_uint_fast32_t) duk_get_length(ctx, -1); for (i = 0; i < len; i++) { /* XXX: not sure what the correct semantic details are here, * e.g. handling of missing values (gaps), handling of non-array * trap results, etc. * * For keys, we simply skip non-string keys which seems to be * consistent with how e.g. Object.keys() will process proxy trap * results (ES6 draft, Section 19.1.2.14). */ if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) { /* [ ... enum_target res trap_result val ] */ duk_push_true(ctx); /* [ ... enum_target res trap_result val true ] */ duk_put_prop(ctx, -4); } else { duk_pop(ctx); } } /* [ ... enum_target res trap_result ] */ duk_pop(ctx); duk_remove(ctx, -2); /* [ ... res ] */ /* The internal _target property is kept pointing to the original * enumeration target (the proxy object), so that the enumerator * 'next' operation can read property values if so requested. The * fact that the _target is a proxy disables key existence check * during enumeration. */ DUK_DDD(DUK_DDDPRINT("proxy enumeration, final res: %!O", (duk_heaphdr *) res)); goto compact_and_return; skip_proxy: #endif /* DUK_USE_ES6_PROXY */ curr = enum_target; while (curr) { /* * Virtual properties. * * String and buffer indices are virtual and always enumerable, * 'length' is virtual and non-enumerable. Array and arguments * object props have special behavior but are concrete. */ if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr) || DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)) { /* String and buffer enumeration behavior is identical now, * so use shared handler. */ if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)) { duk_hstring *h_val; h_val = duk_hobject_get_internal_value_string(thr->heap, curr); DUK_ASSERT(h_val != NULL); /* string objects must not created without internal value */ len = (duk_uint_fast32_t) DUK_HSTRING_GET_CHARLEN(h_val); } else { duk_hbuffer *h_val; DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)); h_val = duk_hobject_get_internal_value_buffer(thr->heap, curr); DUK_ASSERT(h_val != NULL); /* buffer objects must not created without internal value */ len = (duk_uint_fast32_t) DUK_HBUFFER_GET_SIZE(h_val); } for (i = 0; i < len; i++) { duk_hstring *k; k = duk_heap_string_intern_u32_checked(thr, i); DUK_ASSERT(k); duk_push_hstring(ctx, k); duk_push_true(ctx); /* [enum_target res key true] */ duk_put_prop(ctx, -3); /* [enum_target res] */ } /* 'length' property is not enumerable, but is included if * non-enumerable properties are requested. */ if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); duk_push_true(ctx); duk_put_prop(ctx, -3); } } else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) { if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) { duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH); duk_push_true(ctx); duk_put_prop(ctx, -3); } } /* * Array part * * Note: ordering between array and entry part must match 'abandon array' * behavior in duk_hobject_props.c: key order after an array is abandoned * must be the same. */ for (i = 0; i < (duk_uint_fast32_t) curr->a_size; i++) { duk_hstring *k; duk_tval *tv; tv = DUK_HOBJECT_A_GET_VALUE_PTR(curr, i); if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) { continue; } k = duk_heap_string_intern_u32_checked(thr, i); DUK_ASSERT(k); duk_push_hstring(ctx, k); duk_push_true(ctx); /* [enum_target res key true] */ duk_put_prop(ctx, -3); /* [enum_target res] */ } /* * Entries part */ for (i = 0; i < (duk_uint_fast32_t) curr->e_next; i++) { duk_hstring *k; k = DUK_HOBJECT_E_GET_KEY(curr, i); if (!k) { continue; } if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(curr, i) && !(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) { continue; } if (DUK_HSTRING_HAS_INTERNAL(k) && !(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) { continue; } if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) && (DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) { continue; } DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(curr, i) || !DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(curr, i)->v)); duk_push_hstring(ctx, k); duk_push_true(ctx); /* [enum_target res key true] */ duk_put_prop(ctx, -3); /* [enum_target res] */ } if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) { break; } curr = curr->prototype; } /* [enum_target res] */ duk_remove(ctx, -2); /* [res] */ if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) == (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) { /* * Some E5/E5.1 algorithms require that array indices are iterated * in a strictly ascending order. This is the case for e.g. * Array.prototype.forEach() and JSON.stringify() PropertyList * handling. * * To ensure this property for arrays with an array part (and * arbitrary objects too, since e.g. forEach() can be applied * to an array), the caller can request that we sort the keys * here. */ /* XXX: avoid this at least when enum_target is an Array, it has an * array part, and no ancestor properties were included? Not worth * it for JSON, but maybe worth it for forEach(). */ /* XXX: may need a 'length' filter for forEach() */ DUK_DDD(DUK_DDDPRINT("sort array indices by caller request")); duk__sort_array_indices(res); } #if defined(DUK_USE_ES6_PROXY) compact_and_return: #endif /* compact; no need to seal because object is internal */ duk_hobject_compact_props(thr, res); DUK_DDD(DUK_DDDPRINT("created enumerator object: %!iT", (duk_tval *) duk_get_tval(ctx, -1))); }
static duk_ret_t test_func(duk_context *ctx, void *udata) { (void) udata; if (ctx) { printf("dummy - return here\n"); fflush(stdout); return 0; } /* Up-to-date for Duktape 1.3.0, alphabetical order: * $ cd website/api; ls *.yaml */ (void) duk_alloc_raw(ctx, 0); (void) duk_alloc(ctx, 0); (void) duk_base64_decode(ctx, 0); (void) duk_base64_encode(ctx, 0); (void) duk_buffer_to_string(ctx, 0); (void) duk_call_method(ctx, 0); (void) duk_call_prop(ctx, 0, 0); (void) duk_call(ctx, 0); (void) duk_char_code_at(ctx, 0, 0); (void) duk_check_stack_top(ctx, 0); (void) duk_check_stack(ctx, 0); (void) duk_check_type_mask(ctx, 0, 0); (void) duk_check_type(ctx, 0, 0); (void) duk_compact(ctx, 0); (void) duk_compile_lstring_filename(ctx, 0, "dummy", 0); (void) duk_compile_lstring(ctx, 0, "dummy", 0); (void) duk_compile_string_filename(ctx, 0, "dummy"); (void) duk_compile_string(ctx, 0, "dummy"); (void) duk_compile(ctx, 0); (void) duk_concat(ctx, 0); (void) duk_config_buffer(ctx, 0, NULL, 0); (void) duk_copy(ctx, 0, 0); (void) duk_create_heap_default(); (void) duk_create_heap(NULL, NULL, NULL, NULL, NULL); (void) duk_debugger_attach(ctx, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); (void) duk_debugger_cooperate(ctx); (void) duk_debugger_detach(ctx); (void) duk_debugger_notify(ctx, 0); (void) duk_debugger_pause(ctx); (void) duk_decode_string(ctx, 0, NULL, NULL); (void) duk_def_prop(ctx, 0, 0); (void) duk_del_prop_index(ctx, 0, 0); (void) duk_del_prop_string(ctx, 0, "dummy"); (void) duk_del_prop(ctx, 0); (void) duk_destroy_heap(ctx); (void) duk_dump_function(ctx); (void) duk_dup_top(ctx); (void) duk_dup(ctx, 0); (void) duk_enum(ctx, 0, 0); (void) duk_equals(ctx, 0, 0); duk_error_va(ctx, 0, NULL, NULL); duk_error(ctx, 0, "dummy"); /* (void) cast won't work without variadic macros */ (void) duk_eval_lstring_noresult(ctx, "dummy", 0); (void) duk_eval_lstring(ctx, "dummy", 0); (void) duk_eval_noresult(ctx); (void) duk_eval_string_noresult(ctx, "dummy"); (void) duk_eval_string(ctx, "dummy"); (void) duk_eval(ctx); (void) duk_fatal(ctx, "dummy"); (void) duk_free_raw(ctx, NULL); (void) duk_free(ctx, NULL); (void) duk_gc(ctx, 0); (void) duk_get_boolean(ctx, 0); (void) duk_get_buffer_data(ctx, 0, NULL); (void) duk_get_buffer(ctx, 0, NULL); (void) duk_get_c_function(ctx, 0); (void) duk_get_context(ctx, 0); (void) duk_get_current_magic(ctx); (void) duk_get_error_code(ctx, 0); (void) duk_get_finalizer(ctx, 0); (void) duk_get_global_string(ctx, 0); (void) duk_get_heapptr(ctx, 0); (void) duk_get_int(ctx, 0); (void) duk_get_length(ctx, 0); (void) duk_get_lstring(ctx, 0, NULL); (void) duk_get_magic(ctx, 0); (void) duk_get_memory_functions(ctx, NULL); (void) duk_get_number(ctx, 0); (void) duk_get_pointer(ctx, 0); (void) duk_get_prop_index(ctx, 0, 0); (void) duk_get_prop_string(ctx, 0, "dummy"); (void) duk_get_prop(ctx, 0); (void) duk_get_prototype(ctx, 0); (void) duk_get_string(ctx, 0); (void) duk_get_top_index(ctx); (void) duk_get_top(ctx); (void) duk_get_type_mask(ctx, 0); (void) duk_get_type(ctx, 0); (void) duk_get_uint(ctx, 0); (void) duk_has_prop_index(ctx, 0, 0); (void) duk_has_prop_string(ctx, 0, "dummy"); (void) duk_has_prop(ctx, 0); (void) duk_hex_decode(ctx, 0); (void) duk_hex_encode(ctx, 0); (void) duk_insert(ctx, 0); (void) duk_instanceof(ctx, 0, 0); (void) duk_is_array(ctx, 0); (void) duk_is_boolean(ctx, 0); (void) duk_is_bound_function(ctx, 0); (void) duk_is_buffer(ctx, 0); (void) duk_is_callable(ctx, 0); (void) duk_is_c_function(ctx, 0); (void) duk_is_constructor_call(ctx); (void) duk_is_dynamic_buffer(ctx, 0); (void) duk_is_ecmascript_function(ctx, 0); (void) duk_is_error(ctx, 0); (void) duk_is_eval_error(ctx, 0); (void) duk_is_fixed_buffer(ctx, 0); (void) duk_is_function(ctx, 0); (void) duk_is_lightfunc(ctx, 0); (void) duk_is_nan(ctx, 0); (void) duk_is_null_or_undefined(ctx, 0); (void) duk_is_null(ctx, 0); (void) duk_is_number(ctx, 0); (void) duk_is_object_coercible(ctx, 0); (void) duk_is_object(ctx, 0); (void) duk_is_pointer(ctx, 0); (void) duk_is_primitive(ctx, 0); (void) duk_is_range_error(ctx, 0); (void) duk_is_reference_error(ctx, 0); (void) duk_is_strict_call(ctx); (void) duk_is_string(ctx, 0); (void) duk_is_syntax_error(ctx, 0); (void) duk_is_thread(ctx, 0); (void) duk_is_type_error(ctx, 0); (void) duk_is_undefined(ctx, 0); (void) duk_is_uri_error(ctx, 0); (void) duk_is_valid_index(ctx, 0); (void) duk_join(ctx, 0); (void) duk_json_decode(ctx, 0); (void) duk_json_encode(ctx, 0); (void) duk_load_function(ctx); (void) duk_map_string(ctx, 0, NULL, NULL); (void) duk_new(ctx, 0); (void) duk_next(ctx, 0, 0); (void) duk_normalize_index(ctx, 0); (void) duk_pcall_method(ctx, 0); (void) duk_pcall_prop(ctx, 0, 0); (void) duk_pcall(ctx, 0); (void) duk_pcompile_lstring_filename(ctx, 0, "dummy", 0); (void) duk_pcompile_lstring(ctx, 0, "dummy", 0); (void) duk_pcompile_string_filename(ctx, 0, "dummy"); (void) duk_pcompile_string(ctx, 0, "dummy"); (void) duk_pcompile(ctx, 0); (void) duk_peval_lstring_noresult(ctx, "dummy", 0); (void) duk_peval_lstring(ctx, "dummy", 0); (void) duk_peval_noresult(ctx); (void) duk_peval_string_noresult(ctx, "dummy"); (void) duk_peval_string(ctx, "dummy"); (void) duk_peval(ctx); (void) duk_pnew(ctx, 0); (void) duk_pop_2(ctx); (void) duk_pop_3(ctx); (void) duk_pop_n(ctx, 0); (void) duk_pop(ctx); (void) duk_push_array(ctx); (void) duk_push_boolean(ctx, 0); (void) duk_push_buffer_object(ctx, 0, 0, 0, 0); (void) duk_push_buffer(ctx, 0, 0); (void) duk_push_c_function(ctx, NULL, 0); (void) duk_push_c_lightfunc(ctx, NULL, 0, 0, 0); (void) duk_push_context_dump(ctx); (void) duk_push_current_function(ctx); (void) duk_push_current_thread(ctx); (void) duk_push_dynamic_buffer(ctx, 0); (void) duk_push_error_object_va(ctx, 0, NULL, NULL); (void) duk_push_error_object(ctx, 0, "dummy"); (void) duk_push_external_buffer(ctx); (void) duk_push_false(ctx); (void) duk_push_fixed_buffer(ctx, 0); (void) duk_push_global_object(ctx); (void) duk_push_global_stash(ctx); (void) duk_push_heap_stash(ctx); (void) duk_push_heapptr(ctx, NULL); (void) duk_push_int(ctx, 0); (void) duk_push_lstring(ctx, "dummy", 0); (void) duk_push_nan(ctx); (void) duk_push_null(ctx); (void) duk_push_number(ctx, 0.0); (void) duk_push_object(ctx); (void) duk_push_pointer(ctx, NULL); (void) duk_push_sprintf(ctx, "dummy"); (void) duk_push_string(ctx, "dummy"); (void) duk_push_this(ctx); (void) duk_push_thread_new_globalenv(ctx); (void) duk_push_thread_stash(ctx, NULL); (void) duk_push_thread(ctx); (void) duk_push_true(ctx); (void) duk_push_uint(ctx, 0); (void) duk_push_undefined(ctx); (void) duk_push_vsprintf(ctx, "dummy", NULL); (void) duk_put_function_list(ctx, 0, NULL); (void) duk_put_global_string(ctx, NULL); (void) duk_put_number_list(ctx, 0, NULL); (void) duk_put_prop_index(ctx, 0, 0); (void) duk_put_prop_string(ctx, 0, "dummy"); (void) duk_put_prop(ctx, 0); (void) duk_realloc_raw(ctx, NULL, 0); (void) duk_realloc(ctx, NULL, 0); (void) duk_remove(ctx, 0); (void) duk_replace(ctx, 0); (void) duk_require_boolean(ctx, 0); (void) duk_require_buffer_data(ctx, 0, NULL); (void) duk_require_buffer(ctx, 0, NULL); (void) duk_require_c_function(ctx, 0); (void) duk_require_callable(ctx, 0); (void) duk_require_context(ctx, 0); (void) duk_require_function(ctx, 0); (void) duk_require_heapptr(ctx, 0); (void) duk_require_int(ctx, 0); (void) duk_require_lstring(ctx, 0, NULL); (void) duk_require_normalize_index(ctx, 0); (void) duk_require_null(ctx, 0); (void) duk_require_number(ctx, 0); (void) duk_require_object_coercible(ctx, 0); (void) duk_require_pointer(ctx, 0); (void) duk_require_stack_top(ctx, 0); (void) duk_require_stack(ctx, 0); (void) duk_require_string(ctx, 0); (void) duk_require_top_index(ctx); (void) duk_require_type_mask(ctx, 0, 0); (void) duk_require_uint(ctx, 0); (void) duk_require_undefined(ctx, 0); (void) duk_require_valid_index(ctx, 0); (void) duk_resize_buffer(ctx, 0, 0); (void) duk_safe_call(ctx, NULL, NULL, 0, 0); (void) duk_safe_to_lstring(ctx, 0, NULL); (void) duk_safe_to_string(ctx, 0); (void) duk_set_finalizer(ctx, 0); (void) duk_set_global_object(ctx); (void) duk_set_magic(ctx, 0, 0); (void) duk_set_prototype(ctx, 0); (void) duk_set_top(ctx, 0); (void) duk_steal_buffer(ctx, 0, NULL); (void) duk_strict_equals(ctx, 0, 0); (void) duk_substring(ctx, 0, 0, 0); (void) duk_swap_top(ctx, 0); (void) duk_swap(ctx, 0, 0); (void) duk_throw(ctx); (void) duk_to_boolean(ctx, 0); (void) duk_to_buffer(ctx, 0, NULL); (void) duk_to_defaultvalue(ctx, 0, 0); (void) duk_to_dynamic_buffer(ctx, 0, NULL); (void) duk_to_fixed_buffer(ctx, 0, NULL); (void) duk_to_int32(ctx, 0); (void) duk_to_int(ctx, 0); (void) duk_to_lstring(ctx, 0, NULL); (void) duk_to_null(ctx, 0); (void) duk_to_number(ctx, 0); (void) duk_to_object(ctx, 0); (void) duk_to_pointer(ctx, 0); (void) duk_to_primitive(ctx, 0, 0); (void) duk_to_string(ctx, 0); (void) duk_to_uint16(ctx, 0); (void) duk_to_uint32(ctx, 0); (void) duk_to_uint(ctx, 0); (void) duk_to_undefined(ctx, 0); (void) duk_trim(ctx, 0); (void) duk_xcopy_top(ctx, NULL, 0); (void) duk_xmove_top(ctx, NULL, 0); printf("never here\n"); fflush(stdout); return 0; }
static void sjs__setup_system_module(sjs_vm_t* vm) { duk_context* ctx = vm->ctx; /* create system module */ duk_push_object(ctx); duk_put_global_string(ctx, "system"); duk_get_global_string(ctx, "system"); /* -> [ ... system ] */ /* system.versions */ { char duktape_version[16]; duk_push_object(ctx); /* -> [ ... system obj ] */ snprintf(duktape_version, sizeof(duktape_version), "v%ld.%ld.%ld", DUK_VERSION / 10000, DUK_VERSION % 10000 / 100, DUK_VERSION % 100); duk_push_string(ctx, duktape_version); duk_put_prop_string(ctx, -2, "duktape"); duk_push_lstring(ctx, DUK_GIT_COMMIT, 7); duk_put_prop_string(ctx, -2, "duktapeCommit"); duk_push_string(ctx, sjs_version()); duk_put_prop_string(ctx, -2, "sjs"); /* -> [ ... system obj ] */ duk_put_prop_string(ctx, -2, "versions"); /* -> [ ... system ] */ } /* system.env */ { duk_push_object(ctx); /* -> [ ... system obj ] */ for (int i = 0; environ[i]; i++) { const char* e = environ[i]; const char* ptr = strrchr(e, '='); const char* key; const char* value; if (!ptr) { continue; } key = e; value = ptr + 1; duk_push_lstring(ctx, key, (duk_size_t)(ptr - key)); duk_push_string(ctx, value); duk_put_prop(ctx, -3); } /* -> [ ... system obj ] */ duk_put_prop_string(ctx, -2, "env"); /* -> [ ... system ] */ } /* system.path */ { int i = 0; duk_push_array(ctx); /* -> [ ... system array ] */ /* path specified by env variable */ { char* sjs_path = getenv("SJS_PATH"); if (sjs_path) { char* token; char* saveptr; token = strtok_r(sjs_path, ":", &saveptr); for (;;) { if (!token) { break; } duk_push_string(ctx, token); duk_put_prop_index(ctx, -2, i); i++; token = strtok_r(NULL, ":", &saveptr); } } } /* default search paths */ { for (int j = 0; default_search_paths[j]; j++) { duk_push_string(ctx, default_search_paths[j]); duk_put_prop_index(ctx, -2, i); i++; } } duk_put_prop_string(ctx, -2, "path"); /* -> [ ... system ] */ } /* system.arch */ { duk_push_string(ctx, DUK_USE_ARCH_STRING); duk_put_prop_string(ctx, -2, "arch"); } /* system.platform */ { duk_push_string(ctx, DUK_USE_OS_STRING); duk_put_prop_string(ctx, -2, "platform"); } /* system.executable */ { char buf[8192] = {0}; sjs__executable(buf, sizeof(buf)); duk_push_string(ctx, buf); duk_put_prop_string(ctx, -2, "executable"); } /* system.exit(x) */ { duk_push_c_function(ctx, sjs__exit, 1 /* nargs */); duk_put_prop_string(ctx, -2, "exit"); } duk_pop(ctx); }
duk_ret_t ClassSet( duk_context * ctx ) { duk_put_prop( ctx, -3 ); return 1; }