bool idproxyInvoke(NPObject *obj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result) {
err("! fakeInvoke: %@", name);
struct IDProxyObject *obj_ = (void *) obj;
int prop;
int *args_ = malloc(argCount * sizeof(int));
int i; for(i = 0; i < argCount; i++) {
const struct NPFuckedUpVariant *arg = &(((const struct NPFuckedUpVariant *) args)[i]);
int arg_;
switch(arg->type) {
case NPVariantType_String:
assert(!get_string_object(food, (void *) arg->string.value.UTF8Characters, arg->string.value.UTF8Length, &arg_));
break;
case NPVariantType_Int32:
case NPVariantType_Object:
default:
log("called with unhandled argument type");
abort();
}
}
_assertZero(invoke_object_property(food, obj_->id, (void *) CFDataGetBytePtr(name), CFDataGetLength(name), args_, argCount * sizeof(int), &prop));
free(args_);
if(prop) {
*((struct NPFuckedUpVariant *) result) = variant_for_object_name(prop);
return true;
} else {
return false;
}
}
void throw_exception(char *excp, char *err_str)
{
if(!core_library_loaded)
{
printf("Exception %s: %s\n", excp, err_str);
cleanup();
exit(1);
}
//printf("In throw_exception() %s %s\n", excp, err_str);
//getchar();
reg_current_value_rib = cons(cons(get_symbol_object(excp), (OBJECT_PTR)get_string_object(err_str)), NIL);
//basically (REFER THROW (APPLY))
reg_next_expression = cons(cons(REFER, cons(get_symbol_object("THROW"),cons(cons(CONS_APPLY_NIL, NIL), NIL))), NIL);
}
MdsObject* string_string_(MdsObject* l, MdsObject* r, OperatorType op){
MdsStringObject* lstr = (MdsStringObject*)l;
MdsStringObject* rstr = (MdsStringObject*)r;
string a = lstr->get_value();
string b = rstr->get_value();
if (op == ADD)
{
string res = a + b;
MdsStringObject* news = get_string_object(res.data());
return news;
}
int res;
if (op == EQUAL)
res = a == b ? 1 : 0;
else
if (op == NEQ)
res = a != b ? 1 : 0;
else
if (op == GREAT)
res = a > b ? 1 : 0;
else
if (op == LESS)
res = a < b ? 1 : 0;
else
if (op == GE)
res = a >= b ? 1 : 0;
else
if (op == LE)
res = a <= b ? 1 : 0;
else
return NULL;
MdsIntObject* newi = get_int_object(res);
return newi;
}
void raise_error(char *err_str)
{
if(!console_mode && !single_expression_mode && !pipe_mode)
{
show_error_dialog(err_str);
#ifdef INTERPRETER_MODE
debug_mode = true;
debug_continuation = create_current_continuation();
debug_env = reg_current_env;
reg_next_expression = NIL;
debug_execution_stack = reg_current_stack;
create_debug_window(DEFAULT_DEBUG_WINDOW_POSX,
DEFAULT_DEBUG_WINDOW_POSY,
DEFAULT_DEBUG_WINDOW_WIDTH,
DEFAULT_DEBUG_WINDOW_HEIGHT);
#endif
}
else
fprintf(stdout, "%s\n", err_str);
//to stay commented out till we are
//able to prpvide a meaningful backtrace
//fprintf(stdout, "Begin backtrace\n");
//print_backtrace();
//fprintf(stdout, "End backtrace\n");
#ifdef INTERPRETER_MODE
reg_accumulator = NIL;
reg_current_value_rib = NIL;
reg_next_expression = NIL;
#endif
in_error = true;
exception_object = cons(get_symbol_object("EXCEPTION"), get_string_object(err_str));
}
static pyc_object *get_object(RBuffer *buffer) {
RListIter *ref_idx;
bool error = false;
pyc_object *ret = NULL;
ut8 code = get_ut8 (buffer, &error);
ut8 flag = code & FLAG_REF;
ut8 type = code & ~FLAG_REF;
if (error)
return NULL;
if (flag) {
ret = get_none_object ();
if (!ret)
return NULL;
ref_idx = r_list_append (refs, ret);
if (!ref_idx) {
free (ret);
return NULL;
}
}
switch (type) {
case TYPE_NULL:
return NULL;
case TYPE_TRUE:
return get_true_object ();
case TYPE_FALSE:
return get_false_object ();
case TYPE_NONE:
return get_none_object ();
case TYPE_REF:
return get_ref_object (buffer);
case TYPE_SMALL_TUPLE:
ret = get_small_tuple_object (buffer);
break;
case TYPE_TUPLE:
ret = get_tuple_object (buffer);
break;
case TYPE_STRING:
ret = get_string_object (buffer);
break;
case TYPE_CODE_v1:
ret = get_code_object (buffer);
break;
case TYPE_INT:
ret = get_int_object (buffer);
break;
case TYPE_ASCII_INTERNED:
ret = get_ascii_interned_object (buffer);
break;
case TYPE_SHORT_ASCII:
ret = get_short_ascii_object (buffer);
break;
case TYPE_ASCII:
ret = get_ascii_object (buffer);
break;
case TYPE_SHORT_ASCII_INTERNED:
ret = get_short_ascii_interned_object (buffer);
break;
case TYPE_BINARY_COMPLEX:
case TYPE_ELLIPSIS:
case TYPE_BINARY_FLOAT:
case TYPE_CODE_v0:
case TYPE_COMPLEX:
case TYPE_STRINGREF:
case TYPE_DICT:
case TYPE_FLOAT:
case TYPE_FROZENSET:
case TYPE_STOPITER:
case TYPE_INT64:
case TYPE_INTERNED:
case TYPE_LIST:
case TYPE_LONG:
case TYPE_SET:
case TYPE_UNICODE:
case TYPE_UNKNOWN:
eprintf ("Get not implemented for type %x\n", type);
return NULL;
default:
eprintf ("Undefined type in get_object (%x)\n", type);
return NULL;
}
if (flag) {
free_object (ref_idx->data);
ref_idx->data = copy_object (ret);
}
return ret;
}
