Exemple #1
0
static duk_double_t duk__push_this_number_plain(duk_context *ctx) {
	duk_hobject *h;

	/* Number built-in accepts a plain number or a Number object (whose
	 * internal value is operated on).  Other types cause TypeError.
	 */

	duk_push_this(ctx);
	if (duk_is_number(ctx, -1)) {
		DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
		goto done;
	}
	h = duk_get_hobject(ctx, -1);
	if (!h || 
	    (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_NUMBER)) {
		DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, "expected a number");
	}
	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
	DUK_ASSERT(duk_is_number(ctx, -1));
	DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T",
	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
	duk_remove(ctx, -2);

 done:
	return duk_get_number(ctx, -1);
}
static duk_ret_t Line_ToLineSegment_Selector(duk_context* ctx)
{
    int numArgs = duk_get_top(ctx);
    if (numArgs == 2 && duk_is_number(ctx, 0) && duk_is_number(ctx, 1))
        return Line_ToLineSegment_float_float(ctx);
    if (numArgs == 1 && duk_is_number(ctx, 0))
        return Line_ToLineSegment_float(ctx);
    duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
}
static duk_ret_t Line_ClosestPoint_Selector(duk_context* ctx)
{
    int numArgs = duk_get_top(ctx);
    if (numArgs == 3 && GetValueObject<Ray>(ctx, 0, Ray_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_ClosestPoint_Ray_float_float(ctx);
    if (numArgs == 3 && GetValueObject<Line>(ctx, 0, Line_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_ClosestPoint_Line_float_float(ctx);
    if (numArgs == 3 && GetValueObject<LineSegment>(ctx, 0, LineSegment_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_ClosestPoint_LineSegment_float_float(ctx);
    if (numArgs == 3 && GetValueObject<Triangle>(ctx, 0, Triangle_ID) && duk_is_number(ctx, 1) && GetValueObject<float2>(ctx, 2, float2_ID))
        return Line_ClosestPoint_Triangle_float_float2(ctx);
    if (numArgs == 2 && GetValueObject<LineSegment>(ctx, 0, LineSegment_ID) && duk_is_number(ctx, 1))
        return Line_ClosestPoint_LineSegment_float(ctx);
    if (numArgs == 2 && GetValueObject<Triangle>(ctx, 0, Triangle_ID) && duk_is_number(ctx, 1))
        return Line_ClosestPoint_Triangle_float(ctx);
    if (numArgs == 2 && GetValueObject<Line>(ctx, 0, Line_ID) && duk_is_number(ctx, 1))
        return Line_ClosestPoint_Line_float(ctx);
    if (numArgs == 2 && GetValueObject<Ray>(ctx, 0, Ray_ID) && duk_is_number(ctx, 1))
        return Line_ClosestPoint_Ray_float(ctx);
    if (numArgs == 2 && GetValueObject<float3>(ctx, 0, float3_ID) && duk_is_number(ctx, 1))
        return Line_ClosestPoint_float3_float(ctx);
    if (numArgs == 1 && GetValueObject<Triangle>(ctx, 0, Triangle_ID))
        return Line_ClosestPoint_Triangle(ctx);
    if (numArgs == 1 && GetValueObject<float3>(ctx, 0, float3_ID))
        return Line_ClosestPoint_float3(ctx);
    if (numArgs == 1 && GetValueObject<Line>(ctx, 0, Line_ID))
        return Line_ClosestPoint_Line(ctx);
    if (numArgs == 1 && GetValueObject<LineSegment>(ctx, 0, LineSegment_ID))
        return Line_ClosestPoint_LineSegment(ctx);
    if (numArgs == 1 && GetValueObject<Ray>(ctx, 0, Ray_ID))
        return Line_ClosestPoint_Ray(ctx);
    duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
}
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;
}
Exemple #5
0
static duk_ret_t dukzip_zip_newfile(duk_context *ctx) {
	zip_fileinfo zi = {0};
	int res = ZIP_OK;
	zipFile archive = dukzip_zip_from_this(ctx);
	
	const char *filename = "";
	duk_int_t level = Z_DEFAULT_COMPRESSION;
	duk_int_t method = Z_DEFLATED;
	const char *comment = "";


	if (duk_is_object(ctx, 0)) {
		dukzip_zip_checkoptions(ctx, 0, &filename, &level, &method, &comment);
	} else {
		filename = duk_require_string(ctx, 0);

		if (duk_is_number(ctx, 1)) {
			level = duk_get_int(ctx, 1);
		}
	}

	res = zipOpenNewFileInZip64(archive, filename, &zi, NULL, 0, NULL, 0, comment, method, level, 1);

	if (res == ZIP_OK) {
		duk_push_true(ctx);
	} else {
		duk_push_false(ctx);
	}
	return 1;
}
static duk_ret_t nsp_texture_constructor(duk_context *ctx) {
    int width = duk_require_int(ctx, 0);
    int height = duk_require_int(ctx, 1);
    if (width < 1 || height < 1) {
	duk_push_error_object(ctx, DUK_ERR_RANGE_ERROR, "Width and height must be positive");
	duk_throw(ctx);
    }
    bool has_transparency;
    uint16_t transparent_color;
    if ((has_transparency = duk_is_number(ctx, 2))) {
	transparent_color = (uint16_t)duk_get_int(ctx, 2);
    }
    duk_push_this(ctx);
    duk_push_fixed_buffer(ctx, width * height * 2);
    duk_put_prop_string(ctx, -2, "bitmap");
    duk_push_int(ctx, width);
    duk_put_prop_string(ctx, -2, "width");
    duk_push_int(ctx, height);
    duk_put_prop_string(ctx, -2, "height");
    if (has_transparency) {
	duk_push_int(ctx, transparent_color);
    } else {
	duk_push_null(ctx);
    }
    duk_put_prop_string(ctx, -2, "transparentColor");
    return 0;
}
static duk_ret_t Line_Intersects_Selector(duk_context* ctx)
{
    int numArgs = duk_get_top(ctx);
    if (numArgs == 3 && GetValueObject<OBB>(ctx, 0, OBB_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_Intersects_OBB_float_float(ctx);
    if (numArgs == 3 && GetValueObject<AABB>(ctx, 0, AABB_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_Intersects_AABB_float_float(ctx);
    if (numArgs == 1 && GetValueObject<Capsule>(ctx, 0, Capsule_ID))
        return Line_Intersects_Capsule(ctx);
    if (numArgs == 1 && GetValueObject<Frustum>(ctx, 0, Frustum_ID))
        return Line_Intersects_Frustum(ctx);
    if (numArgs == 1 && GetValueObject<AABB>(ctx, 0, AABB_ID))
        return Line_Intersects_AABB(ctx);
    if (numArgs == 1 && GetValueObject<OBB>(ctx, 0, OBB_ID))
        return Line_Intersects_OBB(ctx);
    duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
}
static duk_ret_t Line_Distance_Selector(duk_context* ctx)
{
    int numArgs = duk_get_top(ctx);
    if (numArgs == 3 && GetValueObject<Line>(ctx, 0, Line_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_Distance_Line_float_float(ctx);
    if (numArgs == 3 && GetValueObject<LineSegment>(ctx, 0, LineSegment_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_Distance_LineSegment_float_float(ctx);
    if (numArgs == 3 && GetValueObject<Ray>(ctx, 0, Ray_ID) && duk_is_number(ctx, 1) && duk_is_number(ctx, 2))
        return Line_Distance_Ray_float_float(ctx);
    if (numArgs == 2 && GetValueObject<LineSegment>(ctx, 0, LineSegment_ID) && duk_is_number(ctx, 1))
        return Line_Distance_LineSegment_float(ctx);
    if (numArgs == 2 && GetValueObject<Line>(ctx, 0, Line_ID) && duk_is_number(ctx, 1))
        return Line_Distance_Line_float(ctx);
    if (numArgs == 2 && GetValueObject<float3>(ctx, 0, float3_ID) && duk_is_number(ctx, 1))
        return Line_Distance_float3_float(ctx);
    if (numArgs == 2 && GetValueObject<Ray>(ctx, 0, Ray_ID) && duk_is_number(ctx, 1))
        return Line_Distance_Ray_float(ctx);
    if (numArgs == 1 && GetValueObject<Sphere>(ctx, 0, Sphere_ID))
        return Line_Distance_Sphere(ctx);
    if (numArgs == 1 && GetValueObject<Capsule>(ctx, 0, Capsule_ID))
        return Line_Distance_Capsule(ctx);
    if (numArgs == 1 && GetValueObject<Line>(ctx, 0, Line_ID))
        return Line_Distance_Line(ctx);
    if (numArgs == 1 && GetValueObject<Ray>(ctx, 0, Ray_ID))
        return Line_Distance_Ray(ctx);
    if (numArgs == 1 && GetValueObject<LineSegment>(ctx, 0, LineSegment_ID))
        return Line_Distance_LineSegment(ctx);
    if (numArgs == 1 && GetValueObject<float3>(ctx, 0, float3_ID))
        return Line_Distance_float3(ctx);
    duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
}
Exemple #9
0
    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;
    }
static duk_ret_t EntityReference_Ctor_Selector(duk_context* ctx)
{
    int numArgs = duk_get_top(ctx);
    if (numArgs == 1 && duk_is_number(ctx, 0))
        return EntityReference_Ctor_entity_id_t(ctx);
    if (numArgs == 1 && duk_is_string(ctx, 0))
        return EntityReference_Ctor_String(ctx);
    if (numArgs == 0)
        return EntityReference_Ctor(ctx);
    duk_error(ctx, DUK_ERR_ERROR, "Could not select function overload");
}
Exemple #11
0
static int NativePinSetTrigger(duk_context* ctx)
{
    uint32_t debounce = 0;
    AJS_IO_PinTriggerCondition condition = (AJS_IO_PinTriggerCondition)duk_require_int(ctx, 0);
    if (condition & AJS_IO_PIN_TRIGGER_ON_BOTH) {
        if (duk_is_number(ctx, 2)) {
            debounce = duk_get_int(ctx, 2);
            debounce = min(255, debounce);
        }
    }
    return SetTriggerCallback(ctx, AJS_IO_FUNCTION_DIGITAL_IN, debounce);
}
Exemple #12
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;
    }
gboolean
_gum_duk_parse_bytes (duk_context * ctx,
                      duk_idx_t index,
                      GBytes ** bytes)
{
  gpointer data;
  duk_size_t size;

  data = duk_get_buffer_data (ctx, index, &size);
  if (data != NULL)
  {
    *bytes = g_bytes_new (data, size);
    return TRUE;
  }
  else if (duk_is_array (ctx, index))
  {
    duk_size_t i;

    duk_get_prop_string (ctx, index, "length");
    size = duk_get_uint (ctx, -1);
    duk_pop (ctx);

    if (size >= GUM_MAX_JS_BYTE_ARRAY_LENGTH)
      return FALSE;

    data = g_malloc (size);

    for (i = 0; i != size; i++)
    {
      duk_get_prop_index (ctx, index, (duk_uarridx_t) i);
      ((guint8 *) data)[i] = duk_get_uint (ctx, -1) & 0xff;
      duk_pop (ctx);
    }

    *bytes = g_bytes_new_take (data, size);
    return TRUE;
  }
  else if (duk_is_null_or_undefined (ctx, index) ||
      duk_is_boolean (ctx, index) ||
      duk_is_number (ctx, index) ||
      duk_is_nan (ctx, index) ||
      duk_is_string (ctx, index) ||
      duk_is_function (ctx, index))
  {
    return FALSE;
  }

  *bytes = g_bytes_new (NULL, 0);
  return TRUE;
}
Exemple #14
0
static int
es_sqlite_query(duk_context *ctx)
{
    int argc = duk_get_top(ctx);
    if(argc < 2)
        return DUK_RET_TYPE_ERROR;

    es_sqlite_t *es = es_resource_get(ctx, 0, &es_resource_sqlite);
    const char *query = duk_safe_to_string(ctx, 1);

    if(es->es_stmt) {
        sqlite3_finalize(es->es_stmt);
        es->es_stmt = NULL;
    }

    int rc = db_prepare(es->es_db, &es->es_stmt, query);

    if(rc != SQLITE_OK) {

        if(es->es_transaction && rc == SQLITE_LOCKED)
            duk_error(ctx, ST_ERROR_SQLITE_BASE | rc , "Deadlock");

        duk_error(ctx, ST_ERROR_SQLITE_BASE | rc,
                  "Sqlite error 0x%x -- %s",
                  rc, sqlite3_errmsg(es->es_db));
    }

    sqlite3_stmt *stmt = es->es_stmt;

    for(int i = 2; i < argc; i++) {
        int sqlite_arg = i - 1;

        if(duk_is_null_or_undefined(ctx, i)) {
            sqlite3_bind_null(stmt, sqlite_arg);
        } else if(duk_is_number(ctx, i)) {
            sqlite3_bind_double(stmt, sqlite_arg, duk_get_number(ctx, i));
        } else if(duk_is_boolean(ctx, i)) {
            sqlite3_bind_int(stmt, sqlite_arg, duk_get_boolean(ctx, i));
        } else {
            sqlite3_bind_text(stmt, sqlite_arg, duk_safe_to_string(ctx, i),
                              -1, SQLITE_STATIC);
        }
    }

    es_sqlite_stmt_step(ctx, es);
    return 0;
}
gboolean
_gum_duk_get_uint (duk_context * ctx,
                   duk_idx_t index,
                   guint * u)
{
  duk_double_t number;

  if (!duk_is_number (ctx, index))
    return FALSE;

  number = duk_require_number (ctx, index);
  if (number < 0)
    return FALSE;

  *u = (guint) number;
  return TRUE;
}
gboolean
_gum_duk_get_uint64 (duk_context * ctx,
                     duk_idx_t index,
                     GumDukCore * core,
                     guint64 * u)
{
  if (duk_is_pointer (ctx, index))
  {
    *u = *((const guint64 *) duk_require_pointer (ctx, index));
    return TRUE;
  }
  else if (duk_is_number (ctx, index))
  {
    duk_double_t number;

    number = duk_require_number (ctx, index);
    if (number < 0)
      return FALSE;

    *u = (guint64) number;
    return TRUE;
  }
  else
  {
    gboolean success = FALSE;

    duk_dup (ctx, index);
    duk_push_heapptr (ctx, core->uint64);

    if (duk_instanceof (ctx, -2, -1))
    {
      GumDukUInt64 * object;

      object = _gum_duk_require_data (ctx, -2);

      *u = object->value;
      success = TRUE;
    }

    duk_pop_2 (ctx);

    return success;
  }
}
Exemple #17
0
static void dukzip_zip_checkoptions(duk_context *ctx, duk_idx_t idx, const char **filename, duk_int_t *level, duk_int_t *method, const char **comment) 
{
	duk_get_prop_string(ctx, idx, "filename");
	if (duk_is_string(ctx, -1)) {
		*filename = duk_get_string(ctx, -1);
		duk_pop(ctx);
	} else {
		duk_pop(ctx);
	}

	duk_get_prop_string(ctx, idx, "level");
	if (duk_is_number(ctx, -1)) {
		*level = duk_get_int(ctx, -1);
		duk_pop(ctx);
	} else {
		duk_pop(ctx);
	}

	duk_get_prop_string(ctx, idx, "method");
	if (duk_is_string(ctx, -1)) {
		duk_push_string(ctx, "deflate");
		if (duk_equals(ctx, -1, -2)) {
			*method = Z_DEFLATED;
		} else {
			duk_pop(ctx);
			duk_push_string(ctx, "store");
			if (duk_equals(ctx, -1, -2)) {
				*method = 0;
			}
		}
		duk_pop_2(ctx);
	} else {
		duk_pop(ctx);
	}

	duk_get_prop_string(ctx, idx, "comment");
	if (duk_is_string(ctx, -1)) {
		*comment = duk_get_string(ctx, -1);
		duk_pop(ctx);
	} else {
		duk_pop(ctx);
	}
}
Exemple #18
0
/*
 * Configures a pin as a digital output pin
 */
static int NativeIoDigitalOut(duk_context* ctx)
{
    AJ_Status status;
    int idx;
    void* pinCtx;
    uint32_t pin = GetPinId(ctx, 0, AJS_IO_FUNCTION_DIGITAL_OUT);

    /*
     * Target specific I/O pin initialization
     */
    status = AJS_TargetIO_PinOpen(pin, AJS_IO_PIN_OUTPUT, &pinCtx);
    if (status != AJ_OK) {
        duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "Failed to configure digital output pin: %s", AJ_StatusText(status));
    }
    idx = NewIOObject(ctx, pinCtx, AJS_IO_FUNCTION_DIGITAL_OUT, NativePinFinalizer);
    /*
     * Functions to set/get the pin level
     */
    AJS_SetPropertyAccessors(ctx, idx, "level", NativeLevelSetter, NativeLevelGetter);
    /*
     * Check for and set initial value
     */
    if (duk_is_number(ctx, 1)) {
        duk_dup(ctx, 1);
        duk_put_prop_string(ctx, idx, "level");
    }
    /*
     * Toggle function
     */
    duk_push_c_lightfunc(ctx, NativeTogglePin, 0, 0, 0);
    duk_put_prop_string(ctx, idx, "toggle");
    /*
     * Only allow if the PWM functions is supported
     */
    if (AJS_TargetIO_GetInfo(pin)->functions & AJS_IO_FUNCTION_PWM) {
        duk_push_c_lightfunc(ctx, NativePWM, 2, 0, 0);
        duk_put_prop_string(ctx, idx, "pwm");
    }
    /*
     * Return the digital output pin object
     */
    return 1;
}
Exemple #19
0
int my_adder(duk_context *ctx) {
	int i, n;
	double res = 0.0;

	duk_push_this(ctx);
	printf("this binding: '%s'\n", duk_to_string(ctx, -1));
	duk_pop(ctx);

	n = duk_get_top(ctx);
	for (i = 0; i < n; i++) {
		if (!duk_is_number(ctx, i)) {
			duk_error(ctx, DUK_ERR_TYPE_ERROR, "argument %d is not a number", i);
		}
		res += duk_get_number(ctx, i);
	}

	duk_push_number(ctx, res);
	return 1;
}
gboolean
_gum_duk_parse_pointer (duk_context * ctx,
                        duk_idx_t index,
                        GumDukCore * core,
                        gpointer * ptr)
{
  if (duk_is_string (ctx, index))
  {
    const gchar * ptr_as_string, * end;
    gboolean valid;

    ptr_as_string = duk_require_string (ctx, index);

    if (g_str_has_prefix (ptr_as_string, "0x"))
    {
      *ptr = GSIZE_TO_POINTER (
          g_ascii_strtoull (ptr_as_string + 2, (gchar **) &end, 16));
      valid = end != ptr_as_string + 2;
    }
    else
    {
      *ptr = GSIZE_TO_POINTER (
          g_ascii_strtoull (ptr_as_string, (gchar **) &end, 10));
      valid = end != ptr_as_string;
    }

    return valid;
  }
  else if (duk_is_number (ctx, index))
  {
    duk_double_t number;

    number = duk_require_number (ctx, index);
    if (number < 0)
      return FALSE;

    *ptr = GSIZE_TO_POINTER ((gsize) number);
    return TRUE;
  }

  return _gum_duk_get_pointer (ctx, index, core, ptr);
}
Exemple #21
0
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;
}
Exemple #22
0
static int
es_htsmsg_get_value_duk(duk_context *ctx)
{
  htsmsg_t *m = es_get_native_obj(ctx, 0, &es_native_htsmsg);
  htsmsg_field_t *f;
  int want_attr = 0;

  if(duk_is_number(ctx, 1)) {
    int i = duk_require_int(ctx, 1);

    HTSMSG_FOREACH(f, m) {
      if(f->hmf_flags & HMF_XML_ATTRIBUTE)
        continue;
      if(!i--)
        break;
    }

    if(f == NULL)
      return 0;

  } else {
Exemple #23
0
/*
 * 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;
}
Exemple #24
0
static duk_ret_t
js_ByteArray_getProp(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);
		duk_push_uint(ctx, get_byte(array, index));
		return 1;
	}
	else {
		duk_dup(ctx, 1);
		duk_get_prop(ctx, 0);
		return 1;
	}
}
Exemple #25
0
Fichier : io.c Projet : saghul/sjs
/*
 * Read data from a file. Args:
 * - 0: FILE
 * - 1: nread (a number or a Buffer-ish object)
 */
static duk_ret_t io_fread(duk_context* ctx) {
    FILE* f;
    size_t nread, r;
    char* buf;
    int create_buf = 0;

    f = duk_require_pointer(ctx, 0);
    if (duk_is_number(ctx, 1)) {
        nread = duk_require_int(ctx, 1);
        buf = duk_push_dynamic_buffer(ctx, nread);
        create_buf = 1;
    } else {
        buf = duk_require_buffer_data(ctx, 1, &nread);
        if (buf == NULL || nread == 0) {
            duk_error(ctx, DUK_ERR_TYPE_ERROR, "invalid buffer");
            return -42;    /* control never returns here */
        }
    }

    r = fread(buf, 1, nread, f);
    if (ferror(f)) {
        if (create_buf) {
            duk_pop(ctx);
        }
        clearerr(f);
        SJS_THROW_ERRNO_ERROR2(EIO);
        return -42;    /* control never returns here */
    }

    if (create_buf) {
        /* return the string we read */
        duk_resize_buffer(ctx, -1, r);
    } else {
        /* the data was written to the buffer, return how much we read */
        duk_push_int(ctx, r);
    }

    return 1;
}
Exemple #26
0
Fichier : io.c Projet : saghul/sjs
/*
 * Read a line from a file. Args:
 * - 0: FILE
 * - 1: nread (a number or a Buffer-ish object)
 */
static duk_ret_t io_fgets(duk_context* ctx) {
    FILE* f;
    size_t nread;
    char* r;
    char* buf;
    char* alloc_buf = NULL;

    f = duk_require_pointer(ctx, 0);
    if (duk_is_number(ctx, 1)) {
        nread = duk_require_int(ctx, 1);
        alloc_buf = malloc(nread);
        if (!alloc_buf) {
            SJS_THROW_ERRNO_ERROR2(ENOMEM);
            return -42;    /* control never returns here */
        }
        buf = alloc_buf;
    } else {
        buf = duk_require_buffer_data(ctx, 1, &nread);
        if (buf == NULL || nread == 0) {
            duk_error(ctx, DUK_ERR_TYPE_ERROR, "invalid buffer");
            return -42;    /* control never returns here */
        }
    }

    r = fgets(buf, nread, f);
    if (r == NULL) {
        duk_push_string(ctx, "");
    } else {
        if (alloc_buf) {
            /* return the string we read */
            duk_push_string(ctx, r);
        } else {
            /* the data was written to the buffer, return how much we read */
            duk_push_int(ctx, strlen(r));
        }
    }
    free(alloc_buf);
    return 1;
}
Exemple #27
0
DUK_INTERNAL duk_ret_t duk_bi_array_constructor(duk_context *ctx) {
	duk_idx_t nargs;
	duk_double_t d;
	duk_uint32_t len;
	duk_idx_t i;

	nargs = duk_get_top(ctx);
	duk_push_array(ctx);

	if (nargs == 1 && duk_is_number(ctx, 0)) {
		/* XXX: expensive check (also shared elsewhere - so add a shared internal API call?) */
		d = duk_get_number(ctx, 0);
		len = duk_to_uint32(ctx, 0);
		if (((duk_double_t) len) != d) {
			return DUK_RET_RANGE_ERROR;
		}

		/* XXX: if 'len' is low, may want to ensure array part is kept:
		 * the caller is likely to want a dense array.
		 */
		duk_push_u32(ctx, len);
		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);  /* [ ToUint32(len) array ToUint32(len) ] -> [ ToUint32(len) array ] */
		return 1;
	}

	/* XXX: optimize by creating array into correct size directly, and
	 * operating on the array part directly; values can be memcpy()'d from
	 * value stack directly as long as refcounts are increased.
	 */
	for (i = 0; i < nargs; i++) {
		duk_dup(ctx, i);
		duk_xdef_prop_index_wec(ctx, -2, (duk_uarridx_t) i);
	}

	duk_push_u32(ctx, (duk_uint32_t) nargs);
	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
	return 1;
}
gboolean
_gum_duk_get_int64 (duk_context * ctx,
                    duk_idx_t index,
                    GumDukCore * core,
                    gint64 * i)
{
  if (duk_is_pointer (ctx, index))
  {
    *i = *((const gint64 *) duk_require_pointer (ctx, index));
    return TRUE;
  }
  else if (duk_is_number (ctx, index))
  {
    *i = (gint64) duk_require_number (ctx, index);
    return TRUE;
  }
  else
  {
    gboolean success = FALSE;

    duk_dup (ctx, index);
    duk_push_heapptr (ctx, core->int64);

    if (duk_instanceof (ctx, -2, -1))
    {
      GumDukInt64 * object;

      object = _gum_duk_require_data (ctx, -2);

      *i = object->value;
      success = TRUE;
    }

    duk_pop_2 (ctx);

    return success;
  }
}
Exemple #29
0
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;
}
guint
_gum_duk_require_index (duk_context * ctx,
                        duk_idx_t index)
{
  if (duk_is_number (ctx, index))
  {
    guint value;

    if (_gum_duk_get_uint (ctx, index, &value))
    {
      return value;
    }
    else
    {
      _gum_duk_throw (ctx, "invalid index");
      return 0; /* unreachable */
    }
  }
  else
  {
    const gchar * str;
    gchar * endptr;
    glong value;
    gboolean valid;

    str = duk_require_string (ctx, index);

    value = strtol (str, &endptr, 10);

    valid = *str != '\0' && *endptr == '\0' && value >= 0;
    if (!valid)
      _gum_duk_throw (ctx, "invalid index");

    return value;
  }
}