/*
* Looks for an interface that defines a specific member.
*
* TODO - check for ambiguity - same member defined on multiple interfaces
*/
static const char* FindInterfaceForMember(duk_context* ctx, duk_idx_t mbrIdx, const char** member)
{
const char* iface = NULL;
uint8_t found = FALSE;
size_t numInterfaces;
duk_idx_t listIdx;
duk_get_prop_string(ctx, -1, "interfaces");
numInterfaces = duk_get_length(ctx, -1);
listIdx = AJS_GetAllJoynProperty(ctx, "interfaceDefinition");
if (duk_is_object(ctx, mbrIdx)) {
/*
* Expect an object of form { member:"org.foo.interface" }
*/
duk_enum(ctx, mbrIdx, DUK_ENUM_OWN_PROPERTIES_ONLY);
if (!duk_next(ctx, -1, 1)) {
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Require object of form { 'member-name':'interface-name' }");
}
iface = duk_require_string(ctx, -1);
if (!AJ_StringFindFirstOf(iface, ".") == -1) {
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Interface name '%s' is not a dotted name", iface);
}
*member = duk_require_string(ctx, -2);
duk_get_prop_string(ctx, listIdx, iface);
if (duk_is_undefined(ctx, -1)) {
duk_error(ctx, DUK_ERR_REFERENCE_ERROR, "Unknown interface: '%s'", iface);
}
found = duk_has_prop_string(ctx, -1, *member);
duk_pop_n(ctx, 4);
} else {
size_t i;
/*
* Expect a string
*/
*member = duk_require_string(ctx, mbrIdx);
for (i = 0; !found && (i < numInterfaces); ++i) {
duk_get_prop_index(ctx, -2, i);
iface = duk_require_string(ctx, -1);
duk_get_prop_string(ctx, listIdx, iface);
/*
* See if the requested member exists on this interface
*/
found = duk_has_prop_string(ctx, -1, *member);
duk_pop_2(ctx);
}
}
duk_pop_2(ctx);
if (!found) {
duk_error(ctx, DUK_ERR_REFERENCE_ERROR, "Unknown member: '%s'", *member);
}
return iface;
}
const char *
dukky_message_event_init_get_lastEventId(duk_context *ctx, duk_idx_t idx)
{
const char *ret = NULL; /* No default */
/* ... obj@idx ... */
duk_get_prop_string(ctx, idx, "lastEventId");
/* ... obj@idx ... value/undefined */
if (!duk_is_undefined(ctx, -1)) {
/* Note, this throws a duk_error if it's not a string */
ret = duk_require_string(ctx, -1);
}
duk_pop(ctx);
return ret;
}
gpointer
_gum_duk_get_data (duk_context * ctx,
duk_idx_t index)
{
gpointer result;
duk_get_prop_string (ctx, index, "\xff" "priv");
if (!duk_is_undefined (ctx, -1))
result = duk_require_pointer (ctx, -1);
else
result = NULL;
duk_pop (ctx);
return result;
}
int duk_builtin_object_constructor_create(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_tval *tv;
duk_hobject *proto = NULL;
duk_hobject *h;
DUK_ASSERT_TOP(ctx, 2);
tv = duk_get_tval(ctx, 0);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_NULL(tv)) {
;
} else if (DUK_TVAL_IS_OBJECT(tv)) {
proto = DUK_TVAL_GET_OBJECT(tv);
DUK_ASSERT(proto != NULL);
} else {
return DUK_RET_TYPE_ERROR;
}
/* FIXME: direct helper to create with specific prototype */
(void) duk_push_object_helper(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-1);
h = duk_get_hobject(ctx, -1);
DUK_ASSERT(h != NULL);
DUK_ASSERT(h->prototype == NULL);
DUK_HOBJECT_SET_PROTOTYPE(thr, h, proto);
if (!duk_is_undefined(ctx, 1)) {
/* [ O Properties obj ] */
/* Use original function. No need to get it explicitly,
* just call the helper.
*/
duk_replace(ctx, 0);
/* [ obj Properties ] */
return duk_hobject_object_define_properties(ctx);
}
/* [ O Properties obj ] */
return 1;
}
duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx) {
/* The specification has quite awkward order of coercion and
* checks for toPrecision(). The operations below are a bit
* reordered, within constraints of observable side effects.
*/
duk_double_t d;
duk_small_int_t prec;
duk_small_int_t c;
duk_small_uint_t n2s_flags;
DUK_ASSERT_TOP(ctx, 1);
d = duk__push_this_number_plain(ctx);
if (duk_is_undefined(ctx, 0)) {
goto use_to_string;
}
DUK_ASSERT_TOP(ctx, 2);
duk_to_int(ctx, 0); /* for side effects */
c = (duk_small_int_t) DUK_FPCLASSIFY(d);
if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
goto use_to_string;
}
prec = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 1, 21);
n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |
DUK_N2S_FLAG_NO_ZERO_PAD;
duk_numconv_stringify(ctx,
10 /*radix*/,
prec /*digits*/,
n2s_flags /*flags*/);
return 1;
use_to_string:
/* Used when precision is undefined; also used for NaN (-> "NaN"),
* and +/- infinity (-> "Infinity", "-Infinity").
*/
DUK_ASSERT_TOP(ctx, 2);
duk_to_string(ctx, -1);
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) {
duk_hstring *h;
duk_int_t start_pos, end_pos;
duk_int_t len;
/* Unlike non-obsolete String calls, substr() algorithm in E5.1
* specification will happily coerce undefined and null to strings
* ("undefined" and "null").
*/
duk_push_this(ctx);
h = duk_to_hstring(ctx, -1);
DUK_ASSERT(h != NULL);
len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
/* [ start length str ] */
/* The implementation for computing of start_pos and end_pos differs
* from the standard algorithm, but is intended to result in the exactly
* same behavior. This is not always obvious.
*/
/* combines steps 2 and 5; -len ensures max() not needed for step 5 */
start_pos = duk_to_int_clamped(ctx, 0, -len, len);
if (start_pos < 0) {
start_pos = len + start_pos;
}
DUK_ASSERT(start_pos >= 0 && start_pos <= len);
/* combines steps 3, 6; step 7 is not needed */
if (duk_is_undefined(ctx, 1)) {
end_pos = len;
} else {
DUK_ASSERT(start_pos <= len);
end_pos = start_pos + duk_to_int_clamped(ctx, 1, 0, len - start_pos);
}
DUK_ASSERT(start_pos >= 0 && start_pos <= len);
DUK_ASSERT(end_pos >= 0 && end_pos <= len);
DUK_ASSERT(end_pos >= start_pos);
duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
return 1;
}
void
_gum_duk_protect (duk_context * ctx,
GumDukHeapPtr object)
{
gchar name[32];
duk_uint_t ref_count;
if (object == NULL)
return;
sprintf (name, "protected_%p", object);
duk_push_global_stash (ctx);
duk_get_prop_string (ctx, -1, name);
if (duk_is_undefined (ctx, -1))
{
duk_pop (ctx);
duk_push_object (ctx);
duk_push_heapptr (ctx, object);
duk_put_prop_string (ctx, -2, "o");
ref_count = 1;
duk_push_uint (ctx, ref_count);
duk_put_prop_string (ctx, -2, "n");
duk_put_prop_string (ctx, -2, name);
}
else
{
duk_get_prop_string (ctx, -1, "n");
ref_count = duk_get_uint (ctx, -1);
duk_pop (ctx);
ref_count++;
duk_push_uint (ctx, ref_count);
duk_put_prop_string (ctx, -2, "n");
duk_pop (ctx);
}
duk_pop (ctx);
}
duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx) {
duk_small_int_t radix;
duk_small_uint_t n2s_flags;
(void) duk__push_this_number_plain(ctx);
if (duk_is_undefined(ctx, 0)) {
radix = 10;
} else {
radix = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 2, 36);
}
DUK_DDD(DUK_DDDPRINT("radix=%ld", (long) radix));
n2s_flags = 0;
duk_numconv_stringify(ctx,
radix /*radix*/,
0 /*digits*/,
n2s_flags /*flags*/);
return 1;
}
int duk_builtin_number_prototype_to_string(duk_context *ctx) {
int radix;
int n2s_flags;
(void) push_this_number_plain(ctx);
if (duk_is_undefined(ctx, 0)) {
radix = 10;
} else {
radix = duk_to_int_check_range(ctx, 0, 2, 36);
}
DUK_DDDPRINT("radix=%d", radix);
n2s_flags = 0;
duk_numconv_stringify(ctx,
radix /*radix*/,
0 /*digits*/,
n2s_flags /*flags*/);
return 1;
}
static int NativeIoI2cMaster(duk_context* ctx)
{
AJ_Status status;
uint32_t clock = 0;
void* i2cCtx;
uint8_t sda = GetPinId(ctx, 0, AJS_IO_FUNCTION_I2C_SDA);
uint8_t scl = GetPinId(ctx, 1, AJS_IO_FUNCTION_I2C_SCL);
if (!duk_is_undefined(ctx, 2)) {
clock = duk_require_int(ctx, 2);
}
status = AJS_TargetIO_I2cOpen(sda, scl, clock, AJS_I2C_MODE_MASTER, 0, &i2cCtx);
if (status != AJ_OK) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "Failed to open I2C device in master mode\n");
}
NewIOObject(ctx, i2cCtx, AJS_IO_FUNCTION_I2C_MASTER, NativeI2cFinalizer);
duk_push_c_lightfunc(ctx, NativeI2cTransfer, 3, 0, 0);
duk_put_prop_string(ctx, -2, "transfer");
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx) {
duk_tval *tv;
duk_hobject *proto = NULL;
DUK_ASSERT_TOP(ctx, 2);
tv = duk_get_tval(ctx, 0);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_NULL(tv)) {
;
} else if (DUK_TVAL_IS_OBJECT(tv)) {
proto = DUK_TVAL_GET_OBJECT(tv);
DUK_ASSERT(proto != NULL);
} else {
return DUK_RET_TYPE_ERROR;
}
(void) duk_push_object_helper_proto(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
proto);
if (!duk_is_undefined(ctx, 1)) {
/* [ O Properties obj ] */
/* Use original function. No need to get it explicitly,
* just call the helper.
*/
duk_replace(ctx, 0);
/* [ obj Properties ] */
return duk_hobject_object_define_properties(ctx);
}
/* [ O Properties obj ] */
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx) {
/* Behavior for constructor and non-constructor call is
* the same except for augmenting the created error. When
* called as a constructor, the caller (duk_new()) will handle
* augmentation; when called as normal function, we need to do
* it here.
*/
duk_hthread *thr = (duk_hthread *) ctx;
duk_small_int_t bidx_prototype = duk_get_current_magic(ctx);
/* same for both error and each subclass like TypeError */
duk_uint_t flags_and_class = DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR);
DUK_UNREF(thr);
duk_push_object_helper(ctx, flags_and_class, bidx_prototype);
/* If message is undefined, the own property 'message' is not set at
* all to save property space. An empty message is inherited anyway.
*/
if (!duk_is_undefined(ctx, 0)) {
duk_to_string(ctx, 0);
duk_dup_0(ctx); /* [ message error message ] */
duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
}
/* Augment the error if called as a normal function. __FILE__ and __LINE__
* are not desirable in this case.
*/
#ifdef DUK_USE_AUGMENT_ERROR_CREATE
if (!duk_is_constructor_call(ctx)) {
duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/);
}
#endif
return 1;
}
/*
* Configures a pin as a digital input pin
*/
static int NativeIoDigitalIn(duk_context* ctx)
{
AJ_Status status;
int idx;
void* pinCtx;
int config = -1;
uint32_t pin = GetPinId(ctx, 0, AJS_IO_FUNCTION_DIGITAL_IN);
if (duk_is_undefined(ctx, 1)) {
config = AJS_IO_PIN_PULL_UP;
} else if (duk_is_number(ctx, 1)) {
config = (AJS_IO_PinConfig)duk_get_int(ctx, 1);
}
if ((config != AJS_IO_PIN_OPEN_DRAIN) && (config != AJS_IO_PIN_PULL_UP) && (config != AJS_IO_PIN_PULL_DOWN)) {
duk_error(ctx, DUK_ERR_RANGE_ERROR, "Configuration must be pullUp, pullDown, or openDrain");
}
/*
* Target specific I/O pin initialization
*/
status = AJS_TargetIO_PinOpen(pin, (AJS_IO_PinConfig)config, &pinCtx);
if (status != AJ_OK) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "Failed to open digital input pin: %s", AJ_StatusText(status));
}
idx = NewIOObject(ctx, pinCtx, AJS_IO_FUNCTION_DIGITAL_IN, NativePinFinalizer);
/*
* Function to get the pin level
*/
AJS_SetPropertyAccessors(ctx, idx, "level", NULL, NativeLevelGetter);
/*
* Function to set and clear a trigger
*/
duk_push_c_lightfunc(ctx, NativePinSetTrigger, 3, 0, 0);
duk_put_prop_string(ctx, idx, "setTrigger");
duk_push_c_lightfunc(ctx, NativePinClearTrigger, 1, 0, 0);
duk_put_prop_string(ctx, idx, "clearTrigger");
/*
* Return the digital input pin object
*/
return 1;
}
/*
* like luaL_ref, but assumes storage in "refs" property of heap stash
*/
int
mn_ref(duk_context *ctx) {
int ref;
if (duk_is_undefined(ctx, -1)) {
duk_pop(ctx);
return 0;
}
/* Get the "refs" array in the heap stash */
duk_push_heap_stash(ctx);
duk_get_prop_string(ctx, -1, "refs");
duk_remove(ctx, -2);
/* ref = refs[0] */
duk_get_prop_index(ctx, -1, 0);
ref = duk_get_int(ctx, -1);
duk_pop(ctx);
/* If there was a free slot, remove it from the list */
if (ref != 0) {
/* refs[0] = refs[ref] */
duk_get_prop_index(ctx, -1, ref);
duk_put_prop_index(ctx, -2, 0);
} else {
/* Otherwise use the end of the list */
ref = duk_get_length(ctx, -1);
}
/* Swap the array and the user value in the stack */
duk_insert(ctx, -2);
/* refs[ref] = value */
duk_put_prop_index(ctx, -2, ref);
/* Remove the refs array from the stack. */
duk_pop(ctx);
return ref;
}
static duk_ret_t duk_java_property_get(duk_context *ctx) {
const char* key = duk_to_string(ctx, 0);
DEBUG_LOG("ScriptEngine", "duk_java_property_get key %s", key);
duk_push_this(ctx);
if(duk_get_prop_string(ctx, -1, JAVA_OBJECT_MARK)){
jobject ref = duk_to_pointer(ctx, -1);
JNIEnv* env = get_java_jni_env();
jstring fieldName = (*env)->NewStringUTF(env, key);
DEBUG_LOG("ScriptEngine", "duk_get_prop_string key %s", key);
jobject value = (*env)->CallStaticObjectMethod(env, java_api_class, java_field_get_method, ref, fieldName);
jthrowable exp = ( *env)->ExceptionOccurred(env);
if(exp != NULL){
( *env)->ExceptionClear(env);
jstring exceptionMessage = (*env)->CallStaticObjectMethod(env, java_api_class, java_exception_get_stack_trace_method, exp);
jboolean isCopy = JNI_FALSE;
const char* cstrMessage = (*env)->GetStringUTFChars(env, exceptionMessage, &isCopy);
duk_push_error_object(ctx, DUK_ERR_EVAL_ERROR, "get java property %s error \n %s", key, cstrMessage);
(*env)->ReleaseStringUTFChars(env, exceptionMessage, cstrMessage);
( *env)->DeleteLocalRef(env , exceptionMessage);
(*env)->DeleteLocalRef(env, value);
(*env)->DeleteLocalRef(env, fieldName);
duk_throw(ctx);
return 0;
}
DEBUG_LOG("ScriptEngine", "duk_get_prop_string push object %s value ", key);
duk_push_java_object(ctx, env, value);
DEBUG_LOG("ScriptEngine", "duk_get_prop_string push object %s success", key);
(*env)->DeleteLocalRef(env, value);
(*env)->DeleteLocalRef(env, fieldName);
return 1;
}else{
duk_get_prop_string(ctx, 1, key);
if(duk_is_undefined(ctx, -1)){
LOGW("ScriptEngine", "ScriptEngine warn property %s not found ", key);
}
return 1;
}
}
/*
* Signals require an object path, interface, and member
*/
static void InitSignal(duk_context* ctx, const char* dest, uint32_t session)
{
const char* path = duk_require_string(ctx, 0);
const char* iface;
const char* member;
/*
* Build up a dummy service object
*/
duk_push_object(ctx);
/*
* Get the interfaces from the object path
*/
AJS_GetAllJoynProperty(ctx, "objectDefinition");
duk_get_prop_string(ctx, -1, path);
if (duk_is_undefined(ctx, -1)) {
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Unknown object path '%s'", path);
}
duk_get_prop_string(ctx, -1, "interfaces");
duk_put_prop_string(ctx, -4, "interfaces");
duk_pop_2(ctx);
/*
* Set the endpoint information
*/
duk_push_string(ctx, dest);
duk_put_prop_string(ctx, -2, "dest");
duk_push_number(ctx, session);
duk_put_prop_string(ctx, -2, "session");
/*
* Resolve the interface name
*/
iface = FindInterfaceForMember(ctx, 1, &member);
MessageSetup(ctx, iface, member, path, AJ_MSG_SIGNAL);
duk_dup(ctx, 0);
duk_put_prop_string(ctx, -2, "path");
duk_push_c_lightfunc(ctx, AJS_MarshalSignal, DUK_VARARGS, 0, 0);
duk_put_prop_string(ctx, -2, "send");
}
CEJsValue js_to_cejs_value(duk_context* ctx, int index)
{
if (duk_is_number(ctx, index))
return JS_NUMBER(duk_to_number(ctx, index));
if (duk_is_boolean(ctx, index))
return JS_BOOL(duk_to_boolean(ctx, index));
if (duk_is_string(ctx, index))
return JS_STRING(duk_to_string(ctx, index));
if (duk_is_array(ctx, index))
return JS_STRING(duk_json_encode(ctx, index));
if (duk_is_object(ctx, index))
return JS_STRING(duk_json_encode(ctx, index));
if (duk_is_undefined(ctx, index)) {
return JS_UNDEFINED;
}
return JS_NULL;
}
GlobalStash::GlobalStash(const char *name) : name_(name) {
Isolate *isolate = Isolate::GetCurrent();
duk_context *ctx = isolate->GetDukContext();
// 每个 global 对象对应一个 stash 对象
duk_push_global_stash(ctx);
duk_get_prop_string(ctx, -1, name_);
if (duk_is_undefined(ctx, -1)) {
duk_pop(ctx);
// Create a new array with one `0` at index `0`.
duk_push_array(ctx);
duk_push_int(ctx, 0);
duk_put_prop_index(ctx, -2, 0);
// Store it as "name_" in the heap stash
duk_put_prop_string(ctx, -2, name_);
} else {
duk_pop(ctx);
}
duk_pop(ctx);
}
void GCObjectPool::EnsureObjectList() {
Isolate *isolate = Isolate::GetCurrent();
duk_context *ctx = isolate->GetDukContext();
// 每个 global 对象对应一个 stash 对象
duk_push_global_stash(ctx);
duk_get_prop_string(ctx, -1, "__object_list");
if (duk_is_undefined(ctx, -1)) {
duk_pop(ctx);
// Create a new array with one `0` at index `0`.
duk_push_array(ctx);
duk_push_int(ctx, 0);
duk_put_prop_index(ctx, -2, 0);
duk_dup_top(ctx);
// Store it as "name_" in the heap stash
duk_put_prop_string(ctx, -3, "__object_list");
}
duk_pop_2(ctx);
}
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;
}
//duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index);
duk_bool_t aperl_duk_is_undefined(duk_context *ctx, duk_idx_t index) {
duk_bool_t ret = duk_is_undefined(ctx, index);
return ret;
}
void
_gum_duk_args_parse (const GumDukArgs * args,
const gchar * format,
...)
{
duk_context * ctx = args->ctx;
GumDukCore * core = args->core;
va_list ap;
duk_idx_t arg_index;
const gchar * t;
gboolean is_required;
GSList * byte_arrays = NULL;
const gchar * error_message = NULL;
va_start (ap, format);
arg_index = 0;
is_required = TRUE;
for (t = format; *t != '\0'; t++)
{
if (*t == '|')
{
is_required = FALSE;
continue;
}
if (arg_index >= duk_get_top (ctx) || duk_is_undefined (ctx, arg_index))
{
if (is_required)
goto missing_argument;
else
break;
}
switch (*t)
{
case 'i':
{
if (!duk_is_number (ctx, arg_index))
goto expected_int;
*va_arg (ap, gint *) = duk_require_int (ctx, arg_index);
break;
}
case 'u':
{
guint u;
if (!_gum_duk_get_uint (ctx, arg_index, &u))
goto expected_uint;
*va_arg (ap, guint *) = (guint) u;
break;
}
case 'q':
{
gint64 i;
gboolean is_fuzzy;
is_fuzzy = t[1] == '~';
if (is_fuzzy)
t++;
if (is_fuzzy)
{
if (!_gum_duk_parse_int64 (ctx, arg_index, core, &i))
goto expected_int;
}
else
{
if (!_gum_duk_get_int64 (ctx, arg_index, core, &i))
goto expected_int;
}
*va_arg (ap, gint64 *) = i;
break;
}
case 'Q':
{
guint64 u;
gboolean is_fuzzy;
is_fuzzy = t[1] == '~';
if (is_fuzzy)
t++;
if (is_fuzzy)
{
if (!_gum_duk_parse_uint64 (ctx, arg_index, core, &u))
goto expected_uint;
}
else
{
if (!_gum_duk_get_uint64 (ctx, arg_index, core, &u))
goto expected_uint;
}
*va_arg (ap, guint64 *) = u;
break;
}
case 'z':
{
gssize value;
if (duk_is_number (ctx, arg_index))
{
value = (gssize) duk_require_int (ctx, arg_index);
}
else
{
duk_push_heapptr (ctx, core->int64);
duk_push_heapptr (ctx, core->uint64);
if (duk_instanceof (ctx, arg_index, -2))
{
GumDukInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
value = (gssize) object->value;
}
else if (duk_instanceof (ctx, arg_index, -1))
{
GumDukUInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
value = (gssize) object->value;
}
else
{
goto expected_int;
}
duk_pop_2 (ctx);
}
*va_arg (ap, gssize *) = value;
break;
}
case 'Z':
{
gsize value;
if (duk_is_number (ctx, arg_index))
{
duk_double_t number;
number = duk_require_number (ctx, arg_index);
if (number < 0)
goto expected_uint;
value = (gsize) number;
}
else
{
duk_push_heapptr (ctx, core->int64);
duk_push_heapptr (ctx, core->uint64);
if (duk_instanceof (ctx, arg_index, -1))
{
GumDukUInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
value = (gsize) object->value;
}
else if (duk_instanceof (ctx, arg_index, -2))
{
GumDukInt64 * object;
object = _gum_duk_require_data (ctx, arg_index);
if (object->value < 0)
goto expected_uint;
value = (gsize) object->value;
}
else
{
goto expected_uint;
}
duk_pop_2 (ctx);
}
*va_arg (ap, gsize *) = value;
break;
}
case 'n':
{
if (!duk_is_number (ctx, arg_index))
goto expected_number;
*va_arg (ap, gdouble *) = duk_require_number (ctx, arg_index);
break;
}
case 'p':
{
gpointer ptr;
gboolean is_fuzzy;
is_fuzzy = t[1] == '~';
if (is_fuzzy)
t++;
if (is_fuzzy)
{
if (!_gum_duk_parse_pointer (ctx, arg_index, core, &ptr))
goto expected_pointer;
}
else
{
if (!_gum_duk_get_pointer (ctx, arg_index, core, &ptr))
goto expected_pointer;
}
*va_arg (ap, gpointer *) = ptr;
break;
}
case 's':
{
const gchar * str;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (is_nullable && duk_is_null (ctx, arg_index))
str = NULL;
else if ((str = duk_get_string (ctx, arg_index)) == NULL)
goto expected_string;
*va_arg (ap, const gchar **) = str;
break;
}
case 'm':
{
GumPageProtection prot;
if (!_gum_duk_parse_protection (ctx, arg_index, &prot))
goto expected_protection;
*va_arg (ap, GumPageProtection *) = prot;
break;
}
case 'V':
{
GumDukHeapPtr value;
value = duk_get_heapptr (ctx, arg_index);
if (value == NULL)
goto expected_heap_pointer;
*va_arg (ap, GumDukHeapPtr *) = value;
break;
}
case 'O':
{
if (!duk_is_object (ctx, arg_index))
goto expected_object;
*va_arg (ap, GumDukHeapPtr *) = duk_require_heapptr (ctx, arg_index);
break;
}
case 'A':
{
GumDukHeapPtr array;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (duk_is_array (ctx, arg_index))
array = duk_require_heapptr (ctx, arg_index);
else if (is_nullable && duk_is_null (ctx, arg_index))
array = NULL;
else
goto expected_array;
*va_arg (ap, GumDukHeapPtr *) = array;
break;
}
case 'F':
{
GumDukHeapPtr func;
gboolean is_expecting_object, is_nullable;
is_expecting_object = t[1] == '{';
if (is_expecting_object)
t += 2;
if (is_expecting_object)
{
const gchar * next, * end, * t_end;
if (!duk_is_object (ctx, arg_index))
goto expected_callback_object;
do
{
gchar name[64];
gsize length;
next = strchr (t, ',');
end = strchr (t, '}');
t_end = (next != NULL && next < end) ? next : end;
length = t_end - t;
strncpy (name, t, length);
is_nullable = name[length - 1] == '?';
if (is_nullable)
name[length - 1] = '\0';
else
name[length] = '\0';
duk_get_prop_string (ctx, arg_index, name);
if (duk_is_function (ctx, -1))
{
func = duk_require_heapptr (ctx, -1);
}
else if (is_nullable && duk_is_null_or_undefined (ctx, -1))
{
func = NULL;
}
else
{
duk_pop (ctx);
goto expected_callback_value;
}
duk_pop (ctx);
*va_arg (ap, GumDukHeapPtr *) = func;
t = t_end + 1;
}
while (t_end != end);
t--;
}
else
{
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (duk_is_function (ctx, arg_index))
func = duk_require_heapptr (ctx, arg_index);
else if (is_nullable && duk_is_null (ctx, arg_index))
func = NULL;
else
goto expected_function;
*va_arg (ap, GumDukHeapPtr *) = func;
}
break;
}
case 'B':
{
GBytes * bytes;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (is_nullable && duk_is_null (ctx, arg_index))
bytes = NULL;
else if (!_gum_duk_parse_bytes (ctx, arg_index, &bytes))
goto expected_bytes;
*va_arg (ap, GBytes **) = bytes;
if (bytes != NULL)
byte_arrays = g_slist_prepend (byte_arrays, bytes);
break;
}
case 'C':
{
GumCpuContext * cpu_context;
gboolean is_nullable;
is_nullable = t[1] == '?';
if (is_nullable)
t++;
if (is_nullable && duk_is_null (ctx, arg_index))
cpu_context = NULL;
else if ((cpu_context = _gum_duk_get_cpu_context (ctx, arg_index,
core)) == NULL)
goto expected_cpu_context;
*va_arg (ap, GumCpuContext **) = cpu_context;
break;
}
default:
g_assert_not_reached ();
}
arg_index++;
}
va_end (ap);
g_slist_free (byte_arrays);
return;
missing_argument:
{
error_message = "missing argument";
goto error;
}
expected_int:
{
error_message = "expected an integer";
goto error;
}
expected_uint:
{
error_message = "expected an unsigned integer";
goto error;
}
expected_number:
{
error_message = "expected a number";
goto error;
}
expected_pointer:
{
error_message = "expected a pointer";
goto error;
}
expected_string:
{
error_message = "expected a string";
goto error;
}
expected_protection:
{
error_message = "expected a string specifying memory protection";
goto error;
}
expected_heap_pointer:
{
error_message = "expected a heap-allocated object";
goto error;
}
expected_object:
{
error_message = "expected an object";
goto error;
}
expected_array:
{
error_message = "expected an array";
goto error;
}
expected_callback_object:
{
error_message = "expected an object containing callbacks";
goto error;
}
expected_callback_value:
{
error_message = "expected a callback value";
goto error;
}
expected_function:
{
error_message = "expected a function";
goto error;
}
expected_bytes:
{
error_message = "expected a buffer-like object";
goto error;
}
expected_cpu_context:
{
error_message = "expected a CpuContext object";
goto error;
}
error:
{
va_end (ap);
g_slist_foreach (byte_arrays, (GFunc) g_bytes_unref, NULL);
g_slist_free (byte_arrays);
g_assert (error_message != NULL);
_gum_duk_throw (ctx, error_message);
}
}
int duk_bi_function_prototype_to_string(duk_context *ctx) {
duk_tval *tv;
/*
* E5 Section 15.3.4.2 places few requirements on the output of
* this function:
*
* - The result is an implementation dependent representation
* of the function; in particular
*
* - The result must follow the syntax of a FunctionDeclaration.
* In particular, the function must have a name (even in the
* case of an anonymous function or a function with an empty
* name).
*
* - Note in particular that the output does NOT need to compile
* into anything useful.
*/
/* FIXME: faster internal way to get this */
duk_push_this(ctx);
tv = duk_get_tval(ctx, -1);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_OBJECT(tv)) {
duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv);
const char *func_name = "anonymous";
/* FIXME: rework, it would be nice to avoid C formatting functions to
* ensure there are no Unicode issues.
*/
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
if (!duk_is_undefined(ctx, -1)) {
func_name = duk_to_string(ctx, -1);
DUK_ASSERT(func_name != NULL);
if (func_name[0] == (char) 0) {
func_name = "empty";
}
}
if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj)) {
/* FIXME: actual source, if available */
duk_push_sprintf(ctx, "function %s() {/* source code */}", func_name);
} else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) {
duk_push_sprintf(ctx, "function %s() {/* native code */}", func_name);
} else if (DUK_HOBJECT_HAS_BOUND(obj)) {
duk_push_sprintf(ctx, "function %s() {/* bound */}", func_name);
} else {
goto type_error;
}
} else {
goto type_error;
}
return 1;
type_error:
return DUK_RET_TYPE_ERROR;
}
DUK_INTERNAL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx) {
duk_tval *tv;
/*
* E5 Section 15.3.4.2 places few requirements on the output of
* this function:
*
* - The result is an implementation dependent representation
* of the function; in particular
*
* - The result must follow the syntax of a FunctionDeclaration.
* In particular, the function must have a name (even in the
* case of an anonymous function or a function with an empty
* name).
*
* - Note in particular that the output does NOT need to compile
* into anything useful.
*/
/* XXX: faster internal way to get this */
duk_push_this(ctx);
tv = duk_get_tval(ctx, -1);
DUK_ASSERT(tv != NULL);
if (DUK_TVAL_IS_OBJECT(tv)) {
duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv);
const char *func_name;
/* Function name: missing/undefined is mapped to empty string,
* otherwise coerce to string.
*/
/* XXX: currently no handling for non-allowed identifier characters,
* e.g. a '{' in the function name.
*/
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
if (duk_is_undefined(ctx, -1)) {
func_name = "";
} else {
func_name = duk_to_string(ctx, -1);
DUK_ASSERT(func_name != NULL);
}
/* Indicate function type in the function body using a dummy
* directive.
*/
if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj)) {
duk_push_sprintf(ctx, "function %s() {\"ecmascript\"}", (const char *) func_name);
} else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) {
duk_push_sprintf(ctx, "function %s() {\"native\"}", (const char *) func_name);
} else if (DUK_HOBJECT_HAS_BOUND(obj)) {
duk_push_sprintf(ctx, "function %s() {\"bound\"}", (const char *) func_name);
} else {
goto type_error;
}
} else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
duk_push_lightfunc_tostring(ctx, tv);
} else {
goto type_error;
}
return 1;
type_error:
return DUK_RET_TYPE_ERROR;
}
bool Context::isUndefined(index_t i)
{
return (duk_is_undefined(m_handle, i) ? true: false);
}
static duk_ret_t duk__handle_require(duk_context *ctx) {
/*
* Value stack handling here is a bit sloppy but should be correct.
* Call handling will clean up any extra garbage for us.
*/
const char *id;
const char *parent_id;
duk_idx_t module_idx;
duk_idx_t stash_idx;
duk_int_t ret;
duk_push_global_stash(ctx);
stash_idx = duk_normalize_index(ctx, -1);
duk_push_current_function(ctx);
(void) duk_get_prop_string(ctx, -1, "\xff" "moduleId");
parent_id = duk_require_string(ctx, -1);
(void) parent_id; /* not used directly; suppress warning */
/* [ id stash require parent_id ] */
id = duk_require_string(ctx, 0);
(void) duk_get_prop_string(ctx, stash_idx, "\xff" "modResolve");
duk_dup(ctx, 0); /* module ID */
duk_dup(ctx, -3); /* parent ID */
duk_call(ctx, 2);
/* [ ... stash ... resolved_id ] */
id = duk_require_string(ctx, -1);
if (duk__get_cached_module(ctx, id)) {
goto have_module; /* use the cached module */
}
duk__push_module_object(ctx, id, 0 /*main*/);
duk__put_cached_module(ctx); /* module remains on stack */
/*
* From here on out, we have to be careful not to throw. If it can't be
* avoided, the error must be caught and the module removed from the
* require cache before rethrowing. This allows the application to
* reattempt loading the module.
*/
module_idx = duk_normalize_index(ctx, -1);
/* [ ... stash ... resolved_id module ] */
(void) duk_get_prop_string(ctx, stash_idx, "\xff" "modLoad");
duk_dup(ctx, -3); /* resolved ID */
(void) duk_get_prop_string(ctx, module_idx, "exports");
duk_dup(ctx, module_idx);
ret = duk_pcall(ctx, 3);
if (ret != DUK_EXEC_SUCCESS) {
duk__del_cached_module(ctx, id);
duk_throw(ctx); /* rethrow */
}
if (duk_is_string(ctx, -1)) {
duk_int_t ret;
/* [ ... module source ] */
#if DUK_VERSION >= 19999
ret = duk_safe_call(ctx, duk__eval_module_source, NULL, 2, 1);
#else
ret = duk_safe_call(ctx, duk__eval_module_source, 2, 1);
#endif
if (ret != DUK_EXEC_SUCCESS) {
duk__del_cached_module(ctx, id);
duk_throw(ctx); /* rethrow */
}
} else if (duk_is_undefined(ctx, -1)) {
duk_pop(ctx);
} else {
duk__del_cached_module(ctx, id);
duk_error(ctx, DUK_ERR_TYPE_ERROR, "invalid module load callback return value");
}
/* fall through */
have_module:
/* [ ... module ] */
(void) duk_get_prop_string(ctx, -1, "exports");
return 1;
}
void test(duk_context *ctx) {
duk_idx_t i, n;
/*
* push test values
*/
/* 0 */
duk_push_undefined(ctx);
/* 1 */
duk_push_null(ctx);
/* 2 */
duk_push_true(ctx);
/* 3 */
duk_push_false(ctx);
/* 4 */
duk_push_int(ctx, 123);
/* 5 */
duk_push_number(ctx, 123.4);
/* 6 */
duk_push_nan(ctx);
/* 7 */
duk_push_number(ctx, INFINITY);
/* 8 */
duk_push_number(ctx, -INFINITY);
/* 9 */
duk_push_string(ctx, "");
/* 10 */
duk_push_string(ctx, "foo");
/* 11 */
duk_push_object(ctx);
/* 12 */
duk_push_array(ctx);
/* 13 */
duk_push_c_function(ctx, my_c_func, DUK_VARARGS);
/* 14 */
duk_push_string(ctx, "(function() { print('hello'); })");
duk_eval(ctx);
/* 15 */
duk_push_string(ctx, "escape.bind(null, 'foo')");
duk_eval(ctx);
/* 16 */
duk_push_thread(ctx);
/* 17 */
duk_push_buffer(ctx, 1024, 0 /*dynamic*/);
/* 18 */
duk_push_buffer(ctx, 1024, 1 /*dynamic*/);
/* 19 */
duk_push_pointer(ctx, (void *) 0xf00);
/*
* call checkers for each
*/
n = duk_get_top(ctx);
for (i = 0; i < n; i++) {
printf("%02ld: ", (long) i);
printf(" und=%d", (int) duk_is_undefined(ctx, i));
printf(" null=%d", (int) duk_is_null(ctx, i));
printf(" noru=%d", (int) duk_is_null_or_undefined(ctx, i));
printf(" bool=%d", (int) duk_is_boolean(ctx, i));
printf(" num=%d", (int) duk_is_number(ctx, i));
printf(" nan=%d", (int) duk_is_nan(ctx, i));
printf(" str=%d", (int) duk_is_string(ctx, i));
printf(" obj=%d", (int) duk_is_object(ctx, i));
printf(" arr=%d", (int) duk_is_array(ctx, i));
printf(" fun=%d", (int) duk_is_function(ctx, i));
printf(" cfun=%d", (int) duk_is_c_function(ctx, i));
printf(" efun=%d", (int) duk_is_ecmascript_function(ctx, i));
printf(" bfun=%d", (int) duk_is_bound_function(ctx, i));
printf(" call=%d", (int) duk_is_callable(ctx, i));
printf(" thr=%d", (int) duk_is_thread(ctx, i));
printf(" buf=%d", (int) duk_is_buffer(ctx, i));
printf(" dyn=%d", (int) duk_is_dynamic_buffer(ctx, i));
printf(" fix=%d", (int) duk_is_fixed_buffer(ctx, i));
printf(" ptr=%d", (int) duk_is_pointer(ctx, i));
printf(" prim=%d", (int) duk_is_primitive(ctx, i));
printf(" objcoerc=%d", (int) duk_is_object_coercible(ctx, i));
printf("\n");
}
}
/* XXX: much to improve (code size) */
DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hobject *h_pattern;
DUK_ASSERT_TOP(ctx, 2);
h_pattern = duk_get_hobject(ctx, 0);
if (!duk_is_constructor_call(ctx) &&
h_pattern != NULL &&
DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP &&
duk_is_undefined(ctx, 1)) {
/* Called as a function, pattern has [[Class]] "RegExp" and
* flags is undefined -> return object as is.
*/
duk_dup(ctx, 0);
return 1;
}
/* Else functionality is identical for function call and constructor
* call.
*/
if (h_pattern != NULL &&
DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP) {
if (duk_is_undefined(ctx, 1)) {
duk_bool_t flag_g, flag_i, flag_m;
duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
flag_g = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
flag_i = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_IGNORE_CASE, NULL);
flag_m = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_MULTILINE, NULL);
duk_push_sprintf(ctx, "%s%s%s",
(const char *) (flag_g ? "g" : ""),
(const char *) (flag_i ? "i" : ""),
(const char *) (flag_m ? "m" : ""));
/* [ ... pattern flags ] */
} else {
return DUK_RET_TYPE_ERROR;
}
} else {
if (duk_is_undefined(ctx, 0)) {
duk_push_string(ctx, "");
} else {
duk_dup(ctx, 0);
duk_to_string(ctx, -1);
}
if (duk_is_undefined(ctx, 1)) {
duk_push_string(ctx, "");
} else {
duk_dup(ctx, 1);
duk_to_string(ctx, -1);
}
/* [ ... pattern flags ] */
}
DUK_DDD(DUK_DDDPRINT("RegExp constructor/function call, pattern=%!T, flags=%!T",
(duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
/* [ ... pattern flags ] */
duk_regexp_compile(thr);
/* [ ... bytecode escaped_source ] */
duk_regexp_create_instance(thr);
/* [ ... RegExp ] */
return 1;
}
/* XXX: much to improve (code size) */
DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_hthread *thr) {
duk_hobject *h_pattern;
DUK_ASSERT_TOP(thr, 2);
h_pattern = duk_get_hobject(thr, 0);
if (!duk_is_constructor_call(thr) &&
h_pattern != NULL &&
DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP &&
duk_is_undefined(thr, 1)) {
/* Called as a function, pattern has [[Class]] "RegExp" and
* flags is undefined -> return object as is.
*/
/* XXX: ES2015 has a NewTarget SameValue() check which is not
* yet implemented.
*/
duk_dup_0(thr);
return 1;
}
/* Else functionality is identical for function call and constructor
* call.
*/
if (h_pattern != NULL &&
DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP) {
duk_get_prop_stridx_short(thr, 0, DUK_STRIDX_SOURCE);
if (duk_is_undefined(thr, 1)) {
/* In ES5 one would need to read the flags individually;
* in ES2015 just read .flags.
*/
duk_get_prop_stridx(thr, 0, DUK_STRIDX_FLAGS);
} else {
/* In ES2015 allowed; overrides argument RegExp flags. */
duk_dup_1(thr);
}
} else {
if (duk_is_undefined(thr, 0)) {
duk_push_hstring_empty(thr);
} else {
duk_dup_0(thr);
duk_to_string(thr, -1); /* Rejects Symbols. */
}
if (duk_is_undefined(thr, 1)) {
duk_push_hstring_empty(thr);
} else {
duk_dup_1(thr);
duk_to_string(thr, -1); /* Rejects Symbols. */
}
/* [ ... pattern flags ] */
}
DUK_DDD(DUK_DDDPRINT("RegExp constructor/function call, pattern=%!T, flags=%!T",
(duk_tval *) duk_get_tval(thr, -2), (duk_tval *) duk_get_tval(thr, -1)));
/* [ ... pattern flags ] (both uncoerced) */
duk_to_string(thr, -2);
duk_to_string(thr, -1);
duk_regexp_compile(thr);
/* [ ... bytecode escaped_source ] */
duk_regexp_create_instance(thr);
/* [ ... RegExp ] */
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hstring *h_input;
duk_hstring *h_match;
duk_hstring *h_search;
duk_hobject *h_re;
duk_bufwriter_ctx bw_alloc;
duk_bufwriter_ctx *bw;
#ifdef DUK_USE_REGEXP_SUPPORT
duk_bool_t is_regexp;
duk_bool_t is_global;
#endif
duk_bool_t is_repl_func;
duk_uint32_t match_start_coff, match_start_boff;
#ifdef DUK_USE_REGEXP_SUPPORT
duk_int_t match_caps;
#endif
duk_uint32_t prev_match_end_boff;
const duk_uint8_t *r_start, *r_end, *r; /* repl string scan */
duk_size_t tmp_sz;
DUK_ASSERT_TOP(ctx, 2);
h_input = duk_push_this_coercible_to_string(ctx);
DUK_ASSERT(h_input != NULL);
bw = &bw_alloc;
DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input)); /* input size is good output starting point */
DUK_ASSERT_TOP(ctx, 4);
/* stack[0] = search value
* stack[1] = replace value
* stack[2] = input string
* stack[3] = result buffer
*/
h_re = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP);
if (h_re) {
#ifdef DUK_USE_REGEXP_SUPPORT
is_regexp = 1;
is_global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
if (is_global) {
/* start match from beginning */
duk_push_int(ctx, 0);
duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
}
#else /* DUK_USE_REGEXP_SUPPORT */
return DUK_RET_UNSUPPORTED_ERROR;
#endif /* DUK_USE_REGEXP_SUPPORT */
} else {
duk_to_string(ctx, 0);
#ifdef DUK_USE_REGEXP_SUPPORT
is_regexp = 0;
is_global = 0;
#endif
}
if (duk_is_function(ctx, 1)) {
is_repl_func = 1;
r_start = NULL;
r_end = NULL;
} else {
duk_hstring *h_repl;
is_repl_func = 0;
h_repl = duk_to_hstring(ctx, 1);
DUK_ASSERT(h_repl != NULL);
r_start = DUK_HSTRING_GET_DATA(h_repl);
r_end = r_start + DUK_HSTRING_GET_BYTELEN(h_repl);
}
prev_match_end_boff = 0;
for (;;) {
/*
* If matching with a regexp:
* - non-global RegExp: lastIndex not touched on a match, zeroed
* on a non-match
* - global RegExp: on match, lastIndex will be updated by regexp
* executor to point to next char after the matching part (so that
* characters in the matching part are not matched again)
*
* If matching with a string:
* - always non-global match, find first occurrence
*
* We need:
* - The character offset of start-of-match for the replacer function
* - The byte offsets for start-of-match and end-of-match to implement
* the replacement values $&, $`, and $', and to copy non-matching
* input string portions (including header and trailer) verbatim.
*
* NOTE: the E5.1 specification is a bit vague how the RegExp should
* behave in the replacement process; e.g. is matching done first for
* all matches (in the global RegExp case) before any replacer calls
* are made? See: test-bi-string-proto-replace.js for discussion.
*/
DUK_ASSERT_TOP(ctx, 4);
#ifdef DUK_USE_REGEXP_SUPPORT
if (is_regexp) {
duk_dup(ctx, 0);
duk_dup(ctx, 2);
duk_regexp_match(thr); /* [ ... regexp input ] -> [ res_obj ] */
if (!duk_is_object(ctx, -1)) {
duk_pop(ctx);
break;
}
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
DUK_ASSERT(duk_is_number(ctx, -1));
match_start_coff = duk_get_int(ctx, -1);
duk_pop(ctx);
duk_get_prop_index(ctx, -1, 0);
DUK_ASSERT(duk_is_string(ctx, -1));
h_match = duk_get_hstring(ctx, -1);
DUK_ASSERT(h_match != NULL);
duk_pop(ctx); /* h_match is borrowed, remains reachable through match_obj */
if (DUK_HSTRING_GET_BYTELEN(h_match) == 0) {
/* This should be equivalent to match() algorithm step 8.f.iii.2:
* detect an empty match and allow it, but don't allow it twice.
*/
duk_uint32_t last_index;
duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
last_index = (duk_uint32_t) duk_get_uint(ctx, -1);
DUK_DDD(DUK_DDDPRINT("empty match, bump lastIndex: %ld -> %ld",
(long) last_index, (long) (last_index + 1)));
duk_pop(ctx);
duk_push_int(ctx, last_index + 1);
duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
}
DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_INT_MAX); /* string limits */
match_caps = (duk_int_t) duk_get_length(ctx, -1);
} else {
#else /* DUK_USE_REGEXP_SUPPORT */
{ /* unconditionally */
#endif /* DUK_USE_REGEXP_SUPPORT */
const duk_uint8_t *p_start, *p_end, *p; /* input string scan */
const duk_uint8_t *q_start; /* match string */
duk_size_t q_blen;
#ifdef DUK_USE_REGEXP_SUPPORT
DUK_ASSERT(!is_global); /* single match always */
#endif
p_start = DUK_HSTRING_GET_DATA(h_input);
p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
p = p_start;
h_search = duk_get_hstring(ctx, 0);
DUK_ASSERT(h_search != NULL);
q_start = DUK_HSTRING_GET_DATA(h_search);
q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_search);
p_end -= q_blen; /* ensure full memcmp() fits in while */
match_start_coff = 0;
while (p <= p_end) {
DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
if (DUK_MEMCMP((void *) p, (void *) q_start, (size_t) q_blen) == 0) {
duk_dup(ctx, 0);
h_match = duk_get_hstring(ctx, -1);
DUK_ASSERT(h_match != NULL);
#ifdef DUK_USE_REGEXP_SUPPORT
match_caps = 0;
#endif
goto found;
}
/* track utf-8 non-continuation bytes */
if ((p[0] & 0xc0) != 0x80) {
match_start_coff++;
}
p++;
}
/* not found */
break;
}
found:
/* stack[0] = search value
* stack[1] = replace value
* stack[2] = input string
* stack[3] = result buffer
* stack[4] = regexp match OR match string
*/
match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
tmp_sz = (duk_size_t) (match_start_boff - prev_match_end_boff);
DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz);
prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match);
if (is_repl_func) {
duk_idx_t idx_args;
duk_hstring *h_repl;
/* regexp res_obj is at index 4 */
duk_dup(ctx, 1);
idx_args = duk_get_top(ctx);
#ifdef DUK_USE_REGEXP_SUPPORT
if (is_regexp) {
duk_int_t idx;
duk_require_stack(ctx, match_caps + 2);
for (idx = 0; idx < match_caps; idx++) {
/* match followed by capture(s) */
duk_get_prop_index(ctx, 4, idx);
}
} else {
#else /* DUK_USE_REGEXP_SUPPORT */
{ /* unconditionally */
#endif /* DUK_USE_REGEXP_SUPPORT */
/* match == search string, by definition */
duk_dup(ctx, 0);
}
duk_push_int(ctx, match_start_coff);
duk_dup(ctx, 2);
/* [ ... replacer match [captures] match_char_offset input ] */
duk_call(ctx, duk_get_top(ctx) - idx_args);
h_repl = duk_to_hstring(ctx, -1); /* -> [ ... repl_value ] */
DUK_ASSERT(h_repl != NULL);
DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_repl);
duk_pop(ctx); /* repl_value */
} else {
r = r_start;
while (r < r_end) {
duk_int_t ch1;
duk_int_t ch2;
#ifdef DUK_USE_REGEXP_SUPPORT
duk_int_t ch3;
#endif
duk_size_t left;
ch1 = *r++;
if (ch1 != DUK_ASC_DOLLAR) {
goto repl_write;
}
left = r_end - r;
if (left <= 0) {
goto repl_write;
}
ch2 = r[0];
switch ((int) ch2) {
case DUK_ASC_DOLLAR: {
ch1 = (1 << 8) + DUK_ASC_DOLLAR;
goto repl_write;
}
case DUK_ASC_AMP: {
DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_match);
r++;
continue;
}
case DUK_ASC_GRAVE: {
tmp_sz = (duk_size_t) match_start_boff;
DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input), tmp_sz);
r++;
continue;
}
case DUK_ASC_SINGLEQUOTE: {
duk_uint32_t match_end_boff;
/* Use match charlen instead of bytelen, just in case the input and
* match codepoint encodings would have different lengths.
*/
match_end_boff = duk_heap_strcache_offset_char2byte(thr,
h_input,
match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match));
tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff);
DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + match_end_boff, tmp_sz);
r++;
continue;
}
default: {
#ifdef DUK_USE_REGEXP_SUPPORT
duk_int_t capnum, captmp, capadv;
/* XXX: optional check, match_caps is zero if no regexp,
* so dollar will be interpreted literally anyway.
*/
if (!is_regexp) {
goto repl_write;
}
if (!(ch2 >= DUK_ASC_0 && ch2 <= DUK_ASC_9)) {
goto repl_write;
}
capnum = ch2 - DUK_ASC_0;
capadv = 1;
if (left >= 2) {
ch3 = r[1];
if (ch3 >= DUK_ASC_0 && ch3 <= DUK_ASC_9) {
captmp = capnum * 10 + (ch3 - DUK_ASC_0);
if (captmp < match_caps) {
capnum = captmp;
capadv = 2;
}
}
}
if (capnum > 0 && capnum < match_caps) {
DUK_ASSERT(is_regexp != 0); /* match_caps == 0 without regexps */
/* regexp res_obj is at offset 4 */
duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum);
if (duk_is_string(ctx, -1)) {
duk_hstring *h_tmp_str;
h_tmp_str = duk_get_hstring(ctx, -1);
DUK_ASSERT(h_tmp_str != NULL);
DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_tmp_str);
} else {
/* undefined -> skip (replaced with empty) */
}
duk_pop(ctx);
r += capadv;
continue;
} else {
goto repl_write;
}
#else /* DUK_USE_REGEXP_SUPPORT */
goto repl_write; /* unconditionally */
#endif /* DUK_USE_REGEXP_SUPPORT */
} /* default case */
} /* switch (ch2) */
repl_write:
/* ch1 = (r_increment << 8) + byte */
DUK_BW_WRITE_ENSURE_U8(thr, bw, (duk_uint8_t) (ch1 & 0xff));
r += ch1 >> 8;
} /* while repl */
} /* if (is_repl_func) */
duk_pop(ctx); /* pop regexp res_obj or match string */
#ifdef DUK_USE_REGEXP_SUPPORT
if (!is_global) {
#else
{ /* unconditionally; is_global==0 */
#endif
break;
}
}
/* trailer */
tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff);
DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz);
DUK_ASSERT_TOP(ctx, 4);
DUK_BW_COMPACT(thr, bw);
duk_to_string(ctx, -1);
return 1;
}
/*
* split()
*/
/* XXX: very messy now, but works; clean up, remove unused variables (nomimally
* used so compiler doesn't complain).
*/
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hstring *h_input;
duk_hstring *h_sep;
duk_uint32_t limit;
duk_uint32_t arr_idx;
#ifdef DUK_USE_REGEXP_SUPPORT
duk_bool_t is_regexp;
#endif
duk_bool_t matched; /* set to 1 if any match exists (needed for empty input special case) */
duk_uint32_t prev_match_end_coff, prev_match_end_boff;
duk_uint32_t match_start_boff, match_start_coff;
duk_uint32_t match_end_boff, match_end_coff;
DUK_UNREF(thr);
h_input = duk_push_this_coercible_to_string(ctx);
DUK_ASSERT(h_input != NULL);
duk_push_array(ctx);
if (duk_is_undefined(ctx, 1)) {
limit = 0xffffffffUL;
} else {
limit = duk_to_uint32(ctx, 1);
}
if (limit == 0) {
return 1;
}
/* If the separator is a RegExp, make a "clone" of it. The specification
* algorithm calls [[Match]] directly for specific indices; we emulate this
* by tweaking lastIndex and using a "force global" variant of duk_regexp_match()
* which will use global-style matching even when the RegExp itself is non-global.
*/
if (duk_is_undefined(ctx, 0)) {
/* The spec algorithm first does "R = ToString(separator)" before checking
* whether separator is undefined. Since this is side effect free, we can
* skip the ToString() here.
*/
duk_dup(ctx, 2);
duk_put_prop_index(ctx, 3, 0);
return 1;
} else if (duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP) != NULL) {
#ifdef DUK_USE_REGEXP_SUPPORT
duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
duk_dup(ctx, 0);
duk_new(ctx, 1); /* [ ... RegExp val ] -> [ ... res ] */
duk_replace(ctx, 0);
/* lastIndex is initialized to zero by new RegExp() */
is_regexp = 1;
#else
return DUK_RET_UNSUPPORTED_ERROR;
#endif
} else {
duk_to_string(ctx, 0);
#ifdef DUK_USE_REGEXP_SUPPORT
is_regexp = 0;
#endif
}
/* stack[0] = separator (string or regexp)
* stack[1] = limit
* stack[2] = input string
* stack[3] = result array
*/
prev_match_end_boff = 0;
prev_match_end_coff = 0;
arr_idx = 0;
matched = 0;
for (;;) {
/*
* The specification uses RegExp [[Match]] to attempt match at specific
* offsets. We don't have such a primitive, so we use an actual RegExp
* and tweak lastIndex. Since the RegExp may be non-global, we use a
* special variant which forces global-like behavior for matching.
*/
DUK_ASSERT_TOP(ctx, 4);
#ifdef DUK_USE_REGEXP_SUPPORT
if (is_regexp) {
duk_dup(ctx, 0);
duk_dup(ctx, 2);
duk_regexp_match_force_global(thr); /* [ ... regexp input ] -> [ res_obj ] */
if (!duk_is_object(ctx, -1)) {
duk_pop(ctx);
break;
}
matched = 1;
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
DUK_ASSERT(duk_is_number(ctx, -1));
match_start_coff = duk_get_int(ctx, -1);
match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
duk_pop(ctx);
if (match_start_coff == DUK_HSTRING_GET_CHARLEN(h_input)) {
/* don't allow an empty match at the end of the string */
duk_pop(ctx);
break;
}
duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
DUK_ASSERT(duk_is_number(ctx, -1));
match_end_coff = duk_get_int(ctx, -1);
match_end_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_end_coff);
duk_pop(ctx);
/* empty match -> bump and continue */
if (prev_match_end_boff == match_end_boff) {
duk_push_int(ctx, match_end_coff + 1);
duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
duk_pop(ctx);
continue;
}
} else {
#else /* DUK_USE_REGEXP_SUPPORT */
{ /* unconditionally */
#endif /* DUK_USE_REGEXP_SUPPORT */
const duk_uint8_t *p_start, *p_end, *p; /* input string scan */
const duk_uint8_t *q_start; /* match string */
duk_size_t q_blen, q_clen;
p_start = DUK_HSTRING_GET_DATA(h_input);
p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
p = p_start + prev_match_end_boff;
h_sep = duk_get_hstring(ctx, 0);
DUK_ASSERT(h_sep != NULL);
q_start = DUK_HSTRING_GET_DATA(h_sep);
q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sep);
q_clen = (duk_size_t) DUK_HSTRING_GET_CHARLEN(h_sep);
p_end -= q_blen; /* ensure full memcmp() fits in while */
match_start_coff = prev_match_end_coff;
if (q_blen == 0) {
/* Handle empty separator case: it will always match, and always
* triggers the check in step 13.c.iii initially. Note that we
* must skip to either end of string or start of first codepoint,
* skipping over any continuation bytes!
*
* Don't allow an empty string to match at the end of the input.
*/
matched = 1; /* empty separator can always match */
match_start_coff++;
p++;
while (p < p_end) {
if ((p[0] & 0xc0) != 0x80) {
goto found;
}
p++;
}
goto not_found;
}
DUK_ASSERT(q_blen > 0 && q_clen > 0);
while (p <= p_end) {
DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
DUK_ASSERT(q_blen > 0); /* no issues with empty memcmp() */
if (DUK_MEMCMP((void *) p, (void *) q_start, (duk_size_t) q_blen) == 0) {
/* never an empty match, so step 13.c.iii can't be triggered */
goto found;
}
/* track utf-8 non-continuation bytes */
if ((p[0] & 0xc0) != 0x80) {
match_start_coff++;
}
p++;
}
not_found:
/* not found */
break;
found:
matched = 1;
match_start_boff = (duk_uint32_t) (p - p_start);
match_end_coff = (duk_uint32_t) (match_start_coff + q_clen); /* constrained by string length */
match_end_boff = (duk_uint32_t) (match_start_boff + q_blen); /* ditto */
/* empty match (may happen with empty separator) -> bump and continue */
if (prev_match_end_boff == match_end_boff) {
prev_match_end_boff++;
prev_match_end_coff++;
continue;
}
} /* if (is_regexp) */
/* stack[0] = separator (string or regexp)
* stack[1] = limit
* stack[2] = input string
* stack[3] = result array
* stack[4] = regexp res_obj (if is_regexp)
*/
DUK_DDD(DUK_DDDPRINT("split; match_start b=%ld,c=%ld, match_end b=%ld,c=%ld, prev_end b=%ld,c=%ld",
(long) match_start_boff, (long) match_start_coff,
(long) match_end_boff, (long) match_end_coff,
(long) prev_match_end_boff, (long) prev_match_end_coff));
duk_push_lstring(ctx,
(const char *) (DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff),
(duk_size_t) (match_start_boff - prev_match_end_boff));
duk_put_prop_index(ctx, 3, arr_idx);
arr_idx++;
if (arr_idx >= limit) {
goto hit_limit;
}
#ifdef DUK_USE_REGEXP_SUPPORT
if (is_regexp) {
duk_size_t i, len;
len = duk_get_length(ctx, 4);
for (i = 1; i < len; i++) {
DUK_ASSERT(i <= DUK_UARRIDX_MAX); /* cannot have >4G captures */
duk_get_prop_index(ctx, 4, (duk_uarridx_t) i);
duk_put_prop_index(ctx, 3, arr_idx);
arr_idx++;
if (arr_idx >= limit) {
goto hit_limit;
}
}
duk_pop(ctx);
/* lastIndex already set up for next match */
} else {
#else /* DUK_USE_REGEXP_SUPPORT */
{ /* unconditionally */
#endif /* DUK_USE_REGEXP_SUPPORT */
/* no action */
}
prev_match_end_boff = match_end_boff;
prev_match_end_coff = match_end_coff;
continue;
} /* for */
/* Combined step 11 (empty string special case) and 14-15. */
DUK_DDD(DUK_DDDPRINT("split trailer; prev_end b=%ld,c=%ld",
(long) prev_match_end_boff, (long) prev_match_end_coff));
if (DUK_HSTRING_GET_CHARLEN(h_input) > 0 || !matched) {
/* Add trailer if:
* a) non-empty input
* b) empty input and no (zero size) match found (step 11)
*/
duk_push_lstring(ctx,
(const char *) DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff,
(duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff));
duk_put_prop_index(ctx, 3, arr_idx);
/* No arr_idx update or limit check */
}
return 1;
hit_limit:
#ifdef DUK_USE_REGEXP_SUPPORT
if (is_regexp) {
duk_pop(ctx);
}
#endif
return 1;
}
/*
* Various
*/
#ifdef DUK_USE_REGEXP_SUPPORT
DUK_LOCAL void duk__to_regexp_helper(duk_context *ctx, duk_idx_t index, duk_bool_t force_new) {
duk_hobject *h;
/* Shared helper for match() steps 3-4, search() steps 3-4. */
DUK_ASSERT(index >= 0);
if (force_new) {
goto do_new;
}
h = duk_get_hobject_with_class(ctx, index, DUK_HOBJECT_CLASS_REGEXP);
if (!h) {
goto do_new;
}
return;
do_new:
duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
duk_dup(ctx, index);
duk_new(ctx, 1); /* [ ... RegExp val ] -> [ ... res ] */
duk_replace(ctx, index);
}
#endif /* DUK_USE_REGEXP_SUPPORT */
#ifdef DUK_USE_REGEXP_SUPPORT
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
duk_hthread *thr = (duk_hthread *) ctx;
/* Easiest way to implement the search required by the specification
* is to do a RegExp test() with lastIndex forced to zero. To avoid
* side effects on the argument, "clone" the RegExp if a RegExp was
* given as input.
*
* The global flag of the RegExp should be ignored; setting lastIndex
* to zero (which happens when "cloning" the RegExp) should have an
* equivalent effect.
*/
DUK_ASSERT_TOP(ctx, 1);
(void) duk_push_this_coercible_to_string(ctx); /* at index 1 */
duk__to_regexp_helper(ctx, 0 /*index*/, 1 /*force_new*/);
/* stack[0] = regexp
* stack[1] = string
*/
/* Avoid using RegExp.prototype methods, as they're writable and
* configurable and may have been changed.
*/
duk_dup(ctx, 0);
duk_dup(ctx, 1); /* [ ... re_obj input ] */
duk_regexp_match(thr); /* -> [ ... res_obj ] */
if (!duk_is_object(ctx, -1)) {
duk_push_int(ctx, -1);
return 1;
}
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
DUK_ASSERT(duk_is_number(ctx, -1));
return 1;
}
#else /* DUK_USE_REGEXP_SUPPORT */
DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
DUK_UNREF(ctx);
return DUK_RET_UNSUPPORTED_ERROR;
}