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