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; }