/* Run when an AccessVariable is executed. Uses the details in exec * to access instance variables of args.recv() */ Object* AccessVariable::access_execute(STATE, CallFrame* call_frame, Executable* exec, Module* mod, Arguments& args) { AccessVariable* access = as<AccessVariable>(exec); Object* const self = args.recv(); /* The writer case. */ if(access->write()->true_p()) { if(CBOOL(self->frozen_p(state)) && CBOOL(self->frozen_mod_disallowed(state))) { Exception::frozen_error(state, call_frame, self); return 0; } if(args.total() != 1) { Exception::argument_error(state, 1, args.total()); return NULL; } if(kind_of<Class>(mod) && self->reference_p()) { // Promote this to use a direct accessor if(TypeInfo* ti = state->memory()->find_type_info(self)) { TypeInfo::Slots::iterator it = ti->slots.find(access->name()->index()); if(it != ti->slots.end()) { // Found one! access->set_executor(ti->slot_accessors[it->second]); ti->set_field(state, self, it->second, args.get_argument(0)); return args.get_argument(0); } } /* Fall through, handle it as a normal ivar. */ access->set_executor(access_write_regular_ivar); } self->set_ivar(state, access->name(), args.get_argument(0)); return args.get_argument(0); } /* The read case. */ if(args.total() != 0) { Exception::argument_error(state, 0, args.total()); return NULL; } if(kind_of<Class>(mod) && self->reference_p()) { // Promote this to use a direct accessor if(TypeInfo* ti = state->memory()->find_type_info(self)) { TypeInfo::Slots::iterator it = ti->slots.find(access->name()->index()); if(it != ti->slots.end()) { // Found one! access->set_executor(ti->slot_accessors[it->second]); return ti->get_field(state, self, it->second); } } // Ok, its a table ivar, setup fast access for next time. access->set_executor(access_read_regular_ivar); } return self->get_ivar(state, access->name()); }
String* Time::strftime(STATE, String* format) { struct tm64 tm = get_tm(); struct timespec64 ts; ts.tv_sec = seconds_; ts.tv_nsec = nanoseconds_; int off = 0; if(Fixnum* offset = try_as<Fixnum>(utc_offset(state))) { off = offset->to_int(); } if(format->byte_size() == 0) return String::create(state, NULL, 0); char stack_str[STRFTIME_STACK_BUF]; size_t chars = ::strftime_extended(stack_str, STRFTIME_STACK_BUF, format->c_str(state), &tm, &ts, CBOOL(is_gmt_) ? 1 : 0, off); size_t buf_size = format->byte_size(); String* result = 0; if(chars == 0) { buf_size *= 2; char* malloc_str = (char*)malloc(buf_size); if(!malloc_str) { Exception::memory_error(state); return NULL; } chars = ::strftime_extended(malloc_str, buf_size, format->c_str(state), &tm, &ts, CBOOL(is_gmt_) ? 1 : 0, off); if(chars) { result = String::create(state, malloc_str, chars); result->encoding(state, format->encoding()); } free(malloc_str); } else { result = String::create(state, stack_str, chars); result->encoding(state, format->encoding()); } return result; }
Object* Regexp::propagate_last_match(STATE, CallFrame* call_frame) { Object* obj = call_frame->last_match(state); if(CBOOL(obj)) { Regexp::set_last_match(state, obj, call_frame); } return obj; }
bool NativeFunction::ffi_arg_info(STATE, Object* type, FFIArgInfo* args_info) { if(type->fixnum_p()) { args_info->type = as<Fixnum>(type)->to_int(); args_info->enum_obj = NULL; args_info->callback = NULL; return true; } else if(type->symbol_p()) { LookupTable* tbl = try_as<LookupTable>(G(ffi)->get_const(state, "TypeDefs")); if(!tbl) return false; Fixnum* fix = try_as<Fixnum>(tbl->aref(state, type)); if(!fix) return false; args_info->type = fix->to_int(); args_info->enum_obj = NULL; args_info->callback = NULL; return true; } else if(NativeFunction* cb = try_as<NativeFunction>(type)) { args_info->type = RBX_FFI_TYPE_CALLBACK; args_info->enum_obj = NULL; args_info->callback = cb; return true; } else if(CBOOL(type->respond_to(state, state->symbol("[]"), cTrue))) { args_info->type = RBX_FFI_TYPE_ENUM; args_info->enum_obj = type; args_info->callback = NULL; return true; } return false; }
Array* Array::to_ary(STATE, Object* value, CallFrame* call_frame) { if(Tuple* tup = try_as<Tuple>(value)) { return Array::from_tuple(state, tup); } if(CBOOL(value->respond_to(state, G(sym_to_ary), cTrue))) { Object* res = value->send(state, call_frame, G(sym_to_ary)); if(!res) return 0; if(Array* ary = try_as<Array>(res)) { return ary; } if(LANGUAGE_18_ENABLED || !res->nil_p()) { Exception::type_error(state, "to_ary should return an Array", call_frame); return 0; } // NOTE: On >= 1.9, if res is nil just fall through and return [value] } Array* ary = Array::create(state, 1); ary->set(state, 0, value); return ary; }
Time* Time::specific(STATE, Object* self, Integer* sec, Integer* nsec, Object* gmt, Object* offset) { Time* tm = state->new_object_dirty<Time>(as<Class>(self)); tm->seconds_ = sec->to_long_long(); tm->nanoseconds_ = nsec->to_native(); // Do a little overflow cleanup. if(tm->nanoseconds_ >= 1000000000) { tm->seconds_ += tm->nanoseconds_ / 1000000000; tm->nanoseconds_ %= 1000000000; } if(tm->nanoseconds_ < 0) { tm->seconds_ += NDIV(tm->nanoseconds_, 1000000000); tm->nanoseconds_ = NMOD(tm->nanoseconds_, 1000000000); } tm->decomposed(state, nil<Array>()); tm->is_gmt(state, RBOOL(CBOOL(gmt))); tm->offset(state, offset); tm->zone(state, nil<String>()); return tm; }
/* read-config_sch */ obj_t BGl_readzd2config_schzd2zzinit_libzd2dirzd2(obj_t BgL_fz00_8) { AN_OBJECT; { /* Init/lib_dir.scm 63 */ { /* Init/lib_dir.scm 64 */ obj_t BgL_portz00_124; { /* Init/lib_dir.scm 64 */ BgL_portz00_124 = BGl_openzd2inputzd2filez00zz__r4_ports_6_10_1z00(BgL_fz00_8, BTRUE); } { /* Init/lib_dir.scm 65 */ obj_t BgL_val1508z00_125; BgL_val1508z00_125 = BGl_zc3exitza31528ze3z83zzinit_libzd2dirzd2(BgL_fz00_8, BgL_portz00_124); bgl_close_input_port(BgL_portz00_124); if (CBOOL(BGl_valzd2fromzd2exitzf3zf3zz__bexitz00 (BgL_val1508z00_125))) { /* Init/lib_dir.scm 71 */ return BGl_unwindzd2untilz12zc0zz__bexitz00(CAR(BgL_val1508z00_125), CDR(BgL_val1508z00_125)); } else { /* Init/lib_dir.scm 71 */ return BgL_val1508z00_125; } } } } }
/* unix-filename */ BGL_EXPORTED_DEF obj_t BGl_unixzd2filenamezd2zzcc_execz00(obj_t BgL_argsz00_1) { AN_OBJECT; { /* Cc/exec.scm 33 */ { /* Cc/exec.scm 34 */ obj_t BgL_sz00_91; BgL_sz00_91 = BGl_stringzd2appendzd2zz__r4_strings_6_7z00(BgL_argsz00_1); { /* Cc/exec.scm 35 */ bool_t BgL_testz00_139; { /* Cc/exec.scm 35 */ BgL_testz00_139 = CBOOL(BGl_stringzd2indexzd2zz__r4_strings_6_7z00(BgL_sz00_91, BCHAR(((unsigned char) ' ')), BINT(((long) 0)))); } if (BgL_testz00_139) { /* Cc/exec.scm 35 */ return string_append_3(BGl_string1528z00zzcc_execz00, BgL_sz00_91, BGl_string1528z00zzcc_execz00); } else { /* Cc/exec.scm 35 */ return BgL_sz00_91; } } } } }
/*----------------------------------------------------------------------------------- * Name: dlbe_PassThrough * * Description: * This function verifies the validity of a Unique Record Id and then retrieves the * information from it (RecordType) * * Parameters: * UniqueIdPtr (input) - A Unique Record Id Ptr * * RETURN: * The recordtype that the unique record id coresponds to if the Unique ID is valid, * otherwise returns DAL_OOB. * * ERROR CODES * CSSMERR_DL_INVALID_RECORD_UID *-----------------------------------------------------------------------------------*/ CSSM_RETURN dlbe_PassThrough ( CSSM_DL_DB_HANDLE DLDBHandle, uint32 PassThroughId, const void * InputParams, void ** OutputParams) { FFDL_WRITE_BACK_CACHE_STATUS CacheStatus; if (PassThroughId == FFDL_PASSTHROUGH_SET_WRITE_BACK_CACHE) { if (port_IsBadReadPtr(InputParams, sizeof(FFDL_WRITE_BACK_CACHE_STATUS))) return CSSMERR_DL_INVALID_POINTER; if (DLDBHandle.DBHandle != 0) return CSSMERR_DL_INVALID_DB_HANDLE; CacheStatus = *((const FFDL_WRITE_BACK_CACHE_STATUS *)InputParams); if (CacheStatus != FFDL_ENABLE_CACHE && CacheStatus != FFDL_DISABLE_CACHE) return FFDL_CACHE_STATUS_INVALID; ffport_nrSetCache(CBOOL(CacheStatus == FFDL_ENABLE_CACHE)); } else return CSSMERR_DL_INVALID_PASSTHROUGH_ID; return CSSM_OK; }
Object* Module::cvar_set(STATE, Symbol* name, Object* value) { if(!name->is_cvar_p(state)->true_p()) return Primitives::failure(); if(CBOOL(frozen_p(state))) { Exception::type_error(state, "unable to change frozen object"); } Module* mod = this; Module* mod_to_query; while(!mod->nil_p()) { mod_to_query = get_module_to_query(mod); if(mod_to_query->table_ivar_defined(state, name)->true_p()) { mod_to_query->set_table_ivar(state, name, value); return value; } mod = mod->superclass(); } mod = this; mod_to_query = get_module_to_query(mod); mod_to_query->set_ivar(state, name, value); return value; }
Time* Time::specific(STATE, Object* self, Integer* sec, Integer* nsec, Object* gmt) { Time* tm = state->new_object<Time>(as<Class>(self)); if(sizeof(time_t) == sizeof(long long)) { tm->seconds_ = sec->to_long_long(); tm->nanoseconds_ = nsec->to_long_long(); } else { tm->seconds_ = sec->to_native(); tm->nanoseconds_ = nsec->to_native(); } // Do a little overflow cleanup. if(tm->nanoseconds_ >= 1000000000) { tm->seconds_ += tm->nanoseconds_ / 1000000000; tm->nanoseconds_ %= 1000000000; } if(tm->nanoseconds_ < 0) { tm->seconds_ += NDIV(tm->nanoseconds_, 1000000000); tm->nanoseconds_ = NMOD(tm->nanoseconds_, 1000000000); } if(LANGUAGE_18_ENABLED(state)) { tm->nanoseconds_ -= (tm->nanoseconds_ % 1000); } tm->is_gmt(state, CBOOL(gmt) ? cTrue : cFalse); return tm; }
inline bool goto_if_false(CallFrame* call_frame) { Object* t1 = stack_pop(); if(!CBOOL(t1)) { return true; } else { return false; } }
Object* AccessVariable::access_write_regular_ivar(STATE, CallFrame* call_frame, Executable* exec, Module* mod, Arguments& args) { AccessVariable* access = as<AccessVariable>(exec); if(unlikely(args.total() != 1)) { Exception::argument_error(state, 1, args.total()); return NULL; } Object* recv = args.recv(); if(CBOOL(recv->frozen_p(state)) && CBOOL(recv->frozen_mod_disallowed(state))) { Exception::frozen_error(state, call_frame, recv); return 0; } return recv->set_ivar(state, access->name(), args.get_argument(0)); }
Object* Thread::set_critical(STATE, Object* obj) { if(CBOOL(obj)) { state->shared().set_critical(state); return cTrue; } else { state->shared().clear_critical(state); return cFalse; } }
/** @todo Remove redundancy between this and sends. --rue */ Tuple* locate_method_on(STATE, CallFrame* call_frame, Object* recv, Symbol* name, Object* priv) { LookupData lookup(recv, recv->lookup_begin(state), CBOOL(priv) ? G(sym_private) : G(sym_protected)); Dispatch dis(name); if(!GlobalCache::resolve(state, dis.name, dis, lookup)) { return nil<Tuple>(); } return Tuple::from(state, 2, dis.method, dis.module); }
inline bool set_ivar(STATE, CallFrame* call_frame, intptr_t literal) { if(CBOOL(call_frame->self()->frozen_p(state))) { Exception::frozen_error(state, call_frame->self()); return false; } Symbol* sym = reinterpret_cast<Symbol*>(literal); call_frame->self()->set_ivar(state, sym, stack_top()); return true; }
Object* JIT::enable(STATE) { if(!CBOOL(enabled())) return cFalse; /* TODO: JIT state->shared().llvm_state->enable(state); */ enabled(state, cTrue); return cTrue; }
Object* Thread::set_critical(STATE, Object* obj, CallFrame* calling_environment) { state->set_call_frame(calling_environment); if(CBOOL(obj)) { state->shared().set_critical(state); return cTrue; } else { state->shared().clear_critical(state); return cFalse; } }
/* _exec */ obj_t BGl__execz00zzcc_execz00(obj_t BgL_envz00_123, obj_t BgL_cmdz00_124, obj_t BgL_comezd2backzd2_125, obj_t BgL_namez00_126) { AN_OBJECT; { /* Cc/exec.scm 48 */ return BGl_execz00zzcc_execz00(BgL_cmdz00_124, CBOOL(BgL_comezd2backzd2_125), BgL_namez00_126); } }
Object* JIT::start_method_update(STATE) { if(!CBOOL(enabled())) return cFalse; /* TODO: JIT LLVMState* ls = state->shared().llvm_state; ls->start_method_update(); */ return cTrue; }
/* _effect-walk! */ obj_t BGl__effectzd2walkz12zc0zzeffect_walkz00(obj_t BgL_envz00_1416, obj_t BgL_globalsz00_1417, obj_t BgL_feffectz00_1418) { AN_OBJECT; { /* Effect/walk.scm 33 */ return BGl_effectzd2walkz12zc0zzeffect_walkz00(BgL_globalsz00_1417, CBOOL(BgL_feffectz00_1418)); } }
Thread* Thread::wakeup(STATE) { utilities::thread::SpinLock::LockGuard guard(init_lock_); if(!CBOOL(alive()) || !vm()) { return force_as<Thread>(Primitives::failure()); } vm()->wakeup(state); return this; }
/* _make-tmp-main */ obj_t BGl__makezd2tmpzd2mainz00zzengine_linkz00(obj_t BgL_envz00_532, obj_t BgL_filez00_533, obj_t BgL_mainz00_534, obj_t BgL_modulez00_535, obj_t BgL_clausesz00_536, obj_t BgL_librariesz00_537) { AN_OBJECT; { /* Engine/link.scm 146 */ return BGl_makezd2tmpzd2mainz00zzengine_linkz00(BgL_filez00_533, CBOOL(BgL_mainz00_534), BgL_modulez00_535, BgL_clausesz00_536, BgL_librariesz00_537); } }
Object* JIT::compile_soon(STATE, CompiledCode* code, Class* receiver_class, BlockEnvironment* block_env, bool is_block) { if(!CBOOL(enabled())) return cFalse; /* TODO: JIT LLVMState* ls = state->shared().llvm_state; ls->compile_soon(state, code, receiver_class, block_env, is_block); */ return cTrue; }
Object* JIT::compile_callframe(STATE, CompiledCode* code, int primitive) { if(!CBOOL(enabled())) return cFalse; /* TODO: JIT LLVMState* ls = state->shared().llvm_state; ls->compile_callframe(state, code, primitive); */ return cTrue; }
/* setup-default-values */ BGL_EXPORTED_DEF obj_t BGl_setupzd2defaultzd2valuesz00zzinit_setrcz00() { AN_OBJECT; { /* Init/setrc.scm 25 */ { /* Init/setrc.scm 26 */ obj_t BgL_pathz00_87; { /* Init/setrc.scm 26 */ obj_t BgL_homez00_91; BgL_homez00_91 = BGl_getenvz00zz__osz00(BSTRING_TO_STRING (BGl_string1523z00zzinit_setrcz00)); if (STRINGP(BgL_homez00_91)) { /* Init/setrc.scm 27 */ BgL_pathz00_87 = MAKE_PAIR(BgL_homez00_91, BGl_za2libzd2dirza2zd2zzengine_paramz00); } else { /* Init/setrc.scm 27 */ BgL_pathz00_87 = BGl_za2libzd2dirza2zd2zzengine_paramz00; } } { /* Init/setrc.scm 26 */ obj_t BgL_fnamez00_88; BgL_fnamez00_88 = BGl_findzd2filezf2pathz20zz__osz00(BGl_string1524z00zzinit_setrcz00, BgL_pathz00_87); { /* Init/setrc.scm 30 */ if (CBOOL(BgL_fnamez00_88)) { /* Init/setrc.scm 32 */ obj_t BgL_envz00_90; BgL_envz00_90 = BGl_defaultzd2environmentzd2zz__evalz00(); { /* Init/setrc.scm 32 */ return BGl_loadqz00zz__evalz00(BgL_fnamez00_88, BgL_envz00_90); } } else { /* Init/setrc.scm 31 */ return BFALSE; } } } } } }
/* module-initialization */ BGL_EXPORTED_DEF obj_t BGl_modulezd2initializa7ationz75zz__foreignz00(long BgL_checksumz00_688, char * BgL_fromz00_689) { AN_OBJECT; { if( CBOOL(BGl_requirezd2initializa7ationz75zz__foreignz00)) { BGl_requirezd2initializa7ationz75zz__foreignz00 = BBOOL(((bool_t)0)); BGl_importedzd2moduleszd2initz00zz__foreignz00(); return BUNSPEC;} else { return BUNSPEC;} } }
/* foreign-null? */ BGL_EXPORTED_DEF bool_t BGl_foreignzd2nullzf3z21zz__foreignz00(obj_t BgL_objz00_4) { AN_OBJECT; { /* Llib/foreign.scm 101 */ if( FOREIGNP(BgL_objz00_4)) { /* Llib/foreign.scm 102 */ return FOREIGN_NULLP(BgL_objz00_4);} else { /* Llib/foreign.scm 102 */ return CBOOL( BGl_errorz00zz__errorz00(BGl_string1397z00zz__foreignz00, BGl_string1398z00zz__foreignz00, BgL_objz00_4));} } }
/* unprof-src-name */ BGL_EXPORTED_DEF obj_t BGl_unprofzd2srczd2namez00zzengine_linkz00(obj_t BgL_namez00_1) { AN_OBJECT; { /* Engine/link.scm 71 */ if (CBOOL(BGl_za2profilezd2modeza2zd2zzengine_paramz00)) { /* Engine/link.scm 74 */ long BgL_lenz00_218; BgL_lenz00_218 = STRING_LENGTH(BgL_namez00_1); { /* Engine/link.scm 75 */ bool_t BgL_testz00_614; if ((BgL_lenz00_218 > ((long) 2))) { /* Engine/link.scm 75 */ if ( (STRING_REF(BgL_namez00_1, (BgL_lenz00_218 - ((long) 1))) == ((unsigned char) 'p'))) { /* Engine/link.scm 76 */ BgL_testz00_614 = (STRING_REF(BgL_namez00_1, (BgL_lenz00_218 - ((long) 2))) == ((unsigned char) '_')); } else { /* Engine/link.scm 76 */ BgL_testz00_614 = ((bool_t) 0); } } else { /* Engine/link.scm 75 */ BgL_testz00_614 = ((bool_t) 0); } if (BgL_testz00_614) { /* Engine/link.scm 75 */ return c_substring(BgL_namez00_1, ((long) 0), (BgL_lenz00_218 - ((long) 2))); } else { /* Engine/link.scm 75 */ return BgL_namez00_1; } } } else { /* Engine/link.scm 72 */ return BgL_namez00_1; } } }
Thread* Thread::wakeup(STATE, GCToken gct) { utilities::thread::SpinLock::LockGuard lg(init_lock_); Thread* self = this; OnStack<1> os(state, self); VM* vm = self->vm_; if(!CBOOL(alive()) || !vm) { return force_as<Thread>(Primitives::failure()); } vm->wakeup(state, gct); return self; }