Skip to content

Instantly share code, notes, and snippets.

@miura1729

miura1729/gist:45d16cc4bc22ae18eedd49d62feaeada

Last active January 17, 2026 20:32
Show Gist options

  • Select an option

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

Select an option

Learn more about clone URLs
Save miura1729/45d16cc4bc22ae18eedd49d62feaeada to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gistfile1.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_mutex_t empty_lock;
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 thprocarg1004 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v735;
gproc v736;
struct gctab *prevgctab;
};
struct thprocarg1244 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v1008;
gproc v1009;
struct gctab *prevgctab;
};
struct env3 {
mrb_value v765;
mrb_value_mutex_emptylock v761;
mrb_value_mutex_emptylock v754;
struct env2 *prev;
};
struct env17 {
mrb_value v1035;
mrb_value_mutex_emptylock v1034;
mrb_value_mutex_emptylock v1027;
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 thprocarg859 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v793;
mrb_int v794;
gproc v795;
struct gctab *prevgctab;
};
struct env9 {
mrb_value v879;
struct env3 *prev;
};
struct env16 {
struct env3 *prev;
};
struct env18 {
struct env17 *prev;
};
struct thprocarg1124 {
mrb_state *mrb;
gproc cgproc;
mrb_value_mutex_emptylock v1063;
mrb_int v1064;
gproc v1065;
struct gctab *prevgctab;
};
struct env20 {
mrb_value v1144;
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 v701,struct gctab *);
static mrb_value p3_Object_0_2(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v741, gproc v742, 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 v1014, gproc v1015, 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 v2245, gproc v2246,struct gctab *);
static mrb_int times__Fixnum__9(mrb_state *, mrb_int v2245, gproc v2246,struct gctab *);
static mrb_value each__Array__19(mrb_state *, mrb_value v3988, gproc v3989,struct gctab *);
static mrb_int times__Fixnum__22(mrb_state *, mrb_int v2245, gproc v2246,struct gctab *);
static mrb_int times__Fixnum__28(mrb_state *, mrb_int v2245, gproc v2246,struct gctab *);
static mrb_value each__Array__37(mrb_state *, mrb_value v3988, gproc v3989,struct gctab *);
static mrb_value p4_Object_0_7(mrb_state *, gproc cgproc, mrb_int v772, 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 v870, 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 v986, struct gctab *);
static mrb_value p18_Object_0_26(mrb_state *, gproc cgproc, mrb_int v1042, 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 v1135, 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 v1226, struct gctab *);
static mrb_value p8_Object_0_8(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v800, mrb_int v801, gproc v802, struct gctab *);
static mrb_value p19_Object_0_27(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v1070, mrb_int v1071, gproc v1072, struct gctab *);
static mrb_int times__Fixnum__11(mrb_state *, mrb_int v2245, gproc v2246,struct gctab *);
static mrb_value each__Array__14(mrb_state *, mrb_value v3988, gproc v3989,struct gctab *);
static mrb_value each__Array__16(mrb_state *, mrb_value v3988, gproc v3989,struct gctab *);
static mrb_int times__Fixnum__30(mrb_state *, mrb_int v2245, gproc v2246,struct gctab *);
static mrb_value each__Array__33(mrb_state *, mrb_value v3988, gproc v3989,struct gctab *);
static mrb_value p10_Object_0_13(mrb_state *, gproc cgproc, mrb_int v886, struct gctab *);
static mrb_value p11_Object_1_15(mrb_state *, gproc cgproc, mrb_value v920, struct gctab *);
static mrb_value p15_Object_2_17(mrb_state *, gproc cgproc, mrb_value v946, struct gctab *);
static mrb_value p21_Object_0_32(mrb_state *, gproc cgproc, mrb_int v1151, struct gctab *);
static mrb_value p22_Object_1_35(mrb_state *, gproc cgproc, mrb_value_mutex_emptylock v1189, struct gctab *);
void *apply_thproc_1004(void *arg) {
struct thprocarg1004 *tpargv = (struct thprocarg1004 *)arg;
p3_Object_0_2(tpargv->mrb, tpargv->cgproc, tpargv->v735, tpargv->v736, tpargv->prevgctab);
return NULL;
}
void *apply_thproc_1244(void *arg) {
struct thprocarg1244 *tpargv = (struct thprocarg1244 *)arg;
p17_Object_1_21(tpargv->mrb, tpargv->cgproc, tpargv->v1008, tpargv->v1009, tpargv->prevgctab);
return NULL;
}
void *apply_thproc_859(void *arg) {
struct thprocarg859 *tpargv = (struct thprocarg859 *)arg;
p8_Object_0_8(tpargv->mrb, tpargv->cgproc, tpargv->v793, tpargv->v794, tpargv->v795, tpargv->prevgctab);
return NULL;
}
void *apply_thproc_1124(void *arg) {
struct thprocarg1124 *tpargv = (struct thprocarg1124 *)arg;
p19_Object_0_27(tpargv->mrb, tpargv->cgproc, tpargv->v1063, tpargv->v1064, tpargv->v1065, 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 v701, struct gctab *prevgctab) {
struct env2 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
char *v729 = "START";
char *v731;
mrb_value_mutex_emptylock v732;
struct proc3 v736;
struct cls5_39 * v1004;
struct cls5_39 * ubv1004;
;
struct thread_list *thlist1004 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist1004 = ((struct mmc_system *)mrb->ud)->thread_list;
struct proc17 v1009;
struct cls5_39 * v1244;
struct cls5_39 * ubv1244;
;
struct thread_list *thlist1244 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist1244 = ((struct mmc_system *)mrb->ud)->thread_list;
mrb_value v1250;
mrb_value_mutex_emptylock v1310;
struct cls5_39 * v1311;
struct cls5_39 * v1312;
mrb_int v1313;
mrb_bool v1321;/*snd1*/
mrb_value v1264;
char *v1267 = "foo";
char *v1269;
mrb_value v1273;
char *v1300 = "------";
char *v1302;
mrb_value_mutex_emptylock v1306;
struct cls5_39 * v1333;
struct cls5_39 * v1335;
struct cls5_39 * v1336;
struct cls5_39 * v1338;
char *v1340 = "OK";
char *v1342;
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 = v701;
self = v701;
/* 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);
v731 = "START";
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v732 = mrb_nil_value();
gctab->single[gctab->size] = &v732; /* 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;
v732 = mrb_nil_value();
gctab->single[gctab->size] = &v732; /* conversion */
gctab->size++;
v732 = ({
{
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_mutex_init(&mutex->empty_lock, NULL);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
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);
}
v736.id = 3;
v736.self = self;
v736.env = &env;
{
struct thprocarg1004 *tpargv = malloc(sizeof(struct thprocarg1004));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v736);
tpargv->v735 = v732;
tpargv->v736 = ((gproc)&v736);
tpargv->prevgctab = gctab;
ubv1004 = malloc(sizeof(*ubv1004));
ubv1004->argv = tpargv;
pthread_create(&ubv1004->thread, NULL, apply_thproc_1004, tpargv);
thlist1004->thread = ubv1004->thread;
thlist1004->mrb = nmrb;
thlist1004->next = orgthlist1004;
((struct mmc_system *)mrb->ud)->thread_list = thlist1004;
v1004 = ubv1004;
}
v1009.id = 17;
v1009.self = self;
v1009.env = &env;
{
struct thprocarg1244 *tpargv = malloc(sizeof(struct thprocarg1244));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v1009);
tpargv->v1008 = v732;
tpargv->v1009 = ((gproc)&v1009);
tpargv->prevgctab = gctab;
ubv1244 = malloc(sizeof(*ubv1244));
ubv1244->argv = tpargv;
pthread_create(&ubv1244->thread, NULL, apply_thproc_1244, tpargv);
thlist1244->thread = ubv1244->thread;
thlist1244->mrb = nmrb;
thlist1244->next = orgthlist1244;
((struct mmc_system *)mrb->ud)->thread_list = thlist1244;
v1244 = ubv1244;
}
sleep(1);
v1250 = (mrb_fixnum_value(1));
v1310 = v732; /* 1*/
v1311 = v1004; /* 1*/
v1312 = v1244; /* 1*/
v1313 = 2; /* 1*/
L28:;
v1321 = (v1313 > 0);
if (v1321) goto L25; else goto L29;
L25:;
mrb->allocf_ud = (void *)gctab;
v1264 = ({
struct mutex_wrapper *mutex = (struct mutex_wrapper *)DATA_PTR(mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1310);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
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(v1310)))->mp);
mrb->allocf_ud = (void *)gctab;
gctab->single[0] = &v1310;/* normal */
gctab->single[1] = &v1264;/* 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);
v1269 = "foo";
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v1264);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1273 = v1264;
if ((mrb_test(v1264))) goto L26; else goto L27;
L26:;
v1310 = v1310; /* 2*/
v1311 = v1311; /* 2*/
v1312 = v1312; /* 2*/
v1313 = v1313; /* 2*/
goto L28;
L27:;
mrb->allocf_ud = (void *)gctab;
gctab->size = 1;
{
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, "------")));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1302 = "------";
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1310);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1306 = v1310;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1310)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1310)))->mp);
v1310 = v1310; /* 3*/
v1311 = v1311; /* 3*/
v1312 = v1312; /* 3*/
v1313 = (v1313 - 1); /* 3*/
goto L28;
L29:;
{
void *ret;
pthread_join(v1311->thread, &ret);
}
{
void *ret;
pthread_join(v1312->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);
v1342 = "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 v741, gproc v742, struct gctab *prevgctab) {
struct proc3 *proc = (struct proc3 *)cgproc;
mrb_value v740 = proc->self;
struct env3 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v749;
gproc v750;
mrb_value_mutex_emptylock v754;
mrb_value_mutex_emptylock v761;
mrb_value v764;
struct proc4 v767;
mrb_int v863;
struct proc9 v865;
mrb_int v971;
char *v973 = "hobbit end";
char *v975;
mrb_value_mutex_emptylock v979;
mrb_value_mutex_emptylock v4124;
struct proc16 v981;
mrb_value v1002;
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 = v740;
self = v740;
v749 = v741;
v750 = v742;
/* START END */
env.v754 = v741;/*enter */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v761 = mrb_nil_value();
gctab->single[gctab->size] = &v761; /* 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;
v761 = mrb_nil_value();
gctab->single[gctab->size] = &v761; /* conversion */
gctab->size++;
v761 = ({
{
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_mutex_init(&mutex->empty_lock, NULL);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
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.v761 = v761;/*foo*/
gctab->single[0] = &v741;/* 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);
v764 = ary;
}
env.v765 = v764;/*foo*/
v767.id = 4;
v767.self = self;
v767.env = &env;
gctab->single[2] = &v764;/* normal */
gctab->size = 3;
v863 = times__Fixnum__3(mrb, 9, ((gproc)&v767), gctab);
v865.id = 9;
v865.self = self;
v865.env = &env;
v971 = times__Fixnum__9(mrb, 3, ((gproc)&v865), gctab);
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, "hobbit end")));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v975 = "hobbit end";
mrb->allocf_ud = (void *)gctab;
v4124 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v741);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_unshift(mrb, v4124, ({
{
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;
})
);
v979 = v741;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v741)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v741)))->mp);
v981.id = 16;
v981.self = self;
v981.env = &env;
v1002 = each__Array__19(mrb, v764, ((gproc)&v981), gctab);
mrb_gc_arena_restore(mrb, ai);
return v1002;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value p17_Object_1_21(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v1014, gproc v1015, struct gctab *prevgctab) {
struct proc17 *proc = (struct proc17 *)cgproc;
mrb_value v1013 = proc->self;
struct env17 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v1022;
gproc v1023;
mrb_value_mutex_emptylock v1027;
mrb_value_mutex_emptylock v1034;
mrb_value v1035;
struct proc18 v1037;
mrb_int v1128;
struct proc20 v1130;
mrb_int v1211;
char *v1213 = "tonakai end";
char *v1215;
mrb_value_mutex_emptylock v1219;
mrb_value_mutex_emptylock v4239;
struct proc23 v1221;
mrb_value v1242;
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 = v1013;
self = v1013;
v1022 = v1014;
v1023 = v1015;
/* START END */
env.v1027 = v1014;/*enter */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v1034 = mrb_nil_value();
gctab->single[gctab->size] = &v1034; /* 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;
v1034 = mrb_nil_value();
gctab->single[gctab->size] = &v1034; /* conversion */
gctab->size++;
v1034 = ({
{
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_mutex_init(&mutex->empty_lock, NULL);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
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.v1034 = v1034;/*foo*/
{
mrb_value tmpele[] = {
};
mrb->allocf_ud = (void *)gctab;
v1035 = mrb_nil_value();
gctab->single[gctab->size] = &v1035; /* 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);
v1035 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v1035 = v1035;/*foo*/
v1037.id = 18;
v1037.self = self;
v1037.env = &env;
gctab->single[0] = &v1014;/* normal */
v1128 = times__Fixnum__22(mrb, 27, ((gproc)&v1037), gctab);
v1130.id = 20;
v1130.self = self;
v1130.env = &env;
v1211 = times__Fixnum__28(mrb, 3, ((gproc)&v1130), gctab);
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, "tonakai end")));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1215 = "tonakai end";
mrb->allocf_ud = (void *)gctab;
v4239 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1014);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_unshift(mrb, v4239, ({
{
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;
})
);
v1219 = v1014;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1014)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1014)))->mp);
v1221.id = 23;
v1221.self = self;
v1221.env = &env;
v1242 = each__Array__37(mrb, v1035, ((gproc)&v1221), gctab);
mrb_gc_arena_restore(mrb, ai);
return v1242;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int times__Fixnum__3(mrb_state *mrb, mrb_int v2245, gproc v2246, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2252;
gproc v2302;
mrb_int v2303;
mrb_bool v2310;/*snd1*/
mrb_value v2296;
mrb_int v2298;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2245;
self = 9;
v2252 = v2246;
/* START END */
L101:;
L103:;
v2302 = v2246; /* 1*/
v2303 = 0; /* 1*/
L105:;
v2310 = (v2303 < self);
if (v2310) goto L104; else goto L106;
L104:;
v2296 = (p4_Object_0_7(mrb, v2302, v2303, gctab));
v2298 = (v2303 + 1);
v2302 = v2302; /* 2*/
v2303 = v2298; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_int times__Fixnum__9(mrb_state *mrb, mrb_int v2245, gproc v2246, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2252;
gproc v2302;
mrb_int v2303;
mrb_bool v2310;/*snd1*/
mrb_value v2296;
mrb_int v2298;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2245;
self = 3;
v2252 = v2246;
/* START END */
L101:;
L103:;
v2302 = v2246; /* 1*/
v2303 = 0; /* 1*/
L105:;
v2310 = (v2303 < self);
if (v2310) goto L104; else goto L106;
L104:;
v2296 = (p9_Object_1_18(mrb, v2302, v2303, gctab));
v2298 = (v2303 + 1);
v2302 = v2302; /* 2*/
v2303 = v2298; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__19(mrb_state *mrb, mrb_value v3988, gproc v3989, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3996;
gproc v4054;
mrb_int v4055;
mrb_int v4063;
mrb_bool v4065;/*snd1*/
mrb_value v4046;
struct cls5_39 * v4048;
mrb_int v4050;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3988;
self = v3988;
v3996 = v3989;
/* START END */
L211:;
L213:;
v4054 = v3989; /* 1*/
v4055 = 0; /* 1*/
L215:;
v4063 = ARY_LEN2(mrb_ary_ptr(self));
v4065 = (v4055 < v4063);
if (v4065) goto L214; else goto L216;
L214:;
{
v4046 = ARY_PTR2(mrb_ary_ptr(self))[v4055];
}
v4048 = (p16_Object_2_20(mrb, v4054, v4046, gctab));
v4050 = (v4055 + 1);
v4054 = v4054; /* 2*/
v4055 = v4050; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_int times__Fixnum__22(mrb_state *mrb, mrb_int v2245, gproc v2246, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2252;
gproc v2302;
mrb_int v2303;
mrb_bool v2310;/*snd1*/
mrb_value v2296;
mrb_int v2298;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2245;
self = 27;
v2252 = v2246;
/* START END */
L101:;
L103:;
v2302 = v2246; /* 1*/
v2303 = 0; /* 1*/
L105:;
v2310 = (v2303 < self);
if (v2310) goto L104; else goto L106;
L104:;
v2296 = (p18_Object_0_26(mrb, v2302, v2303, gctab));
v2298 = (v2303 + 1);
v2302 = v2302; /* 2*/
v2303 = v2298; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_int times__Fixnum__28(mrb_state *mrb, mrb_int v2245, gproc v2246, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2252;
gproc v2302;
mrb_int v2303;
mrb_bool v2310;/*snd1*/
mrb_value v2296;
mrb_int v2298;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2245;
self = 3;
v2252 = v2246;
/* START END */
L101:;
L103:;
v2302 = v2246; /* 1*/
v2303 = 0; /* 1*/
L105:;
v2310 = (v2303 < self);
if (v2310) goto L104; else goto L106;
L104:;
v2296 = (p20_Object_1_36(mrb, v2302, v2303, gctab));
v2298 = (v2303 + 1);
v2302 = v2302; /* 2*/
v2303 = v2298; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__37(mrb_state *mrb, mrb_value v3988, gproc v3989, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3996;
gproc v4054;
mrb_int v4055;
mrb_int v4063;
mrb_bool v4065;/*snd1*/
mrb_value v4046;
struct cls5_39 * v4048;
mrb_int v4050;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3988;
self = v3988;
v3996 = v3989;
/* START END */
L211:;
L213:;
v4054 = v3989; /* 1*/
v4055 = 0; /* 1*/
L215:;
v4063 = ARY_LEN2(mrb_ary_ptr(self));
v4065 = (v4055 < v4063);
if (v4065) goto L214; else goto L216;
L214:;
{
v4046 = ARY_PTR2(mrb_ary_ptr(self))[v4055];
}
v4048 = (p23_Object_2_38(mrb, v4054, v4046, gctab));
v4050 = (v4055 + 1);
v4054 = v4054; /* 2*/
v4055 = v4050; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_value p4_Object_0_7(mrb_state *mrb, gproc cgproc, mrb_int v772, struct gctab *prevgctab) {
struct proc4 *proc = (struct proc4 *)cgproc;
mrb_value v771 = proc->self;
struct env4 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v780;
mrb_value v790;
mrb_value_mutex_emptylock v793;
mrb_int v794;/*snd*/
struct proc8 v795;
mrb_value v859;
struct cls5_39 * ubv859;
;
struct thread_list *thlist859 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist859 = ((struct mmc_system *)mrb->ud)->thread_list;
mrb_value v861;
mrb_value v2345;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L31:;
mutexself = v771;
self = v771;
v780 = v772;
/* START END */
v790 = proc->env->v765;
v793 = proc->env->v761;
v794 = v772;
v795.id = 8;
v795.self = self;
v795.env = &env;
{
struct thprocarg859 *tpargv = malloc(sizeof(struct thprocarg859));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v795);
tpargv->v793 = v793;
tpargv->v794 = v794;
tpargv->v795 = ((gproc)&v795);
tpargv->prevgctab = gctab;
ubv859 = malloc(sizeof(*ubv859));
ubv859->argv = tpargv;
pthread_create(&ubv859->thread, NULL, apply_thproc_859, tpargv);
thlist859->thread = ubv859->thread;
thlist859->mrb = nmrb;
thlist859->next = orgthlist859;
((struct mmc_system *)mrb->ud)->thread_list = thlist859;
v859 = (mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, ubv859, &thread_data_header)));
}
mrb->allocf_ud = (void *)gctab;
v2345 = v790;
mrb_ary_push(mrb, v2345, v859);
v861 = v790;
return v861;
}
static mrb_value p9_Object_1_18(mrb_state *mrb, gproc cgproc, mrb_int v870, struct gctab *prevgctab) {
struct proc9 *proc = (struct proc9 *)cgproc;
mrb_value v869 = proc->self;
struct env9 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v876;
mrb_value v879;
struct proc10 v881;
mrb_int v912;
mrb_value v913;
struct proc11 v915;
mrb_value v935;
mrb_value_mutex_emptylock v936;
mrb_value_mutex_emptylock v939;
mrb_value_mutex_emptylock v4083;
struct proc15 v941;
mrb_value v969;
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 = v869;
self = v869;
v876 = v870;
/* START END */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v879 = mrb_nil_value();
gctab->single[gctab->size] = &v879; /* 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);
v879 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v879 = v879;/*foo*/
v881.id = 10;
v881.self = self;
v881.env = &env;
v912 = times__Fixnum__11(mrb, 3, ((gproc)&v881), 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);
v913 = mrb_str_new(mrb, "HoHo Let's make present\n", 24);
v915.id = 11;
v915.self = self;
v915.env = &env;
gctab->single[1] = &v913;/* normal */
gctab->size = 2;
v935 = each__Array__14(mrb, v879, ((gproc)&v915), gctab);
v936 = proc->env->v754;
mrb->allocf_ud = (void *)gctab;
v4083 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v936);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_unshift(mrb, v4083, ({
{
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 = v913;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v939 = v936;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v936)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v936)))->mp);
v941.id = 15;
v941.self = self;
v941.env = &env;
v969 = each__Array__16(mrb, v879, ((gproc)&v941), gctab);
mrb_gc_arena_restore(mrb, ai);
return v969;
mrb_gc_arena_restore(mrb, ai);
}
static struct cls5_39 * p16_Object_2_20(mrb_state *mrb, gproc cgproc, mrb_value v986, struct gctab *prevgctab) {
struct proc16 *proc = (struct proc16 *)cgproc;
mrb_value v985 = proc->self;
struct env16 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v991;
mrb_value v998;
struct cls5_39 * v1000;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L37:;
mutexself = v985;
self = v985;
v991 = v986;
/* START END */
{
void *ret;
pthread_join(((struct cls5_39 * )DATA_PTR(v986))->thread, &ret);
}
return v1000;
}
static mrb_value p18_Object_0_26(mrb_state *mrb, gproc cgproc, mrb_int v1042, struct gctab *prevgctab) {
struct proc18 *proc = (struct proc18 *)cgproc;
mrb_value v1041 = proc->self;
struct env18 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v1050;
mrb_value v1060;
mrb_value_mutex_emptylock v1063;
mrb_int v1064;/*snd*/
struct proc19 v1065;
mrb_value v1124;
struct cls5_39 * ubv1124;
;
struct thread_list *thlist1124 = malloc(sizeof(struct thread_list));
struct thread_list *orgthlist1124 = ((struct mmc_system *)mrb->ud)->thread_list;
mrb_value v1126;
mrb_value v4163;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L39:;
mutexself = v1041;
self = v1041;
v1050 = v1042;
/* START END */
v1060 = proc->env->v1035;
v1063 = proc->env->v1034;
v1064 = v1042;
v1065.id = 19;
v1065.self = self;
v1065.env = &env;
{
struct thprocarg1124 *tpargv = malloc(sizeof(struct thprocarg1124));
mrb_state *nmrb = malloc(sizeof(mrb_state));
*nmrb = *mrb;
tpargv->mrb = nmrb;
tpargv->cgproc = ((gproc)&v1065);
tpargv->v1063 = v1063;
tpargv->v1064 = v1064;
tpargv->v1065 = ((gproc)&v1065);
tpargv->prevgctab = gctab;
ubv1124 = malloc(sizeof(*ubv1124));
ubv1124->argv = tpargv;
pthread_create(&ubv1124->thread, NULL, apply_thproc_1124, tpargv);
thlist1124->thread = ubv1124->thread;
thlist1124->mrb = nmrb;
thlist1124->next = orgthlist1124;
((struct mmc_system *)mrb->ud)->thread_list = thlist1124;
v1124 = (mrb_obj_value(mrb_data_object_alloc(mrb, ((struct mmc_system *)mrb->ud)->pthread_class, ubv1124, &thread_data_header)));
}
mrb->allocf_ud = (void *)gctab;
v4163 = v1060;
mrb_ary_push(mrb, v4163, v1124);
v1126 = v1060;
return v1126;
}
static mrb_value p20_Object_1_36(mrb_state *mrb, gproc cgproc, mrb_int v1135, struct gctab *prevgctab) {
struct proc20 *proc = (struct proc20 *)cgproc;
mrb_value v1134 = proc->self;
struct env20 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v1141;
mrb_value v1144;
struct proc21 v1146;
mrb_int v1177;
mrb_value v1178;
mrb_value_mutex_emptylock v1179;
mrb_value_mutex_emptylock v1182;
mrb_value_mutex_emptylock v4206;
struct proc22 v1184;
mrb_value v1209;
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 = v1134;
self = v1134;
v1141 = v1135;
/* START END */
{
mrb_value tmpele[] = {
};
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v1144 = mrb_nil_value();
gctab->single[gctab->size] = &v1144; /* 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);
v1144 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 0);
}
env.v1144 = v1144;/*foo*/
v1146.id = 21;
v1146.self = self;
v1146.env = &env;
v1177 = times__Fixnum__30(mrb, 9, ((gproc)&v1146), 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);
v1178 = mrb_str_new(mrb, "HoHo Let's send present\n", 24);
v1179 = proc->env->v1027;
mrb->allocf_ud = (void *)gctab;
v4206 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1179);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_unshift(mrb, v4206, ({
{
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 = v1178;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v1182 = v1179;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1179)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1179)))->mp);
v1184.id = 22;
v1184.self = self;
v1184.env = &env;
gctab->single[1] = &v1178;/* normal */
gctab->size = 2;
v1209 = each__Array__33(mrb, v1144, ((gproc)&v1184), gctab);
mrb_gc_arena_restore(mrb, ai);
return v1209;
mrb_gc_arena_restore(mrb, ai);
}
static struct cls5_39 * p23_Object_2_38(mrb_state *mrb, gproc cgproc, mrb_value v1226, struct gctab *prevgctab) {
struct proc23 *proc = (struct proc23 *)cgproc;
mrb_value v1225 = proc->self;
struct env23 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v1231;
mrb_value v1238;
struct cls5_39 * v1240;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L44:;
mutexself = v1225;
self = v1225;
v1231 = v1226;
/* START END */
{
void *ret;
pthread_join(((struct cls5_39 * )DATA_PTR(v1226))->thread, &ret);
}
return v1240;
}
static mrb_value p8_Object_0_8(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v800, mrb_int v801, gproc v802, struct gctab *prevgctab) {
struct proc8 *proc = (struct proc8 *)cgproc;
mrb_value v799 = proc->self;
struct env8 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v809;
mrb_int v810;
gproc v811;
mrb_float2 v825;
mrb_int v830;
mrb_value v832;
char *v834 = "hobbit wake up ";
mrb_value v836; /* cat */
mrb_value v838;
mrb_value_mutex_emptylock v840;
mrb_value v841;
mrb_value_mutex_emptylock v845;
mrb_value_mutex_emptylock v2338;
mrb_value_mutex_emptylock v849;
mrb_value v851;
char *v853 = "Hobbit Work done ";
mrb_int v854;/*snd*/
mrb_value v855; /* cat */
mrb_value v857;
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 = v799;
self = v799;
v809 = v800;
v810 = v801;
v811 = v802;
/* START END */
v825 = (((mrb_float)(rand() % 0x7fffffff)) / (double)0x7fffffff);
v830 = ((mrb_int)(v825 * ((mrb_float)10)));
sleep(v830);
v832 = (mrb_fixnum_value(v830));
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v836 = mrb_nil_value();
gctab->single[gctab->size] = &v836; /* conversion */
gctab->size++;
v836 = (mrb_str_new_cstr(mrb, "hobbit wake up "));
mrb->allocf_ud = (void *)gctab;
v836 = mrb_str_cat_cstr(mrb, v836, ({char *_buf = alloca(255);sprintf(_buf, "%d", v801);_buf;}));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
gctab->single[0] = &v800;/* normal */
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v836);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v838 = v836;
{
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;
v840 = ({
{
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_mutex_init(&mutex->empty_lock, NULL);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
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(v801)), v840
};
mrb->allocf_ud = (void *)gctab;
v841 = mrb_nil_value();
gctab->single[gctab->size] = &v841; /* 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);
v841 = array;
ARY_SET_LEN(mrb_ary_ptr(array), 2);
}
mrb->allocf_ud = (void *)gctab;
mrb->allocf_ud = (void *)gctab;
v2338 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v800);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_push(mrb, v2338, ({
{
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 = v841;
mrb_iv_set(mrb, mutexobj, mrb_intern_cstr(mrb, "@object"), mutex->obj);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
mutexobj;
})
);
v845 = v800;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v800)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v800)))->mp);
{
v849 = ARY_PTR2(mrb_ary_ptr(v841))[1];
}
mrb->allocf_ud = (void *)gctab;
v851 = mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v849);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
);
if (ARY_LEN(mrb_ary_ptr(((struct mutex_wrapper_emptylock *)(DATA_PTR(v849)))->obj)) > 0) {
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v849)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v849)))->mp);
}
else {
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v849)))->mp);
}
v854 = v801;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
v855 = mrb_nil_value();
gctab->single[gctab->size] = &v855; /* conversion */
gctab->size++;
v855 = (mrb_str_new_cstr(mrb, "Hobbit Work done "));
mrb->allocf_ud = (void *)gctab;
v855 = mrb_str_cat_cstr(mrb, v855, ({char *_buf = alloca(255);sprintf(_buf, "%d", v854);_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, v855);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v857 = v855;
mrb_gc_arena_restore(mrb, ai);
return v857;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_value p19_Object_0_27(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v1070, mrb_int v1071, gproc v1072, struct gctab *prevgctab) {
struct proc19 *proc = (struct proc19 *)cgproc;
mrb_value v1069 = proc->self;
struct env19 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v1079;
mrb_int v1080;
gproc v1081;
mrb_float2 v1095;
mrb_int v1100;
mrb_value v1102;
char *v1104 = "tonakai wake up ";
mrb_value v1106; /* cat */
mrb_value v1108;
mrb_value_mutex_emptylock v1109;
mrb_value_mutex_emptylock v1113;
mrb_value_mutex_emptylock v4157;
mrb_value v1116;
char *v1118 = "Tonakai Work done ";
mrb_int v1119;/*snd*/
mrb_value v1120; /* cat */
mrb_value v1122;
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 = v1069;
self = v1069;
v1079 = v1070;
v1080 = v1071;
v1081 = v1072;
/* START END */
v1095 = (((mrb_float)(rand() % 0x7fffffff)) / (double)0x7fffffff);
v1100 = ((mrb_int)(v1095 * ((mrb_float)10)));
sleep(v1100);
v1102 = (mrb_fixnum_value(v1100));
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
gctab->size = 0;
mrb->allocf_ud = (void *)gctab;
v1106 = mrb_nil_value();
gctab->single[gctab->size] = &v1106; /* conversion */
gctab->size++;
v1106 = (mrb_str_new_cstr(mrb, "tonakai wake up "));
mrb->allocf_ud = (void *)gctab;
v1106 = mrb_str_cat_cstr(mrb, v1106, ({char *_buf = alloca(255);sprintf(_buf, "%d", v1071);_buf;}));
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
gctab->single[0] = &v1070;/* normal */
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
mrb_p(mrb, v1106);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1108 = v1106;
{
mrb_value tmpele[] = {
};
mrb->allocf_ud = (void *)gctab;
v1109 = mrb_nil_value();
gctab->single[gctab->size] = &v1109; /* 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;
v1109 = mrb_nil_value();
gctab->single[gctab->size] = &v1109; /* conversion */
gctab->size++;
v1109 = ({
{
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_mutex_init(&mutex->empty_lock, NULL);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
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;
v4157 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1070);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_push(mrb, v4157, v1109);
v1113 = v1070;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1070)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1070)))->mp);
mrb->allocf_ud = (void *)gctab;
v1116 = mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1109);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
);
if (ARY_LEN(mrb_ary_ptr(((struct mutex_wrapper_emptylock *)(DATA_PTR(v1109)))->obj)) > 0) {
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1109)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1109)))->mp);
}
else {
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1109)))->mp);
}
v1119 = v1071;
{
pthread_mutex_t *mut = (((struct mmc_system *)mrb->ud)->io_mutex);
pthread_mutex_lock(mut);
}
mrb->allocf_ud = (void *)gctab;
v1120 = mrb_nil_value();
gctab->single[gctab->size] = &v1120; /* conversion */
gctab->size++;
v1120 = (mrb_str_new_cstr(mrb, "Tonakai Work done "));
mrb->allocf_ud = (void *)gctab;
v1120 = mrb_str_cat_cstr(mrb, v1120, ({char *_buf = alloca(255);sprintf(_buf, "%d", v1119);_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, v1120);
pthread_mutex_unlock(((struct mmc_system *)mrb->ud)->io_mutex);
v1122 = v1120;
mrb_gc_arena_restore(mrb, ai);
return v1122;
mrb_gc_arena_restore(mrb, ai);
}
static mrb_int times__Fixnum__11(mrb_state *mrb, mrb_int v2245, gproc v2246, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2252;
gproc v2302;
mrb_int v2303;
mrb_bool v2310;/*snd1*/
mrb_value v2296;
mrb_int v2298;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2245;
self = 3;
v2252 = v2246;
/* START END */
L101:;
L103:;
v2302 = v2246; /* 1*/
v2303 = 0; /* 1*/
L105:;
v2310 = (v2303 < self);
if (v2310) goto L104; else goto L106;
L104:;
v2296 = (p10_Object_0_13(mrb, v2302, v2303, gctab));
v2298 = (v2303 + 1);
v2302 = v2302; /* 2*/
v2303 = v2298; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__14(mrb_state *mrb, mrb_value v3988, gproc v3989, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3996;
gproc v4054;
mrb_int v4055;
mrb_int v4063;
mrb_bool v4065;/*snd1*/
mrb_value v4046;
mrb_value v4048;
mrb_int v4050;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3988;
self = v3988;
v3996 = v3989;
/* START END */
L211:;
L213:;
v4054 = v3989; /* 1*/
v4055 = 0; /* 1*/
L215:;
v4063 = ARY_LEN2(mrb_ary_ptr(self));
v4065 = (v4055 < v4063);
if (v4065) goto L214; else goto L216;
L214:;
{
v4046 = ARY_PTR2(mrb_ary_ptr(self))[v4055];
}
v4048 = (p11_Object_1_15(mrb, v4054, v4046, gctab));
v4050 = (v4055 + 1);
v4054 = v4054; /* 2*/
v4055 = v4050; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_value each__Array__16(mrb_state *mrb, mrb_value v3988, gproc v3989, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3996;
gproc v4054;
mrb_int v4055;
mrb_int v4063;
mrb_bool v4065;/*snd1*/
mrb_value v4046;
mrb_value v4048;
mrb_int v4050;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3988;
self = v3988;
v3996 = v3989;
/* START END */
L211:;
L213:;
v4054 = v3989; /* 1*/
v4055 = 0; /* 1*/
L215:;
v4063 = ARY_LEN2(mrb_ary_ptr(self));
v4065 = (v4055 < v4063);
if (v4065) goto L214; else goto L216;
L214:;
{
v4046 = ARY_PTR2(mrb_ary_ptr(self))[v4055];
}
v4048 = (p15_Object_2_17(mrb, v4054, v4046, gctab));
v4050 = (v4055 + 1);
v4054 = v4054; /* 2*/
v4055 = v4050; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_int times__Fixnum__30(mrb_state *mrb, mrb_int v2245, gproc v2246, struct gctab *prevgctab) {
struct env7 env;
struct REnv *venv = NULL;
mrb_int self;
mrb_int mutexself;
gproc v2252;
gproc v2302;
mrb_int v2303;
mrb_bool v2310;/*snd1*/
mrb_value v2296;
mrb_int v2298;/*snd1*/
struct gctab *gctab = prevgctab;
L100:;
mutexself = v2245;
self = 9;
v2252 = v2246;
/* START END */
L101:;
L103:;
v2302 = v2246; /* 1*/
v2303 = 0; /* 1*/
L105:;
v2310 = (v2303 < self);
if (v2310) goto L104; else goto L106;
L104:;
v2296 = (p21_Object_0_32(mrb, v2302, v2303, gctab));
v2298 = (v2303 + 1);
v2302 = v2302; /* 2*/
v2303 = v2298; /* 2*/
goto L105;
L106:;
return self;
}
static mrb_value each__Array__33(mrb_state *mrb, mrb_value v3988, gproc v3989, struct gctab *prevgctab) {
struct env14 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
gproc v3996;
gproc v4054;
mrb_int v4055;
mrb_int v4063;
mrb_bool v4065;/*snd1*/
mrb_value_mutex_emptylock v4046;
mrb_value v4048;
mrb_int v4050;/*snd1*/
struct gctab *gctab = prevgctab;
L210:;
mutexself = v3988;
self = v3988;
v3996 = v3989;
/* START END */
L211:;
L213:;
v4054 = v3989; /* 1*/
v4055 = 0; /* 1*/
L215:;
v4063 = ARY_LEN2(mrb_ary_ptr(self));
v4065 = (v4055 < v4063);
if (v4065) goto L214; else goto L216;
L214:;
{
v4046 = ARY_PTR2(mrb_ary_ptr(self))[v4055];
}
v4048 = (p22_Object_1_35(mrb, v4054, v4046, gctab));
v4050 = (v4055 + 1);
v4054 = v4054; /* 2*/
v4055 = v4050; /* 2*/
goto L215;
L216:;
return self;
}
static mrb_value p10_Object_0_13(mrb_state *mrb, gproc cgproc, mrb_int v886, struct gctab *prevgctab) {
struct proc10 *proc = (struct proc10 *)cgproc;
mrb_value v885 = proc->self;
struct env10 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v893;
mrb_value_mutex_emptylock v903;
mrb_value v905;
mrb_value v907;
mrb_value v910;
mrb_value v2380;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L34:;
mutexself = v885;
self = v885;
v893 = v886;
/* START END */
v903 = proc->env->prev->v761;
mrb->allocf_ud = (void *)gctab;
v905 = ({
struct mutex_wrapper *mutex = (struct mutex_wrapper *)DATA_PTR(mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v903);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
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(v903)))->mp);
v907 = proc->env->v879;
mrb->allocf_ud = (void *)gctab;
v2380 = v907;
mrb_ary_push(mrb, v2380, v905);
v910 = v907;
return v910;
}
static mrb_value p11_Object_1_15(mrb_state *mrb, gproc cgproc, mrb_value v920, struct gctab *prevgctab) {
struct proc11 *proc = (struct proc11 *)cgproc;
mrb_value v919 = proc->self;
struct env11 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v925;
mrb_int v929;
mrb_value_mutex_emptylock v930;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L35:;
mutexself = v919;
self = v919;
v925 = v920;
/* START END */
{
mrb_value *array = ARY_PTR2(mrb_ary_ptr(v925));
v929 = (mrb_fixnum(array[0]));
v930 = array[1];
}
return mrb_nil_value();
}
static mrb_value p15_Object_2_17(mrb_state *mrb, gproc cgproc, mrb_value v946, struct gctab *prevgctab) {
struct proc15 *proc = (struct proc15 *)cgproc;
mrb_value v945 = proc->self;
struct env15 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value v952;
mrb_value_mutex_emptylock v963;
mrb_value_mutex_emptylock v966;
mrb_value_mutex_emptylock v4087;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L36:;
mutexself = v945;
self = v945;
v952 = v946;
/* START END */
{
v963 = ARY_PTR2(mrb_ary_ptr(v946))[1];
}
mrb->allocf_ud = (void *)gctab;
v4087 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v963);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_push(mrb, v4087, (mrb_fixnum_value(1)));
v966 = v963;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v963)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v963)))->mp);
return mrb_nil_value();
}
static mrb_value p21_Object_0_32(mrb_state *mrb, gproc cgproc, mrb_int v1151, struct gctab *prevgctab) {
struct proc21 *proc = (struct proc21 *)cgproc;
mrb_value v1150 = proc->self;
struct env21 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_int v1158;
mrb_value_mutex_emptylock v1168;
mrb_value_mutex_emptylock v1170;
mrb_value v1172;
mrb_value v1175;
mrb_value v4198;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L42:;
mutexself = v1150;
self = v1150;
v1158 = v1151;
/* START END */
v1168 = proc->env->prev->v1034;
mrb->allocf_ud = (void *)gctab;
v1170 = mrb_ary_pop(mrb, ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1168);
{
pthread_mutex_t *mut = (&mutex->empty_lock);
pthread_mutex_lock(mut);
}
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
);
if (ARY_LEN(mrb_ary_ptr(((struct mutex_wrapper_emptylock *)(DATA_PTR(v1168)))->obj)) > 0) {
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1168)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1168)))->mp);
}
else {
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1168)))->mp);
}
v1172 = proc->env->v1144;
mrb->allocf_ud = (void *)gctab;
v4198 = v1172;
mrb_ary_push(mrb, v4198, v1170);
v1175 = v1172;
return v1175;
}
static mrb_value p22_Object_1_35(mrb_state *mrb, gproc cgproc, mrb_value_mutex_emptylock v1189, struct gctab *prevgctab) {
struct proc22 *proc = (struct proc22 *)cgproc;
mrb_value v1188 = proc->self;
struct env22 env;
struct REnv *venv = NULL;
mrb_value self;
mrb_value mutexself;
mrb_value_mutex_emptylock v1195;
mrb_value_mutex_emptylock v1206;
mrb_value_mutex_emptylock v4208;
struct gctab *gctab = prevgctab;
env.prev = proc->env;
L43:;
mutexself = v1188;
self = v1188;
v1195 = v1189;
/* START END */
mrb->allocf_ud = (void *)gctab;
v4208 = ({
struct mutex_wrapper_emptylock *mutex = (struct mutex_wrapper_emptylock *)DATA_PTR(v1189);
{
pthread_mutex_t *mut = (&mutex->mp);
pthread_mutex_lock(mut);
}
mrb_value tmp = mutex->obj;
tmp;
})
;
mrb_ary_push(mrb, v4208, (mrb_fixnum_value(1)));
v1206 = v1189;
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1189)))->empty_lock);
pthread_mutex_unlock(&((struct mutex_wrapper_emptylock *)(DATA_PTR(v1189)))->mp);
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=-ce89660 <#<Irep:0x7ffff312dbb0> pos=../mruby-meta-circular/sample/santa2.rb:116>> e=false=>:canempty, Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 41, :unshift], Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>[:modify, 79, :unshift]}>]]
Class #<Class:MMC_EXT>
Instance variables
methodes
Module Integral
Instance variables
methodes
Class Fixnum
Instance variables
methodes
times (Literal Fixnum, Proc<irep=-ce80160 <#<Irep:0x7ffff32a2810> pos=../mruby-meta-circular/sample/santa2.rb:18>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-ce87ce0 <#<Irep:0x7ffff32cb7c0> pos=../mruby-meta-circular/sample/santa2.rb:31>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-ce87e00 <#<Irep:0x7ffff32ad670> pos=../mruby-meta-circular/sample/santa2.rb:30>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-ce76950 <#<Irep:0x7ffff3303060> pos=../mruby-meta-circular/sample/santa2.rb:61>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-ce75960 <#<Irep:0x7ffff332d330> pos=../mruby-meta-circular/sample/santa2.rb:74>>) -> Literal Fixnum
times (Literal Fixnum, Proc<irep=-ce75a30 <#<Irep:0x7ffff33305d0> pos=../mruby-meta-circular/sample/santa2.rb:73>>) -> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}, Proc<irep=-ce87990 <#<Irep:0x7ffff32c3ea0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}, Proc<irep=-ce75eb0 <#<Irep:0x7ffff32de520> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> 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=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 45, :push], Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true=>:canempty}> e=true l=7 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>:arrayset}> e=true l=6 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 33, :push]}
each (Array<[:undef] => Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true|1 => Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true> e=true l=4 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> pos=../mruby-meta-circular/sample/santa2.rb:15>> e=false=>[:modify, 19, :push]}, Proc<irep=-ce76bf0 <#<Irep:0x7ffff32f3cf0> pos=../mruby-meta-circular/sample/santa2.rb:52>>) -> Array<[:undef] => Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true|1 => Thread Proc<irep=-ce80040 <#<Irep:0x7ffff329d6e0> pos=../mruby-meta-circular/sample/santa2.rb:19>> e=true> e=true l=4 th={Thread Proc<irep=-ce80290 <#<Irep:0x7ffff3287970> 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=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>:arrayset, Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true=>:canempty}|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>:arrayset, Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true=>:canempty}> e=true l=6 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>[:modify, 76, :push]}, Proc<irep=-ce7bb30 <#<Irep:0x7ffff33459a0> pos=../mruby-meta-circular/sample/santa2.rb:81>>) -> Array<[:undef] => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>:arrayset, Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true=>:canempty}|1 => Array<[:undef] => Literal Fixnum|1 => Literal Fixnum> e=true l=7 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>:arrayset, Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true=>:canempty}> e=true l=6 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>[:modify, 76, :push]}
each (Array<[:undef] => Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true|1 => Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true> e=true l=4 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>[:modify, 62, :push]}, Proc<irep=-ce7b950 <#<Irep:0x7ffff333bb30> pos=../mruby-meta-circular/sample/santa2.rb:89>>) -> Array<[:undef] => Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true|1 => Thread Proc<irep=-ce75e20 <#<Irep:0x7ffff32fdf30> pos=../mruby-meta-circular/sample/santa2.rb:62>> e=true> e=true l=4 th={Thread Proc<irep=-ce76a30 <#<Irep:0x7ffff3308100> pos=../mruby-meta-circular/sample/santa2.rb:58>> e=false=>[:modify, 62, :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