int duk_builtin_math_object_twoarg_shared(duk_context *ctx) {
int fun_idx = duk_get_magic(ctx);
two_arg_func fun;
DUK_ASSERT(fun_idx >= 0 && fun_idx < sizeof(two_arg_funcs) / sizeof(two_arg_func));
fun = two_arg_funcs[fun_idx];
duk_push_number(ctx, fun(duk_to_number(ctx, 0), duk_to_number(ctx, 1)));
return 1;
}
duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) {
duk_small_int_t fun_idx = duk_get_magic(ctx);
duk__two_arg_func fun;
DUK_ASSERT(fun_idx >= 0);
DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__two_arg_funcs) / sizeof(duk__two_arg_func)));
fun = duk__two_arg_funcs[fun_idx];
/* FIXME: double typing here: double or duk_double_t? */
duk_push_number(ctx, fun((double) duk_to_number(ctx, 0), (double) duk_to_number(ctx, 1)));
return 1;
}
static int Light_SetShadowBias(duk_context* ctx)
{
float constantBias = (float) duk_to_number(ctx, 0);
float slopeScaledBias = (float) duk_to_number(ctx, 1);
BiasParameters bparms(constantBias, slopeScaledBias);
duk_push_this(ctx);
Light* light = js_to_class_instance<Light>(ctx, -1, 0);
light->SetShadowBias(bparms);
return 0;
}
static int Camera_GetScreenRay(duk_context* ctx)
{
float x = (float) duk_to_number(ctx, 0);
float y = (float) duk_to_number(ctx, 1);
duk_push_this(ctx);
Camera* camera = js_to_class_instance<Camera>(ctx, -1, 0);
Ray ray = camera->GetScreenRay(x, y);
duk_push_new_ray(ctx, ray);
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) {
duk_small_int_t fun_idx = duk_get_current_magic(ctx);
duk__two_arg_func fun;
duk_double_t arg1;
duk_double_t arg2;
DUK_ASSERT(fun_idx >= 0);
DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__two_arg_funcs) / sizeof(duk__two_arg_func)));
arg1 = duk_to_number(ctx, 0); /* explicit ordered evaluation to match coercion semantics */
arg2 = duk_to_number(ctx, 1);
fun = duk__two_arg_funcs[fun_idx];
duk_push_number(ctx, (duk_double_t) fun((double) arg1, (double) arg2));
return 1;
}
DUK_LOCAL duk_ret_t duk__math_minmax(duk_context *ctx, duk_double_t initial, duk__two_arg_func min_max) {
duk_idx_t n = duk_get_top(ctx);
duk_idx_t i;
duk_double_t res = initial;
duk_double_t t;
/*
* Note: fmax() does not match the E5 semantics. E5 requires
* that if -any- input to Math.max() is a NaN, the result is a
* NaN. fmax() will return a NaN only if -both- inputs are NaN.
* Same applies to fmin().
*
* Note: every input value must be coerced with ToNumber(), even
* if we know the result will be a NaN anyway: ToNumber() may have
* side effects for which even order of evaluation matters.
*/
for (i = 0; i < n; i++) {
t = duk_to_number(ctx, i);
if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) {
/* Note: not normalized, but duk_push_number() will normalize */
res = (duk_double_t) DUK_DOUBLE_NAN;
} else {
res = (duk_double_t) min_max(res, (double) t);
}
}
duk_push_number(ctx, res);
return 1;
}
/**
* fd, newsize
*/
static int
es_file_ftruncate(duk_context *ctx)
{
es_fd_t *efd = es_fd_get(ctx, 0);
fa_ftruncate(efd->efd_fh, duk_to_number(ctx, 1));
return 0;
}
static int FileSystem_ScanDir(duk_context* ctx)
{
duk_push_this(ctx);
FileSystem* fs = js_to_class_instance<FileSystem>(ctx, -1, 0);
if ( !duk_is_string(ctx, 0) || !duk_is_string(ctx, 1) ||
!duk_is_number(ctx, 2) || !duk_is_boolean(ctx, 3))
{
duk_push_string(ctx, "FileSystem::ScanDir bad args");
duk_throw(ctx);
}
const char* pathName = duk_to_string(ctx, 0);
const char* filter = duk_to_string(ctx, 1);
unsigned flags = duk_to_number(ctx, 2);
bool recursive = duk_to_boolean(ctx, 3) ? true : false;
Vector<String> result;
fs->ScanDir(result, pathName, filter, flags, recursive);
duk_push_array(ctx);
for (unsigned i = 0; i < result.Size(); i++)
{
duk_push_string(ctx, result[i].CString());
duk_put_prop_index(ctx, -2, i);
}
return 1;
}
/**
*
* performance tips
* https://www.ibm.com/developerworks/library/j-jni/
* */
jobject duk_to_java_object(duk_context *ctx, JNIEnv* env, int i){
int type = duk_get_type(ctx, i);
if(type == DUK_TYPE_BOOLEAN){
jboolean value = duk_to_boolean(ctx, i);
DEBUG_LOG("ScriptEngine","invoke_java_method call, convert %d args to boolean %d", i, value);
jmethodID methodID = (*env)->GetMethodID(env, java_boolean_class, "<init>", "(Z)V");
jobject booleanObject = (*env)->NewObject(env, java_boolean_class, methodID, value);
return booleanObject;
}else if(type == DUK_TYPE_NUMBER){
jdouble value = duk_to_number(ctx, i);
jclass doubleClass = (*env)->FindClass(env, "java/lang/Double");
jmethodID methodID = (*env)->GetMethodID(env, doubleClass, "<init>", "(D)V");
jobject numberObject = (*env)->NewObject(env, doubleClass, methodID, value);
(*env)->DeleteLocalRef(env, doubleClass);
DEBUG_LOG("ScriptEngine","invoke_java_method call, convert %d args to number %f", i, value);
return numberObject;
}else if(type == DUK_TYPE_STRING){
const char* chs = duk_to_string(ctx, i);
DEBUG_LOG("ScriptEngine","invoke_java_method call, convert %d args to string %s", i, chs);
return (*env)->NewStringUTF(env, chs);
}else if(type == DUK_TYPE_OBJECT){
if(duk_get_prop_string(ctx, i, JAVA_OBJECT_MARK)){
DEBUG_LOG("ScriptEngine","invoke_java_method call, convert %d args to java object", i);
jobject value = duk_to_pointer(ctx, -1);
duk_pop(ctx);
return (*env)->NewLocalRef(env, value);
}else{
duk_pop(ctx);
if(duk_get_prop_string(ctx, i, JS_REF_MARK)){
DEBUG_LOG("ScriptEngine","reuse javascript object's JSRef");
jweak weakRef = duk_to_pointer(ctx, -1);
jobject jsRefObject = (*env)->NewLocalRef(env, weakRef);
duk_pop(ctx);
if(jsRefObject != NULL){
return jsRefObject;
}
}else{
duk_pop(ctx);
}
duk_dup(ctx, i);
jint ref = duk_js_ref(ctx);
if(ref != 0){
DEBUG_LOG("ScriptEngine","convert javascript object to JSRef Ref Value %d ", ref);
jobject engine = get_engine_from_context(ctx);
DEBUG_LOG("ScriptEngine","convert javascript object to JSRef Ref Value");
jobject jsRefObject = (*env)->NewObject(env, js_ref_class, js_ref_new_method, engine, ref);
jweak jsWeakRef = (*env)->NewWeakGlobalRef(env, jsRefObject);
duk_dup(ctx, i);
duk_push_pointer(ctx, jsWeakRef);
duk_put_prop_string(ctx, -2, JS_REF_MARK);
duk_pop(ctx);
DEBUG_LOG("ScriptEngine","convert javascript object to JSRef Ref Value Success");
return jsRefObject;
}
return NULL;
}
}
DEBUG_LOG("ScriptEngine","invoke_java_method call, unhandled type convert %d args to null %s", i, duk_to_string(ctx, i));
return NULL;
}
static duk_ret_t test_2(duk_context *ctx, void *udata) {
(void) udata;
duk_set_top(ctx, 0);
duk_to_number(ctx, 3);
printf("index 3 OK\n");
return 0;
}
static duk_ret_t test_3(duk_context *ctx, void *udata) {
(void) udata;
duk_set_top(ctx, 0);
duk_to_number(ctx, DUK_INVALID_INDEX);
printf("index DUK_INVALID_INDEX OK\n");
return 0;
}
DUK_LOCAL duk_ret_t duk__construct_from_codepoints(duk_context *ctx, duk_bool_t nonbmp) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_bufwriter_ctx bw_alloc;
duk_bufwriter_ctx *bw;
duk_idx_t i, n;
duk_ucodepoint_t cp;
/* XXX: It would be nice to build the string directly but ToUint16()
* coercion is needed so a generic helper would not be very
* helpful (perhaps coerce the value stack first here and then
* build a string from a duk_tval number sequence in one go?).
*/
n = duk_get_top(ctx);
bw = &bw_alloc;
DUK_BW_INIT_PUSHBUF(thr, bw, n); /* initial estimate for ASCII only codepoints */
for (i = 0; i < n; i++) {
/* XXX: could improve bufwriter handling to write multiple codepoints
* with one ensure call but the relative benefit would be quite small.
*/
if (nonbmp) {
/* ES6 requires that (1) SameValue(cp, ToInteger(cp)) and
* (2) cp >= 0 and cp <= 0x10ffff. This check does not
* implement the steps exactly but the outcome should be
* the same.
*/
duk_int32_t i32 = 0;
if (!duk_is_whole_get_int32(duk_to_number(ctx, i), &i32) ||
i32 < 0 || i32 > 0x10ffffL) {
DUK_DCERROR_RANGE_INVALID_ARGS((duk_hthread *) ctx);
}
cp = (duk_ucodepoint_t) i32;
DUK_ASSERT(cp >= 0 && cp <= 0x10ffffL);
DUK_BW_WRITE_ENSURE_CESU8(thr, bw, cp);
} else {
#if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT)
/* ToUint16() coercion is mandatory in the E5.1 specification, but
* this non-compliant behavior makes more sense because we support
* non-BMP codepoints. Don't use CESU-8 because that'd create
* surrogate pairs.
*/
cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i);
DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp);
#else
cp = (duk_ucodepoint_t) duk_to_uint16(ctx, i);
DUK_ASSERT(cp >= 0 && cp <= 0x10ffffL);
DUK_BW_WRITE_ENSURE_CESU8(thr, bw, cp);
#endif
}
}
DUK_BW_COMPACT(thr, bw);
(void) duk_buffer_to_string(ctx, -1);
return 1;
}
static int duk_disasm(RAsm *a, RAsmOp *op, const ut8 *buf, int len) {
int res = 0, res2 = 0;
const char *opstr = NULL;
ut8 *b = a->cur->user;
duk_push_global_stash (ctx);
duk_dup (ctx, 0); /* timer callback */
duk_get_prop_string (ctx, -2, "disfun");
b = a->cur->user = duk_require_tval (ctx, -1);
// pushBuffer (buf, len);
if (duk_is_callable(ctx, -1)) {
int i;
// duk_push_string (ctx, "TODO 2");
pushBuffer (buf, len);
duk_call (ctx, 1);
// [ size, str ]
for (i = 0; i<3; i++) {
duk_dup_top (ctx);
duk_get_prop_index (ctx, -1, i);
if (duk_is_number (ctx, -1)) {
if (res)
res2 = duk_to_number (ctx, -1);
else
res2 = res = duk_to_number (ctx, -1);
} else if (duk_is_string (ctx, -1)) {
if (!opstr) {
opstr = duk_to_string (ctx, -1);
}
}
duk_pop (ctx);
}
} else {
eprintf ("[:(] Is not a function %02x %02x\n", b[0],b[1]);
}
// fill op struct
op->size = res;
if (!opstr) opstr = "invalid";
strncpy (op->buf_asm, opstr, sizeof (op->buf_asm));
r_hex_bin2str (buf, op->size, op->buf_hex);
return res2;
}
int Get( duk_context * ctx, const int index, const int * )
{
dukbind_assert( duk_is_number( ctx, index ), "No conversion is allowed in Get methods" );
duk_double_t double_result = duk_to_number( ctx, index );
int int_result = static_cast<int>( double_result );
dukbind_assert( double_result == (duk_double_t)int_result, "Number is not a valid integer" );
return int_result;
}
int duk_builtin_date_prototype_set_time(duk_context *ctx) {
double d;
(void) push_this_and_get_timeval(ctx, 0 /*flags*/); /* -> [ timeval this ] */
d = timeclip(duk_to_number(ctx, 0));
duk_push_number(ctx, d);
duk_dup_top(ctx);
duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE); /* -> [ timeval this timeval ] */
return 1;
}
DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) {
duk_small_int_t fun_idx = duk_get_current_magic(ctx);
duk__one_arg_func fun;
duk_double_t arg1;
DUK_ASSERT(fun_idx >= 0);
DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__one_arg_funcs) / sizeof(duk__one_arg_func)));
arg1 = duk_to_number(ctx, 0);
fun = duk__one_arg_funcs[fun_idx];
duk_push_number(ctx, (duk_double_t) fun((double) arg1));
return 1;
}
static duk_ret_t native_adder(duk_context *ctx) {
duk_idx_t i, n;
double res = 0.0;
n = duk_get_top(ctx); /* number of args */
for (i = 0; i < n; i++) {
res += duk_to_number(ctx, i);
}
duk_push_number(ctx, res);
return 1;
}
static int Light_SetShadowCascade(duk_context* ctx)
{
//CascadeParameters(float split1, float split2, float split3, float split4, float fadeStart, float biasAutoAdjust = 1.0f) :
int numargs = duk_get_top(ctx);
float split1;
float split2;
float split3;
float split4;
float fadeStart;
float biasAutoAdjust = 1.0f;
split1 = (float) duk_to_number(ctx, 0);
split2 = (float) duk_to_number(ctx, 1);
split3 = (float) duk_to_number(ctx, 2);
split4 = (float) duk_to_number(ctx, 3);
fadeStart = (float) duk_to_number(ctx, 4);
if (numargs == 6)
biasAutoAdjust = (float) duk_to_number(ctx, 5);
CascadeParameters cparms(split1, split2, split3, split4, fadeStart, biasAutoAdjust);
duk_push_this(ctx);
Light* light = js_to_class_instance<Light>(ctx, -1, 0);
light->SetShadowCascade(cparms);
return 0;
}
float Get( duk_context * ctx, const int index, const float * )
{
dukbind_assert( duk_is_number( ctx, index ), "No conversion is allowed in Get methods" );
duk_double_t double_result = duk_to_number( ctx, index );
float float_result = static_cast<float>( double_result );
#if DUKBIND_NO_FLOAT_CONVERSION
dukbind_assert( double_result == (duk_double_t)float_result, "Number is not a valid integer" );
#endif
return float_result;
}
duk_ret_t duk_bi_number_constructor(duk_context *ctx) {
duk_idx_t nargs;
duk_hobject *h_this;
/*
* The Number constructor uses ToNumber(arg) for number coercion
* (coercing an undefined argument to NaN). However, if the
* argument is not given at all, +0 must be used instead. To do
* this, a vararg function is used.
*/
nargs = duk_get_top(ctx);
if (nargs == 0) {
duk_push_int(ctx, 0);
}
duk_to_number(ctx, 0);
duk_set_top(ctx, 1);
DUK_ASSERT_TOP(ctx, 1);
if (!duk_is_constructor_call(ctx)) {
return 1;
}
/*
* E5 Section 15.7.2.1 requires that the constructed object
* must have the original Number.prototype as its internal
* prototype. However, since Number.prototype is non-writable
* and non-configurable, this doesn't have to be enforced here:
* The default object (bound to 'this') is OK, though we have
* to change its class.
*
* Internal value set to ToNumber(arg) or +0; if no arg given,
* ToNumber(undefined) = NaN, so special treatment is needed
* (above). String internal value is immutable.
*/
/* XXX: helper */
duk_push_this(ctx);
h_this = duk_get_hobject(ctx, -1);
DUK_ASSERT(h_this != NULL);
DUK_HOBJECT_SET_CLASS_NUMBER(h_this, DUK_HOBJECT_CLASS_NUMBER);
DUK_ASSERT(h_this->prototype == ((duk_hthread *) ctx)->builtins[DUK_BIDX_NUMBER_PROTOTYPE]);
DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_this) == DUK_HOBJECT_CLASS_NUMBER);
DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_this));
duk_dup(ctx, 0); /* -> [ val obj val ] */
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
return 0; /* no return value -> don't replace created value */
}
int comResolver(duk_context *ctx) {
int i, hasRetVal ;
const char* meth = 0;
int realArgCount = 0;
int hInst = 0;
int n = duk_get_top(ctx); //padded number of args..not usable for us here..
if(n < 3) return 0; //we require at least 3 args for this function..
if(vbHostResolver==NULL) return 0;
meth = duk_safe_to_string(ctx, 0); //arg0 is obj.method string
realArgCount = duk_to_number(ctx,1); //arg1 is arguments.length
hInst = duk_to_number(ctx,2); //arg2 is this com objects hinst variable if not a top level obj (0 if not)
hasRetVal = vbHostResolver(meth, ctx, realArgCount, hInst);
if(hasRetVal != 0 && hasRetVal != 1){
MessageBox(0,"comresolver","vbdev the hasRetVal must be 0 or 1",0);
hasRetVal = 1;
}
return hasRetVal;
}
int adder(duk_context *ctx) {
int i;
int n = duk_get_top(ctx);
double res = 0.0;
for (i = 0; i < n; i++) {
res += duk_to_number(ctx, i);
}
duk_push_number(ctx, res);
return 1;
}
static duk_ret_t test_1(duk_context *ctx, void *udata) {
duk_idx_t i, n;
(void) udata;
duk_set_top(ctx, 0);
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_true(ctx);
duk_push_false(ctx);
duk_push_int(ctx, 1);
duk_push_number(ctx, -123.456);
duk_push_nan(ctx);
duk_push_number(ctx, INFINITY);
duk_push_string(ctx, "");
duk_push_string(ctx, "foo");
duk_push_string(ctx, "123");
duk_push_string(ctx, "123.456");
duk_push_string(ctx, "123.456e3");
duk_push_string(ctx, " -123.456e+3 ");
duk_push_string(ctx, "NaN");
duk_push_string(ctx, "-Infinity");
duk_push_string(ctx, "+Infinity");
duk_push_string(ctx, "Infinity");
duk_push_string(ctx, "Infinityx");
duk_push_string(ctx, "xInfinity");
duk_push_string(ctx, " Infinity ");
duk_push_object(ctx);
duk_push_thread(ctx);
duk_push_fixed_buffer(ctx, 0); /* coerces like string: ToNumber('') = 0 */
duk_push_fixed_buffer(ctx, 1024); /* coerces like string: ToNumber('\u0000\u0000...') = NaN */
duk_push_dynamic_buffer(ctx, 0);
duk_push_dynamic_buffer(ctx, 1024);
duk_push_pointer(ctx, (void *) NULL);
duk_push_pointer(ctx, (void *) 0xdeadbeefUL);
n = duk_get_top(ctx);
printf("top: %ld\n", (long) n);
for (i = 0; i < n; i++) {
printf("index %ld, number: %lf\n", (long) i, (double) duk_to_number(ctx, i));
}
return 0;
}
int duk_builtin_date_constructor(duk_context *ctx) {
int nargs = duk_get_top(ctx);
int is_cons = duk_is_constructor_call(ctx);
double dparts[NUM_PARTS];
double d;
DUK_DDDPRINT("Date constructor, nargs=%d, is_cons=%d", nargs, is_cons);
duk_push_object_helper(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATE),
DUK_BIDX_DATE_PROTOTYPE);
/* Unlike most built-ins, the internal [[PrimitiveValue]] of a Date
* is mutable.
*/
if (nargs == 0 || !is_cons) {
d = timeclip(GET_NOW_TIMEVAL(ctx));
duk_push_number(ctx, d);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W);
if (!is_cons) {
/* called as a normal function: return new Date().toString() */
duk_to_string(ctx, -1);
}
return 1;
} else if (nargs == 1) {
duk_to_primitive(ctx, 0, DUK_HINT_NONE);
if (duk_is_string(ctx, 0)) {
parse_string(ctx, duk_to_string(ctx, 0));
duk_replace(ctx, 0); /* may be NaN */
}
d = timeclip(duk_to_number(ctx, 0));
duk_push_number(ctx, d);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W);
return 1;
}
set_parts_from_args(ctx, dparts, nargs);
/* Parts are in local time, convert when setting. */
set_this_timeval_from_dparts(ctx, dparts, FLAG_LOCALTIME /*flags*/); /* -> [ ... this timeval ] */
duk_pop(ctx); /* -> [ ... this ] */
return 1;
}
/* Apply ToNumber() to specified index; if ToInteger(val) in [0,99], add
* 1900 and replace value at idx_val.
*/
static void twodigit_year_fixup(duk_context *ctx, int idx_val) {
double d;
/* E5 Sections 15.9.3.1, B.2.4, B.2.5 */
duk_to_number(ctx, idx_val);
if (duk_is_nan(ctx, idx_val)) {
return;
}
duk_dup(ctx, idx_val);
duk_to_int(ctx, -1);
d = duk_get_number(ctx, -1); /* get as double to handle huge numbers correctly */
if (d >= 0.0 && d <= 99.0) {
d += 1900.0;
duk_push_number(ctx, d);
duk_replace(ctx, idx_val);
}
duk_pop(ctx);
}
/* Push 'this' binding, check that it is a Date object; then push the
* internal time value. At the end, stack is: [ ... this timeval ].
* Returns the time value. Local time adjustment is done if requested.
*/
static double push_this_and_get_timeval_tzoffset(duk_context *ctx, int flags, int *out_tzoffset) {
duk_hthread *thr = (duk_hthread *) ctx;
duk_hobject *h;
double d;
int tzoffset = 0;
duk_push_this(ctx);
h = duk_get_hobject(ctx, -1); /* FIXME: getter with class check, useful in built-ins */
if (h == NULL || DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_DATE) {
DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "expected Date");
}
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
d = duk_to_number(ctx, -1);
duk_pop(ctx);
if (DUK_ISNAN(d)) {
if (flags & FLAG_NAN_TO_ZERO) {
d = 0.0;
}
if (flags & FLAG_NAN_TO_RANGE_ERROR) {
DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "Invalid Date");
}
}
/* if no NaN handling flag, may still be NaN here, but not Inf */
DUK_ASSERT(!DUK_ISINF(d));
if (flags & FLAG_LOCALTIME) {
/* Note: DST adjustment is determined using UTC time.
* If 'd' is NaN, tzoffset will be 0.
*/
tzoffset = GET_LOCAL_TZOFFSET(d); /* seconds */
d += tzoffset * 1000;
}
if (out_tzoffset) {
*out_tzoffset = tzoffset;
}
/* [ ... this ] */
return d;
}
static duk_ret_t duk_textri(duk_context* duk)
{
float pt[12];
for (s32 i = 0; i < COUNT_OF(pt); i++)
pt[i] = (float)duk_to_number(duk, i);
tic_mem* memory = (tic_mem*)getDukMachine(duk);
bool use_map = duk_is_null_or_undefined(duk, 12) ? false : duk_to_boolean(duk, 12);
u8 chroma = duk_is_null_or_undefined(duk, 13) ? 0xff : duk_to_int(duk, 13);
memory->api.textri(memory, pt[0], pt[1], // xy 1
pt[2], pt[3], // xy 2
pt[4], pt[5], // xy 3
pt[6], pt[7], // uv 1
pt[8], pt[9], // uv 2
pt[10], pt[11],// uv 3
use_map, // usemap
chroma); // chroma
return 0;
}
/* Set datetime parts from stack arguments, defaulting any missing values.
* Day-of-week is not set; it is not required when setting the time value.
*/
static void set_parts_from_args(duk_context *ctx, double *dparts, int nargs) {
double d;
int i;
int idx;
/* Causes a ToNumber() coercion, but doesn't break coercion order since
* year is coerced first anyway.
*/
twodigit_year_fixup(ctx, 0);
/* There are at most 7 args, but we use 8 here so that also
* IDX_WEEKDAY gets initialized (to zero) to avoid the potential
* for any Valgrind gripes later.
*/
for (i = 0; i < 8; i++) {
/* Note: rely on index ordering */
idx = IDX_YEAR + i;
if (i < nargs) {
d = duk_to_number(ctx, i);
if (idx == IDX_DAY) {
/* Convert day from one-based to zero-based (internal). This may
* cause the day part to be negative, which is OK.
*/
d -= 1.0;
}
} else {
/* All components default to 0 except day-of-month which defaults
* to 1. However, because our internal day-of-month is zero-based,
* it also defaults to zero here.
*/
d = 0.0;
}
dparts[idx] = d;
}
DUK_DDDPRINT("parts from args -> %lf %lf %lf %lf %lf %lf %lf %lf",
dparts[0], dparts[1], dparts[2], dparts[3],
dparts[4], dparts[5], dparts[6], dparts[7]);
}
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;
}
//returns 0 for success, -1 for error
int __stdcall DukOp(int operation, duk_context *ctx, int arg1, char* arg2){
#pragma EXPORT
//these do not require a context..
switch(operation){
case opd_LastString: return mLastString;
case opd_ScriptTimeout:
watchdogTimeout = arg1; return 0;
}
if(ctx == 0) return -1;
switch(operation){
case opd_PushUndef: duk_push_undefined(ctx); return 0;
case opd_PushNum: duk_push_number(ctx,arg1); return 0;
case opd_PushStr: duk_push_string(ctx, arg2); return 0;
case opd_GetInt: return duk_to_number(ctx, arg1);
case opd_IsNullUndef: return (int)duk_is_null_or_undefined(ctx, arg1);
case opd_GetString: return (int)duk_safe_to_string(ctx, arg1);
case opd_Destroy: duk_destroy_heap(ctx); ctx = 0; return 0;
case opd_dbgCoOp: duk_debugger_cooperate(ctx); return 0;
case opd_PushBool: duk_push_boolean(ctx, (arg1==0 ? 0 : 1) ); return 0; //(0==false, 1==true, vbtrue = -1 ok)
case opd_debugAttach:
if(arg1==1){
if(vbDbgReadHandler==0 || vbStdOut==0 || vbDbgWriteHandler==0) return -1;
duk_debugger_attach(ctx, DebugRead, DebugWrite, 0, 0,0, DebugDetached,0);
}
else duk_debugger_detach(ctx);
return 0;
/*case opd_dbgCurLine: return duk_debug_curr_line(ctx); */
case opd_dbgTriggerRead: duk__debug_process_message(ctx); return 0;
}
return -1;
}