added partial experimental code for io event handling
This commit is contained in:
hyunghwan.chung
parent
bc5ab97ccf
commit
be677dd53a
@ -426,12 +426,21 @@ class ProcessScheduler(Object)
|
||||
self primitiveFailed.
|
||||
}
|
||||
|
||||
"method signal: semaphore onInput: file
|
||||
method signal: semaphore onInput: file
|
||||
{
|
||||
}"
|
||||
"method signal: semaphore onOutput: file
|
||||
<primitive: #_processor_add_input_semaphore>
|
||||
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
|
||||
{
|
||||
|
||||
@ -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_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: or should it check if it's a subclass, subsubclass, subsubsubclass, etc of a large_integer as well? */
|
||||
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_oop_t c;
|
||||
moo_oop_class_t c;
|
||||
|
||||
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_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)
|
||||
{
|
||||
moo_oop_t c;
|
||||
moo_oop_class_t _class;
|
||||
|
||||
MOO_ASSERT (moo, MOO_OOP_IS_POINTER(oop));
|
||||
if (MOO_OBJ_GET_CLASS(oop) == moo->_large_positive_integer)
|
||||
{
|
||||
c = moo->_large_negative_integer;
|
||||
_class = moo->_large_negative_integer;
|
||||
}
|
||||
else
|
||||
{
|
||||
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)
|
||||
|
||||
@ -6341,7 +6341,7 @@ static int __compile_class_definition (moo_t* moo, int extend)
|
||||
|
||||
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 &&
|
||||
|
||||
@ -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);
|
||||
|
||||
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;
|
||||
while (newbuc->slot[index] != moo->_nil) index = (index + 1) % newsz;
|
||||
@ -334,14 +334,14 @@ found:
|
||||
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_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;
|
||||
|
||||
MOO_ASSERT (moo, MOO_OBJ_GET_SIZE(dic) == MOO_SET_NAMED_INSTVARS);
|
||||
|
||||
141
moo/lib/exec.c
141
moo/lib/exec.c
@ -107,6 +107,8 @@
|
||||
# define __PRIMITIVE_NAME__ (&__FUNCTION__[4])
|
||||
#endif
|
||||
|
||||
static void signal_io_semaphore (moo_t* moo, int mask, void* ctx);
|
||||
|
||||
/* ------------------------------------------------------------------------- */
|
||||
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)
|
||||
{
|
||||
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)
|
||||
{
|
||||
moo_ooi_t index;
|
||||
int n;
|
||||
|
||||
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);
|
||||
|
||||
if (moo->vmprim.mux_add (moo) <= -1) /*TODO: pass data */
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
MOO_ASSERT (moo, sem->io_index == MOO_SMOOI_TO_OOP(-1));
|
||||
|
||||
index = moo->sem_io_count;
|
||||
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++;
|
||||
|
||||
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)
|
||||
@ -784,10 +793,11 @@ static void delete_from_sem_io (moo_t* moo, moo_ooi_t index)
|
||||
moo_oop_semaphore_t sem, lastsem;
|
||||
|
||||
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);
|
||||
|
||||
moo->vmprim.mux_del (moo); /* TODO: pass data... */
|
||||
|
||||
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)
|
||||
{
|
||||
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;
|
||||
/* TODO: implement method lookup cache */
|
||||
|
||||
cls = (moo_oop_class_t)MOO_CLASSOF(moo, receiver);
|
||||
if ((moo_oop_t)cls == moo->_class)
|
||||
cls = MOO_CLASSOF(moo, receiver);
|
||||
if (cls == moo->_class)
|
||||
{
|
||||
/* receiver is a class object (an instance of Class) */
|
||||
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);
|
||||
|
||||
not_found:
|
||||
if ((moo_oop_t)cls == moo->_class)
|
||||
if (cls == moo->_class)
|
||||
{
|
||||
/* the object is an instance of Class. find the method
|
||||
* 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)
|
||||
{
|
||||
/* 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;
|
||||
|
||||
_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)
|
||||
{
|
||||
moo_oop_t rcv, c;
|
||||
moo_oop_t rcv;
|
||||
moo_oop_class_t _class;
|
||||
|
||||
MOO_ASSERT (moo, nargs == 0);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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 */
|
||||
|
||||
_class = MOO_STACK_GETRCV(moo, nargs);
|
||||
_class = (moo_oop_class_t)MOO_STACK_GETRCV(moo, nargs);
|
||||
if (MOO_CLASSOF(moo, _class) != moo->_class)
|
||||
{
|
||||
/* 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;
|
||||
}
|
||||
|
||||
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_ASSERT (moo, nargs == 3);
|
||||
MOO_ASSERT (moo, nargs == 2);
|
||||
|
||||
nsec = MOO_STACK_GETARG (moo, nargs, 2);
|
||||
if (!MOO_OOP_IS_SMOOI(nsec)) return MOO_PF_FAILURE;
|
||||
|
||||
sec = MOO_STACK_GETARG(moo, nargs, 1);
|
||||
fd = MOO_STACK_GETARG(moo, nargs, 1);
|
||||
sem = (moo_oop_semaphore_t)MOO_STACK_GETARG(moo, nargs, 0);
|
||||
rcv = MOO_STACK_GETRCV(moo, nargs);
|
||||
|
||||
/* ProcessScheduler>>signal:after: calls this primitive function. */
|
||||
if (rcv != (moo_oop_t)moo->processor ||
|
||||
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) &&
|
||||
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));
|
||||
}
|
||||
|
||||
/* TOOD: sanity check on argument 2 and 3 */
|
||||
sem->io_data = MOO_STACK_GETARG(moo, nargs, 1);
|
||||
sem->io_mask = MOO_STACK_GETARG(moo, nargs, 2);
|
||||
if (add_to_sem_io (moo, sem) <= -1) return MOO_PF_HARD_FAILURE;
|
||||
sem->io_handle = fd;
|
||||
sem->io_mask = MOO_SMOOI_TO_OOP(mask);
|
||||
if (add_to_sem_io (moo, sem) <= -1) return MOO_PF_HARD_FAILURE; /*TODO: let it return SUCESS but SETRET(error()); */
|
||||
|
||||
MOO_STACK_SETRETTORCV (moo, nargs); /* ^self */
|
||||
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)
|
||||
{
|
||||
/* 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) &&
|
||||
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));
|
||||
}
|
||||
|
||||
@ -2672,7 +2730,9 @@ static pf_t pftab[] =
|
||||
|
||||
{ 1, 1, pf_processor_schedule, "_processor_schedule" },
|
||||
{ 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" },
|
||||
{ 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;
|
||||
|
||||
/* TODO: have the pftable sorted alphabetically and do binary search */
|
||||
for (i = 0; i < MOO_COUNTOF(pftab); i++)
|
||||
{
|
||||
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);
|
||||
|
||||
if (moo->sem_io_count > 0)
|
||||
{
|
||||
MOO_DEBUG0 (moo, "ABOUT TO CALL VM_MUX_WAIT()\n");
|
||||
vm_mux_wait (moo, &ft);
|
||||
}
|
||||
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);
|
||||
}
|
||||
else
|
||||
@ -3106,7 +3173,7 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
|
||||
/* there is a running process. go on */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (moo->sem_heap_count > 0 && !moo->abort_req);
|
||||
}
|
||||
|
||||
@ -3795,7 +3862,7 @@ int moo_execute (moo_t* moo)
|
||||
t = (moo_oop_t)moo_makedic (moo, moo->_dictionary, b1 + 10);
|
||||
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));
|
||||
if (send_message (moo, moo->dicnewsym, 0, 1) <= -1) goto oops;
|
||||
break;
|
||||
|
||||
22
moo/lib/gc.c
22
moo/lib/gc.c
@ -120,7 +120,7 @@ static kernel_class_info_t kernel_classes[] =
|
||||
* 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;
|
||||
|
||||
@ -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;
|
||||
|
||||
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->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)
|
||||
@ -154,7 +154,7 @@ static int ignite_1 (moo_t* moo)
|
||||
if (!moo->_class) return -1;
|
||||
|
||||
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.
|
||||
@ -220,7 +220,7 @@ static int ignite_1 (moo_t* moo)
|
||||
!moo->_character || !moo->_small_integer ||
|
||||
!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;
|
||||
}
|
||||
|
||||
@ -268,7 +268,7 @@ static int ignite_2 (moo_t* moo)
|
||||
moo->processor->active = moo->nil_process;
|
||||
|
||||
/* 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;
|
||||
}
|
||||
@ -309,11 +309,11 @@ static int ignite_3 (moo_t* moo)
|
||||
|
||||
sym = moo_makesymbol (moo, str_dicnew, MOO_COUNTOF(str_dicnew));
|
||||
if (!sym) return -1;
|
||||
moo->dicnewsym = sym;
|
||||
moo->dicnewsym = (moo_oop_char_t)sym;
|
||||
|
||||
sym = moo_makesymbol (moo, str_dicputassoc, MOO_COUNTOF(str_dicputassoc));
|
||||
if (!sym) return -1;
|
||||
moo->dicputassocsym = sym;
|
||||
moo->dicputassocsym = (moo_oop_char_t)sym;
|
||||
|
||||
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
|
||||
* in the 'else' block below. i can simply return it
|
||||
* without further migration. */
|
||||
return MOO_OBJ_GET_CLASS(oop);
|
||||
return (moo_oop_t)MOO_OBJ_GET_CLASS(oop);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -527,7 +527,7 @@ static moo_uint8_t* scan_new_heap (moo_t* moo, moo_uint8_t* ptr)
|
||||
}
|
||||
#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)
|
||||
{
|
||||
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_class_t c;
|
||||
|
||||
c = (moo_oop_class_t)MOO_OBJ_GET_CLASS(oop);
|
||||
c = MOO_OBJ_GET_CLASS(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)));
|
||||
moo_poptmp(moo);
|
||||
|
||||
@ -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));
|
||||
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_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]);
|
||||
}
|
||||
}
|
||||
else if ((moo_oop_t)c == moo->_large_positive_integer)
|
||||
else if (c == moo->_large_positive_integer)
|
||||
{
|
||||
moo_oow_t i;
|
||||
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)
|
||||
{
|
||||
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);
|
||||
}
|
||||
@ -455,7 +455,7 @@ static void print_object (moo_t* moo, moo_oow_t mask, moo_oop_t oop)
|
||||
}
|
||||
moo_logbfmt (moo, mask, "]]]");
|
||||
}
|
||||
else if ((moo_oop_t)c == moo->_array)
|
||||
else if (c == moo->_array)
|
||||
{
|
||||
moo_logbfmt (moo, mask, "#(");
|
||||
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, ")");
|
||||
}
|
||||
else if ((moo_oop_t)c == moo->_class)
|
||||
else if (c == moo->_class)
|
||||
{
|
||||
/* 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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
@ -821,42 +821,74 @@ static void vm_sleep (moo_t* moo, const moo_ntime_t* dur)
|
||||
#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);
|
||||
struct epoll_event ev;
|
||||
moo_ooi_t mask;
|
||||
|
||||
ev.events = EPOLLIN | EPOLLOUT;
|
||||
ev.data.u64 = 10;
|
||||
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));
|
||||
|
||||
/*
|
||||
if (epoll_ctl (xtn->ep, EPOLL_CTL_DEL, 000, &ev) == -1)
|
||||
mask = MOO_OOP_TO_SMOOI(sem->io_mask);
|
||||
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;
|
||||
}
|
||||
*/
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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);
|
||||
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);
|
||||
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 (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);
|
||||
}
|
||||
*/
|
||||
}
|
||||
/* ========================================================================= */
|
||||
|
||||
|
||||
@ -1036,9 +1036,9 @@ int moo_deletedic (
|
||||
);
|
||||
|
||||
moo_oop_set_t moo_makedic (
|
||||
moo_t* moo,
|
||||
moo_oop_t cls,
|
||||
moo_oow_t size
|
||||
moo_t* moo,
|
||||
moo_oop_class_t _class,
|
||||
moo_oow_t size
|
||||
);
|
||||
|
||||
/* ========================================================================= */
|
||||
@ -1048,7 +1048,6 @@ moo_oop_process_t moo_makeproc (
|
||||
moo_t* moo
|
||||
);
|
||||
|
||||
|
||||
/* ========================================================================= */
|
||||
/* bigint.c */
|
||||
/* ========================================================================= */
|
||||
@ -1200,7 +1199,7 @@ void moo_closemod (
|
||||
|
||||
int moo_importmod (
|
||||
moo_t* moo,
|
||||
moo_oop_t _class,
|
||||
moo_oop_class_t _class,
|
||||
const moo_ooch_t* name,
|
||||
moo_oow_t len
|
||||
);
|
||||
|
||||
@ -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_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.
|
||||
* i need to protect _class in case the user-defined callback allocates
|
||||
* 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);
|
||||
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 */
|
||||
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 */
|
||||
|
||||
moo_oop_char_t mnsym, pfidsym;
|
||||
moo_oop_method_t mth;
|
||||
moo_oop_class_t cls;
|
||||
moo_oow_t tmp_count = 0, i;
|
||||
moo_ooi_t arg_count = 0;
|
||||
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;
|
||||
|
||||
cls = (moo_oop_class_t)_class;
|
||||
moo_pushtmp (moo, (moo_oop_t*)&cls); tmp_count++;
|
||||
MOO_ASSERT (moo, MOO_CLASSOF(moo, (moo_oop_t)cls->mthdic[type]) == moo->_method_dictionary);
|
||||
moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
|
||||
MOO_ASSERT (moo, MOO_CLASSOF(moo, (moo_oop_t)_class->mthdic[type]) == moo->_method_dictionary);
|
||||
|
||||
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] != ':')
|
||||
{
|
||||
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;
|
||||
goto oops;
|
||||
}
|
||||
|
||||
cs.ptr = (moo_ooch_t*)mthname;
|
||||
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;
|
||||
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, 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;
|
||||
}
|
||||
|
||||
pfidsym = (moo_oop_char_t)moo_makesymbol (moo, moo->sbuf[0].ptr, moo->sbuf[0].len);
|
||||
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;
|
||||
}
|
||||
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
|
||||
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;
|
||||
}
|
||||
|
||||
@ -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;
|
||||
|
||||
/* premable should contain the index to the literal frame which is always 0 */
|
||||
mth->owner = cls;
|
||||
mth->owner = _class;
|
||||
mth->name = mnsym;
|
||||
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));
|
||||
@ -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?? */
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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;
|
||||
return 0;
|
||||
@ -756,12 +754,12 @@ oops:
|
||||
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;
|
||||
moo_oow_t i;
|
||||
|
||||
moo_pushtmp (moo, &_class);
|
||||
moo_pushtmp (moo, (moo_oop_t*)&_class);
|
||||
for (i = 0; i < pfcount; i++)
|
||||
{
|
||||
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_oow_t spec;
|
||||
|
||||
MOO_ASSERT (moo, MOO_CLASSOF(moo, _class) == moo->_class);
|
||||
MOO_ASSERT (moo, size <= MOO_SMOOI_MAX);
|
||||
|
||||
c = (moo_oop_class_t)_class;
|
||||
if ((moo_oop_t)c == moo->_method)
|
||||
if (_class == moo->_method)
|
||||
{
|
||||
/* the bytes code emitted by the compiler go to the trailer part
|
||||
* 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",
|
||||
size,
|
||||
MOO_OBJ_GET_SIZE(c->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(c->name));
|
||||
MOO_OBJ_GET_SIZE(_class->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(_class->name));
|
||||
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)
|
||||
{
|
||||
MOO_DEBUG3 (moo, "Not allowed to set trailer size to %zu on the %.*js class representing a non-pointer object\n",
|
||||
size,
|
||||
MOO_OBJ_GET_SIZE(c->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(c->name));
|
||||
MOO_OBJ_GET_SIZE(_class->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(_class->name));
|
||||
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",
|
||||
size,
|
||||
MOO_OBJ_GET_SIZE(c->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(c->name));
|
||||
MOO_OBJ_GET_SIZE(_class->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(_class->name));
|
||||
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))
|
||||
{
|
||||
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,
|
||||
MOO_OBJ_GET_SIZE(c->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(c->name),
|
||||
MOO_OBJ_GET_SIZE(_class->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(_class->name),
|
||||
MOO_OOP_TO_SMOOI(sc->trsize),
|
||||
MOO_OBJ_GET_SIZE(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 */
|
||||
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",
|
||||
size,
|
||||
MOO_OBJ_GET_SIZE(c->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(c->name));
|
||||
MOO_OBJ_GET_SIZE(_class->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(_class->name));
|
||||
return 0;
|
||||
|
||||
eperm:
|
||||
|
||||
@ -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_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_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 */
|
||||
#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 io_index;
|
||||
moo_oop_t io_data;
|
||||
moo_oop_t io_handle;
|
||||
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_sleep_t) (moo_t* moo, const moo_ntime_t* duration);
|
||||
|
||||
typedef int (*moo_vmprim_muxadd_t) (moo_t* moo);
|
||||
typedef void (*moo_vmprim_muxdel_t) (moo_t* moo);
|
||||
typedef void (*moo_vmprim_muxwait_t) (moo_t* moo, const moo_ntime_t* duration);
|
||||
typedef int (*moo_vmprim_muxadd_t) (moo_t* moo, moo_oop_semaphore_t sem);
|
||||
typedef void (*moo_vmprim_muxdel_t) (moo_t* moo, moo_oop_semaphore_t sem);
|
||||
|
||||
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
|
||||
{
|
||||
@ -844,7 +846,7 @@ typedef int (*moo_mod_load_t) (
|
||||
typedef int (*moo_mod_import_t) (
|
||||
moo_t* moo,
|
||||
moo_mod_t* mod,
|
||||
moo_oop_t _class
|
||||
moo_oop_class_t _class
|
||||
);
|
||||
|
||||
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
|
||||
* kernel_classes table in gc.c
|
||||
* ============================================================= */
|
||||
moo_oop_t _apex; /* Apex */
|
||||
moo_oop_t _undefined_object; /* UndefinedObject */
|
||||
moo_oop_t _class; /* Class */
|
||||
moo_oop_t _object; /* Object */
|
||||
moo_oop_t _string; /* String */
|
||||
moo_oop_class_t _apex; /* Apex */
|
||||
moo_oop_class_t _undefined_object; /* UndefinedObject */
|
||||
moo_oop_class_t _class; /* Class */
|
||||
moo_oop_class_t _object; /* Object */
|
||||
moo_oop_class_t _string; /* String */
|
||||
|
||||
moo_oop_t _symbol; /* Symbol */
|
||||
moo_oop_t _array; /* Array */
|
||||
moo_oop_t _byte_array; /* ByteArray */
|
||||
moo_oop_t _symbol_set; /* SymbolSet */
|
||||
moo_oop_t _dictionary;
|
||||
moo_oop_t _system_dictionary; /* SystemDictionary */
|
||||
moo_oop_class_t _symbol; /* Symbol */
|
||||
moo_oop_class_t _array; /* Array */
|
||||
moo_oop_class_t _byte_array; /* ByteArray */
|
||||
moo_oop_class_t _symbol_set; /* SymbolSet */
|
||||
moo_oop_class_t _dictionary;
|
||||
moo_oop_class_t _system_dictionary; /* SystemDictionary */
|
||||
|
||||
moo_oop_t _namespace; /* Namespace */
|
||||
moo_oop_t _pool_dictionary; /* PoolDictionary */
|
||||
moo_oop_t _method_dictionary; /* MethodDictionary */
|
||||
moo_oop_t _method; /* CompiledMethod */
|
||||
moo_oop_t _association; /* Association */
|
||||
moo_oop_class_t _namespace; /* Namespace */
|
||||
moo_oop_class_t _pool_dictionary; /* PoolDictionary */
|
||||
moo_oop_class_t _method_dictionary; /* MethodDictionary */
|
||||
moo_oop_class_t _method; /* CompiledMethod */
|
||||
moo_oop_class_t _association; /* Association */
|
||||
|
||||
moo_oop_t _method_context; /* MethodContext */
|
||||
moo_oop_t _block_context; /* BlockContext */
|
||||
moo_oop_t _process; /* Process */
|
||||
moo_oop_t _semaphore; /* Semaphore */
|
||||
moo_oop_t _process_scheduler; /* ProcessScheduler */
|
||||
moo_oop_class_t _method_context; /* MethodContext */
|
||||
moo_oop_class_t _block_context; /* BlockContext */
|
||||
moo_oop_class_t _process; /* Process */
|
||||
moo_oop_class_t _semaphore; /* Semaphore */
|
||||
moo_oop_class_t _process_scheduler; /* ProcessScheduler */
|
||||
|
||||
moo_oop_t _error_class; /* Error */
|
||||
moo_oop_t _true_class; /* True */
|
||||
moo_oop_t _false_class; /* False */
|
||||
moo_oop_t _character; /* Character */
|
||||
moo_oop_t _small_integer; /* SmallInteger */
|
||||
moo_oop_class_t _error_class; /* Error */
|
||||
moo_oop_class_t _true_class; /* True */
|
||||
moo_oop_class_t _false_class; /* False */
|
||||
moo_oop_class_t _character; /* Character */
|
||||
moo_oop_class_t _small_integer; /* SmallInteger */
|
||||
|
||||
moo_oop_t _large_positive_integer; /* LargePositiveInteger */
|
||||
moo_oop_t _large_negative_integer; /* LargeNegativeInteger */
|
||||
moo_oop_class_t _large_positive_integer; /* LargePositiveInteger */
|
||||
moo_oop_class_t _large_negative_integer; /* LargeNegativeInteger */
|
||||
/* =============================================================
|
||||
* END KERNEL CLASSES
|
||||
* ============================================================= */
|
||||
@ -978,7 +980,7 @@ struct moo_t
|
||||
/* =============================================================
|
||||
* 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 sysdic; /* system dictionary. instance of SystemDictionary */
|
||||
moo_oop_process_scheduler_t processor; /* instance of ProcessScheduler */
|
||||
@ -1351,15 +1353,15 @@ MOO_EXPORT void moo_gc (
|
||||
*
|
||||
*/
|
||||
MOO_EXPORT moo_oop_t moo_instantiate (
|
||||
moo_t* moo,
|
||||
moo_oop_t _class,
|
||||
moo_t* moo,
|
||||
moo_oop_class_t _class,
|
||||
const void* vptr,
|
||||
moo_oow_t vlen
|
||||
moo_oow_t vlen
|
||||
);
|
||||
|
||||
MOO_EXPORT moo_oop_t moo_instantiatewithtrailer (
|
||||
moo_t* moo,
|
||||
moo_oop_t _class,
|
||||
moo_oop_class_t _class,
|
||||
moo_oow_t vlen,
|
||||
const moo_oob_t* trptr,
|
||||
moo_oow_t trlen
|
||||
@ -1453,9 +1455,9 @@ MOO_EXPORT int moo_inttoooi (
|
||||
* TRAILER MANAGEMENT
|
||||
* ========================================================================= */
|
||||
MOO_EXPORT int moo_setclasstrsize (
|
||||
moo_t* moo,
|
||||
moo_oop_t _class,
|
||||
moo_oow_t size
|
||||
moo_t* moo,
|
||||
moo_oop_class_t _class,
|
||||
moo_oow_t size
|
||||
);
|
||||
|
||||
MOO_EXPORT void* moo_getobjtrailer (
|
||||
@ -1505,14 +1507,13 @@ MOO_EXPORT void moo_freemem (
|
||||
void* ptr
|
||||
);
|
||||
|
||||
|
||||
/* =========================================================================
|
||||
* PRIMITIVE METHOD MANIPULATION
|
||||
* ========================================================================= */
|
||||
MOO_EXPORT int moo_genpfmethod (
|
||||
moo_t* moo,
|
||||
moo_mod_t* mod,
|
||||
moo_oop_t _class,
|
||||
moo_oop_class_t _class,
|
||||
moo_method_type_t type,
|
||||
const moo_ooch_t* mthname,
|
||||
int variadic,
|
||||
@ -1522,7 +1523,7 @@ MOO_EXPORT int moo_genpfmethod (
|
||||
MOO_EXPORT int moo_genpfmethods (
|
||||
moo_t* moo,
|
||||
moo_mod_t* mod,
|
||||
moo_oop_t _class,
|
||||
moo_oop_class_t _class,
|
||||
const moo_pfinfo_t* pfinfo,
|
||||
moo_oow_t pfcount
|
||||
);
|
||||
|
||||
@ -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);
|
||||
}
|
||||
|
||||
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 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_CLASSOF(moo, _class) == moo->_class);
|
||||
|
||||
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(((moo_oop_class_t)_class)->spec));
|
||||
spec = MOO_OOP_TO_SMOOI(((moo_oop_class_t)_class)->spec);
|
||||
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(_class->spec));
|
||||
spec = MOO_OOP_TO_SMOOI(_class->spec);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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_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;
|
||||
}
|
||||
|
||||
moo_pushtmp (moo, &_class); tmp_count++;
|
||||
moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
@ -307,12 +307,13 @@ moo_oop_t moo_instantiate (moo_t* moo, moo_oop_t _class, const void* vptr, moo_o
|
||||
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);
|
||||
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_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;
|
||||
}
|
||||
|
||||
moo_pushtmp (moo, &_class); tmp_count++;
|
||||
moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
|
||||
|
||||
/* TODO: support NGC */
|
||||
switch (type)
|
||||
@ -364,7 +365,7 @@ moo_oop_t moo_instantiate2 (moo_t* moo, moo_oop_t _class, const void* vptr, moo_
|
||||
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_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;
|
||||
}
|
||||
|
||||
moo_pushtmp (moo, &_class); tmp_count++;
|
||||
moo_pushtmp (moo, (moo_oop_t*)&_class); tmp_count++;
|
||||
|
||||
switch (type)
|
||||
{
|
||||
@ -389,8 +390,8 @@ moo_oop_t moo_instantiatewithtrailer (moo_t* moo, moo_oop_t _class, moo_oow_t vl
|
||||
|
||||
default:
|
||||
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_CHAR_SLOT(((moo_oop_class_t)_class)->name),
|
||||
MOO_OBJ_GET_SIZE(_class->name),
|
||||
MOO_OBJ_GET_CHAR_SLOT(_class->name),
|
||||
trlen);
|
||||
|
||||
moo->errnum = MOO_EPERM;
|
||||
|
||||
@ -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)
|
||||
{
|
||||
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) &&
|
||||
moo_equaloochars (ptr, symbol->slot, len))
|
||||
|
||||
@ -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;
|
||||
return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos));
|
||||
|
||||
@ -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;
|
||||
return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos));
|
||||
|
||||
100
moo/mod/x11.c
100
moo/mod/x11.c
@ -94,12 +94,6 @@ static moo_pfrc_t pf_disconnect (moo_t* moo, moo_ooi_t nargs)
|
||||
{
|
||||
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);
|
||||
|
||||
MOO_DEBUG1 (moo, "<x11.disconnect> %p\n", x11->c);
|
||||
@ -115,33 +109,86 @@ softfail:
|
||||
return MOO_PF_SUCCESS;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
static moo_pfrc_t pf_win_create (moo_t* moo, moo_ooi_t nargs)
|
||||
static moo_pfrc_t pf_getfd (moo_t* moo, moo_ooi_t nargs)
|
||||
{
|
||||
MOO_STACK_SETRET (moo, nargs, moo->_nil);
|
||||
#if 0
|
||||
x11_t* x11;
|
||||
|
||||
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);
|
||||
}
|
||||
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;
|
||||
x11->mw = xcb_generate_id (xtn->c);
|
||||
win = xcb_generate_id (x11->c);
|
||||
|
||||
xcb_create_window (x11->c,
|
||||
XCB_COPY_FROM_PARENT,
|
||||
xtn->mw,
|
||||
win,
|
||||
screen->root,
|
||||
0, 0, 300, 300, 10,
|
||||
XCB_WINDOW_CLASS_INPUT_OUTPUT,
|
||||
screen->root_visual,
|
||||
0, MOO_NULL);
|
||||
|
||||
xcb_map_window (xtn->xcb, xtn->mw);
|
||||
xcb_flush (xtn->xcb);
|
||||
/*TODO: use xcb_request_check() for error handling */
|
||||
xcb_map_window (x11->c, win);
|
||||
xcb_flush (x11->c);
|
||||
|
||||
xcb_generic_event_t* evt;
|
||||
while ((evt = xcb_poll_for_event(xtn->xcb, 0))
|
||||
{
|
||||
/* TODO: dispatch event read */
|
||||
}
|
||||
#endif
|
||||
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(win)); /* TODO: write this function to return a window handle... */
|
||||
return MOO_PF_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
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");
|
||||
return MOO_PF_SUCCESS;
|
||||
}
|
||||
@ -153,15 +200,20 @@ MOO_DEBUG0 (moo, "x11.window.destroy....\n");
|
||||
return MOO_PF_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
||||
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, { '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;
|
||||
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 }
|
||||
};
|
||||
|
||||
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;
|
||||
return moo_genpfmethods(moo, mod, _class, x11_win_pfinfo, MOO_COUNTOF(x11_win_pfinfo));
|
||||
|
||||
Loading…
Reference in New Issue
Block a user