Skip to content

Instantly share code, notes, and snippets.

@miura1729

miura1729/out.c

Created January 18, 2026 02:53
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save miura1729/ce2b37dd5f86f4437620359b590191a0 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save miura1729/ce2b37dd5f86f4437620359b590191a0 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
out.c
#include <mruby.h>
#include <mruby/value.h>
#include <mruby/array.h>
#include <mruby/hash.h>
#include <mruby/throw.h>
#include <mruby/proc.h>
#include <mruby/string.h>
#include <mruby/range.h>
#include <mruby/error.h>
#include <mruby/variable.h>
#include <mruby/throw.h>
#include <mruby/data.h>
#include <mruby/class.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <pthread.h>
#undef mrb_int
typedef mrb_float mrb_float2;
#define mrb_float_value2(n) ({\
mrb_value rc; \
rc.f = n; \
rc; \
})
#define mmc_boxing_array(src, size, boxing_func) ({ \
mrb_value ary; \
ary = mrb_ary_new_capa(mrb, (size)); \
for (int i = 0; i < (size); i++) { \
mrb_ary_push(mrb, ary, (boxing_func)(mrb, (src)[i])); \
} \
ary; \
})
#define ARY_PTR2(a) ({struct RArray* ary=(a);ARY_PTR(ary);})
#define ARY_LEN2(a) ({struct RArray* ary=(a);ARY_LEN(ary);})
typedef void *gproc;
struct gctab {
int size;
int csize;
int osize;
struct gctab *prev;
mrb_value **complex;
mrb_value **object;
void *caller_alloc;
int ret_status;
mrb_value *single[0];
};
typedef mrb_value mrb_value_mutex;
typedef mrb_value mrb_value_mutex_emptylock;
struct mutex_wrapper {
pthread_mutex_t mp;
mrb_value obj;
};
struct mutex_wrapper_emptylock {
pthread_mutex_t mp;
pthread_cond_t empty_cond;
mrb_value obj;
};
void mrb_mutex_free(mrb_state *mrb, void *data)
{
struct mutex_wrapper *mutex_data = (struct mutex_wrapper *)data;
pthread_mutex_destroy(&mutex_data->mp);
mrb_free(mrb, data);
}
mrb_data_type mutex_data_header = {"Mutex Data", mrb_mutex_free};
mrb_data_type thread_data_header = {"Thread Data", mrb_free};
struct thread_list {
struct pthead_t *thread;
mrb_state *mrb;
struct thread_list *next;
};
struct mmc_system {
struct RClass *pthread_class;
struct thread_list *thread_list;
mrb_state *root_mrb;
pthread_mutex_t *io_mutex;
pthread_mutex_t *gc_mutex;
};
void mrb_mark_local(mrb_state *mrb)
{
if (mrb->ud == NULL) {
return;
}
struct thread_list *thlist = ((struct mmc_system *)mrb->ud)->thread_list;
while (thlist) {
mrb_state *tmrb = thlist->mrb;
struct gctab *curtab = (struct gctab *)tmrb->allocf_ud;
thlist = thlist->next;
while (curtab) {
for (int i = curtab->size; i--;) {
if (!mrb_immediate_p(*curtab->single[i])) {
mrb_gc_mark(mrb, mrb_basic_ptr(*curtab->single[i]));
}
}
for (int i = curtab->osize; i--;) {
if (!mrb_immediate_p(*curtab->object[i])) {
mrb_gc_mark(mrb, mrb_basic_ptr(*curtab->object[i]));
}
}
for (int i = curtab->csize; i--;) {
mrb_value *cptr = curtab->complex[i];
for (int j = 0; cptr[j].value.ttt != MRB_TT_FREE; j++) {
if (!mrb_immediate_p(cptr[i])) {
mrb_gc_mark(mrb, mrb_basic_ptr(cptr[j]));
}
}
}
curtab = curtab->prev;
}
}
}
struct env2 {
struct env0 *prev;
};
struct thprocarg984 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v719;
gproc v720;
struct gctab *prevgctab;
};
struct thprocarg1220 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v988;
gproc v989;
struct gctab *prevgctab;
};
struct env3 {
mrb_value v749;
mrb_value_mutex_emptylock v745;
mrb_value_mutex_emptylock v738;
struct env2 *prev;
};
struct env17 {
mrb_value v1015;
mrb_value_mutex_emptylock v1014;
mrb_value_mutex_emptylock v1007;
struct env2 *prev;
};
struct cls0_39 {
};
struct cls5_39 {
pthread_t thread;
void *argv;
void (*thread_func)(void *);
};
struct env7 {
struct env3 *prev;
};
struct env14 {
struct env3 *prev;
};
struct env4 {
struct env3 *prev;
};
struct thprocarg843 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v777;
mrb_int v778;
gproc v779;
struct gctab *prevgctab;
};
struct env9 {
mrb_value v863;
struct env3 *prev;
};
struct env16 {
struct env3 *prev;
};
struct env18 {
struct env17 *prev;
};
struct thprocarg1104 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v1043;
mrb_int v1044;
gproc v1045;
struct gctab *prevgctab;
};
struct env20 {
mrb_value v1124;
struct env17 *prev;
};
struct env23 {
struct env17 *prev;
};
struct env8 {
struct env4 *prev;
};
struct env19 {
struct env18 *prev;
};
struct env10 {
struct env9 *prev;
};
struct env11 {
struct env9 *prev;
};
struct env15 {
struct env9 *prev;
};
struct env21 {
struct env20 *prev;
};
struct env22 {
struct env20 *prev;
};
static mrb_value main_Object_0(mrb_state *, mrb_value v9,struct gctab *);
mrb_value const0;
mrb_value const1;
struct proc3 {
int id;
void *code[1];
struct env2 *env;
mrb_value self;
};
struct proc17 {
int id;
void *code[1];
struct env2 *env;
mrb_value self;
};
static mrb_value main__Object__1(mrb_state *, mrb_value v685,struct gctab *);
static mrb_value p3_Object_0_2(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v725, gproc v726, struct gctab *);
mrb_value const2;
struct proc4 {
int id;
void *code[2];
struct env3 *env;
mrb_value self;
};
struct proc9 {
int id;
void *code[2];
struct env3 *env;
mrb_value self;
};
struct proc16 {
int id;
void *code[1];
struct env3 *env;
mrb_value self;
};
static mrb_value p17_Object_1_21(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v994, gproc v995, struct gctab *);
struct proc18 {
int id;
void *code[2];
struct env17 *env;
mrb_value self;
};
struct proc20 {
int id;
void *code[2];
struct env17 *env;
mrb_value self;
};
struct proc23 {
int id;
void *code[1];
struct env17 *env;
mrb_value self;
};
static mrb_int times__Fixnum__3(mrb_state *, mrb_int v2213, gproc v2214,struct gctab *);
static mrb_int times__Fixnum__9(mrb_state *, mrb_int v2213, gproc v2214,struct gctab *);
static mrb_value each__Array__19(mrb_state *, mrb_value v3956, gproc v3957,struct gctab *);
static mrb_int times__Fixnum__22(mrb_state *, mrb_int v2213, gproc v2214,struct gctab *);
static mrb_int times__Fixnum__28(mrb_state *, mrb_int v2213, gproc v2214,struct gctab *);
static mrb_value each__Array__37(mrb_state *, mrb_value v3956, gproc v3957,struct gctab *);
static mrb_value p4_Object_0_7(mrb_state *, gproc cgproc, mrb_int v756, struct gctab *);
struct proc8 {
int id;
void *code[3];
struct env4 *env;
mrb_value self;
};
static mrb_value p9_Object_1_18(mrb_state *, gproc cgproc, mrb_int v854, struct gctab *);
struct proc10 {
int id;
void *code[2];
struct env9 *env;
mrb_value self;
};
struct proc11 {
int id;
void *code[1];
struct env9 *env;
mrb_value self;
};
struct proc15 {
int id;
void *code[1];
struct env9 *env;
mrb_value self;
};
static struct cls5_39 * p16_Object_2_20(mrb_state *, gproc cgproc, mrb_value v966, struct gctab *);
static mrb_value p18_Object_0_26(mrb_state *, gproc cgproc, mrb_int v1022, struct gctab *);
struct proc19 {
int id;
void *code[3];
struct env18 *env;
mrb_value self;
};
static mrb_value p20_Object_1_36(mrb_state *, gproc cgproc, mrb_int v1115, struct gctab *);
struct proc21 {
int id;
void *code[2];
struct env20 *env;
mrb_value self;
};
struct proc22 {
int id;
void *code[2];
struct env20 *env;
mrb_value self;
};
static struct cls5_39 * p23_Object_2_38(mrb_state *, gproc cgproc, mrb_value v1202, struct gctab *);
static mrb_value p8_Object_0_8(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v784, mrb_int v785, gproc v786, struct gctab *);
static mrb_value p19_Object_0_27(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v1050, mrb_int v1051, gproc v1052, struct gctab *);
static mrb_int times__Fixnum__11(mrb_state *, mrb_int v2213, gproc v2214,struct gctab *);
static mrb_value each__Array__14(mrb_state *, mrb_value v3956, gproc v3957,struct gctab *);
static mrb_value each__Array__16(mrb_state *, mrb_value v3956, gproc v3957,struct gctab *);
static mrb_int times__Fixnum__30(mrb_state *, mrb_int v2213, gproc v2214,struct gctab *);
static mrb_value each__Array__33(mrb_state *, mrb_value v3956, gproc v3957,struct gctab *);
static mrb_value p10_Object_0_13(mrb_state *, gproc cgproc, mrb_int v870, struct gctab *);
static mrb_value p11_Object_1_15(mrb_state *, gproc cgproc, mrb_value v904, struct gctab *);
static mrb_value p15_Object_2_17(mrb_state *, gproc cgproc, mrb_value v930, struct gctab *);
static mrb_value p21_Object_0_32(mrb_state *, gproc cgproc, mrb_int v1131, struct gctab *);
static mrb_value p22_Object_1_35(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v1169, struct gctab *);
void *apply_thproc_984(void *arg) {
struct thprocarg984 *tpargv = (struct thprocarg984 *)arg;
p3_Object_0_2(tpargv->mrb, tpargv->cgproc, tpargv->v719, tpargv->v720, tpargv->prevgctab);
return NULL;
}
void *apply_thproc_1220(void *arg) {
struct thprocarg1220 *tpargv = (struct thprocarg1220 *)arg;
p17_Object_1_21(tpargv->mrb, tpargv->cgproc, tpargv->v988, tpargv->v989, tpargv->prevgctab);
return NULL;
}
void *apply_thproc_843(void *arg) {
struct thprocarg843 *tpargv = (struct thprocarg843 *)arg;
p8_Object_0_8(tpargv->mrb, tpargv->cgproc, tpargv->v777, tpargv->v778, tpargv->v779, tpargv->prevgctab);
return NULL;
}
void *apply_thproc_1104(void *arg) {
struct thprocarg1104 *tpargv = (struct thprocarg1104 *)arg;
p19_Object_0_27(tpargv->mrb, tpargv->cgproc, tpargv->v1043, tpargv->v1044, tpargv->v1045, tpargv->prevgctab);
return NULL;
}
int main(int argc, char **argv)
{
mrb_state *mrb = mrb_open();
struct mrb_jmpbuf c_jmp;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab));
struct RClass *pthread_class;
struct thread_list *thread_list;
pthread_mutex_t *io_mutex;
pthread_mutex_t *gc_mutex;
struct mmc_system *mmc_system;
gctab->prev = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
mmc_system = malloc(sizeof(struct mmc_system));
pthread_class = mrb_define_class(mrb, "Pthread", mrb->object_class);
mmc_system->pthread_class = pthread_class;
thread_list = malloc(sizeof(struct thread_list));
thread_list->thread = pthread_self();
thread_list->next = NULL;
mmc_system->thread_list = thread_list;
io_mutex = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(io_mutex, NULL);
mmc_system->root_mrb = mrb;
mmc_system->io_mutex = io_mutex;
gc_mutex = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(gc_mutex, NULL);
mmc_system->gc_mutex = gc_mutex;
mrb->ud = (void *)mmc_system;
MRB_SET_INSTANCE_TT(((struct mmc_system *)mrb->ud)->pthread_class, MRB_TT_DATA);
MRB_TRY(&c_jmp) {
mrb->jmp = &c_jmp;
main_Object_0(mrb, mrb_top_self(mrb), gctab);
}
MRB_CATCH(&c_jmp) {
mrb_p(mrb, mrb_obj_value(mrb->exc));
return 1;
}
MRB_END_EXC(&c_jmp);
return 0;
}
static mrb_value main_Object_0(mrb_state *mrb, mrb_value v9, struct gctab *prevgctab) {
mrb_value self;
mrb_value mutexself;
mrb_value v16;
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 1 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L0:;
mutexself = v9;
self = v9;
/* START END */
gctab->single[0] = &mutexself;/* normal */
gctab->size = 1;
v16 = main__Object__1(mrb, self, gctab);
return v16;
}
static mrb_value main__Object__1(mrb_state *mrb, mrb_value v685, struct gctab *prevgctab) {
struct env2 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
char *v713 = "START";
char *v715;
mrb_value_mutex_emptylock v716;
struct proc3 v720;
struct cls5_39 * v984;
struct cls5_39 * ubv984;
;
struct thread_list *thlist984 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist984 = ((struct mmc_system *)mrb->ud)->thread_list;
struct proc17 v989;
struct cls5_39 * v1220;
struct cls5_39 * ubv1220;
;
struct thread_list *thlist1220 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist1220 = ((struct mmc_system *)mrb->ud)->thread_list;
mrb_value v1226;
mrb_value_mutex_emptylock v1278;
struct cls5_39 * v1279;
struct cls5_39 * v1280;
mrb_int v1281;
mrb_bool v1289;/*snd1*/
mrb_value v1240;
char *v1243 = "foo";
char *v1245;
mrb_value v1249;
mrb_int v1273;/*snd1*/
struct cls5_39 * v1301;
struct cls5_39 * v1303;
struct cls5_39 * v1304;
struct cls5_39 * v1306;
char *v1308 = "OK";
char *v1310;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 2 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
L24:;
mutexself = v685;
self = v685;
/* START END */
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, (mrb_str_new_cstr(mrb, "START")));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v715 = "START";
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v716 = mrb_nil_value();
gctab->single[gctab->size] = &v716; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mrb->allocf_ud = (void *)gctab;
v716 = mrb_nil_value();
gctab->single[gctab->size] = &v716; /* conversion */
gctab->size++;
v716 = ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper_emptylock *mutex = malloc(sizeof(struct mutex_wrapper_emptylock));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
pthread_cond_init(&mutex->empty_cond, NULL);
mutex->obj = array;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
v720.id = 3;
v720.self = self;
v720.env = &env;
{
struct thprocarg984 *tpargv = malloc(sizeof(struct thprocarg984));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v720);
tpargv->v719 = v716;
tpargv->v720 = ((gproc)&v720);
tpargv->prevgctab = gctab;
ubv984 = malloc(sizeof(*ubv984));
ubv984->argv = tpargv;
pthread_create(&ubv984->thread, NULL, apply_thproc_984, tpargv);
thlist984->thread = ubv984->thread;
thlist984->mrb = nmrb;
thlist984->next = orgthlist984;
((struct mmc_system *)mrb->ud)->thread_list = thlist984;
v984 = ubv984;
}
v989.id = 17;
v989.self = self;
v989.env = &env;
{
struct thprocarg1220 *tpargv = malloc(sizeof(struct thprocarg1220));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v989);
tpargv->v988 = v716;
tpargv->v989 = ((gproc)&v989);
tpargv->prevgctab = gctab;
ubv1220 = malloc(sizeof(*ubv1220));
ubv1220->argv = tpargv;
pthread_create(&ubv1220->thread, NULL, apply_thproc_1220, tpargv);
thlist1220->thread = ubv1220->thread;
thlist1220->mrb = nmrb;
thlist1220->next = orgthlist1220;
((struct mmc_system *)mrb->ud)->thread_list = thlist1220;
v1220 = ubv1220;
}
sleep(1);
v1226 = (mrb_fixnum_value(1));
v1278 = v716; /* 1*/
v1279 = v984; /* 1*/
v1280 = v1220; /* 1*/
v1281 = 2; /* 1*/
L28:;
v1289 = (v1281 > 0);
if (v1289) goto L25; else goto L29;
L25:;
mrb->allocf_ud = (void *)gctab;
v1240 = ({
struct mutex_wrapper *mutex = (struct mutex_wrapper *)DATA_PTR(mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1278);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
while (ARY_LEN2(mrb_ary_ptr(tmp)) == 0) {
pthread_cond_wait(&mutex->empty_cond, &mutex->mp);
}
tmp;
})
));
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
pthread_mutex_unlock(&((struct mutex_wrapper *)(DATA_PTR(v1278)))->mp);
mrb->allocf_ud = (void *)gctab;
gctab->single[0] = &v1278;/* normal */
gctab->single[1] = &v1240;/* normal */
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, (mrb_str_new_cstr(mrb, "foo")));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1245 = "foo";
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v1240);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1249 = v1240;
if ((mrb_test(v1240))) goto L26; else goto L27;
L26:;
v1278 = v1278; /* 2*/
v1279 = v1279; /* 2*/
v1280 = v1280; /* 2*/
v1281 = v1281; /* 2*/
goto L28;
L27:;
v1273 = (v1281 - 1);
v1278 = v1278; /* 3*/
v1279 = v1279; /* 3*/
v1280 = v1280; /* 3*/
v1281 = v1273; /* 3*/
goto L28;
L29:;
{
void *ret;
pthread_join(v1279->thread, &ret);
}
{
void *ret;
pthread_join(v1280->thread, &ret);
}
mrb->allocf_ud = (void *)gctab;
gctab->size = 0;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, (mrb_str_new_cstr(mrb, "OK")));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1310 = "OK";
mrb_gc_arena_restore(mrb, ai);
return mrb_nil_value();
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value p3_Object_0_2(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v725, gproc v726, struct gctab *prevgctab) {
struct proc3 *proc = (struct proc3 *)cgproc;
mrb_value v724 = proc->self;
struct env3 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v733;
gproc v734;
mrb_value_mutex_emptylock v738;
mrb_value_mutex_emptylock v745;
mrb_value v748;
struct proc4 v751;
mrb_int v847;
struct proc9 v849;
mrb_int v955;
mrb_value_mutex_emptylock v959;
mrb_value_mutex_emptylock v4091;
struct proc16 v961;
mrb_value v982;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 3 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
env.prev = proc->env;
L30:;
mutexself = v724;
self = v724;
v733 = v725;
v734 = v726;
/* START END */
env.v738 = v725;/*enter */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v745 = mrb_nil_value();
gctab->single[gctab->size] = &v745; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mrb->allocf_ud = (void *)gctab;
v745 = mrb_nil_value();
gctab->single[gctab->size] = &v745; /* conversion */
gctab->size++;
v745 = ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper_emptylock *mutex = malloc(sizeof(struct mutex_wrapper_emptylock));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
pthread_cond_init(&mutex->empty_cond, NULL);
mutex->obj = array;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v745 = v745;/*foo*/
gctab->single[0] = &v725;/* normal */
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
{
mrb_value ary = mrb_ary_new_capa(mrb, 1);
ARY_SET_LEN(mrb_ary_ptr(ary), 0);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v748 = ary;
}
env.v749 = v748;/*foo*/
v751.id = 4;
v751.self = self;
v751.env = &env;
gctab->single[2] = &v748;/* normal */
gctab->size = 3;
v847 = times__Fixnum__3(mrb, 9, ((gproc)&v751), gctab);
v849.id = 9;
v849.self = self;
v849.env = &env;
v955 = times__Fixnum__9(mrb, 3, ((gproc)&v849), gctab);
mrb->allocf_ud = (void *)gctab;
v4091 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v725);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_unshift(mrb, v4091, ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper *mutex = malloc(sizeof(struct mutex_wrapper));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
mutex->obj = mrb_nil_value();
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v959 = v725;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v725)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v725)))->empty_cond);
v961.id = 16;
v961.self = self;
v961.env = &env;
v982 = each__Array__19(mrb, v748, ((gproc)&v961), gctab);
mrb_gc_arena_restore(mrb, ai);
return v982;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value p17_Object_1_21(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v994, gproc v995, struct gctab *prevgctab) {
struct proc17 *proc = (struct proc17 *)cgproc;
mrb_value v993 = proc->self;
struct env17 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v1002;
gproc v1003;
mrb_value_mutex_emptylock v1007;
mrb_value_mutex_emptylock v1014;
mrb_value v1015;
struct proc18 v1017;
mrb_int v1108;
struct proc20 v1110;
mrb_int v1191;
mrb_value_mutex_emptylock v1195;
mrb_value_mutex_emptylock v4205;
struct proc23 v1197;
mrb_value v1218;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 3 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
env.prev = proc->env;
L38:;
mutexself = v993;
self = v993;
v1002 = v994;
v1003 = v995;
/* START END */
env.v1007 = v994;/*enter */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v1014 = mrb_nil_value();
gctab->single[gctab->size] = &v1014; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mrb->allocf_ud = (void *)gctab;
v1014 = mrb_nil_value();
gctab->single[gctab->size] = &v1014; /* conversion */
gctab->size++;
v1014 = ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper_emptylock *mutex = malloc(sizeof(struct mutex_wrapper_emptylock));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
pthread_cond_init(&mutex->empty_cond, NULL);
mutex->obj = array;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v1014 = v1014;/*foo*/
{
mrb_value tmpele[] = {
};
mrb->allocf_ud = (void *)gctab;
v1015 = mrb_nil_value();
gctab->single[gctab->size] = &v1015; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1015 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v1015 = v1015;/*foo*/
v1017.id = 18;
v1017.self = self;
v1017.env = &env;
gctab->single[0] = &v994;/* normal */
v1108 = times__Fixnum__22(mrb, 27, ((gproc)&v1017), gctab);
v1110.id = 20;
v1110.self = self;
v1110.env = &env;
v1191 = times__Fixnum__28(mrb, 3, ((gproc)&v1110), gctab);
mrb->allocf_ud = (void *)gctab;
v4205 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v994);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_unshift(mrb, v4205, ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper *mutex = malloc(sizeof(struct mutex_wrapper));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
mutex->obj = mrb_nil_value();
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v1195 = v994;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v994)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v994)))->empty_cond);
v1197.id = 23;
v1197.self = self;
v1197.env = &env;
v1218 = each__Array__37(mrb, v1015, ((gproc)&v1197), gctab);
mrb_gc_arena_restore(mrb, ai);
return v1218;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int times__Fixnum__3(mrb_state *mrb, mrb_int v2213, gproc v2214, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2220;
gproc v2270;
mrb_int v2271;
mrb_bool v2278;/*snd1*/
mrb_value v2264;
mrb_int v2266;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2213;
self = 9;
v2220 = v2214;
/* START END */
L101:;
L103:;
v2270 = v2214; /* 1*/
v2271 = 0; /* 1*/
L105:;
v2278 = (v2271 < self);
if (v2278) goto L104; else goto L106;
L104:;
v2264 = (p4_Object_0_7(mrb, v2270, v2271, gctab));
v2266 = (v2271 + 1);
v2270 = v2270; /* 2*/
v2271 = v2266; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_int times__Fixnum__9(mrb_state *mrb, mrb_int v2213, gproc v2214, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2220;
gproc v2270;
mrb_int v2271;
mrb_bool v2278;/*snd1*/
mrb_value v2264;
mrb_int v2266;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2213;
self = 3;
v2220 = v2214;
/* START END */
L101:;
L103:;
v2270 = v2214; /* 1*/
v2271 = 0; /* 1*/
L105:;
v2278 = (v2271 < self);
if (v2278) goto L104; else goto L106;
L104:;
v2264 = (p9_Object_1_18(mrb, v2270, v2271, gctab));
v2266 = (v2271 + 1);
v2270 = v2270; /* 2*/
v2271 = v2266; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__19(mrb_state *mrb, mrb_value v3956, gproc v3957, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3964;
gproc v4022;
mrb_int v4023;
mrb_int v4031;
mrb_bool v4033;/*snd1*/
mrb_value v4014;
struct cls5_39 * v4016;
mrb_int v4018;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3956;
self = v3956;
v3964 = v3957;
/* START END */
L211:;
L213:;
v4022 = v3957; /* 1*/
v4023 = 0; /* 1*/
L215:;
v4031 = ARY_LEN2(mrb_ary_ptr(self));
v4033 = (v4023 < v4031);
if (v4033) goto L214; else goto L216;
L214:;
{
v4014 = ARY_PTR2(mrb_ary_ptr(self))[v4023];
}
v4016 = (p16_Object_2_20(mrb, v4022, v4014, gctab));
v4018 = (v4023 + 1);
v4022 = v4022; /* 2*/
v4023 = v4018; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_int times__Fixnum__22(mrb_state *mrb, mrb_int v2213, gproc v2214, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2220;
gproc v2270;
mrb_int v2271;
mrb_bool v2278;/*snd1*/
mrb_value v2264;
mrb_int v2266;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2213;
self = 27;
v2220 = v2214;
/* START END */
L101:;
L103:;
v2270 = v2214; /* 1*/
v2271 = 0; /* 1*/
L105:;
v2278 = (v2271 < self);
if (v2278) goto L104; else goto L106;
L104:;
v2264 = (p18_Object_0_26(mrb, v2270, v2271, gctab));
v2266 = (v2271 + 1);
v2270 = v2270; /* 2*/
v2271 = v2266; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_int times__Fixnum__28(mrb_state *mrb, mrb_int v2213, gproc v2214, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2220;
gproc v2270;
mrb_int v2271;
mrb_bool v2278;/*snd1*/
mrb_value v2264;
mrb_int v2266;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2213;
self = 3;
v2220 = v2214;
/* START END */
L101:;
L103:;
v2270 = v2214; /* 1*/
v2271 = 0; /* 1*/
L105:;
v2278 = (v2271 < self);
if (v2278) goto L104; else goto L106;
L104:;
v2264 = (p20_Object_1_36(mrb, v2270, v2271, gctab));
v2266 = (v2271 + 1);
v2270 = v2270; /* 2*/
v2271 = v2266; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__37(mrb_state *mrb, mrb_value v3956, gproc v3957, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3964;
gproc v4022;
mrb_int v4023;
mrb_int v4031;
mrb_bool v4033;/*snd1*/
mrb_value v4014;
struct cls5_39 * v4016;
mrb_int v4018;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3956;
self = v3956;
v3964 = v3957;
/* START END */
L211:;
L213:;
v4022 = v3957; /* 1*/
v4023 = 0; /* 1*/
L215:;
v4031 = ARY_LEN2(mrb_ary_ptr(self));
v4033 = (v4023 < v4031);
if (v4033) goto L214; else goto L216;
L214:;
{
v4014 = ARY_PTR2(mrb_ary_ptr(self))[v4023];
}
v4016 = (p23_Object_2_38(mrb, v4022, v4014, gctab));
v4018 = (v4023 + 1);
v4022 = v4022; /* 2*/
v4023 = v4018; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_value p4_Object_0_7(mrb_state *mrb, gproc cgproc, mrb_int v756, struct gctab *prevgctab) {
struct proc4 *proc = (struct proc4 *)cgproc;
mrb_value v755 = proc->self;
struct env4 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v764;
mrb_value v774;
mrb_value_mutex_emptylock v777;
mrb_int v778;/*snd*/
struct proc8 v779;
mrb_value v843;
struct cls5_39 * ubv843;
;
struct thread_list *thlist843 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist843 = ((struct mmc_system *)mrb->ud)->thread_list;
mrb_value v845;
mrb_value v2313;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L31:;
mutexself = v755;
self = v755;
v764 = v756;
/* START END */
v774 = proc->env->v749;
v777 = proc->env->v745;
v778 = v756;
v779.id = 8;
v779.self = self;
v779.env = &env;
{
struct thprocarg843 *tpargv = malloc(sizeof(struct thprocarg843));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v779);
tpargv->v777 = v777;
tpargv->v778 = v778;
tpargv->v779 = ((gproc)&v779);
tpargv->prevgctab = gctab;
ubv843 = malloc(sizeof(*ubv843));
ubv843->argv = tpargv;
pthread_create(&ubv843->thread, NULL, apply_thproc_843, tpargv);
thlist843->thread = ubv843->thread;
thlist843->mrb = nmrb;
thlist843->next = orgthlist843;
((struct mmc_system *)mrb->ud)->thread_list = thlist843;
v843 = (mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, ubv843, &thread_data_header)));
}
mrb->allocf_ud = (void *)gctab;
v2313 = v774;
mrb_ary_push(mrb, v2313, v843);
v845 = v774;
return v845;
}
static mrb_value p9_Object_1_18(mrb_state *mrb, gproc cgproc, mrb_int v854, struct gctab *prevgctab) {
struct proc9 *proc = (struct proc9 *)cgproc;
mrb_value v853 = proc->self;
struct env9 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v860;
mrb_value v863;
struct proc10 v865;
mrb_int v896;
mrb_value v897;
struct proc11 v899;
mrb_value v919;
mrb_value_mutex_emptylock v920;
mrb_value_mutex_emptylock v923;
mrb_value_mutex_emptylock v4051;
struct proc15 v925;
mrb_value v953;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 2 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
env.prev = proc->env;
L33:;
mutexself = v853;
self = v853;
v860 = v854;
/* START END */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v863 = mrb_nil_value();
gctab->single[gctab->size] = &v863; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v863 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v863 = v863;/*foo*/
v865.id = 10;
v865.self = self;
v865.env = &env;
v896 = times__Fixnum__11(mrb, 3, ((gproc)&v865), gctab);
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v897 = mrb_str_new(mrb, "HoHo Let's make present\n", 24);
v899.id = 11;
v899.self = self;
v899.env = &env;
gctab->single[1] = &v897;/* normal */
gctab->size = 2;
v919 = each__Array__14(mrb, v863, ((gproc)&v899), gctab);
v920 = proc->env->v738;
mrb->allocf_ud = (void *)gctab;
v4051 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v920);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_unshift(mrb, v4051, ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper *mutex = malloc(sizeof(struct mutex_wrapper));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
mutex->obj = v897;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v923 = v920;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v920)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v920)))->empty_cond);
v925.id = 15;
v925.self = self;
v925.env = &env;
v953 = each__Array__16(mrb, v863, ((gproc)&v925), gctab);
mrb_gc_arena_restore(mrb, ai);
return v953;
mrb_gc_arena_restore(mrb, ai);
}
static struct cls5_39 * p16_Object_2_20(mrb_state *mrb, gproc cgproc, mrb_value v966, struct gctab *prevgctab) {
struct proc16 *proc = (struct proc16 *)cgproc;
mrb_value v965 = proc->self;
struct env16 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v971;
mrb_value v978;
struct cls5_39 * v980;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L37:;
mutexself = v965;
self = v965;
v971 = v966;
/* START END */
{
void *ret;
pthread_join(((struct cls5_39 * )DATA_PTR(v966))->thread, &ret);
}
return v980;
}
static mrb_value p18_Object_0_26(mrb_state *mrb, gproc cgproc, mrb_int v1022, struct gctab *prevgctab) {
struct proc18 *proc = (struct proc18 *)cgproc;
mrb_value v1021 = proc->self;
struct env18 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v1030;
mrb_value v1040;
mrb_value_mutex_emptylock v1043;
mrb_int v1044;/*snd*/
struct proc19 v1045;
mrb_value v1104;
struct cls5_39 * ubv1104;
;
struct thread_list *thlist1104 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist1104 = ((struct mmc_system *)mrb->ud)->thread_list;
mrb_value v1106;
mrb_value v4130;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L39:;
mutexself = v1021;
self = v1021;
v1030 = v1022;
/* START END */
v1040 = proc->env->v1015;
v1043 = proc->env->v1014;
v1044 = v1022;
v1045.id = 19;
v1045.self = self;
v1045.env = &env;
{
struct thprocarg1104 *tpargv = malloc(sizeof(struct thprocarg1104));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v1045);
tpargv->v1043 = v1043;
tpargv->v1044 = v1044;
tpargv->v1045 = ((gproc)&v1045);
tpargv->prevgctab = gctab;
ubv1104 = malloc(sizeof(*ubv1104));
ubv1104->argv = tpargv;
pthread_create(&ubv1104->thread, NULL, apply_thproc_1104, tpargv);
thlist1104->thread = ubv1104->thread;
thlist1104->mrb = nmrb;
thlist1104->next = orgthlist1104;
((struct mmc_system *)mrb->ud)->thread_list = thlist1104;
v1104 = (mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, ubv1104, &thread_data_header)));
}
mrb->allocf_ud = (void *)gctab;
v4130 = v1040;
mrb_ary_push(mrb, v4130, v1104);
v1106 = v1040;
return v1106;
}
static mrb_value p20_Object_1_36(mrb_state *mrb, gproc cgproc, mrb_int v1115, struct gctab *prevgctab) {
struct proc20 *proc = (struct proc20 *)cgproc;
mrb_value v1114 = proc->self;
struct env20 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v1121;
mrb_value v1124;
struct proc21 v1126;
mrb_int v1157;
mrb_value v1158;
mrb_value_mutex_emptylock v1159;
mrb_value_mutex_emptylock v1162;
mrb_value_mutex_emptylock v4173;
struct proc22 v1164;
mrb_value v1189;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 2 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
env.prev = proc->env;
L41:;
mutexself = v1114;
self = v1114;
v1121 = v1115;
/* START END */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v1124 = mrb_nil_value();
gctab->single[gctab->size] = &v1124; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1124 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v1124 = v1124;/*foo*/
v1126.id = 21;
v1126.self = self;
v1126.env = &env;
v1157 = times__Fixnum__30(mrb, 9, ((gproc)&v1126), gctab);
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1158 = mrb_str_new(mrb, "HoHo Let's send present\n", 24);
v1159 = proc->env->v1007;
mrb->allocf_ud = (void *)gctab;
mrb->allocf_ud = (void *)gctab;
v4173 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1159);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_push(mrb, v4173, ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper *mutex = malloc(sizeof(struct mutex_wrapper));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
mutex->obj = v1158;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v1162 = v1159;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1159)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1159)))->empty_cond);
v1164.id = 22;
v1164.self = self;
v1164.env = &env;
gctab->single[1] = &v1158;/* normal */
gctab->size = 2;
v1189 = each__Array__33(mrb, v1124, ((gproc)&v1164), gctab);
mrb_gc_arena_restore(mrb, ai);
return v1189;
mrb_gc_arena_restore(mrb, ai);
}
static struct cls5_39 * p23_Object_2_38(mrb_state *mrb, gproc cgproc, mrb_value v1202, struct gctab *prevgctab) {
struct proc23 *proc = (struct proc23 *)cgproc;
mrb_value v1201 = proc->self;
struct env23 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v1207;
mrb_value v1214;
struct cls5_39 * v1216;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L44:;
mutexself = v1201;
self = v1201;
v1207 = v1202;
/* START END */
{
void *ret;
pthread_join(((struct cls5_39 * )DATA_PTR(v1202))->thread, &ret);
}
return v1216;
}
static mrb_value p8_Object_0_8(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v784, mrb_int v785, gproc v786, struct gctab *prevgctab) {
struct proc8 *proc = (struct proc8 *)cgproc;
mrb_value v783 = proc->self;
struct env8 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v793;
mrb_int v794;
gproc v795;
mrb_float2 v809;
mrb_int v814;
mrb_value v816;
char *v818 = "hobbit wake up ";
mrb_value v820; /* cat */
mrb_value v822;
mrb_value_mutex_emptylock v824;
mrb_value v825;
mrb_value_mutex_emptylock v829;
mrb_value_mutex_emptylock v2306;
mrb_value_mutex_emptylock v833;
mrb_value v835;
char *v837 = "Hobbit Work done ";
mrb_int v838;/*snd*/
mrb_value v839; /* cat */
mrb_value v841;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 3 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
env.prev = proc->env;
L32:;
mutexself = v783;
self = v783;
v793 = v784;
v794 = v785;
v795 = v786;
/* START END */
v809 = (((mrb_float)(rand() % 0x7fffffff)) / (double)0x7fffffff);
v814 = ((mrb_int)(v809 * ((mrb_float)10)));
sleep(v814);
v816 = (mrb_fixnum_value(v814));
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v820 = mrb_nil_value();
gctab->single[gctab->size] = &v820; /* conversion */
gctab->size++;
v820 = (mrb_str_new_cstr(mrb, "hobbit wake up "));
mrb->allocf_ud = (void *)gctab;
v820 = mrb_str_cat_cstr(mrb, v820, ({char *_buf = alloca(255);sprintf(_buf, "%d", v785);_buf;}));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
gctab->single[0] = &v784;/* normal */
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v820);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v822 = v820;
{
mrb_value tmpele[] = {
};
mrb->allocf_ud = (void *)gctab;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mrb->allocf_ud = (void *)gctab;
v824 = ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper_emptylock *mutex = malloc(sizeof(struct mutex_wrapper_emptylock));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
pthread_cond_init(&mutex->empty_cond, NULL);
mutex->obj = array;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
{
mrb_value tmpele[] = {
(mrb_fixnum_value(v785)), v824
};
mrb->allocf_ud = (void *)gctab;
v825 = mrb_nil_value();
gctab->single[gctab->size] = &v825; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 2, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v825 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 2);
}
mrb->allocf_ud = (void *)gctab;
mrb->allocf_ud = (void *)gctab;
v2306 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v784);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_push(mrb, v2306, ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper *mutex = malloc(sizeof(struct mutex_wrapper));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
mutex->obj = v825;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v829 = v784;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v784)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v784)))->empty_cond);
{
v833 = ARY_PTR2(mrb_ary_ptr(v825))[1];
}
mrb->allocf_ud = (void *)gctab;
v835 = mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v833);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
while (ARY_LEN2(mrb_ary_ptr(tmp)) == 0) {
pthread_cond_wait(&mutex->empty_cond, &mutex->mp);
}
tmp;
})
);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v833)))->mp);
v838 = v785;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
v839 = mrb_nil_value();
gctab->single[gctab->size] = &v839; /* conversion */
gctab->size++;
v839 = (mrb_str_new_cstr(mrb, "Hobbit Work done "));
mrb->allocf_ud = (void *)gctab;
v839 = mrb_str_cat_cstr(mrb, v839, ({char *_buf = alloca(255);sprintf(_buf, "%d", v838);_buf;}));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
gctab->size = 2;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v839);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v841 = v839;
mrb_gc_arena_restore(mrb, ai);
return v841;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value p19_Object_0_27(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v1050, mrb_int v1051, gproc v1052, struct gctab *prevgctab) {
struct proc19 *proc = (struct proc19 *)cgproc;
mrb_value v1049 = proc->self;
struct env19 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v1059;
mrb_int v1060;
gproc v1061;
mrb_float2 v1075;
mrb_int v1080;
mrb_value v1082;
char *v1084 = "tonakai wake up ";
mrb_value v1086; /* cat */
mrb_value v1088;
mrb_value_mutex_emptylock v1089;
mrb_value_mutex_emptylock v1093;
mrb_value_mutex_emptylock v4124;
mrb_value v1096;
char *v1098 = "Tonakai Work done ";
mrb_int v1099;/*snd*/
mrb_value v1100; /* cat */
mrb_value v1102;
int ai = mrb_gc_arena_save(mrb);
struct gctab *gctab = (struct gctab *)alloca(sizeof(struct gctab) + 4 * sizeof(mrb_value *));
gctab->prev = prevgctab;
gctab->complex = NULL;
gctab->object = NULL;
gctab->size = 0;
gctab->csize = 0;
gctab->osize = 0;
gctab->ret_status = 0;
env.prev = proc->env;
L40:;
mutexself = v1049;
self = v1049;
v1059 = v1050;
v1060 = v1051;
v1061 = v1052;
/* START END */
v1075 = (((mrb_float)(rand() % 0x7fffffff)) / (double)0x7fffffff);
v1080 = ((mrb_int)(v1075 * ((mrb_float)10)));
sleep(v1080);
v1082 = (mrb_fixnum_value(v1080));
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v1086 = mrb_nil_value();
gctab->single[gctab->size] = &v1086; /* conversion */
gctab->size++;
v1086 = (mrb_str_new_cstr(mrb, "tonakai wake up "));
mrb->allocf_ud = (void *)gctab;
v1086 = mrb_str_cat_cstr(mrb, v1086, ({char *_buf = alloca(255);sprintf(_buf, "%d", v1051);_buf;}));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
gctab->single[0] = &v1050;/* normal */
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v1086);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1088 = v1086;
{
mrb_value tmpele[] = {
};
mrb->allocf_ud = (void *)gctab;
v1089 = mrb_nil_value();
gctab->single[gctab->size] = &v1089; /* conversion */
gctab->size++;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb_value array = mrb_ary_new_from_values(mrb, 0, tmpele);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mrb->allocf_ud = (void *)gctab;
v1089 = mrb_nil_value();
gctab->single[gctab->size] = &v1089; /* conversion */
gctab->size++;
v1089 = ({
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
struct mutex_wrapper_emptylock *mutex = malloc(sizeof(struct mutex_wrapper_emptylock));
mrb_value mutexobj = mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, mutex, &mutex_data_header));
pthread_mutex_init(&mutex->mp, NULL);
pthread_cond_init(&mutex->empty_cond, NULL);
mutex->obj = array;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
mrb->allocf_ud = (void *)gctab;
v4124 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1050);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_push(mrb, v4124, v1089);
v1093 = v1050;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1050)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1050)))->empty_cond);
mrb->allocf_ud = (void *)gctab;
v1096 = mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1089);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
while (ARY_LEN2(mrb_ary_ptr(tmp)) == 0) {
pthread_cond_wait(&mutex->empty_cond, &mutex->mp);
}
tmp;
})
);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1089)))->mp);
v1099 = v1051;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
v1100 = mrb_nil_value();
gctab->single[gctab->size] = &v1100; /* conversion */
gctab->size++;
v1100 = (mrb_str_new_cstr(mrb, "Tonakai Work done "));
mrb->allocf_ud = (void *)gctab;
v1100 = mrb_str_cat_cstr(mrb, v1100, ({char *_buf = alloca(255);sprintf(_buf, "%d", v1099);_buf;}));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
gctab->size = 2;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v1100);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1102 = v1100;
mrb_gc_arena_restore(mrb, ai);
return v1102;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int times__Fixnum__11(mrb_state *mrb, mrb_int v2213, gproc v2214, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2220;
gproc v2270;
mrb_int v2271;
mrb_bool v2278;/*snd1*/
mrb_value v2264;
mrb_int v2266;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2213;
self = 3;
v2220 = v2214;
/* START END */
L101:;
L103:;
v2270 = v2214; /* 1*/
v2271 = 0; /* 1*/
L105:;
v2278 = (v2271 < self);
if (v2278) goto L104; else goto L106;
L104:;
v2264 = (p10_Object_0_13(mrb, v2270, v2271, gctab));
v2266 = (v2271 + 1);
v2270 = v2270; /* 2*/
v2271 = v2266; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__14(mrb_state *mrb, mrb_value v3956, gproc v3957, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3964;
gproc v4022;
mrb_int v4023;
mrb_int v4031;
mrb_bool v4033;/*snd1*/
mrb_value v4014;
mrb_value v4016;
mrb_int v4018;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3956;
self = v3956;
v3964 = v3957;
/* START END */
L211:;
L213:;
v4022 = v3957; /* 1*/
v4023 = 0; /* 1*/
L215:;
v4031 = ARY_LEN2(mrb_ary_ptr(self));
v4033 = (v4023 < v4031);
if (v4033) goto L214; else goto L216;
L214:;
{
v4014 = ARY_PTR2(mrb_ary_ptr(self))[v4023];
}
v4016 = (p11_Object_1_15(mrb, v4022, v4014, gctab));
v4018 = (v4023 + 1);
v4022 = v4022; /* 2*/
v4023 = v4018; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_value each__Array__16(mrb_state *mrb, mrb_value v3956, gproc v3957, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3964;
gproc v4022;
mrb_int v4023;
mrb_int v4031;
mrb_bool v4033;/*snd1*/
mrb_value v4014;
mrb_value v4016;
mrb_int v4018;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3956;
self = v3956;
v3964 = v3957;
/* START END */
L211:;
L213:;
v4022 = v3957; /* 1*/
v4023 = 0; /* 1*/
L215:;
v4031 = ARY_LEN2(mrb_ary_ptr(self));
v4033 = (v4023 < v4031);
if (v4033) goto L214; else goto L216;
L214:;
{
v4014 = ARY_PTR2(mrb_ary_ptr(self))[v4023];
}
v4016 = (p15_Object_2_17(mrb, v4022, v4014, gctab));
v4018 = (v4023 + 1);
v4022 = v4022; /* 2*/
v4023 = v4018; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_int times__Fixnum__30(mrb_state *mrb, mrb_int v2213, gproc v2214, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2220;
gproc v2270;
mrb_int v2271;
mrb_bool v2278;/*snd1*/
mrb_value v2264;
mrb_int v2266;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2213;
self = 9;
v2220 = v2214;
/* START END */
L101:;
L103:;
v2270 = v2214; /* 1*/
v2271 = 0; /* 1*/
L105:;
v2278 = (v2271 < self);
if (v2278) goto L104; else goto L106;
L104:;
v2264 = (p21_Object_0_32(mrb, v2270, v2271, gctab));
v2266 = (v2271 + 1);
v2270 = v2270; /* 2*/
v2271 = v2266; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__33(mrb_state *mrb, mrb_value v3956, gproc v3957, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3964;
gproc v4022;
mrb_int v4023;
mrb_int v4031;
mrb_bool v4033;/*snd1*/
mrb_value_mutex_emptylock v4014;
mrb_value v4016;
mrb_int v4018;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3956;
self = v3956;
v3964 = v3957;
/* START END */
L211:;
L213:;
v4022 = v3957; /* 1*/
v4023 = 0; /* 1*/
L215:;
v4031 = ARY_LEN2(mrb_ary_ptr(self));
v4033 = (v4023 < v4031);
if (v4033) goto L214; else goto L216;
L214:;
{
v4014 = ARY_PTR2(mrb_ary_ptr(self))[v4023];
}
v4016 = (p22_Object_1_35(mrb, v4022, v4014, gctab));
v4018 = (v4023 + 1);
v4022 = v4022; /* 2*/
v4023 = v4018; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_value p10_Object_0_13(mrb_state *mrb, gproc cgproc, mrb_int v870, struct gctab *prevgctab) {
struct proc10 *proc = (struct proc10 *)cgproc;
mrb_value v869 = proc->self;
struct env10 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v877;
mrb_value_mutex_emptylock v887;
mrb_value v889;
mrb_value v891;
mrb_value v894;
mrb_value v2348;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L34:;
mutexself = v869;
self = v869;
v877 = v870;
/* START END */
v887 = proc->env->prev->v745;
mrb->allocf_ud = (void *)gctab;
v889 = ({
struct mutex_wrapper *mutex = (struct mutex_wrapper *)DATA_PTR(mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v887);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
while (ARY_LEN2(mrb_ary_ptr(tmp)) == 0) {
pthread_cond_wait(&mutex->empty_cond, &mutex->mp);
}
tmp;
})
));
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
pthread_mutex_unlock(&((struct mutex_wrapper *)(DATA_PTR(v887)))->mp);
v891 = proc->env->v863;
mrb->allocf_ud = (void *)gctab;
v2348 = v891;
mrb_ary_push(mrb, v2348, v889);
v894 = v891;
return v894;
}
static mrb_value p11_Object_1_15(mrb_state *mrb, gproc cgproc, mrb_value v904, struct gctab *prevgctab) {
struct proc11 *proc = (struct proc11 *)cgproc;
mrb_value v903 = proc->self;
struct env11 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v909;
mrb_int v913;
mrb_value_mutex_emptylock v914;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L35:;
mutexself = v903;
self = v903;
v909 = v904;
/* START END */
{
mrb_value *array = ARY_PTR2(mrb_ary_ptr(v909));
v913 = (mrb_fixnum(array[0]));
v914 = array[1];
}
return mrb_nil_value();
}
static mrb_value p15_Object_2_17(mrb_state *mrb, gproc cgproc, mrb_value v930, struct gctab *prevgctab) {
struct proc15 *proc = (struct proc15 *)cgproc;
mrb_value v929 = proc->self;
struct env15 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v936;
mrb_value_mutex_emptylock v947;
mrb_value_mutex_emptylock v950;
mrb_value_mutex_emptylock v4055;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L36:;
mutexself = v929;
self = v929;
v936 = v930;
/* START END */
{
v947 = ARY_PTR2(mrb_ary_ptr(v930))[1];
}
mrb->allocf_ud = (void *)gctab;
v4055 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v947);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_push(mrb, v4055, (mrb_fixnum_value(1)));
v950 = v947;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v947)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v947)))->empty_cond);
return mrb_nil_value();
}
static mrb_value p21_Object_0_32(mrb_state *mrb, gproc cgproc, mrb_int v1131, struct gctab *prevgctab) {
struct proc21 *proc = (struct proc21 *)cgproc;
mrb_value v1130 = proc->self;
struct env21 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v1138;
mrb_value_mutex_emptylock v1148;
mrb_value_mutex_emptylock v1150;
mrb_value v1152;
mrb_value v1155;
mrb_value v4165;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L42:;
mutexself = v1130;
self = v1130;
v1138 = v1131;
/* START END */
v1148 = proc->env->prev->v1014;
mrb->allocf_ud = (void *)gctab;
v1150 = mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1148);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
while (ARY_LEN2(mrb_ary_ptr(tmp)) == 0) {
pthread_cond_wait(&mutex->empty_cond, &mutex->mp);
}
tmp;
})
);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1148)))->mp);
v1152 = proc->env->v1124;
mrb->allocf_ud = (void *)gctab;
v4165 = v1152;
mrb_ary_push(mrb, v4165, v1150);
v1155 = v1152;
return v1155;
}
static mrb_value p22_Object_1_35(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v1169, struct gctab *prevgctab) {
struct proc22 *proc = (struct proc22 *)cgproc;
mrb_value v1168 = proc->self;
struct env22 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v1175;
mrb_value_mutex_emptylock v1186;
mrb_value_mutex_emptylock v4175;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L43:;
mutexself = v1168;
self = v1168;
v1175 = v1169;
/* START END */
mrb->allocf_ud = (void *)gctab;
v4175 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1169);
struct mrb_value tmp = mutex->obj;
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
tmp;
})
;
mrb_ary_push(mrb, v4175, (mrb_fixnum_value(1)));
v1186 = v1169;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1169)))->mp);
pthread_cond_signal(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1169)))->empty_cond);
return mrb_nil_value();
}
/*
Class Object
Instance variables
methodes
main (Literal Object, NilClass e=false l=0 var=0) -> Literal NilClass
-- effects ---
canempty pop [[MutexEmptyLock<Array<[:undef] => Literal String val="HoHo Let's make present\n"|[:undef] => Literal NilClass|[:undef] => String e=true l=0 var=0|1 => Literal String val="HoHo Let's make present\n"|1 => Literal NilClass|1 => String e=true l=0 var=0|1 => String e=false l=0 var=0> e=true l=3 th={Thread Proc<irep=-2129da70 <#<Irep:0x7fffded0c100> pos=../mruby-meta-circular/sample/santa2.rb:112>> e=false=>:canempty, Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 41, :unshift], Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>[:modify, 78, :push]}>]]
Class #<Class:MMC_EXT>
Instance variables
methodes
Module Integral
Instance variables
methodes
Class Fixnum
Instance variables
methodes
times (Literal Fixnum, Proc<irep=-212a23b0 <#<Irep:0x7fffdee62990> pos=../mruby-meta-circular/sample/santa2.rb:18>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-212a9f30 <#<Irep:0x7fffdee8c0b0> pos=../mruby-meta-circular/sample/santa2.rb:31>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-212aa050 <#<Irep:0x7fffdee8f3e0> pos=../mruby-meta-circular/sample/santa2.rb:30>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-21298bf0 <#<Irep:0x7fffdeee46c0> pos=../mruby-meta-circular/sample/santa2.rb:60>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-21297d10 <#<Irep:0x7fffdef0edc0> pos=../mruby-meta-circular/sample/santa2.rb:73>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-21297de0 <#<Irep:0x7fffdeef0aa0> pos=../mruby-meta-circular/sample/santa2.rb:72>>) -> Literal Fixnum
-- effects ---
Class Array
Instance variables
methodes
each (Array<[:undef] => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}|1 => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}, Proc<irep=-212a9be0 <#<Irep:0x7fffdeea4d60> pos=../mruby-meta-circular/sample/santa2.rb:36>>) -> Array<[:undef] => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}|1 => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}
each (Array<[:undef] => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}|1 => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}, Proc<irep=-21298100 <#<Irep:0x7fffdee9eb20> pos=../mruby-meta-circular/sample/santa2.rb:44>>) -> Array<[:undef] => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}|1 => Array<[:undef] => Literal Fixnum|[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}|[:undef] => Fixnum e=false pos =true|0 => Literal Fixnum|0 => Fixnum e=false pos =true|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}
each (Array<[:undef] => Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true|1 => Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true> e=true l=4 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 19, :push]}, Proc<irep=-21298e80 <#<Irep:0x7fffdeeb5790> pos=../mruby-meta-circular/sample/santa2.rb:51>>) -> Array<[:undef] => Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true|1 => Thread Proc<irep=-212a2290 <#<Irep:0x7fffdee7e2a0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true> e=true l=4 th={Thread Proc<irep=-212a24e0 <#<Irep:0x7fffdee683c0> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 19, :push]}
each (Array<[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>:arrayset, Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true=>:canempty}|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>:arrayset, Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true=>:canempty}> e=true l=6 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>[:modify, 75, :push]}, Proc<irep=-2129dea0 <#<Irep:0x7fffdef06ae0> pos=../mruby-meta-circular/sample/santa2.rb:80>>) -> Array<[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>:arrayset, Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true=>:canempty}|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>:arrayset, Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true=>:canempty}> e=true l=6 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>[:modify, 75, :push]}
each (Array<[:undef] => Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true|1 => Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true> e=true l=4 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>[:modify, 61, :push]}, Proc<irep=-2129dd40 <#<Irep:0x7fffdef1e5e0> pos=../mruby-meta-circular/sample/santa2.rb:87>>) -> Array<[:undef] => Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true|1 => Thread Proc<irep=-21298ad0 <#<Irep:0x7fffdeedf590> pos=../mruby-meta-circular/sample/santa2.rb:61>> e=true> e=true l=4 th={Thread Proc<irep=-21298cd0 <#<Irep:0x7fffdeeca990> pos=../mruby-meta-circular/sample/santa2.rb:57>> e=false=>[:modify, 61, :push]}
-- effects ---
Class MMC_EXT::Thread
Instance variables
methodes
*/
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment