hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added partial experimental code for io event handling

Browse Source
This commit is contained in:
hyunghwan.chung 2017-02-15 11:57:24 +00:00
parent bc5ab97ccf
commit be677dd53a
16 changed files with 368 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
moo/kernel/Process.moo
View File

@ -426,12 +426,21 @@ class ProcessScheduler(Object)
self primitiveFailed. self primitiveFailed.
} }
"method signal: semaphore onInput: file method signal: semaphore onInput: file
{ {
}" <primitive: #_processor_add_input_semaphore>
"method signal: semaphore onOutput: file self primitiveFailed.
}
method signal: semaphore onOutput: file
{ {
}" <primitive: #_processor_add_output_semaphore>
self primitiveFailed.
}
method signal: semaphore onInOutput: file
{
<primitive: #_processor_add_inoutput_semaphore>
self primitiveFailed.
}
method return: object to: context method return: object to: context
{ {

14
moo/lib/bigint.c
View File

@ -209,7 +209,7 @@ static int is_normalized_integer (moo_t* moo, moo_oop_t oop)
if (MOO_OOP_IS_SMOOI(oop)) return 1; if (MOO_OOP_IS_SMOOI(oop)) return 1;
if (MOO_OOP_IS_POINTER(oop)) if (MOO_OOP_IS_POINTER(oop))
{ {
moo_oop_t c; moo_oop_class_t c;
/* TODO: is it better to introduce a special integer mark into the class itself */ /* TODO: is it better to introduce a special integer mark into the class itself */
/* TODO: or should it check if it's a subclass, subsubclass, subsubsubclass, etc of a large_integer as well? */ /* TODO: or should it check if it's a subclass, subsubclass, subsubsubclass, etc of a large_integer as well? */
c = MOO_OBJ_GET_CLASS(oop); c = MOO_OBJ_GET_CLASS(oop);
@ -231,7 +231,7 @@ static int is_normalized_integer (moo_t* moo, moo_oop_t oop)
MOO_INLINE static int is_bigint (moo_t* moo, moo_oop_t x) MOO_INLINE static int is_bigint (moo_t* moo, moo_oop_t x)
{ {
moo_oop_t c; moo_oop_class_t c;
MOO_ASSERT (moo, MOO_OOP_IS_POINTER(x)); MOO_ASSERT (moo, MOO_OOP_IS_POINTER(x));
@ -540,7 +540,7 @@ static MOO_INLINE moo_oop_t expand_bigint (moo_t* moo, moo_oop_t oop, moo_oow_t
} }
static MOO_INLINE moo_oop_t _clone_bigint (moo_t* moo, moo_oop_t oop, moo_oow_t count, moo_oop_t _class) static MOO_INLINE moo_oop_t _clone_bigint (moo_t* moo, moo_oop_t oop, moo_oow_t count, moo_oop_class_t _class)
{ {
moo_oop_t z; moo_oop_t z;
moo_oow_t i; moo_oow_t i;
@ -567,20 +567,20 @@ static MOO_INLINE moo_oop_t clone_bigint (moo_t* moo, moo_oop_t oop, moo_oow_t c
static MOO_INLINE moo_oop_t clone_bigint_negated (moo_t* moo, moo_oop_t oop, moo_oow_t count) static MOO_INLINE moo_oop_t clone_bigint_negated (moo_t* moo, moo_oop_t oop, moo_oow_t count)
{ {
moo_oop_t c; moo_oop_class_t _class;
MOO_ASSERT (moo, MOO_OOP_IS_POINTER(oop)); MOO_ASSERT (moo, MOO_OOP_IS_POINTER(oop));
if (MOO_OBJ_GET_CLASS(oop) == moo->_large_positive_integer) if (MOO_OBJ_GET_CLASS(oop) == moo->_large_positive_integer)
{ {
c = moo->_large_negative_integer; _class = moo->_large_negative_integer;
} }
else else
{ {
MOO_ASSERT (moo, MOO_OBJ_GET_CLASS(oop) == moo->_large_negative_integer); MOO_ASSERT (moo, MOO_OBJ_GET_CLASS(oop) == moo->_large_negative_integer);
c = moo->_large_positive_integer; _class = moo->_large_positive_integer;
} }
return _clone_bigint (moo, oop, count, c); return _clone_bigint (moo, oop, count, _class);
} }
static MOO_INLINE moo_oop_t clone_bigint_to_positive (moo_t* moo, moo_oop_t oop, moo_oow_t count) static MOO_INLINE moo_oop_t clone_bigint_to_positive (moo_t* moo, moo_oop_t oop, moo_oow_t count)

2
moo/lib/comp.c
View File

@ -6341,7 +6341,7 @@ static int __compile_class_definition (moo_t* moo, int extend)
if (modnamelen > 0) if (modnamelen > 0)
{ {
if (moo_importmod (moo, (moo_oop_t)moo->c->cls.self_oop, modname, modnamelen) <= -1) return -1; if (moo_importmod (moo, moo->c->cls.self_oop, modname, modnamelen) <= -1) return -1;
} }
if (moo->c->cls.self_oop->trsize == moo->_nil && if (moo->c->cls.self_oop->trsize == moo->_nil &&

8
moo/lib/dic.c
View File

@ -74,7 +74,7 @@ static moo_oop_oop_t expand_bucket (moo_t* moo, moo_oop_oop_t oldbuc)
MOO_ASSERT (moo, MOO_CLASSOF(moo,ass) == moo->_association); MOO_ASSERT (moo, MOO_CLASSOF(moo,ass) == moo->_association);
key = (moo_oop_char_t)ass->key; key = (moo_oop_char_t)ass->key;
MOO_ASSERT (moo, MOO_CLASSOF(moo,key) == (moo_oop_t)moo->_symbol); MOO_ASSERT (moo, MOO_CLASSOF(moo,key) == moo->_symbol);
index = moo_hashoochars(key->slot, MOO_OBJ_GET_SIZE(key)) % newsz; index = moo_hashoochars(key->slot, MOO_OBJ_GET_SIZE(key)) % newsz;
while (newbuc->slot[index] != moo->_nil) index = (index + 1) % newsz; while (newbuc->slot[index] != moo->_nil) index = (index + 1) % newsz;
@ -334,14 +334,14 @@ found:
return 0; return 0;
} }
moo_oop_set_t moo_makedic (moo_t* moo, moo_oop_t cls, moo_oow_t size) moo_oop_set_t moo_makedic (moo_t* moo, moo_oop_class_t _class, moo_oow_t size)
{ {
moo_oop_set_t dic; moo_oop_set_t dic;
moo_oop_t tmp; moo_oop_t tmp;
MOO_ASSERT (moo, MOO_CLASSOF(moo,cls) == moo->_class); MOO_ASSERT (moo, MOO_CLASSOF(moo,_class) == moo->_class);
dic = (moo_oop_set_t)moo_instantiate (moo, cls, MOO_NULL, 0); dic = (moo_oop_set_t)moo_instantiate (moo, _class, MOO_NULL, 0);
if (!dic) return MOO_NULL; if (!dic) return MOO_NULL;
MOO_ASSERT (moo, MOO_OBJ_GET_SIZE(dic) == MOO_SET_NAMED_INSTVARS); MOO_ASSERT (moo, MOO_OBJ_GET_SIZE(dic) == MOO_SET_NAMED_INSTVARS);

139
moo/lib/exec.c
View File

@ -107,6 +107,8 @@
# define __PRIMITIVE_NAME__ (&__FUNCTION__[4]) # define __PRIMITIVE_NAME__ (&__FUNCTION__[4])
#endif #endif
static void signal_io_semaphore (moo_t* moo, int mask, void* ctx);
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
static MOO_INLINE int vm_startup (moo_t* moo) static MOO_INLINE int vm_startup (moo_t* moo)
{ {
@ -139,7 +141,7 @@ static MOO_INLINE void vm_sleep (moo_t* moo, const moo_ntime_t* dur)
static MOO_INLINE void vm_mux_wait (moo_t* moo, const moo_ntime_t* dur) static MOO_INLINE void vm_mux_wait (moo_t* moo, const moo_ntime_t* dur)
{ {
moo->vmprim.mux_wait (moo, dur); moo->vmprim.mux_wait (moo, dur, signal_io_semaphore);
} }
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
@ -741,6 +743,7 @@ static void update_sem_heap (moo_t* moo, moo_ooi_t index, moo_oop_semaphore_t ne
static int add_to_sem_io (moo_t* moo, moo_oop_semaphore_t sem) static int add_to_sem_io (moo_t* moo, moo_oop_semaphore_t sem)
{ {
moo_ooi_t index; moo_ooi_t index;
int n;
if (moo->sem_io_count >= SEM_IO_MAX) if (moo->sem_io_count >= SEM_IO_MAX)
{ {
@ -764,18 +767,24 @@ static int add_to_sem_io (moo_t* moo, moo_oop_semaphore_t sem)
} }
MOO_ASSERT (moo, moo->sem_io_count <= MOO_SMOOI_MAX); MOO_ASSERT (moo, moo->sem_io_count <= MOO_SMOOI_MAX);
MOO_ASSERT (moo, sem->io_index == MOO_SMOOI_TO_OOP(-1));
if (moo->vmprim.mux_add (moo) <= -1) /*TODO: pass data */
{
return -1;
}
index = moo->sem_io_count; index = moo->sem_io_count;
moo->sem_io[index] = sem; moo->sem_io[index] = sem;
sem->heap_index = MOO_SMOOI_TO_OOP(index); sem->io_index = MOO_SMOOI_TO_OOP(index);
moo->sem_io_count++; moo->sem_io_count++;
return 0; moo_pushtmp (moo, (moo_oop_t*)&sem);
n = moo->vmprim.mux_add (moo, sem);
moo_poptmp (moo);
if (n <= -1)
{
/* roll back */
sem->io_index = MOO_SMOOI_TO_OOP(-1);
moo->sem_io_count--;
}
MOO_DEBUG1 (moo, "ADDED TO SEM IO => sem_io_count => %d\n", (int)moo->sem_io_count);
return n;
} }
static void delete_from_sem_io (moo_t* moo, moo_ooi_t index) static void delete_from_sem_io (moo_t* moo, moo_ooi_t index)
@ -784,10 +793,11 @@ static void delete_from_sem_io (moo_t* moo, moo_ooi_t index)
moo_oop_semaphore_t sem, lastsem; moo_oop_semaphore_t sem, lastsem;
sem = moo->sem_io[index]; sem = moo->sem_io[index];
moo_pushtmp (moo, (moo_oop_t*)&sem);
moo->vmprim.mux_del (moo, sem);
moo_poptmp (moo);
sem->io_index = MOO_SMOOI_TO_OOP(-1); sem->io_index = MOO_SMOOI_TO_OOP(-1);
moo->vmprim.mux_del (moo); /* TODO: pass data... */
moo->sem_io_count--; moo->sem_io_count--;
if (moo->sem_io_count > 0 && index != moo->sem_io_count) if (moo->sem_io_count > 0 && index != moo->sem_io_count)
{ {
@ -798,6 +808,41 @@ static void delete_from_sem_io (moo_t* moo, moo_ooi_t index)
} }
} }
static void signal_io_semaphore (moo_t* moo, int mask, void* ctx)
{
moo_oow_t sem_io_index = (moo_oow_t)ctx;
/* TODO: sanity check on the index. conditional handling on mask */
if (sem_io_index < moo->sem_io_count)
{
moo_oop_semaphore_t sem;
moo_oop_process_t proc;
sem = moo->sem_io[sem_io_index];
proc = signal_semaphore (moo, sem);
if (moo->processor->active == moo->nil_process && (moo_oop_t)proc != moo->_nil)
{
/* this is the only runnable process.
* switch the process to the running state.
* it uses wake_new_process() instead of
* switch_to_process() as there is no running
* process at this moment */
MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE));
MOO_ASSERT (moo, proc == moo->processor->runnable_head);
wake_new_process (moo, proc); /* switch to running */
moo->proc_switched = 1;
}
}
else
{
MOO_LOG1 (moo, MOO_LOG_WARN, "Warning - Invalid semaphore index %zu\n", sem_io_index);
}
}
/* ------------------------------------------------------------------------- */
static moo_oop_process_t start_initial_process (moo_t* moo, moo_oop_context_t c) static moo_oop_process_t start_initial_process (moo_t* moo, moo_oop_context_t c)
{ {
moo_oop_process_t proc; moo_oop_process_t proc;
@ -949,8 +994,8 @@ static moo_oop_method_t find_method (moo_t* moo, moo_oop_t receiver, const moo_o
int dic_no; int dic_no;
/* TODO: implement method lookup cache */ /* TODO: implement method lookup cache */
cls = (moo_oop_class_t)MOO_CLASSOF(moo, receiver); cls = MOO_CLASSOF(moo, receiver);
if ((moo_oop_t)cls == moo->_class) if (cls == moo->_class)
{ {
/* receiver is a class object (an instance of Class) */ /* receiver is a class object (an instance of Class) */
c = receiver; c = receiver;
@ -997,7 +1042,7 @@ static moo_oop_method_t find_method (moo_t* moo, moo_oop_t receiver, const moo_o
while (c != moo->_nil); while (c != moo->_nil);
not_found: not_found:
if ((moo_oop_t)cls == moo->_class) if (cls == moo->_class)
{ {
/* the object is an instance of Class. find the method /* the object is an instance of Class. find the method
* in an instance method dictionary of Class also */ * in an instance method dictionary of Class also */
@ -1189,7 +1234,8 @@ static moo_pfrc_t pf_log (moo_t* moo, moo_ooi_t nargs)
else if (MOO_OBJ_GET_FLAGS_TYPE(msg) == MOO_OBJ_TYPE_OOP) else if (MOO_OBJ_GET_FLAGS_TYPE(msg) == MOO_OBJ_TYPE_OOP)
{ {
/* visit only 1-level down into an array-like object */ /* visit only 1-level down into an array-like object */
moo_oop_t inner, _class; moo_oop_t inner;
moo_oop_class_t _class;
moo_oow_t i, spec; moo_oow_t i, spec;
_class = MOO_CLASSOF(moo, msg); _class = MOO_CLASSOF(moo, msg);
@ -1339,23 +1385,25 @@ static moo_pfrc_t pf_not_equal (moo_t* moo, moo_ooi_t nargs)
static moo_pfrc_t pf_class (moo_t* moo, moo_ooi_t nargs) static moo_pfrc_t pf_class (moo_t* moo, moo_ooi_t nargs)
{ {
moo_oop_t rcv, c; moo_oop_t rcv;
moo_oop_class_t _class;
MOO_ASSERT (moo, nargs == 0); MOO_ASSERT (moo, nargs == 0);
rcv = MOO_STACK_GETRCV(moo, nargs); rcv = MOO_STACK_GETRCV(moo, nargs);
c = MOO_CLASSOF(moo, rcv); _class = MOO_CLASSOF(moo, rcv);
MOO_STACK_SETRET (moo, nargs, c); MOO_STACK_SETRET (moo, nargs, (moo_oop_t)_class);
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
static MOO_INLINE moo_pfrc_t pf_basic_new (moo_t* moo, moo_ooi_t nargs) static MOO_INLINE moo_pfrc_t pf_basic_new (moo_t* moo, moo_ooi_t nargs)
{ {
moo_oop_t _class, szoop, obj; moo_oop_class_t _class;
moo_oop_t szoop, obj;
moo_oow_t size = 0; /* size of the variable/indexed part */ moo_oow_t size = 0; /* size of the variable/indexed part */
_class = MOO_STACK_GETRCV(moo, nargs); _class = (moo_oop_class_t)MOO_STACK_GETRCV(moo, nargs);
if (MOO_CLASSOF(moo, _class) != moo->_class) if (MOO_CLASSOF(moo, _class) != moo->_class)
{ {
/* the receiver is not a class object */ /* the receiver is not a class object */
@ -2091,24 +2139,20 @@ static moo_pfrc_t pf_processor_add_timed_semaphore (moo_t* moo, moo_ooi_t nargs)
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
static moo_pfrc_t pf_processor_add_io_semaphore (moo_t* moo, moo_ooi_t nargs) static moo_pfrc_t __processor_add_io_semaphore (moo_t* moo, moo_ooi_t nargs, int mask)
{ {
moo_oop_t rcv, sec, nsec; moo_oop_t rcv, fd;
moo_oop_semaphore_t sem; moo_oop_semaphore_t sem;
MOO_ASSERT (moo, nargs == 3); MOO_ASSERT (moo, nargs == 2);
nsec = MOO_STACK_GETARG (moo, nargs, 2); fd = MOO_STACK_GETARG(moo, nargs, 1);
if (!MOO_OOP_IS_SMOOI(nsec)) return MOO_PF_FAILURE;
sec = MOO_STACK_GETARG(moo, nargs, 1);
sem = (moo_oop_semaphore_t)MOO_STACK_GETARG(moo, nargs, 0); sem = (moo_oop_semaphore_t)MOO_STACK_GETARG(moo, nargs, 0);
rcv = MOO_STACK_GETRCV(moo, nargs); rcv = MOO_STACK_GETRCV(moo, nargs);
/* ProcessScheduler>>signal:after: calls this primitive function. */
if (rcv != (moo_oop_t)moo->processor || if (rcv != (moo_oop_t)moo->processor ||
MOO_CLASSOF(moo,sem) != moo->_semaphore || MOO_CLASSOF(moo,sem) != moo->_semaphore ||
!MOO_OOP_IS_SMOOI(sec)) return MOO_PF_FAILURE; !MOO_OOP_IS_SMOOI(fd)) return MOO_PF_FAILURE;
if (MOO_OOP_IS_SMOOI(sem->io_index) && if (MOO_OOP_IS_SMOOI(sem->io_index) &&
sem->io_index != MOO_SMOOI_TO_OOP(-1)) sem->io_index != MOO_SMOOI_TO_OOP(-1))
@ -2118,15 +2162,29 @@ static moo_pfrc_t pf_processor_add_io_semaphore (moo_t* moo, moo_ooi_t nargs)
MOO_ASSERT (moo, sem->io_index == MOO_SMOOI_TO_OOP(-1)); MOO_ASSERT (moo, sem->io_index == MOO_SMOOI_TO_OOP(-1));
} }
/* TOOD: sanity check on argument 2 and 3 */ sem->io_handle = fd;
sem->io_data = MOO_STACK_GETARG(moo, nargs, 1); sem->io_mask = MOO_SMOOI_TO_OOP(mask);
sem->io_mask = MOO_STACK_GETARG(moo, nargs, 2); if (add_to_sem_io (moo, sem) <= -1) return MOO_PF_HARD_FAILURE; /*TODO: let it return SUCESS but SETRET(error()); */
if (add_to_sem_io (moo, sem) <= -1) return MOO_PF_HARD_FAILURE;
MOO_STACK_SETRETTORCV (moo, nargs); /* ^self */ MOO_STACK_SETRETTORCV (moo, nargs); /* ^self */
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
static moo_pfrc_t pf_processor_add_input_semaphore (moo_t* moo, moo_ooi_t nargs)
{
return __processor_add_io_semaphore (moo, nargs, 1);
}
static moo_pfrc_t pf_processor_add_output_semaphore (moo_t* moo, moo_ooi_t nargs)
{
return __processor_add_io_semaphore (moo, nargs, 2);
}
static moo_pfrc_t pf_processor_add_inoutput_semaphore (moo_t* moo, moo_ooi_t nargs)
{
return __processor_add_io_semaphore (moo, nargs, 3);
}
static moo_pfrc_t pf_processor_remove_semaphore (moo_t* moo, moo_ooi_t nargs) static moo_pfrc_t pf_processor_remove_semaphore (moo_t* moo, moo_ooi_t nargs)
{ {
/* remove a semaphore from processor's signal scheduling */ /* remove a semaphore from processor's signal scheduling */
@ -2156,7 +2214,7 @@ static moo_pfrc_t pf_processor_remove_semaphore (moo_t* moo, moo_ooi_t nargs)
if (MOO_OOP_IS_SMOOI(sem->io_index) && if (MOO_OOP_IS_SMOOI(sem->io_index) &&
sem->io_index != MOO_SMOOI_TO_OOP(-1)) sem->io_index != MOO_SMOOI_TO_OOP(-1))
{ {
delete_from_sem_io (moo, MOO_OOP_TO_SMOOI(sem->heap_index)); delete_from_sem_io (moo, MOO_OOP_TO_SMOOI(sem->io_index));
MOO_ASSERT (moo, sem->io_index == MOO_SMOOI_TO_OOP(-1)); MOO_ASSERT (moo, sem->io_index == MOO_SMOOI_TO_OOP(-1));
} }
@ -2672,7 +2730,9 @@ static pf_t pftab[] =
{ 1, 1, pf_processor_schedule, "_processor_schedule" }, { 1, 1, pf_processor_schedule, "_processor_schedule" },
{ 2, 3, pf_processor_add_timed_semaphore, "_processor_add_timed_semaphore" }, { 2, 3, pf_processor_add_timed_semaphore, "_processor_add_timed_semaphore" },
{ 3, 3, pf_processor_add_io_semaphore, "_processor_add_io_semaphore" }, { 2, 2, pf_processor_add_input_semaphore, "_processor_add_input_semaphore" },
{ 2, 2, pf_processor_add_output_semaphore, "_processor_add_output_semaphore" },
{ 2, 2, pf_processor_add_inoutput_semaphore, "_processor_add_inoutput_semaphore" },
{ 1, 1, pf_processor_remove_semaphore, "_processor_remove_semaphore" }, { 1, 1, pf_processor_remove_semaphore, "_processor_remove_semaphore" },
{ 2, 2, pf_processor_return_to, "_processor_return_to" }, { 2, 2, pf_processor_return_to, "_processor_return_to" },
@ -2710,6 +2770,7 @@ int moo_getpfnum (moo_t* moo, const moo_ooch_t* ptr, moo_oow_t len)
{ {
int i; int i;
/* TODO: have the pftable sorted alphabetically and do binary search */
for (i = 0; i < MOO_COUNTOF(pftab); i++) for (i = 0; i < MOO_COUNTOF(pftab); i++)
{ {
if (moo_compoocharsbcstr(ptr, len, pftab[i].name) == 0) if (moo_compoocharsbcstr(ptr, len, pftab[i].name) == 0)
@ -3096,9 +3157,15 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
MOO_SUBNTIME (&ft, &ft, (moo_ntime_t*)&now); MOO_SUBNTIME (&ft, &ft, (moo_ntime_t*)&now);
if (moo->sem_io_count > 0) if (moo->sem_io_count > 0)
{
MOO_DEBUG0 (moo, "ABOUT TO CALL VM_MUX_WAIT()\n");
vm_mux_wait (moo, &ft); vm_mux_wait (moo, &ft);
}
else else
vm_sleep (moo, &ft); /* TODO: change this to i/o multiplexer??? */ {
MOO_DEBUG0 (moo, "ABOUT TO CALL VM_MUX_SLEEP()\n");
vm_sleep (moo, &ft);
}
vm_gettime (moo, &now); vm_gettime (moo, &now);
} }
else else
@ -3795,7 +3862,7 @@ int moo_execute (moo_t* moo)
t = (moo_oop_t)moo_makedic (moo, moo->_dictionary, b1 + 10); t = (moo_oop_t)moo_makedic (moo, moo->_dictionary, b1 + 10);
MOO_STACK_PUSH (moo, t); MOO_STACK_PUSH (moo, t);
*/ */
MOO_STACK_PUSH (moo, moo->_dictionary); MOO_STACK_PUSH (moo, (moo_oop_t)moo->_dictionary);
MOO_STACK_PUSH (moo, MOO_SMOOI_TO_OOP(b1)); MOO_STACK_PUSH (moo, MOO_SMOOI_TO_OOP(b1));
if (send_message (moo, moo->dicnewsym, 0, 1) <= -1) goto oops; if (send_message (moo, moo->dicnewsym, 0, 1) <= -1) goto oops;
break; break;

22
moo/lib/gc.c
View File

@ -120,7 +120,7 @@ static kernel_class_info_t kernel_classes[] =
* BOOTSTRAPPER * BOOTSTRAPPER
* ----------------------------------------------------------------------- */ * ----------------------------------------------------------------------- */
static moo_oop_t alloc_kernel_class (moo_t* moo, moo_oow_t indexed_classvars, moo_oow_t spec) static moo_oop_class_t alloc_kernel_class (moo_t* moo, moo_oow_t indexed_classvars, moo_oow_t spec)
{ {
moo_oop_class_t c; moo_oop_class_t c;
@ -128,11 +128,11 @@ static moo_oop_t alloc_kernel_class (moo_t* moo, moo_oow_t indexed_classvars, mo
if (!c) return MOO_NULL; if (!c) return MOO_NULL;
MOO_OBJ_SET_FLAGS_KERNEL (c, 1); MOO_OBJ_SET_FLAGS_KERNEL (c, 1);
MOO_OBJ_SET_CLASS (c, moo->_class); MOO_OBJ_SET_CLASS (c, (moo_oop_t)moo->_class);
c->spec = MOO_SMOOI_TO_OOP(spec); c->spec = MOO_SMOOI_TO_OOP(spec);
c->selfspec = MOO_SMOOI_TO_OOP(MOO_CLASS_SELFSPEC_MAKE(indexed_classvars, 0)); c->selfspec = MOO_SMOOI_TO_OOP(MOO_CLASS_SELFSPEC_MAKE(indexed_classvars, 0));
return (moo_oop_t)c; return c;
} }
static int ignite_1 (moo_t* moo) static int ignite_1 (moo_t* moo)
@ -154,7 +154,7 @@ static int ignite_1 (moo_t* moo)
if (!moo->_class) return -1; if (!moo->_class) return -1;
MOO_ASSERT (moo, MOO_OBJ_GET_CLASS(moo->_class) == MOO_NULL); MOO_ASSERT (moo, MOO_OBJ_GET_CLASS(moo->_class) == MOO_NULL);
MOO_OBJ_SET_CLASS (moo->_class, moo->_class); MOO_OBJ_SET_CLASS (moo->_class, (moo_oop_t)moo->_class);
/* -------------------------------------------------------------- /* --------------------------------------------------------------
* Apex - proto-object with 1 class variable. * Apex - proto-object with 1 class variable.
@ -220,7 +220,7 @@ static int ignite_1 (moo_t* moo)
!moo->_character || !moo->_small_integer || !moo->_character || !moo->_small_integer ||
!moo->_large_positive_integer || !moo->_large_negative_integer) return -1; !moo->_large_positive_integer || !moo->_large_negative_integer) return -1;
MOO_OBJ_SET_CLASS (moo->_nil, moo->_undefined_object); MOO_OBJ_SET_CLASS (moo->_nil, (moo_oop_t)moo->_undefined_object);
return 0; return 0;
} }
@ -268,7 +268,7 @@ static int ignite_2 (moo_t* moo)
moo->processor->active = moo->nil_process; moo->processor->active = moo->nil_process;
/* Export the system dictionary via the first class variable of the Stix class */ /* Export the system dictionary via the first class variable of the Stix class */
((moo_oop_class_t)moo->_apex)->slot[0] = (moo_oop_t)moo->sysdic; moo->_apex->slot[0] = (moo_oop_t)moo->sysdic;
return 0; return 0;
} }
@ -309,11 +309,11 @@ static int ignite_3 (moo_t* moo)
sym = moo_makesymbol (moo, str_dicnew, MOO_COUNTOF(str_dicnew)); sym = moo_makesymbol (moo, str_dicnew, MOO_COUNTOF(str_dicnew));
if (!sym) return -1; if (!sym) return -1;
moo->dicnewsym = sym; moo->dicnewsym = (moo_oop_char_t)sym;
sym = moo_makesymbol (moo, str_dicputassoc, MOO_COUNTOF(str_dicputassoc)); sym = moo_makesymbol (moo, str_dicputassoc, MOO_COUNTOF(str_dicputassoc));
if (!sym) return -1; if (!sym) return -1;
moo->dicputassocsym = sym; moo->dicputassocsym = (moo_oop_char_t)sym;
return 0; return 0;
} }
@ -459,7 +459,7 @@ moo_oop_t moo_moveoop (moo_t* moo, moo_oop_t oop)
* the class field has been updated to the new object * the class field has been updated to the new object
* in the 'else' block below. i can simply return it * in the 'else' block below. i can simply return it
* without further migration. */ * without further migration. */
return MOO_OBJ_GET_CLASS(oop); return (moo_oop_t)MOO_OBJ_GET_CLASS(oop);
} }
else else
{ {
@ -527,7 +527,7 @@ static moo_uint8_t* scan_new_heap (moo_t* moo, moo_uint8_t* ptr)
} }
#endif #endif
MOO_OBJ_SET_CLASS (oop, moo_moveoop(moo, MOO_OBJ_GET_CLASS(oop))); MOO_OBJ_SET_CLASS (oop, moo_moveoop(moo, (moo_oop_t)MOO_OBJ_GET_CLASS(oop)));
if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_OOP) if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_OOP)
{ {
moo_oop_oop_t xtmp; moo_oop_oop_t xtmp;
@ -732,7 +732,7 @@ moo_oop_t moo_shallowcopy (moo_t* moo, moo_oop_t oop)
moo_oop_t z; moo_oop_t z;
moo_oop_class_t c; moo_oop_class_t c;
c = (moo_oop_class_t)MOO_OBJ_GET_CLASS(oop); c = MOO_OBJ_GET_CLASS(oop);
moo_pushtmp (moo, &oop); moo_pushtmp (moo, &oop);
z = moo_instantiate (moo, (moo_oop_t)c, MOO_NULL, MOO_OBJ_GET_SIZE(oop) - MOO_CLASS_SPEC_NAMED_INSTVAR(MOO_OOP_TO_SMOOI(c->spec))); z = moo_instantiate (moo, (moo_oop_t)c, MOO_NULL, MOO_OBJ_GET_SIZE(oop) - MOO_CLASS_SPEC_NAMED_INSTVAR(MOO_OOP_TO_SMOOI(c->spec)));
moo_poptmp(moo); moo_poptmp(moo);

12
moo/lib/logfmt.c
View File

@ -328,7 +328,7 @@ static void print_object (moo_t* moo, moo_oow_t mask, moo_oop_t oop)
MOO_ASSERT (moo, MOO_OOP_IS_POINTER(oop)); MOO_ASSERT (moo, MOO_OOP_IS_POINTER(oop));
c = (moo_oop_class_t)MOO_OBJ_GET_CLASS(oop); /*MOO_CLASSOF(moo, oop);*/ c = (moo_oop_class_t)MOO_OBJ_GET_CLASS(oop); /*MOO_CLASSOF(moo, oop);*/
if ((moo_oop_t)c == moo->_large_negative_integer) if (c == moo->_large_negative_integer)
{ {
moo_oow_t i; moo_oow_t i;
moo_logbfmt (moo, mask, "-16r"); moo_logbfmt (moo, mask, "-16r");
@ -337,7 +337,7 @@ static void print_object (moo_t* moo, moo_oow_t mask, moo_oop_t oop)
moo_logbfmt (moo, mask, "%0*lX", (int)(MOO_SIZEOF(moo_liw_t) * 2), (unsigned long)((moo_oop_liword_t)oop)->slot[--i]); moo_logbfmt (moo, mask, "%0*lX", (int)(MOO_SIZEOF(moo_liw_t) * 2), (unsigned long)((moo_oop_liword_t)oop)->slot[--i]);
} }
} }
else if ((moo_oop_t)c == moo->_large_positive_integer) else if (c == moo->_large_positive_integer)
{ {
moo_oow_t i; moo_oow_t i;
moo_logbfmt (moo, mask, "16r"); moo_logbfmt (moo, mask, "16r");
@ -348,7 +348,7 @@ static void print_object (moo_t* moo, moo_oow_t mask, moo_oop_t oop)
} }
else if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_CHAR) else if (MOO_OBJ_GET_FLAGS_TYPE(oop) == MOO_OBJ_TYPE_CHAR)
{ {
if ((moo_oop_t)c == moo->_symbol) if (c == moo->_symbol)
{ {
moo_logbfmt (moo, mask, "#%.*js", MOO_OBJ_GET_SIZE(oop), ((moo_oop_char_t)oop)->slot); moo_logbfmt (moo, mask, "#%.*js", MOO_OBJ_GET_SIZE(oop), ((moo_oop_char_t)oop)->slot);
} }
@ -455,7 +455,7 @@ static void print_object (moo_t* moo, moo_oow_t mask, moo_oop_t oop)
} }
moo_logbfmt (moo, mask, "]]]"); moo_logbfmt (moo, mask, "]]]");
} }
else if ((moo_oop_t)c == moo->_array) else if (c == moo->_array)
{ {
moo_logbfmt (moo, mask, "#("); moo_logbfmt (moo, mask, "#(");
for (i = 0; i < MOO_OBJ_GET_SIZE(oop); i++) for (i = 0; i < MOO_OBJ_GET_SIZE(oop); i++)
@ -465,12 +465,12 @@ static void print_object (moo_t* moo, moo_oow_t mask, moo_oop_t oop)
} }
moo_logbfmt (moo, mask, ")"); moo_logbfmt (moo, mask, ")");
} }
else if ((moo_oop_t)c == moo->_class) else if (c == moo->_class)
{ {
/* print the class name */ /* print the class name */
moo_logbfmt (moo, mask, "%.*js", MOO_OBJ_GET_SIZE(((moo_oop_class_t)oop)->name), ((moo_oop_class_t)oop)->name->slot); moo_logbfmt (moo, mask, "%.*js", MOO_OBJ_GET_SIZE(((moo_oop_class_t)oop)->name), ((moo_oop_class_t)oop)->name->slot);
} }
else if ((moo_oop_t)c == moo->_association) else if (c == moo->_association)
{ {
moo_logbfmt (moo, mask, "%O -> %O", ((moo_oop_association_t)oop)->key, ((moo_oop_association_t)oop)->value); moo_logbfmt (moo, mask, "%O -> %O", ((moo_oop_association_t)oop)->key, ((moo_oop_association_t)oop)->value);
} }

60
moo/lib/main.c
View File

@ -821,42 +821,74 @@ static void vm_sleep (moo_t* moo, const moo_ntime_t* dur)
#endif #endif
} }
static int mux_add (moo_t* moo) static int mux_add (moo_t* moo, moo_oop_semaphore_t sem)
{ {
xtn_t* xtn = (xtn_t*)moo_getxtn(moo); xtn_t* xtn = (xtn_t*)moo_getxtn(moo);
struct epoll_event ev; struct epoll_event ev;
moo_ooi_t mask;
ev.events = EPOLLIN | EPOLLOUT; MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(sem->io_index));
ev.data.u64 = 10; MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(sem->io_handle));
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(sem->io_mask));
/* mask = MOO_OOP_TO_SMOOI(sem->io_mask);
if (epoll_ctl (xtn->ep, EPOLL_CTL_DEL, 000, &ev) == -1) ev.events = 0;
if (mask & 1) ev.events |= EPOLLIN; /*TODO: define io mask constants... */
if (mask & 2) ev.events |= EPOLLOUT;
ev.data.ptr = (void*)MOO_OOP_TO_SMOOI(sem->io_index);
if (ev.events == 0)
{ {
moo_syserrtoerrnum (errno); MOO_DEBUG2 (moo, "<mux_add> Invalid semaphore mask %zd on handle %zd\n", mask, MOO_OOP_TO_SMOOI(sem->io_handle));
moo_seterrnum (moo, MOO_EINVAL);
return -1; return -1;
} }
*/
if (epoll_ctl (xtn->ep, EPOLL_CTL_ADD, MOO_OOP_TO_SMOOI(sem->io_handle), &ev) == -1)
{
moo_seterrnum (moo, moo_syserrtoerrnum (errno));
MOO_DEBUG2 (moo, "<mux_add> epoll_ctl failure on handle %zd - %hs\n", MOO_OOP_TO_SMOOI(sem->io_handle), strerror(errno));
return -1;
}
return 0; return 0;
} }
static void mux_del (moo_t* moo) static void mux_del (moo_t* moo, moo_oop_semaphore_t sem)
{ {
xtn_t* xtn = (xtn_t*)moo_getxtn(moo); xtn_t* xtn = (xtn_t*)moo_getxtn(moo);
struct epoll_event ev; struct epoll_event ev;
/* epoll_ctl (xtn->ep, EPOLL_CTL_DEL, 00, &ev);*/
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(sem->io_index));
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(sem->io_handle));
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(sem->io_mask));
epoll_ctl (xtn->ep, EPOLL_CTL_DEL, MOO_OOP_TO_SMOOI(sem->io_handle), &ev);
} }
static void mux_wait (moo_t* moo, const moo_ntime_t* dur) static void mux_wait (moo_t* moo, const moo_ntime_t* dur, moo_vmprim_muxwait_cb_t muxwcb)
{ {
xtn_t* xtn = (xtn_t*)moo_getxtn(moo); xtn_t* xtn = (xtn_t*)moo_getxtn(moo);
int tmout = 0; int tmout = 0, n;
struct epoll_event ev[32]; /*TODO: make it into xtn->evt_ptr or somewhere else as a dynamically allocated memory block */
if (dur) tmout = MOO_SECNSEC_TO_MSEC(dur->sec, dur->nsec); if (dur) tmout = MOO_SECNSEC_TO_MSEC(dur->sec, dur->nsec);
/*
if (epoll_wait (xtn->ep, xtn->evt_ptr, xtn->evt_capa, tmout) > 0) n = epoll_wait (xtn->ep, ev, MOO_COUNTOF(ev), tmout);
while (n > 0)
{ {
int mask;
--n;
mask = 0;
if (ev[n].events & EPOLLIN) mask |= 1; /* TODO define constants for IO Mask */
if (ev[n].events & EPOLLOUT) mask |= 2;
if (ev[n].events & EPOLLERR) mask |= 4;
if (ev[n].events & EPOLLHUP) mask |= 8;
muxwcb (moo, mask, ev[n].data.ptr);
} }
*/
} }
/* ========================================================================= */ /* ========================================================================= */

5
moo/lib/moo-prv.h
View File

@ -1037,7 +1037,7 @@ int moo_deletedic (
moo_oop_set_t moo_makedic ( moo_oop_set_t moo_makedic (
moo_t* moo, moo_t* moo,
moo_oop_t cls, moo_oop_class_t _class,
moo_oow_t size moo_oow_t size
); );
@ -1048,7 +1048,6 @@ moo_oop_process_t moo_makeproc (
moo_t* moo moo_t* moo
); );
/* ========================================================================= */ /* ========================================================================= */
/* bigint.c */ /* bigint.c */
/* ========================================================================= */ /* ========================================================================= */
@ -1200,7 +1199,7 @@ void moo_closemod (
int moo_importmod ( int moo_importmod (
moo_t* moo, moo_t* moo,
moo_oop_t _class, moo_oop_class_t _class,
const moo_ooch_t* name, const moo_ooch_t* name,
moo_oow_t len moo_oow_t len
); );

70
moo/lib/moo.c
View File

@ -531,7 +531,7 @@ void moo_closemod (moo_t* moo, moo_mod_data_t* mdp)
} }
} }
int moo_importmod (moo_t* moo, moo_oop_t _class, const moo_ooch_t* name, moo_oow_t len) int moo_importmod (moo_t* moo, moo_oop_class_t _class, const moo_ooch_t* name, moo_oow_t len)
{ {
moo_rbt_pair_t* pair; moo_rbt_pair_t* pair;
moo_mod_data_t* mdp; moo_mod_data_t* mdp;
@ -540,7 +540,7 @@ int moo_importmod (moo_t* moo, moo_oop_t _class, const moo_ooch_t* name, moo_oow
/* moo_openmod(), moo_closemod(), etc call a user-defined callback. /* moo_openmod(), moo_closemod(), etc call a user-defined callback.
* i need to protect _class in case the user-defined callback allocates * i need to protect _class in case the user-defined callback allocates
* a OOP memory chunk and GC occurs */ * a OOP memory chunk and GC occurs */
moo_pushtmp (moo, &_class); moo_pushtmp (moo, (moo_oop_t*)&_class);
pair = moo_rbt_search (&moo->modtab, name, len); pair = moo_rbt_search (&moo->modtab, name, len);
if (pair) if (pair)
@ -644,13 +644,12 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* add a new primitive method */ /* add a new primitive method */
int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_type_t type, const moo_ooch_t* mthname, int variadic, const moo_ooch_t* pfname) int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class, moo_method_type_t type, const moo_ooch_t* mthname, int variadic, const moo_ooch_t* pfname)
{ {
/* NOTE: this function is a subset of add_compiled_method() in comp.c */ /* NOTE: this function is a subset of add_compiled_method() in comp.c */
moo_oop_char_t mnsym, pfidsym; moo_oop_char_t mnsym, pfidsym;
moo_oop_method_t mth; moo_oop_method_t mth;
moo_oop_class_t cls;
moo_oow_t tmp_count = 0, i; moo_oow_t tmp_count = 0, i;
moo_ooi_t arg_count = 0; moo_ooi_t arg_count = 0;
moo_oocs_t cs; moo_oocs_t cs;
@ -661,9 +660,8 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
if (!pfname) pfname = mthname; if (!pfname) pfname = mthname;
cls = (moo_oop_class_t)_class; moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
moo_pushtmp (moo, (moo_oop_t*)&cls); tmp_count++; MOO_ASSERT (moo, MOO_CLASSOF(moo, (moo_oop_t)_class->mthdic[type]) == moo->_method_dictionary);
MOO_ASSERT (moo, MOO_CLASSOF(moo, (moo_oop_t)cls->mthdic[type]) == moo->_method_dictionary);
for (i = 0; mthname[i]; i++) for (i = 0; mthname[i]; i++)
{ {
@ -678,16 +676,16 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
if (arg_count > 0 && mthname[i - 1] != ':') if (arg_count > 0 && mthname[i - 1] != ':')
{ {
oops_inval: oops_inval:
MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - invalid name\n", mthname, cls->name); MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - invalid name\n", mthname, _class->name);
moo->errnum = MOO_EINVAL; moo->errnum = MOO_EINVAL;
goto oops; goto oops;
} }
cs.ptr = (moo_ooch_t*)mthname; cs.ptr = (moo_ooch_t*)mthname;
cs.len = i; cs.len = i;
if (moo_lookupdic (moo, cls->mthdic[type], &cs) != MOO_NULL) if (moo_lookupdic (moo, _class->mthdic[type], &cs) != MOO_NULL)
{ {
MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - duplicate\n", mthname, cls->name); MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - duplicate\n", mthname, _class->name);
moo->errnum = MOO_EEXIST; moo->errnum = MOO_EEXIST;
goto oops; goto oops;
} }
@ -702,14 +700,14 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
moo_concatoocstrtosbuf(moo, dot, 0) <= -1 || moo_concatoocstrtosbuf(moo, dot, 0) <= -1 ||
moo_concatoocstrtosbuf(moo, pfname, 0) <= -1) moo_concatoocstrtosbuf(moo, pfname, 0) <= -1)
{ {
MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - VM memory shortage\n", mthname, cls->name); MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - VM memory shortage\n", mthname, _class->name);
return -1; return -1;
} }
pfidsym = (moo_oop_char_t)moo_makesymbol (moo, moo->sbuf[0].ptr, moo->sbuf[0].len); pfidsym = (moo_oop_char_t)moo_makesymbol (moo, moo->sbuf[0].ptr, moo->sbuf[0].len);
if (!pfidsym) if (!pfidsym)
{ {
MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - symbol instantiation failure\n", mthname, cls->name); MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - symbol instantiation failure\n", mthname, _class->name);
goto oops; goto oops;
} }
moo_pushtmp (moo, (moo_oop_t*)&pfidsym); tmp_count++; moo_pushtmp (moo, (moo_oop_t*)&pfidsym); tmp_count++;
@ -721,7 +719,7 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
#endif #endif
if (!mth) if (!mth)
{ {
MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - method instantiation failure\n", mthname, cls->name); MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - method instantiation failure\n", mthname, _class->name);
goto oops; goto oops;
} }
@ -729,7 +727,7 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
mth->slot[0] = (moo_oop_t)pfidsym; mth->slot[0] = (moo_oop_t)pfidsym;
/* premable should contain the index to the literal frame which is always 0 */ /* premable should contain the index to the literal frame which is always 0 */
mth->owner = cls; mth->owner = _class;
mth->name = mnsym; mth->name = mnsym;
if (variadic) preamble_flags |= MOO_METHOD_PREAMBLE_FLAG_VARIADIC; if (variadic) preamble_flags |= MOO_METHOD_PREAMBLE_FLAG_VARIADIC;
mth->preamble = MOO_SMOOI_TO_OOP(MOO_METHOD_MAKE_PREAMBLE(MOO_METHOD_PREAMBLE_NAMED_PRIMITIVE, 0, preamble_flags)); mth->preamble = MOO_SMOOI_TO_OOP(MOO_METHOD_MAKE_PREAMBLE(MOO_METHOD_PREAMBLE_NAMED_PRIMITIVE, 0, preamble_flags));
@ -740,13 +738,13 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
/* TODO: emit BCODE_RETURN_NIL as a fallback or self primitiveFailed? or anything else?? */ /* TODO: emit BCODE_RETURN_NIL as a fallback or self primitiveFailed? or anything else?? */
if (!moo_putatdic (moo, cls->mthdic[type], (moo_oop_t)mnsym, (moo_oop_t)mth)) if (!moo_putatdic (moo, _class->mthdic[type], (moo_oop_t)mnsym, (moo_oop_t)mth))
{ {
MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - failed to add to method dictionary\n", mthname, cls->name); MOO_DEBUG2 (moo, "Cannot generate primitive function method [%js] in [%O] - failed to add to method dictionary\n", mthname, _class->name);
goto oops; goto oops;
} }
MOO_DEBUG2 (moo, "Generated primitive function method [%js] in [%O]\n", mthname, cls->name); MOO_DEBUG2 (moo, "Generated primitive function method [%js] in [%O]\n", mthname, _class->name);
moo_poptmps (moo, tmp_count); tmp_count = 0; moo_poptmps (moo, tmp_count); tmp_count = 0;
return 0; return 0;
@ -756,12 +754,12 @@ oops:
return -1; return -1;
} }
int moo_genpfmethods (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, const moo_pfinfo_t* pfinfo, moo_oow_t pfcount) int moo_genpfmethods (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class, const moo_pfinfo_t* pfinfo, moo_oow_t pfcount)
{ {
int ret = 0; int ret = 0;
moo_oow_t i; moo_oow_t i;
moo_pushtmp (moo, &_class); moo_pushtmp (moo, (moo_oop_t*)&_class);
for (i = 0; i < pfcount; i++) for (i = 0; i < pfcount; i++)
{ {
if (moo_genpfmethod (moo, mod, _class, pfinfo[i].type, pfinfo[i].mthname, pfinfo[i].variadic, MOO_NULL) <= -1) if (moo_genpfmethod (moo, mod, _class, pfinfo[i].type, pfinfo[i].mthname, pfinfo[i].variadic, MOO_NULL) <= -1)
@ -801,53 +799,51 @@ moo_pfimpl_t moo_findpfimpl (moo_t* moo, const moo_pfinfo_t* pfinfo, moo_oow_t p
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
int moo_setclasstrsize (moo_t* moo, moo_oop_t _class, moo_oow_t size) int moo_setclasstrsize (moo_t* moo, moo_oop_class_t _class, moo_oow_t size)
{ {
register moo_oop_class_t c;
moo_oop_class_t sc; moo_oop_class_t sc;
moo_oow_t spec; moo_oow_t spec;
MOO_ASSERT (moo, MOO_CLASSOF(moo, _class) == moo->_class); MOO_ASSERT (moo, MOO_CLASSOF(moo, _class) == moo->_class);
MOO_ASSERT (moo, size <= MOO_SMOOI_MAX); MOO_ASSERT (moo, size <= MOO_SMOOI_MAX);
c = (moo_oop_class_t)_class; if (_class == moo->_method)
if ((moo_oop_t)c == moo->_method)
{ {
/* the bytes code emitted by the compiler go to the trailer part /* the bytes code emitted by the compiler go to the trailer part
* regardless of the trailer size. you're not allowed to change it */ * regardless of the trailer size. you're not allowed to change it */
MOO_DEBUG3 (moo, "Not allowed to set trailer size to %zu on the %.*js class\n", MOO_DEBUG3 (moo, "Not allowed to set trailer size to %zu on the %.*js class\n",
size, size,
MOO_OBJ_GET_SIZE(c->name), MOO_OBJ_GET_SIZE(_class->name),
MOO_OBJ_GET_CHAR_SLOT(c->name)); MOO_OBJ_GET_CHAR_SLOT(_class->name));
goto eperm; goto eperm;
} }
spec = MOO_OOP_TO_SMOOI(c->spec); spec = MOO_OOP_TO_SMOOI(_class->spec);
if (MOO_CLASS_SPEC_IS_INDEXED(spec) && MOO_CLASS_SPEC_INDEXED_TYPE(spec) != MOO_OBJ_TYPE_OOP) if (MOO_CLASS_SPEC_IS_INDEXED(spec) && MOO_CLASS_SPEC_INDEXED_TYPE(spec) != MOO_OBJ_TYPE_OOP)
{ {
MOO_DEBUG3 (moo, "Not allowed to set trailer size to %zu on the %.*js class representing a non-pointer object\n", MOO_DEBUG3 (moo, "Not allowed to set trailer size to %zu on the %.*js class representing a non-pointer object\n",
size, size,
MOO_OBJ_GET_SIZE(c->name), MOO_OBJ_GET_SIZE(_class->name),
MOO_OBJ_GET_CHAR_SLOT(c->name)); MOO_OBJ_GET_CHAR_SLOT(_class->name));
goto eperm; goto eperm;
} }
if (c->trsize != moo->_nil) if (_class->trsize != moo->_nil)
{ {
MOO_DEBUG3 (moo, "Not allowed to re-set trailer size to %zu on the %.*js class\n", MOO_DEBUG3 (moo, "Not allowed to re-set trailer size to %zu on the %.*js class\n",
size, size,
MOO_OBJ_GET_SIZE(c->name), MOO_OBJ_GET_SIZE(_class->name),
MOO_OBJ_GET_CHAR_SLOT(c->name)); MOO_OBJ_GET_CHAR_SLOT(_class->name));
goto eperm; goto eperm;
} }
sc = (moo_oop_class_t)c->superclass; sc = (moo_oop_class_t)_class->superclass;
if (MOO_OOP_IS_SMOOI(sc->trsize) && size < MOO_OOP_TO_SMOOI(sc->trsize)) if (MOO_OOP_IS_SMOOI(sc->trsize) && size < MOO_OOP_TO_SMOOI(sc->trsize))
{ {
MOO_DEBUG6 (moo, "Not allowed to set the trailer size of %.*js to be smaller(%zu) than that(%zu) of the superclass %.*js\n", MOO_DEBUG6 (moo, "Not allowed to set the trailer size of %.*js to be smaller(%zu) than that(%zu) of the superclass %.*js\n",
size, size,
MOO_OBJ_GET_SIZE(c->name), MOO_OBJ_GET_SIZE(_class->name),
MOO_OBJ_GET_CHAR_SLOT(c->name), MOO_OBJ_GET_CHAR_SLOT(_class->name),
MOO_OOP_TO_SMOOI(sc->trsize), MOO_OOP_TO_SMOOI(sc->trsize),
MOO_OBJ_GET_SIZE(sc->name), MOO_OBJ_GET_SIZE(sc->name),
MOO_OBJ_GET_CHAR_SLOT(sc->name)); MOO_OBJ_GET_CHAR_SLOT(sc->name));
@ -855,11 +851,11 @@ int moo_setclasstrsize (moo_t* moo, moo_oop_t _class, moo_oow_t size)
} }
/* you can only set the trailer size once when it's not set yet */ /* you can only set the trailer size once when it's not set yet */
c->trsize = MOO_SMOOI_TO_OOP(size); _class->trsize = MOO_SMOOI_TO_OOP(size);
MOO_DEBUG3 (moo, "Set trailer size to %zu on the %.*js class\n", MOO_DEBUG3 (moo, "Set trailer size to %zu on the %.*js class\n",
size, size,
MOO_OBJ_GET_SIZE(c->name), MOO_OBJ_GET_SIZE(_class->name),
MOO_OBJ_GET_CHAR_SLOT(c->name)); MOO_OBJ_GET_CHAR_SLOT(_class->name));
return 0; return 0;
eperm: eperm:

85
moo/lib/moo.h
View File

@ -353,10 +353,10 @@ typedef enum moo_obj_type_t moo_obj_type_t;
#define MOO_OBJ_SET_FLAGS_TRAILER(oop,v) MOO_SETBITS(moo_oow_t, (oop)->_flags, MOO_OBJ_FLAGS_TRAILER_SHIFT, MOO_OBJ_FLAGS_TRAILER_BITS, v) #define MOO_OBJ_SET_FLAGS_TRAILER(oop,v) MOO_SETBITS(moo_oow_t, (oop)->_flags, MOO_OBJ_FLAGS_TRAILER_SHIFT, MOO_OBJ_FLAGS_TRAILER_BITS, v)
#define MOO_OBJ_GET_SIZE(oop) ((oop)->_size) #define MOO_OBJ_GET_SIZE(oop) ((oop)->_size)
#define MOO_OBJ_GET_CLASS(oop) ((oop)->_class) #define MOO_OBJ_GET_CLASS(oop) ((moo_oop_class_t)((oop)->_class))
#define MOO_OBJ_SET_SIZE(oop,v) ((oop)->_size = (v)) #define MOO_OBJ_SET_SIZE(oop,v) ((oop)->_size = (v))
#define MOO_OBJ_SET_CLASS(oop,c) ((oop)->_class = (c)) #define MOO_OBJ_SET_CLASS(oop,c) ((oop)->_class = (moo_oop_t)(c))
/* [NOTE] this macro doesn't include the size of the trailer */ /* [NOTE] this macro doesn't include the size of the trailer */
#define MOO_OBJ_BYTESOF(oop) ((MOO_OBJ_GET_SIZE(oop) + MOO_OBJ_GET_FLAGS_EXTRA(oop)) * MOO_OBJ_GET_FLAGS_UNIT(oop)) #define MOO_OBJ_BYTESOF(oop) ((MOO_OBJ_GET_SIZE(oop) + MOO_OBJ_GET_FLAGS_EXTRA(oop)) * MOO_OBJ_GET_FLAGS_UNIT(oop))
@ -697,7 +697,7 @@ struct moo_semaphore_t
moo_oop_t heap_ftime_nsec; /* firing time */ moo_oop_t heap_ftime_nsec; /* firing time */
moo_oop_t io_index; moo_oop_t io_index;
moo_oop_t io_data; moo_oop_t io_handle;
moo_oop_t io_mask; /* SmallInteger */ moo_oop_t io_mask; /* SmallInteger */
}; };
@ -759,9 +759,11 @@ typedef void (*moo_vmprim_cleanup_t) (moo_t* moo);
typedef void (*moo_vmprim_gettime_t) (moo_t* moo, moo_ntime_t* now); typedef void (*moo_vmprim_gettime_t) (moo_t* moo, moo_ntime_t* now);
typedef void (*moo_vmprim_sleep_t) (moo_t* moo, const moo_ntime_t* duration); typedef void (*moo_vmprim_sleep_t) (moo_t* moo, const moo_ntime_t* duration);
typedef int (*moo_vmprim_muxadd_t) (moo_t* moo); typedef int (*moo_vmprim_muxadd_t) (moo_t* moo, moo_oop_semaphore_t sem);
typedef void (*moo_vmprim_muxdel_t) (moo_t* moo); typedef void (*moo_vmprim_muxdel_t) (moo_t* moo, moo_oop_semaphore_t sem);
typedef void (*moo_vmprim_muxwait_t) (moo_t* moo, const moo_ntime_t* duration);
typedef void (*moo_vmprim_muxwait_cb_t) (moo_t* moo, int mask, void* ctx);
typedef void (*moo_vmprim_muxwait_t) (moo_t* moo, const moo_ntime_t* duration, moo_vmprim_muxwait_cb_t muxwcb);
struct moo_vmprim_t struct moo_vmprim_t
{ {
@ -844,7 +846,7 @@ typedef int (*moo_mod_load_t) (
typedef int (*moo_mod_import_t) ( typedef int (*moo_mod_import_t) (
moo_t* moo, moo_t* moo,
moo_mod_t* mod, moo_mod_t* mod,
moo_oop_t _class moo_oop_class_t _class
); );
typedef moo_pfimpl_t (*moo_mod_query_t) ( typedef moo_pfimpl_t (*moo_mod_query_t) (
@ -938,39 +940,39 @@ struct moo_t
* Be sure to Keep these kernel class pointers registered in the * Be sure to Keep these kernel class pointers registered in the
* kernel_classes table in gc.c * kernel_classes table in gc.c
* ============================================================= */ * ============================================================= */
moo_oop_t _apex; /* Apex */ moo_oop_class_t _apex; /* Apex */
moo_oop_t _undefined_object; /* UndefinedObject */ moo_oop_class_t _undefined_object; /* UndefinedObject */
moo_oop_t _class; /* Class */ moo_oop_class_t _class; /* Class */
moo_oop_t _object; /* Object */ moo_oop_class_t _object; /* Object */
moo_oop_t _string; /* String */ moo_oop_class_t _string; /* String */
moo_oop_t _symbol; /* Symbol */ moo_oop_class_t _symbol; /* Symbol */
moo_oop_t _array; /* Array */ moo_oop_class_t _array; /* Array */
moo_oop_t _byte_array; /* ByteArray */ moo_oop_class_t _byte_array; /* ByteArray */
moo_oop_t _symbol_set; /* SymbolSet */ moo_oop_class_t _symbol_set; /* SymbolSet */
moo_oop_t _dictionary; moo_oop_class_t _dictionary;
moo_oop_t _system_dictionary; /* SystemDictionary */ moo_oop_class_t _system_dictionary; /* SystemDictionary */
moo_oop_t _namespace; /* Namespace */ moo_oop_class_t _namespace; /* Namespace */
moo_oop_t _pool_dictionary; /* PoolDictionary */ moo_oop_class_t _pool_dictionary; /* PoolDictionary */
moo_oop_t _method_dictionary; /* MethodDictionary */ moo_oop_class_t _method_dictionary; /* MethodDictionary */
moo_oop_t _method; /* CompiledMethod */ moo_oop_class_t _method; /* CompiledMethod */
moo_oop_t _association; /* Association */ moo_oop_class_t _association; /* Association */
moo_oop_t _method_context; /* MethodContext */ moo_oop_class_t _method_context; /* MethodContext */
moo_oop_t _block_context; /* BlockContext */ moo_oop_class_t _block_context; /* BlockContext */
moo_oop_t _process; /* Process */ moo_oop_class_t _process; /* Process */
moo_oop_t _semaphore; /* Semaphore */ moo_oop_class_t _semaphore; /* Semaphore */
moo_oop_t _process_scheduler; /* ProcessScheduler */ moo_oop_class_t _process_scheduler; /* ProcessScheduler */
moo_oop_t _error_class; /* Error */ moo_oop_class_t _error_class; /* Error */
moo_oop_t _true_class; /* True */ moo_oop_class_t _true_class; /* True */
moo_oop_t _false_class; /* False */ moo_oop_class_t _false_class; /* False */
moo_oop_t _character; /* Character */ moo_oop_class_t _character; /* Character */
moo_oop_t _small_integer; /* SmallInteger */ moo_oop_class_t _small_integer; /* SmallInteger */
moo_oop_t _large_positive_integer; /* LargePositiveInteger */ moo_oop_class_t _large_positive_integer; /* LargePositiveInteger */
moo_oop_t _large_negative_integer; /* LargeNegativeInteger */ moo_oop_class_t _large_negative_integer; /* LargeNegativeInteger */
/* ============================================================= /* =============================================================
* END KERNEL CLASSES * END KERNEL CLASSES
* ============================================================= */ * ============================================================= */
@ -978,7 +980,7 @@ struct moo_t
/* ============================================================= /* =============================================================
* KEY SYSTEM DICTIONARIES * KEY SYSTEM DICTIONARIES
* ============================================================= */ * ============================================================= */
moo_oop_t* tagged_classes[4]; moo_oop_class_t* tagged_classes[4];
moo_oop_set_t symtab; /* system-wide symbol table. instance of SymbolSet */ moo_oop_set_t symtab; /* system-wide symbol table. instance of SymbolSet */
moo_oop_set_t sysdic; /* system dictionary. instance of SystemDictionary */ moo_oop_set_t sysdic; /* system dictionary. instance of SystemDictionary */
moo_oop_process_scheduler_t processor; /* instance of ProcessScheduler */ moo_oop_process_scheduler_t processor; /* instance of ProcessScheduler */
@ -1352,14 +1354,14 @@ MOO_EXPORT void moo_gc (
*/ */
MOO_EXPORT moo_oop_t moo_instantiate ( MOO_EXPORT moo_oop_t moo_instantiate (
moo_t* moo, moo_t* moo,
moo_oop_t _class, moo_oop_class_t _class,
const void* vptr, const void* vptr,
moo_oow_t vlen moo_oow_t vlen
); );
MOO_EXPORT moo_oop_t moo_instantiatewithtrailer ( MOO_EXPORT moo_oop_t moo_instantiatewithtrailer (
moo_t* moo, moo_t* moo,
moo_oop_t _class, moo_oop_class_t _class,
moo_oow_t vlen, moo_oow_t vlen,
const moo_oob_t* trptr, const moo_oob_t* trptr,
moo_oow_t trlen moo_oow_t trlen
@ -1454,7 +1456,7 @@ MOO_EXPORT int moo_inttoooi (
* ========================================================================= */ * ========================================================================= */
MOO_EXPORT int moo_setclasstrsize ( MOO_EXPORT int moo_setclasstrsize (
moo_t* moo, moo_t* moo,
moo_oop_t _class, moo_oop_class_t _class,
moo_oow_t size moo_oow_t size
); );
@ -1505,14 +1507,13 @@ MOO_EXPORT void moo_freemem (
void* ptr void* ptr
); );
/* ========================================================================= /* =========================================================================
* PRIMITIVE METHOD MANIPULATION * PRIMITIVE METHOD MANIPULATION
* ========================================================================= */ * ========================================================================= */
MOO_EXPORT int moo_genpfmethod ( MOO_EXPORT int moo_genpfmethod (
moo_t* moo, moo_t* moo,
moo_mod_t* mod, moo_mod_t* mod,
moo_oop_t _class, moo_oop_class_t _class,
moo_method_type_t type, moo_method_type_t type,
const moo_ooch_t* mthname, const moo_ooch_t* mthname,
int variadic, int variadic,
@ -1522,7 +1523,7 @@ MOO_EXPORT int moo_genpfmethod (
MOO_EXPORT int moo_genpfmethods ( MOO_EXPORT int moo_genpfmethods (
moo_t* moo, moo_t* moo,
moo_mod_t* mod, moo_mod_t* mod,
moo_oop_t _class, moo_oop_class_t _class,
const moo_pfinfo_t* pfinfo, const moo_pfinfo_t* pfinfo,
moo_oow_t pfcount moo_oow_t pfcount
); );

25
moo/lib/obj.c
View File

@ -169,7 +169,7 @@ moo_oop_t moo_allocwordobj (moo_t* moo, const moo_oow_t* ptr, moo_oow_t len)
return alloc_numeric_array (moo, ptr, len, MOO_OBJ_TYPE_WORD, MOO_SIZEOF(moo_oow_t), 0); return alloc_numeric_array (moo, ptr, len, MOO_OBJ_TYPE_WORD, MOO_SIZEOF(moo_oow_t), 0);
} }
static MOO_INLINE int decode_spec (moo_t* moo, moo_oop_t _class, moo_oow_t vlen, moo_obj_type_t* type, moo_oow_t* outlen) static MOO_INLINE int decode_spec (moo_t* moo, moo_oop_class_t _class, moo_oow_t vlen, moo_obj_type_t* type, moo_oow_t* outlen)
{ {
moo_oow_t spec; moo_oow_t spec;
moo_oow_t named_instvar; moo_oow_t named_instvar;
@ -178,8 +178,8 @@ static MOO_INLINE int decode_spec (moo_t* moo, moo_oop_t _class, moo_oow_t vlen,
MOO_ASSERT (moo, MOO_OOP_IS_POINTER(_class)); MOO_ASSERT (moo, MOO_OOP_IS_POINTER(_class));
MOO_ASSERT (moo, MOO_CLASSOF(moo, _class) == moo->_class); MOO_ASSERT (moo, MOO_CLASSOF(moo, _class) == moo->_class);
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(((moo_oop_class_t)_class)->spec)); MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(_class->spec));
spec = MOO_OOP_TO_SMOOI(((moo_oop_class_t)_class)->spec); spec = MOO_OOP_TO_SMOOI(_class->spec);
named_instvar = MOO_CLASS_SPEC_NAMED_INSTVAR(spec); /* size of the named_instvar part */ named_instvar = MOO_CLASS_SPEC_NAMED_INSTVAR(spec); /* size of the named_instvar part */
@ -243,7 +243,7 @@ static MOO_INLINE int decode_spec (moo_t* moo, moo_oop_t _class, moo_oow_t vlen,
return 0; return 0;
} }
moo_oop_t moo_instantiate (moo_t* moo, moo_oop_t _class, const void* vptr, moo_oow_t vlen) moo_oop_t moo_instantiate (moo_t* moo, moo_oop_class_t _class, const void* vptr, moo_oow_t vlen)
{ {
moo_oop_t oop; moo_oop_t oop;
moo_obj_type_t type; moo_obj_type_t type;
@ -258,7 +258,7 @@ moo_oop_t moo_instantiate (moo_t* moo, moo_oop_t _class, const void* vptr, moo_o
return MOO_NULL; return MOO_NULL;
} }
moo_pushtmp (moo, &_class); tmp_count++; moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
switch (type) switch (type)
{ {
@ -307,12 +307,13 @@ moo_oop_t moo_instantiate (moo_t* moo, moo_oop_t _class, const void* vptr, moo_o
break; break;
} }
if (oop) MOO_OBJ_SET_CLASS (oop, _class); if (oop) MOO_OBJ_SET_CLASS (oop, (moo_oop_t)_class);
moo_poptmps (moo, tmp_count); moo_poptmps (moo, tmp_count);
return oop; return oop;
} }
moo_oop_t moo_instantiate2 (moo_t* moo, moo_oop_t _class, const void* vptr, moo_oow_t vlen, int ngc) /* TODO: ... */
moo_oop_t moo_instantiate2 (moo_t* moo, moo_oop_class_t _class, const void* vptr, moo_oow_t vlen, int ngc)
{ {
moo_oop_t oop; moo_oop_t oop;
moo_obj_type_t type; moo_obj_type_t type;
@ -327,7 +328,7 @@ moo_oop_t moo_instantiate2 (moo_t* moo, moo_oop_t _class, const void* vptr, moo_
return MOO_NULL; return MOO_NULL;
} }
moo_pushtmp (moo, &_class); tmp_count++; moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
/* TODO: support NGC */ /* TODO: support NGC */
switch (type) switch (type)
@ -364,7 +365,7 @@ moo_oop_t moo_instantiate2 (moo_t* moo, moo_oop_t _class, const void* vptr, moo_
return oop; return oop;
} }
moo_oop_t moo_instantiatewithtrailer (moo_t* moo, moo_oop_t _class, moo_oow_t vlen, const moo_oob_t* trptr, moo_oow_t trlen) moo_oop_t moo_instantiatewithtrailer (moo_t* moo, moo_oop_class_t _class, moo_oow_t vlen, const moo_oob_t* trptr, moo_oow_t trlen)
{ {
moo_oop_t oop; moo_oop_t oop;
moo_obj_type_t type; moo_obj_type_t type;
@ -379,7 +380,7 @@ moo_oop_t moo_instantiatewithtrailer (moo_t* moo, moo_oop_t _class, moo_oow_t vl
return MOO_NULL; return MOO_NULL;
} }
moo_pushtmp (moo, &_class); tmp_count++; moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
switch (type) switch (type)
{ {
@ -389,8 +390,8 @@ moo_oop_t moo_instantiatewithtrailer (moo_t* moo, moo_oop_t _class, moo_oow_t vl
default: default:
MOO_DEBUG3 (moo, "Not allowed to instantiate a non-pointer object of the %.*js class with trailer %zu\n", MOO_DEBUG3 (moo, "Not allowed to instantiate a non-pointer object of the %.*js class with trailer %zu\n",
MOO_OBJ_GET_SIZE(((moo_oop_class_t)_class)->name), MOO_OBJ_GET_SIZE(_class->name),
MOO_OBJ_GET_CHAR_SLOT(((moo_oop_class_t)_class)->name), MOO_OBJ_GET_CHAR_SLOT(_class->name),
trlen); trlen);
moo->errnum = MOO_EPERM; moo->errnum = MOO_EPERM;

2
moo/lib/sym.c
View File

@ -103,7 +103,7 @@ static moo_oop_t find_or_make_symbol (moo_t* moo, const moo_ooch_t* ptr, moo_oow
while (moo->symtab->bucket->slot[index] != moo->_nil) while (moo->symtab->bucket->slot[index] != moo->_nil)
{ {
symbol = (moo_oop_char_t)moo->symtab->bucket->slot[index]; symbol = (moo_oop_char_t)moo->symtab->bucket->slot[index];
MOO_ASSERT (moo, MOO_CLASSOF(moo,symbol) == (moo_oop_t)moo->_symbol); MOO_ASSERT (moo, MOO_CLASSOF(moo,symbol) == moo->_symbol);
if (len == MOO_OBJ_GET_SIZE(symbol) && if (len == MOO_OBJ_GET_SIZE(symbol) &&
moo_equaloochars (ptr, symbol->slot, len)) moo_equaloochars (ptr, symbol->slot, len))

2
moo/mod/ffi.c
View File

@ -550,7 +550,7 @@ static moo_pfinfo_t pfinfos[] =
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static int import (moo_t* moo, moo_mod_t* mod, moo_oop_t _class) static int import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
{ {
if (moo_setclasstrsize (moo, _class, MOO_SIZEOF(ffi_t)) <= -1) return -1; if (moo_setclasstrsize (moo, _class, MOO_SIZEOF(ffi_t)) <= -1) return -1;
return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos)); return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos));

2
moo/mod/stdio.c
View File

@ -221,7 +221,7 @@ static moo_pfinfo_t pfinfos[] =
}; };
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static int import (moo_t* moo, moo_mod_t* mod, moo_oop_t _class) static int import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
{ {
if (moo_setclasstrsize (moo, _class, MOO_SIZEOF(stdio_t)) <= -1) return -1; if (moo_setclasstrsize (moo, _class, MOO_SIZEOF(stdio_t)) <= -1) return -1;
return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos)); return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos));

94
moo/mod/x11.c
View File

@ -94,12 +94,6 @@ static moo_pfrc_t pf_disconnect (moo_t* moo, moo_ooi_t nargs)
{ {
x11_t* x11; x11_t* x11;
if (nargs != 0)
{
moo_seterrnum (moo, MOO_EINVAL);
goto softfail;
}
x11 = (x11_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL); x11 = (x11_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
MOO_DEBUG1 (moo, "<x11.disconnect> %p\n", x11->c); MOO_DEBUG1 (moo, "<x11.disconnect> %p\n", x11->c);
@ -115,33 +109,86 @@ softfail:
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
/* ------------------------------------------------------------------------ */ static moo_pfrc_t pf_getfd (moo_t* moo, moo_ooi_t nargs)
{
x11_t* x11;
static moo_pfrc_t pf_win_create (moo_t* moo, moo_ooi_t nargs) x11 = (x11_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
MOO_DEBUG1 (moo, "<x11.getfd> %p\n", x11->c);
if (x11->c)
{
int c;
c = xcb_get_file_descriptor(x11->c);
if (!MOO_IN_SMOOI_RANGE(c)) goto error;
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(c));
}
else
{
error:
MOO_STACK_SETRETTOERROR (moo, nargs); /* TODO: be more specific about error code */
}
return MOO_PF_SUCCESS;
}
static moo_pfrc_t pf_getevent (moo_t* moo, moo_ooi_t nargs)
{
x11_t* x11;
xcb_generic_event_t* evt;
x11 = (x11_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
MOO_DEBUG1 (moo, "<x11.__getevent> %p\n", x11->c);
evt = xcb_poll_for_event(x11->c);
if (evt)
{
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(evt->response_type)); /* TODO: translate evt to the event object */
}
else
{ {
MOO_STACK_SETRET (moo, nargs, moo->_nil); MOO_STACK_SETRET (moo, nargs, moo->_nil);
#if 0 }
return MOO_PF_SUCCESS;
}
static moo_pfrc_t pf_makewin (moo_t* moo, moo_ooi_t nargs)
{
x11_t* x11;
xcb_screen_t* screen;
xcb_window_t win;
x11 = (x11_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
MOO_DEBUG1 (moo, "<x11.__makewin> %p\n", x11->c);
screen = xcb_setup_roots_iterator(xcb_get_setup(x11->c)).data; screen = xcb_setup_roots_iterator(xcb_get_setup(x11->c)).data;
x11->mw = xcb_generate_id (xtn->c); win = xcb_generate_id (x11->c);
xcb_create_window (x11->c, xcb_create_window (x11->c,
XCB_COPY_FROM_PARENT, XCB_COPY_FROM_PARENT,
xtn->mw, win,
screen->root, screen->root,
0, 0, 300, 300, 10, 0, 0, 300, 300, 10,
XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_WINDOW_CLASS_INPUT_OUTPUT,
screen->root_visual, screen->root_visual,
0, MOO_NULL); 0, MOO_NULL);
xcb_map_window (xtn->xcb, xtn->mw); /*TODO: use xcb_request_check() for error handling */
xcb_flush (xtn->xcb); xcb_map_window (x11->c, win);
xcb_flush (x11->c);
xcb_generic_event_t* evt; MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(win)); /* TODO: write this function to return a window handle... */
while ((evt = xcb_poll_for_event(xtn->xcb, 0)) return MOO_PF_SUCCESS;
{
/* TODO: dispatch event read */
} }
#endif
/* ------------------------------------------------------------------------ */
static moo_pfrc_t pf_win_create (moo_t* moo, moo_ooi_t nargs)
{
MOO_STACK_SETRET (moo, nargs, moo->_nil);
MOO_DEBUG0 (moo, "x11.window.create....\n"); MOO_DEBUG0 (moo, "x11.window.create....\n");
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
@ -153,15 +200,20 @@ MOO_DEBUG0 (moo, "x11.window.destroy....\n");
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static moo_pfinfo_t x11_pfinfo[] = static moo_pfinfo_t x11_pfinfo[] =
{ {
{ I, { '_','_','g','e','t','e','v','e','n','t','\0'}, 0, pf_getevent },
{ I, { '_','_','m','a','k','e','w','i','n','\0'}, 0, pf_makewin },
{ I, { 'c','o','n','n','e','c','t','\0' }, 0, pf_connect }, { I, { 'c','o','n','n','e','c','t','\0' }, 0, pf_connect },
{ I, { 'd','i','s','c','o','n','n','e','c','t','\0' }, 0, pf_disconnect } { I, { 'd','i','s','c','o','n','n','e','c','t','\0' }, 0, pf_disconnect },
{ I, { 'g','e','t','f','d','\0' }, 0, pf_getfd }
}; };
static int x11_import (moo_t* moo, moo_mod_t* mod, moo_oop_t _class) static int x11_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
{ {
if (moo_setclasstrsize(moo, _class, MOO_SIZEOF(x11_t)) <= -1) return -1; if (moo_setclasstrsize(moo, _class, MOO_SIZEOF(x11_t)) <= -1) return -1;
return moo_genpfmethods(moo, mod, _class, x11_pfinfo, MOO_COUNTOF(x11_pfinfo)); return moo_genpfmethods(moo, mod, _class, x11_pfinfo, MOO_COUNTOF(x11_pfinfo));
@ -194,7 +246,7 @@ static moo_pfinfo_t x11_win_pfinfo[] =
{ I, { 'd','i','s','t','r','o','y','\0' }, 0, pf_win_destroy } { I, { 'd','i','s','t','r','o','y','\0' }, 0, pf_win_destroy }
}; };
static int x11_win_import (moo_t* moo, moo_mod_t* mod, moo_oop_t _class) static int x11_win_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
{ {
if (moo_setclasstrsize(moo, _class, MOO_SIZEOF(x11_win_t)) <= -1) return -1; if (moo_setclasstrsize(moo, _class, MOO_SIZEOF(x11_win_t)) <= -1) return -1;
return moo_genpfmethods(moo, mod, _class, x11_win_pfinfo, MOO_COUNTOF(x11_win_pfinfo)); return moo_genpfmethods(moo, mod, _class, x11_win_pfinfo, MOO_COUNTOF(x11_win_pfinfo));