static duk_ret_t dukky_html_table_cell_element_noWrap_setter(duk_context *ctx)
{
/* Get private data for method */
html_table_cell_element_private_t *priv = NULL;
duk_push_this(ctx);
duk_get_prop_string(ctx, -1, dukky_magic_string_private);
priv = duk_get_pointer(ctx, -1);
duk_pop_2(ctx);
if (priv == NULL) {
return 0; /* can do? No can do. */
}
#line 32 "HTMLTableCellElement.bnd"
dom_exception exc;
bool b;
b = duk_get_boolean(ctx, 0);
exc = dom_html_table_cell_element_set_no_wrap((struct dom_html_table_cell_element *)((node_private_t*)priv)->node, b);
if (exc != DOM_NO_ERR) {
return 0;
}
return 0;
}
static int
es_faprovider_statRespond(duk_context *ctx)
{
es_fa_handle_t *fah = es_get_native_obj(ctx, 0, &es_native_fah);
if(duk_get_boolean(ctx, 1)) {
hts_mutex_lock(&es_fa_mutex);
if(fah->fah_status == ES_FA_WORKING) {
fah->fah_status = ES_FA_OK;
fah->fah_return_value = 0;
fah->fah_size = duk_get_number(ctx, 2);
fah->fah_type = CONTENT_FILE;
const char *type = duk_get_string(ctx, 3);
if(type) {
if(!strcmp(type, "dir"))
fah->fah_type = CONTENT_DIR;
}
fah->fah_mtime = duk_get_number(ctx, 4);
hts_cond_broadcast(&es_fa_cond);
}
hts_mutex_unlock(&es_fa_mutex);
} else {
fah_fail(fah, ctx);
}
return 0;
}
bool StyleContext::evalFilter(FunctionID _id) const {
if (!duk_get_global_string(m_ctx, FUNC_ID)) {
logMsg("Error: evalFilterFn - functions not initialized\n");
return false;
}
if (!duk_get_prop_index(m_ctx, -1, _id)) {
logMsg("Error: evalFilterFn - function %d not set\n", _id);
}
if (duk_pcall(m_ctx, 0) != 0) {
logMsg("Error: evalFilterFn: %s\n", duk_safe_to_string(m_ctx, -1));
}
bool result = false;
if (duk_is_boolean(m_ctx, -1)) {
result = duk_get_boolean(m_ctx, -1);
}
// pop result
duk_pop(m_ctx);
// pop fns obj
duk_pop(m_ctx);
DUMP("evalFilterFn\n");
return result;
}
static int
es_gumbo_node_childs(duk_context *ctx)
{
es_gumbo_node_t *egn = es_get_native_obj(ctx, 0, &es_native_gumbo_node);
int all = duk_get_boolean(ctx, 1);
const GumboNode *node = egn->node;
duk_push_array(ctx);
if(node->type == GUMBO_NODE_ELEMENT || node->type == GUMBO_NODE_TEMPLATE) {
const GumboElement *e = &node->v.element;
int num = 0;
for(int i = 0; i < e->children.length; i++) {
GumboNode *child = e->children.data[i];
if(child->type == GUMBO_NODE_WHITESPACE)
continue;
if(!all) {
if(child->type == GUMBO_NODE_TEXT ||
child->type == GUMBO_NODE_CDATA ||
child->type == GUMBO_NODE_COMMENT)
continue;
}
push_gumbo_node(ctx, child, egn->output);
duk_put_prop_index(ctx, -2, num++);
}
}
return 1;
}
static int NativeIoSpi(duk_context* ctx)
{
uint32_t mosi, miso, cs, clk, clock;
uint8_t master;
uint8_t cpol, cpha, data;
void* spiCtx;
AJ_Status status;
int idx;
mosi = GetPinId(ctx, 0, AJS_IO_FUNCTION_SPI_MOSI);
miso = GetPinId(ctx, 1, AJS_IO_FUNCTION_SPI_MISO);
cs = GetPinId(ctx, 2, AJS_IO_FUNCTION_SPI_SS);
clk = GetPinId(ctx, 3, AJS_IO_FUNCTION_SPI_SCK);
duk_get_prop_string(ctx, 4, "clock");
clock = duk_require_int(ctx, -1);
duk_get_prop_string(ctx, 4, "master");
if (duk_get_boolean(ctx, -1)) {
master = TRUE;
} else {
master = FALSE;
}
duk_get_prop_string(ctx, 4, "cpol");
cpol = duk_require_int(ctx, -1);
duk_get_prop_string(ctx, 4, "cpha");
cpha = duk_require_int(ctx, -1);
duk_get_prop_string(ctx, 4, "data");
data = duk_require_int(ctx, -1);
duk_pop(ctx);
// Clock polarity must be high (1) or low (0)
if (cpol != 0 && cpol != 1) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "cpol must be 0 or 1; you gave %u", cpol);
}
// Clock edge phase must be one edge (0) or two edge (1)
if (cpha != 0 && cpha != 1) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "cpha must be 0 or 1; you gave %u", cpha);
}
// Data bits must be 8, 16, or 32
if (data != 8 && data != 16 && data != 32) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "data bits must be 8, 16 or 32; you gave %u", data);
}
status = AJS_TargetIO_SpiOpen(mosi, miso, cs, clk, clock, master, cpol, cpha, data, &spiCtx);
if (status != AJ_OK) {
duk_error(ctx, DUK_ERR_INTERNAL_ERROR, "Failed to open SPI device");
}
idx = NewIOObject(ctx, spiCtx, AJS_IO_FUNCTION_SPI, NativeSpiFinalizer);
duk_push_c_lightfunc(ctx, NativeSpiRead, 1, 0, 0);
duk_put_prop_string(ctx, idx, "read");
duk_push_c_lightfunc(ctx, NativeSpiWrite, 1, 0, 0);
duk_put_prop_string(ctx, idx, "write");
return 1;
}
static void print_top(duk_context *ctx) {
duk_size_t clen = 0;
if (duk_is_string(ctx, -1)) {
clen = duk_get_length(ctx, -1);
}
printf("top=%ld type=%ld bool=%d num=%.6lf clen=%ld str='%s' str-is-NULL=%d ptr-is-NULL=%d\n",
(long) duk_get_top(ctx), (long) duk_get_type(ctx, -1), (int) duk_get_boolean(ctx, -1),
(double) duk_get_number(ctx, -1), (long) clen, duk_get_string(ctx, -1),
(duk_get_string(ctx, -1) ? 0 : 1),
(duk_get_pointer(ctx, -1) ? 0 : 1));
}
void test(duk_context *ctx) {
duk_idx_t i, n;
duk_push_undefined(ctx);
duk_push_null(ctx);
duk_push_boolean(ctx, 0);
duk_push_boolean(ctx, 123);
duk_push_number(ctx, 234);
duk_push_string(ctx, "foo");
duk_push_object(ctx);
duk_push_array(ctx);
duk_push_c_function(ctx, my_c_func, DUK_VARARGS);
duk_push_fixed_buffer(ctx, 1024);
duk_push_dynamic_buffer(ctx, 1024);
duk_push_pointer(ctx, (void *) 0xdeadbeefUL);
n = duk_get_top(ctx);
for (i = 0; i < n + 1; i++) { /* end on invalid index on purpose */
duk_int_t typeval, typemask;
typeval = duk_get_type(ctx, i);
typemask = duk_get_type_mask(ctx, i);
printf("stack[%ld] --> type=%ld mask=0x%08lx ",
(long) i, (long) typeval, (long) typemask);
switch(duk_get_type(ctx, i)) {
case DUK_TYPE_NONE: printf("none"); break;
case DUK_TYPE_UNDEFINED: printf("undefined"); break;
case DUK_TYPE_NULL: printf("null"); break;
case DUK_TYPE_BOOLEAN: printf("boolean"); break;
case DUK_TYPE_NUMBER: printf("number"); break;
case DUK_TYPE_STRING: printf("string"); break;
case DUK_TYPE_OBJECT: printf("object"); break;
case DUK_TYPE_BUFFER: printf("buffer"); break;
case DUK_TYPE_POINTER: printf("pointer"); break;
default: printf("unknown(%d)", (int) duk_get_type(ctx, i)); break;
}
printf(" bool=%d num=%lf str=%s buf-is-null=%d ptr=%p",
(int) duk_get_boolean(ctx, i),
(double) duk_get_number(ctx, i),
duk_get_string(ctx, i),
(duk_get_buffer(ctx, i, NULL) == NULL ? 1 : 0),
duk_get_pointer(ctx, i));
printf(" isobj=%d isarr=%d isfunc=%d",
(int) duk_is_object(ctx, i),
(int) duk_is_array(ctx, i),
(int) duk_is_function(ctx, i));
printf("\n");
}
}
static int
es_faprovider_openRespond(duk_context *ctx)
{
es_fa_handle_t *fah = es_get_native_obj(ctx, 0, &es_native_fah);
if(duk_get_boolean(ctx, 1)) {
es_root_register(ctx, 2, fah);
fah_ok(fah);
} else {
fah_fail(fah, ctx);
}
return 0;
}
/*
* Serializes various data types into a buffer. Leaves the buffer on the top of the stack.
*/
static uint8_t* SerializeToBuffer(duk_context* ctx, duk_idx_t idx, duk_size_t* sz)
{
uint8_t* ptr;
switch (duk_get_type(ctx, idx)) {
case DUK_TYPE_BUFFER:
duk_dup(ctx, idx);
ptr = duk_get_buffer(ctx, -1, sz);
break;
case DUK_TYPE_BOOLEAN:
ptr = duk_push_fixed_buffer(ctx, 1);
ptr[0] = duk_get_boolean(ctx, idx);
*sz = 1;
break;
case DUK_TYPE_NUMBER:
ptr = duk_push_fixed_buffer(ctx, 1);
ptr[0] = duk_get_int(ctx, idx);
*sz = 1;
break;
case DUK_TYPE_STRING:
duk_dup(ctx, idx);
ptr = duk_to_fixed_buffer(ctx, -1, sz);
break;
case DUK_TYPE_OBJECT:
if (duk_is_array(ctx, idx)) {
duk_idx_t i;
duk_idx_t len = duk_get_length(ctx, idx);
ptr = duk_push_fixed_buffer(ctx, len);
for (i = 0; i < len; ++i) {
duk_get_prop_index(ctx, idx, i);
ptr[i] = duk_require_uint(ctx, -1);
duk_pop(ctx);
}
*sz = len;
} else {
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Can only serialize arrays of numbers");
}
break;
default:
duk_error(ctx, DUK_ERR_TYPE_ERROR, "Cannot serialize");
break;
}
return ptr;
}
bool StyleContext::evalFilter(FunctionID _id) {
bool result = false;
if (!evalFunction(_id)) { return false; };
// check for evaluated value sitting at value stack top
if (duk_is_boolean(m_ctx, -1)) {
result = duk_get_boolean(m_ctx, -1);
}
// pop result
duk_pop(m_ctx);
return result;
}
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;
}
void CallDisconnectSignal(duk_context* ctx, void* signal)
{
int numArgs = duk_get_top(ctx);
duk_push_number(ctx, (size_t)signal);
duk_insert(ctx, 0);
duk_push_global_object(ctx);
duk_get_prop_string(ctx, -1, "_DisconnectSignal");
duk_remove(ctx, -2); // Global object
duk_insert(ctx, 0);
duk_pcall(ctx, numArgs + 1);
if (duk_get_boolean(ctx, -1)) // Last receiver disconnected
{
HashMap<void*, SharedPtr<SignalReceiver> >& signalReceivers = JavaScriptInstance::InstanceFromContext(ctx)->SignalReceivers();
signalReceivers.Erase(signal);
}
duk_pop(ctx); // Result
}
AJ_Status AJS_HandleAcceptSession(duk_context* ctx, AJ_Message* msg, uint16_t port, uint32_t sessionId, const char* joiner)
{
uint32_t accept = TRUE;
SessionInfo* sessionInfo;
/*
* Create an entry in the sessions table so we can track this peer
*/
AJS_GetGlobalStashObject(ctx, "sessions");
sessionInfo = AllocSessionObject(ctx, joiner);
/*
* If there is no handler automatically accept the connection
*/
AJS_GetAllJoynProperty(ctx, "onPeerConnected");
if (duk_is_callable(ctx, -1)) {
/* Empty interface array */
duk_push_array(ctx);
AddServiceObject(ctx, sessionInfo, "/", joiner);
if (AJS_DebuggerIsAttached()) {
msg = AJS_CloneAndCloseMessage(ctx, msg);
}
if (duk_pcall(ctx, 1) != DUK_EXEC_SUCCESS) {
AJS_ConsoleSignalError(ctx);
accept = FALSE;
} else {
accept = duk_get_boolean(ctx, -1);
}
}
duk_pop_2(ctx);
/*
* It is possible that we already have an outbound session to this peer so if we are not
* accepting the session we can only delete the entry if the refCount is zero.
*/
if (accept) {
++sessionInfo->refCount;
sessionInfo->port = port;
sessionInfo->sessionId = sessionId;
} else if (sessionInfo->refCount == 0) {
duk_del_prop_string(ctx, -1, joiner);
}
/* Pop sessions object */
duk_pop(ctx);
return AJ_BusReplyAcceptSession(msg, accept);
}
bool StyleContext::evalFilterFn(const std::string& _name) {
if (!duk_get_global_string(m_ctx, _name.c_str())) {
logMsg("Error: evalFilter %s\n", _name.c_str());
return false;
}
if (duk_pcall(m_ctx, 0) != 0) {
logMsg("Error: evalFilterFn: %s\n", duk_safe_to_string(m_ctx, -1));
}
bool result = false;
if (duk_is_boolean(m_ctx, -1)) {
result = duk_get_boolean(m_ctx, -1);
}
// pop result
duk_pop(m_ctx);
DUMP("evalFilterFn\n");
return result;
}
Variant GetVariant(duk_context* ctx, duk_idx_t stackIndex)
{
if (duk_is_boolean(ctx, stackIndex))
return Variant(duk_get_boolean(ctx, stackIndex) ? true : false);
if (duk_is_number(ctx, stackIndex))
return Variant(duk_get_number(ctx, stackIndex));
else if (duk_is_string(ctx, stackIndex))
return Variant(String(duk_get_string(ctx, stackIndex)));
else if (duk_is_object(ctx, stackIndex))
{
const char* objTypeName = GetValueObjectType(ctx, stackIndex);
if (objTypeName == float2_ID)
return Variant(Urho3D::Vector2(*GetValueObject<float2>(ctx, stackIndex, nullptr)));
else if (objTypeName == float3_ID)
return Variant(Urho3D::Vector3(*GetValueObject<float3>(ctx, stackIndex, nullptr)));
else if (objTypeName == float4_ID)
return Variant(Urho3D::Vector4(*GetValueObject<float4>(ctx, stackIndex, nullptr)));
else if (objTypeName == Quat_ID)
return Variant(Urho3D::Quaternion(*GetValueObject<Quat>(ctx, stackIndex, nullptr)));
}
/// \todo More types
return Variant();
}
int duk_bi_buffer_constructor(duk_context *ctx) {
duk_size_t buf_size;
duk_small_int_t buf_dynamic;
duk_uint8_t *buf_data;
const duk_uint8_t *src_data;
duk_hobject *h_obj;
/*
* Constructor arguments are currently somewhat compatible with
* (keep it that way if possible):
*
* http://nodejs.org/api/buffer.html
*
*/
buf_dynamic = duk_get_boolean(ctx, 1); /* default to false */
switch (duk_get_type(ctx, 0)) {
case DUK_TYPE_NUMBER:
/* new buffer of specified size */
buf_size = (duk_size_t) duk_to_int(ctx, 0);
(void) duk_push_buffer(ctx, buf_size, buf_dynamic);
break;
case DUK_TYPE_BUFFER:
/* return input buffer, converted to a Buffer object if called as a
* constructor (no change if called as a function).
*/
duk_set_top(ctx, 1);
break;
case DUK_TYPE_STRING:
/* new buffer with string contents */
src_data = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &buf_size);
DUK_ASSERT(src_data != NULL); /* even for zero-length string */
buf_data = (duk_uint8_t *) duk_push_buffer(ctx, buf_size, buf_dynamic);
DUK_MEMCPY((void *) buf_data, (const void *) src_data, (size_t) buf_size);
break;
case DUK_TYPE_OBJECT:
/* Buffer object: get the plain buffer inside. If called as as
* constructor, a new Buffer object pointing to the same plain
* buffer is created below.
*/
h_obj = duk_get_hobject(ctx, 0);
DUK_ASSERT(h_obj != NULL);
if (DUK_HOBJECT_GET_CLASS_NUMBER(h_obj) != DUK_HOBJECT_CLASS_BUFFER) {
return DUK_RET_TYPE_ERROR;
}
duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_VALUE);
DUK_ASSERT(duk_is_buffer(ctx, -1));
break;
case DUK_TYPE_NONE:
default:
return DUK_RET_TYPE_ERROR;
}
/* stack is unbalanced, but: [ <something> buf ] */
if (duk_is_constructor_call(ctx)) {
duk_push_object_helper(ctx,
DUK_HOBJECT_FLAG_EXTENSIBLE |
DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ |
DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER),
DUK_BIDX_BUFFER_PROTOTYPE);
/* Buffer object internal value is immutable */
duk_dup(ctx, -2);
duk_def_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
}
/* Note: unbalanced stack on purpose */
return 1;
}
void StyleContext::parseStyleResult(StyleParamKey _key, StyleParam::Value& _val) const {
_val = none_type{};
if (duk_is_string(m_ctx, -1)) {
std::string value(duk_get_string(m_ctx, -1));
_val = StyleParam::parseString(_key, value);
} else if (duk_is_boolean(m_ctx, -1)) {
bool value = duk_get_boolean(m_ctx, -1);
switch (_key) {
case StyleParamKey::interactive:
case StyleParamKey::text_interactive:
case StyleParamKey::visible:
_val = value;
break;
case StyleParamKey::extrude:
_val = value ? glm::vec2(NAN, NAN) : glm::vec2(0.0f, 0.0f);
break;
default:
break;
}
} else if (duk_is_array(m_ctx, -1)) {
duk_get_prop_string(m_ctx, -1, "length");
int len = duk_get_int(m_ctx, -1);
duk_pop(m_ctx);
switch (_key) {
case StyleParamKey::extrude: {
if (len != 2) {
LOGW("Wrong array size for extrusion: '%d'.", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double v1 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double v2 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
_val = glm::vec2(v1, v2);
break;
}
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
if (len < 3 || len > 4) {
LOGW("Wrong array size for color: '%d'.", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double r = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double g = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 2);
double b = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
double a = 1.0;
if (len == 4) {
duk_get_prop_index(m_ctx, -1, 3);
a = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
}
_val = (((uint32_t)(255.0 * a) & 0xff) << 24) |
(((uint32_t)(255.0 * r) & 0xff)<< 16) |
(((uint32_t)(255.0 * g) & 0xff)<< 8) |
(((uint32_t)(255.0 * b) & 0xff));
break;
}
default:
break;
}
} else if (duk_is_nan(m_ctx, -1)) {
// Ignore setting value
LOGD("duk evaluates JS method to NAN.\n");
} else if (duk_is_number(m_ctx, -1)) {
switch (_key) {
case StyleParamKey::extrude:
_val = glm::vec2(0.f, static_cast<float>(duk_get_number(m_ctx, -1)));
break;
case StyleParamKey::width:
case StyleParamKey::outline_width: {
// TODO more efficient way to return pixels.
// atm this only works by return value as string
double v = duk_get_number(m_ctx, -1);
_val = StyleParam::Width{static_cast<float>(v)};
break;
}
case StyleParamKey::text_font_stroke_width: {
_val = static_cast<float>(duk_get_number(m_ctx, -1));
break;
}
case StyleParamKey::order:
case StyleParamKey::outline_order:
case StyleParamKey::priority:
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::text_font_fill:
case StyleParamKey::text_font_stroke_color: {
_val = static_cast<uint32_t>(duk_get_uint(m_ctx, -1));
break;
}
default:
break;
}
} else if (duk_is_null_or_undefined(m_ctx, -1)) {
// Ignore setting value
LOGD("duk evaluates JS method to null or undefined.");
} else {
LOGW("Unhandled return type from Javascript style function for %d.", _key);
}
DUMP("parseStyleResult\n");
}
static duk_ret_t test_func(duk_context *ctx, void *udata) {
(void) udata;
if (ctx) {
printf("dummy - return here\n"); fflush(stdout);
return 0;
}
/* Up-to-date for Duktape 1.3.0, alphabetical order:
* $ cd website/api; ls *.yaml
*/
(void) duk_alloc_raw(ctx, 0);
(void) duk_alloc(ctx, 0);
(void) duk_base64_decode(ctx, 0);
(void) duk_base64_encode(ctx, 0);
(void) duk_buffer_to_string(ctx, 0);
(void) duk_call_method(ctx, 0);
(void) duk_call_prop(ctx, 0, 0);
(void) duk_call(ctx, 0);
(void) duk_char_code_at(ctx, 0, 0);
(void) duk_check_stack_top(ctx, 0);
(void) duk_check_stack(ctx, 0);
(void) duk_check_type_mask(ctx, 0, 0);
(void) duk_check_type(ctx, 0, 0);
(void) duk_compact(ctx, 0);
(void) duk_compile_lstring_filename(ctx, 0, "dummy", 0);
(void) duk_compile_lstring(ctx, 0, "dummy", 0);
(void) duk_compile_string_filename(ctx, 0, "dummy");
(void) duk_compile_string(ctx, 0, "dummy");
(void) duk_compile(ctx, 0);
(void) duk_concat(ctx, 0);
(void) duk_config_buffer(ctx, 0, NULL, 0);
(void) duk_copy(ctx, 0, 0);
(void) duk_create_heap_default();
(void) duk_create_heap(NULL, NULL, NULL, NULL, NULL);
(void) duk_debugger_attach(ctx, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
(void) duk_debugger_cooperate(ctx);
(void) duk_debugger_detach(ctx);
(void) duk_debugger_notify(ctx, 0);
(void) duk_debugger_pause(ctx);
(void) duk_decode_string(ctx, 0, NULL, NULL);
(void) duk_def_prop(ctx, 0, 0);
(void) duk_del_prop_index(ctx, 0, 0);
(void) duk_del_prop_string(ctx, 0, "dummy");
(void) duk_del_prop(ctx, 0);
(void) duk_destroy_heap(ctx);
(void) duk_dump_function(ctx);
(void) duk_dup_top(ctx);
(void) duk_dup(ctx, 0);
(void) duk_enum(ctx, 0, 0);
(void) duk_equals(ctx, 0, 0);
duk_error_va(ctx, 0, NULL, NULL);
duk_error(ctx, 0, "dummy"); /* (void) cast won't work without variadic macros */
(void) duk_eval_lstring_noresult(ctx, "dummy", 0);
(void) duk_eval_lstring(ctx, "dummy", 0);
(void) duk_eval_noresult(ctx);
(void) duk_eval_string_noresult(ctx, "dummy");
(void) duk_eval_string(ctx, "dummy");
(void) duk_eval(ctx);
(void) duk_fatal(ctx, "dummy");
(void) duk_free_raw(ctx, NULL);
(void) duk_free(ctx, NULL);
(void) duk_gc(ctx, 0);
(void) duk_get_boolean(ctx, 0);
(void) duk_get_buffer_data(ctx, 0, NULL);
(void) duk_get_buffer(ctx, 0, NULL);
(void) duk_get_c_function(ctx, 0);
(void) duk_get_context(ctx, 0);
(void) duk_get_current_magic(ctx);
(void) duk_get_error_code(ctx, 0);
(void) duk_get_finalizer(ctx, 0);
(void) duk_get_global_string(ctx, 0);
(void) duk_get_heapptr(ctx, 0);
(void) duk_get_int(ctx, 0);
(void) duk_get_length(ctx, 0);
(void) duk_get_lstring(ctx, 0, NULL);
(void) duk_get_magic(ctx, 0);
(void) duk_get_memory_functions(ctx, NULL);
(void) duk_get_number(ctx, 0);
(void) duk_get_pointer(ctx, 0);
(void) duk_get_prop_index(ctx, 0, 0);
(void) duk_get_prop_string(ctx, 0, "dummy");
(void) duk_get_prop(ctx, 0);
(void) duk_get_prototype(ctx, 0);
(void) duk_get_string(ctx, 0);
(void) duk_get_top_index(ctx);
(void) duk_get_top(ctx);
(void) duk_get_type_mask(ctx, 0);
(void) duk_get_type(ctx, 0);
(void) duk_get_uint(ctx, 0);
(void) duk_has_prop_index(ctx, 0, 0);
(void) duk_has_prop_string(ctx, 0, "dummy");
(void) duk_has_prop(ctx, 0);
(void) duk_hex_decode(ctx, 0);
(void) duk_hex_encode(ctx, 0);
(void) duk_insert(ctx, 0);
(void) duk_instanceof(ctx, 0, 0);
(void) duk_is_array(ctx, 0);
(void) duk_is_boolean(ctx, 0);
(void) duk_is_bound_function(ctx, 0);
(void) duk_is_buffer(ctx, 0);
(void) duk_is_callable(ctx, 0);
(void) duk_is_c_function(ctx, 0);
(void) duk_is_constructor_call(ctx);
(void) duk_is_dynamic_buffer(ctx, 0);
(void) duk_is_ecmascript_function(ctx, 0);
(void) duk_is_error(ctx, 0);
(void) duk_is_eval_error(ctx, 0);
(void) duk_is_fixed_buffer(ctx, 0);
(void) duk_is_function(ctx, 0);
(void) duk_is_lightfunc(ctx, 0);
(void) duk_is_nan(ctx, 0);
(void) duk_is_null_or_undefined(ctx, 0);
(void) duk_is_null(ctx, 0);
(void) duk_is_number(ctx, 0);
(void) duk_is_object_coercible(ctx, 0);
(void) duk_is_object(ctx, 0);
(void) duk_is_pointer(ctx, 0);
(void) duk_is_primitive(ctx, 0);
(void) duk_is_range_error(ctx, 0);
(void) duk_is_reference_error(ctx, 0);
(void) duk_is_strict_call(ctx);
(void) duk_is_string(ctx, 0);
(void) duk_is_syntax_error(ctx, 0);
(void) duk_is_thread(ctx, 0);
(void) duk_is_type_error(ctx, 0);
(void) duk_is_undefined(ctx, 0);
(void) duk_is_uri_error(ctx, 0);
(void) duk_is_valid_index(ctx, 0);
(void) duk_join(ctx, 0);
(void) duk_json_decode(ctx, 0);
(void) duk_json_encode(ctx, 0);
(void) duk_load_function(ctx);
(void) duk_map_string(ctx, 0, NULL, NULL);
(void) duk_new(ctx, 0);
(void) duk_next(ctx, 0, 0);
(void) duk_normalize_index(ctx, 0);
(void) duk_pcall_method(ctx, 0);
(void) duk_pcall_prop(ctx, 0, 0);
(void) duk_pcall(ctx, 0);
(void) duk_pcompile_lstring_filename(ctx, 0, "dummy", 0);
(void) duk_pcompile_lstring(ctx, 0, "dummy", 0);
(void) duk_pcompile_string_filename(ctx, 0, "dummy");
(void) duk_pcompile_string(ctx, 0, "dummy");
(void) duk_pcompile(ctx, 0);
(void) duk_peval_lstring_noresult(ctx, "dummy", 0);
(void) duk_peval_lstring(ctx, "dummy", 0);
(void) duk_peval_noresult(ctx);
(void) duk_peval_string_noresult(ctx, "dummy");
(void) duk_peval_string(ctx, "dummy");
(void) duk_peval(ctx);
(void) duk_pnew(ctx, 0);
(void) duk_pop_2(ctx);
(void) duk_pop_3(ctx);
(void) duk_pop_n(ctx, 0);
(void) duk_pop(ctx);
(void) duk_push_array(ctx);
(void) duk_push_boolean(ctx, 0);
(void) duk_push_buffer_object(ctx, 0, 0, 0, 0);
(void) duk_push_buffer(ctx, 0, 0);
(void) duk_push_c_function(ctx, NULL, 0);
(void) duk_push_c_lightfunc(ctx, NULL, 0, 0, 0);
(void) duk_push_context_dump(ctx);
(void) duk_push_current_function(ctx);
(void) duk_push_current_thread(ctx);
(void) duk_push_dynamic_buffer(ctx, 0);
(void) duk_push_error_object_va(ctx, 0, NULL, NULL);
(void) duk_push_error_object(ctx, 0, "dummy");
(void) duk_push_external_buffer(ctx);
(void) duk_push_false(ctx);
(void) duk_push_fixed_buffer(ctx, 0);
(void) duk_push_global_object(ctx);
(void) duk_push_global_stash(ctx);
(void) duk_push_heap_stash(ctx);
(void) duk_push_heapptr(ctx, NULL);
(void) duk_push_int(ctx, 0);
(void) duk_push_lstring(ctx, "dummy", 0);
(void) duk_push_nan(ctx);
(void) duk_push_null(ctx);
(void) duk_push_number(ctx, 0.0);
(void) duk_push_object(ctx);
(void) duk_push_pointer(ctx, NULL);
(void) duk_push_sprintf(ctx, "dummy");
(void) duk_push_string(ctx, "dummy");
(void) duk_push_this(ctx);
(void) duk_push_thread_new_globalenv(ctx);
(void) duk_push_thread_stash(ctx, NULL);
(void) duk_push_thread(ctx);
(void) duk_push_true(ctx);
(void) duk_push_uint(ctx, 0);
(void) duk_push_undefined(ctx);
(void) duk_push_vsprintf(ctx, "dummy", NULL);
(void) duk_put_function_list(ctx, 0, NULL);
(void) duk_put_global_string(ctx, NULL);
(void) duk_put_number_list(ctx, 0, NULL);
(void) duk_put_prop_index(ctx, 0, 0);
(void) duk_put_prop_string(ctx, 0, "dummy");
(void) duk_put_prop(ctx, 0);
(void) duk_realloc_raw(ctx, NULL, 0);
(void) duk_realloc(ctx, NULL, 0);
(void) duk_remove(ctx, 0);
(void) duk_replace(ctx, 0);
(void) duk_require_boolean(ctx, 0);
(void) duk_require_buffer_data(ctx, 0, NULL);
(void) duk_require_buffer(ctx, 0, NULL);
(void) duk_require_c_function(ctx, 0);
(void) duk_require_callable(ctx, 0);
(void) duk_require_context(ctx, 0);
(void) duk_require_function(ctx, 0);
(void) duk_require_heapptr(ctx, 0);
(void) duk_require_int(ctx, 0);
(void) duk_require_lstring(ctx, 0, NULL);
(void) duk_require_normalize_index(ctx, 0);
(void) duk_require_null(ctx, 0);
(void) duk_require_number(ctx, 0);
(void) duk_require_object_coercible(ctx, 0);
(void) duk_require_pointer(ctx, 0);
(void) duk_require_stack_top(ctx, 0);
(void) duk_require_stack(ctx, 0);
(void) duk_require_string(ctx, 0);
(void) duk_require_top_index(ctx);
(void) duk_require_type_mask(ctx, 0, 0);
(void) duk_require_uint(ctx, 0);
(void) duk_require_undefined(ctx, 0);
(void) duk_require_valid_index(ctx, 0);
(void) duk_resize_buffer(ctx, 0, 0);
(void) duk_safe_call(ctx, NULL, NULL, 0, 0);
(void) duk_safe_to_lstring(ctx, 0, NULL);
(void) duk_safe_to_string(ctx, 0);
(void) duk_set_finalizer(ctx, 0);
(void) duk_set_global_object(ctx);
(void) duk_set_magic(ctx, 0, 0);
(void) duk_set_prototype(ctx, 0);
(void) duk_set_top(ctx, 0);
(void) duk_steal_buffer(ctx, 0, NULL);
(void) duk_strict_equals(ctx, 0, 0);
(void) duk_substring(ctx, 0, 0, 0);
(void) duk_swap_top(ctx, 0);
(void) duk_swap(ctx, 0, 0);
(void) duk_throw(ctx);
(void) duk_to_boolean(ctx, 0);
(void) duk_to_buffer(ctx, 0, NULL);
(void) duk_to_defaultvalue(ctx, 0, 0);
(void) duk_to_dynamic_buffer(ctx, 0, NULL);
(void) duk_to_fixed_buffer(ctx, 0, NULL);
(void) duk_to_int32(ctx, 0);
(void) duk_to_int(ctx, 0);
(void) duk_to_lstring(ctx, 0, NULL);
(void) duk_to_null(ctx, 0);
(void) duk_to_number(ctx, 0);
(void) duk_to_object(ctx, 0);
(void) duk_to_pointer(ctx, 0);
(void) duk_to_primitive(ctx, 0, 0);
(void) duk_to_string(ctx, 0);
(void) duk_to_uint16(ctx, 0);
(void) duk_to_uint32(ctx, 0);
(void) duk_to_uint(ctx, 0);
(void) duk_to_undefined(ctx, 0);
(void) duk_trim(ctx, 0);
(void) duk_xcopy_top(ctx, NULL, 0);
(void) duk_xmove_top(ctx, NULL, 0);
printf("never here\n"); fflush(stdout);
return 0;
}
static VALUE ctx_stack_to_value(struct state *state, int index)
{
duk_context *ctx = state->ctx;
size_t len;
const char *buf;
int type;
state->was_complex = 0;
type = duk_get_type(ctx, index);
switch (type) {
case DUK_TYPE_NULL:
case DUK_TYPE_UNDEFINED:
return Qnil;
case DUK_TYPE_NUMBER:
return rb_float_new(duk_get_number(ctx, index));
case DUK_TYPE_BOOLEAN:
return duk_get_boolean(ctx, index) ? Qtrue : Qfalse;
case DUK_TYPE_STRING:
buf = duk_get_lstring(ctx, index, &len);
VALUE str = rb_str_new(buf, len);
return decode_cesu8(state, str);
case DUK_TYPE_OBJECT:
if (duk_is_function(ctx, index)) {
state->was_complex = 1;
return state->complex_object;
} else if (duk_is_array(ctx, index)) {
VALUE ary = rb_ary_new();
duk_enum(ctx, index, DUK_ENUM_ARRAY_INDICES_ONLY);
while (duk_next(ctx, -1, 1)) {
rb_ary_store(ary, duk_to_int(ctx, -2), ctx_stack_to_value(state, -1));
duk_pop_2(ctx);
}
duk_pop(ctx);
return ary;
} else if (duk_is_object(ctx, index)) {
VALUE hash = rb_hash_new();
duk_enum(ctx, index, DUK_ENUM_OWN_PROPERTIES_ONLY);
while (duk_next(ctx, -1, 1)) {
VALUE key = ctx_stack_to_value(state, -2);
VALUE val = ctx_stack_to_value(state, -1);
duk_pop_2(ctx);
if (state->was_complex)
continue;
rb_hash_aset(hash, key, val);
}
duk_pop(ctx);
return hash;
} else {
state->was_complex = 1;
return state->complex_object;
}
case DUK_TYPE_BUFFER:
case DUK_TYPE_POINTER:
default:
return state->complex_object;
}
return Qnil;
}
//duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index);
duk_bool_t aperl_duk_get_boolean(duk_context *ctx, duk_idx_t index) {
duk_bool_t ret = duk_get_boolean(ctx, index);
return ret;
}
bool StyleContext::parseStyleResult(StyleParamKey _key, StyleParam::Value& _val) const {
_val = none_type{};
if (duk_is_string(m_ctx, -1)) {
std::string value(duk_get_string(m_ctx, -1));
_val = StyleParam::parseString(_key, value);
} else if (duk_is_boolean(m_ctx, -1)) {
bool value = duk_get_boolean(m_ctx, -1);
switch (_key) {
case StyleParamKey::visible:
_val = value;
break;
case StyleParamKey::extrude:
_val = value ? glm::vec2(NAN, NAN) : glm::vec2(0.0f, 0.0f);
break;
default:
break;
}
} else if (duk_is_array(m_ctx, -1)) {
duk_get_prop_string(m_ctx, -1, "length");
int len = duk_get_int(m_ctx, -1);
duk_pop(m_ctx);
switch (_key) {
case StyleParamKey::extrude: {
if (len != 2) {
logMsg("Warning: Wrong array size for extrusion: '%d'.\n", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double v1 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double v2 = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
_val = glm::vec2(v1, v2);
break;
}
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::font_fill:
case StyleParamKey::font_stroke:
case StyleParamKey::font_stroke_color: {
if (len < 3 || len > 4) {
logMsg("Warning: Wrong array size for color: '%d'.\n", len);
break;
}
duk_get_prop_index(m_ctx, -1, 0);
double r = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 1);
double g = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
duk_get_prop_index(m_ctx, -1, 2);
double b = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
double a = 1.0;
if (len == 4) {
duk_get_prop_index(m_ctx, -1, 3);
a = duk_get_number(m_ctx, -1);
duk_pop(m_ctx);
}
_val = (((uint32_t)(255.0 * a) & 0xff) << 24) |
(((uint32_t)(255.0 * r) & 0xff)<< 16) |
(((uint32_t)(255.0 * g) & 0xff)<< 8) |
(((uint32_t)(255.0 * b) & 0xff));
break;
}
default:
break;
}
} else if (duk_is_number(m_ctx, -1)) {
switch (_key) {
case StyleParamKey::width:
case StyleParamKey::outline_width:
case StyleParamKey::font_stroke_width: {
double v = duk_get_number(m_ctx, -1);
_val = static_cast<float>(v);
break;
}
case StyleParamKey::order:
case StyleParamKey::priority:
case StyleParamKey::color:
case StyleParamKey::outline_color:
case StyleParamKey::font_fill:
case StyleParamKey::font_stroke:
case StyleParamKey::font_stroke_color: {
_val = static_cast<uint32_t>(duk_get_uint(m_ctx, -1));
break;
}
default:
break;
}
} else {
logMsg("Warning: Unhandled return type from Javascript function.\n");
}
duk_pop(m_ctx);
DUMP("parseStyleResult\n");
return !_val.is<none_type>();
}
bool Context::getBool(index_t i)
{
return (duk_get_boolean(m_handle, i) ? true: false);
}
int8_t sendSms(duk_context *JsContext, InputParameters_t *Parameters, char *Input[])
{
extern const char const *ErrorMessages[];
extern HttpHandle_t *Handle;
extern Output_t OutputMessages;
int8_t RetCode = EXIT_SUCCESS;
char *GatewayLocation;
if (Parameters->GatewayLocation)
{
uint8_t GatewayLocationLength = strlen(Input[Parameters->GatewayLocation] );
if ( Input[Parameters->GatewayLocation][GatewayLocationLength - 1] == '/')
{
Input[Parameters->GatewayLocation][GatewayLocationLength - 1] = '\0';
GatewayLocationLength--;
}
// 10 = '/' + ".gateway" + '\0'
GatewayLocation = malloc(GatewayLocationLength + strlen(Input[Parameters->Gateway] ) + 10);
if (!GatewayLocation)
{
setErrorMsg(ErrorMessages[MEMORY], true);
return NO_MEMORY;
}
sprintf(GatewayLocation, "%s/%s.gateway",Input[Parameters->GatewayLocation], Input[Parameters->Gateway] );
}
else
{
// 27 = "/usr/share/esmska/" + ".gateway" + '\0'
GatewayLocation = malloc(strlen(Input[Parameters->Gateway] ) + 27);
if (!GatewayLocation)
{
setErrorMsg(ErrorMessages[MEMORY], true);
return NO_MEMORY;
}
sprintf(GatewayLocation, "/usr/share/esmska/%s.gateway", Input[Parameters->Gateway] );
}
if (duk_peval_file(JsContext, GatewayLocation) )
{
duk_get_prop_string(JsContext, -1, "message");
setErrorMsg(ErrorMessages[MODULE_PROCESSING], false);
setErrorMsg(Input[Parameters->Gateway], false);
setErrorMsg(duk_get_string(JsContext, -1), true);
free(GatewayLocation);
return MODULE_ERROR;
}
free(GatewayLocation);
duk_pop(JsContext); // Zahozeni vysledku (undefined)
// Zpristupneni potrebnych udaju jako username, passwd, cislo, text zpravy
duk_push_global_object(JsContext);
if (Parameters->User) duk_push_string(JsContext, Input[Parameters->User] );
else duk_push_string(JsContext, "");
duk_put_prop_string(JsContext, -2, "LOGIN");
if (Parameters->Password) duk_push_string(JsContext, Input[Parameters->Password] );
else duk_push_string(JsContext, "");
duk_put_prop_string(JsContext, -2, "PASSWORD");
if (Parameters->SenderNumber) duk_push_string(JsContext, Input[Parameters->SenderNumber] );
else duk_push_string(JsContext, "");
duk_put_prop_string(JsContext, -2, "SENDERNUMBER");
duk_push_string(JsContext, Input[Parameters->Number] );
duk_put_prop_string(JsContext, -2, "NUMBER");
duk_push_string(JsContext, Input[Parameters->Text] );
duk_put_prop_string(JsContext, -2, "MESSAGE");
if (duk_peval_string(JsContext, "RECEIPT = (getFeatures().indexOf('RECEIPT') > -1 ? true : false)") )
{
duk_get_prop_string(JsContext, -1, "message");
setErrorMsg(ErrorMessages[RECEIPT_SETTING], false);
setErrorMsg(duk_get_string(JsContext, -1), true);
return MODULE_ERROR;
}
duk_pop(JsContext);
// Zpristupneni potrebnych metod, promennych a samotny objekt EXEC
duk_push_object(JsContext);
duk_push_c_function(JsContext, get, 2);
duk_put_prop_string(JsContext, -2, "getURL");
duk_push_c_function(JsContext, post, 3);
duk_put_prop_string(JsContext, -2, "postURL");
duk_push_c_function(JsContext, setProblem, 2);
duk_put_prop_string(JsContext, -2, "setProblem");
duk_push_c_function(JsContext, setSupplementalMsg, 1);
duk_put_prop_string(JsContext, -2, "setSupplementalMessage");
duk_push_c_function(JsContext, stall, 1);
duk_put_prop_string(JsContext, -2, "sleep");
duk_push_c_function(JsContext, setReferer, 1);
duk_put_prop_string(JsContext, -2, "setReferer");
duk_push_string(JsContext, "Free SMS remaining: ");
duk_put_prop_string(JsContext, -2, "INFO_FREE_SMS_REMAINING");
duk_push_string(JsContext, "The gateway doesn't provide any information about successful sending. The message might be and might not be delivered.");
duk_put_prop_string(JsContext, -2, "INFO_STATUS_NOT_PROVIDED");
duk_push_string(JsContext, "Remaining credit: ");
duk_put_prop_string(JsContext, -2, "INFO_CREDIT_REMAINING");
duk_put_prop_string(JsContext, -2, "EXEC");
// Vytvoreni CURL contextu
if ( !(Handle = httpInit() ) )
{
setErrorMsg(ErrorMessages[NO_CURL_CONTEXT], true);
return CURL_ERROR;
}
// Volani funkce send()
duk_get_prop_string(JsContext, -1, "send");
if (duk_pcall(JsContext, 0) )
{
if (duk_is_number(JsContext, -1) )
{
uint8_t ErrCode = duk_get_number(JsContext, -1);
if (ErrCode < 90)
{
setErrorMsg(ErrorMessages[GENERIC], false);
setErrorMsg(curl_easy_strerror(ErrCode), true);
RetCode = CURL_ERROR;
}
else
{
OutputMessages.MessagesArray[OutputMessages.NextFree].MsgType = ERR;
OutputMessages.MessagesArray[OutputMessages.NextFree].IsEndOfMsg = 1;
switch (ErrCode)
{
case NO_MEMORY:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[MEMORY];
RetCode = INTERNAL_ERROR;
break;
case NO_POST_DATA:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[POST_DATA];
RetCode = MODULE_ERROR;
break;
case SET_PROBLEM_NO_MSG:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[NO_EXPLAINING];
RetCode = MODULE_ERROR;
break;
case SLEEP_NOT_NUMBER:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[SLEEP_NUMBER];
RetCode = MODULE_ERROR;
break;
case ODD_URL_PARAMETERS:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[URL_PARAMETERS];
RetCode = MODULE_ERROR;
break;
case ODD_POST_PARAMETERS:
OutputMessages.MessagesArray[OutputMessages.NextFree++].Msg = ErrorMessages[POST_PARAMETERS];
RetCode = MODULE_ERROR;
break;
}
}
}
else
{
setErrorMsg(duk_safe_to_string(JsContext, -1), true);
RetCode = DUKTAPE_ERROR;
}
}
else
{
bool SendRetVal;
if (duk_is_boolean(JsContext, -1) ) SendRetVal = duk_get_boolean(JsContext, -1);
else
{
setErrorMsg(ErrorMessages[NOT_BOOL], true);
SendRetVal = (bool) ( (int8_t) duk_to_number(JsContext, -1) );
}
if (!SendRetVal) RetCode = GATEWAY_ERROR;
}
httpCleanUp(Handle);
return RetCode;
}
void AssignAttributeValue(duk_context* ctx, duk_idx_t stackIndex, IAttribute* destAttr, AttributeChange::Type change)
{
if (!destAttr)
return;
switch (destAttr->TypeId())
{
case IAttribute::BoolId:
static_cast<Attribute<bool>*>(destAttr)->Set(duk_get_boolean(ctx, stackIndex) ? true : false, change);
break;
case IAttribute::IntId:
static_cast<Attribute<int>*>(destAttr)->Set((int)duk_get_number(ctx, stackIndex), change);
break;
case IAttribute::UIntId:
static_cast<Attribute<uint>*>(destAttr)->Set((uint)duk_get_number(ctx, stackIndex), change);
break;
case IAttribute::RealId:
static_cast<Attribute<float>*>(destAttr)->Set((float)duk_get_number(ctx, stackIndex), change);
break;
case IAttribute::StringId:
static_cast<Attribute<String>*>(destAttr)->Set(String(duk_get_string(ctx, stackIndex)), change);
break;
case IAttribute::Float2Id:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), float2_ID) == 0)
static_cast<Attribute<float2>*>(destAttr)->Set(*GetValueObject<float2>(ctx, stackIndex, nullptr), change);
break;
case IAttribute::Float3Id:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), float3_ID) == 0)
static_cast<Attribute<float3>*>(destAttr)->Set(*GetValueObject<float3>(ctx, stackIndex, nullptr), change);
break;
case IAttribute::Float4Id:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), float4_ID) == 0)
static_cast<Attribute<float4>*>(destAttr)->Set(*GetValueObject<float4>(ctx, stackIndex, nullptr), change);
break;
case IAttribute::QuatId:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), Quat_ID) == 0)
static_cast<Attribute<Quat>*>(destAttr)->Set(*GetValueObject<Quat>(ctx, stackIndex, nullptr), change);
break;
case IAttribute::TransformId:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), Transform_ID) == 0)
static_cast<Attribute<Transform>*>(destAttr)->Set(*GetValueObject<Transform>(ctx, stackIndex, nullptr), change);
break;
case IAttribute::AssetReferenceId:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), AssetReference_ID) == 0)
static_cast<Attribute<AssetReference>*>(destAttr)->Set(*GetValueObject<AssetReference>(ctx, stackIndex, nullptr), change);
break;
case IAttribute::AssetReferenceListId:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), AssetReferenceList_ID) == 0)
static_cast<Attribute<AssetReferenceList>*>(destAttr)->Set(*GetValueObject<AssetReferenceList>(ctx, stackIndex, nullptr), change);
// Also allow assigning a single AssetReference to an AssetReferenceList
else if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), AssetReference_ID) == 0)
{
const AssetReference& ref = *GetValueObject<AssetReference>(ctx, stackIndex, nullptr);
AssetReferenceList list;
list.type = ref.type;
list.Append(ref);
static_cast<Attribute<AssetReferenceList>*>(destAttr)->Set(list);
}
break;
case IAttribute::EntityReferenceId:
if (duk_is_object(ctx, stackIndex) && strcmp(GetValueObjectType(ctx, stackIndex), EntityReference_ID) == 0)
static_cast<Attribute<EntityReference>*>(destAttr)->Set(*GetValueObject<EntityReference>(ctx, stackIndex, nullptr), change);
break;
}
}
