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

added moo_pfbase_t and changed some functions to return moo_pfbase_t* instead of moo_pfimpl_t

Browse Source 
touched up some modules
This commit is contained in:
hyunghwan.chung 2017-03-30 14:59:55 +00:00
parent 9748410354
commit 0f84a115ae
13 changed files with 159 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
moo/kernel/Console.moo
View File

@ -1,3 +1,4 @@
## TODO: move Pointe to a separate file
class Point(Object) class Point(Object)
{ {
dcl x y. dcl x y.
@ -46,20 +47,22 @@ extend SmallInteger
} }
} }
class Console(Object) from 'console'
class Console(Object)
{ {
dcl handle. method(#primitive) _open.
" method(#primitive) _close.
method(#primitive) _clear.
method(#primitive) _setcursor(x, y).
method(#primitive) _write(msg).
(*
method finalize method finalize
{ {
handle notNil ifTrue: [ if (still open) {
self _close: handle. self _close.
] }
} }
" *)
## method(#class) input ## method(#class) input
@ -72,7 +75,7 @@ class Console(Object)
| c | | c |
c := self new. c := self new.
c handle: (c _open). c _open. ## TODO error check - if ((e := c _open) isError) { ^e }.
^c ^c
} }
@ -80,127 +83,24 @@ class Console(Object)
## { ## {
## } ## }
method handle: v
{
self.handle := v.
}
method close method close
{ {
self _close: self.handle. self _close.
self.handle := nil.
} }
method write: text method write: text
{ {
^self _writeOn: self.handle text: text. ^self _write(text)
} }
method clear method clear
{ {
^self _clear: self.handle ^self _clear.
} }
method setCursor: point method setCursor: point
{ {
^self _setCursor: self.handle point: point. ^self _setcursor(point x, point y)
}
"
method _open: filename mode: mode
{
self.handle := self __open: filename mode: mode.
^self.
}
method __open: filename mode: mode
{
<primitive: #console.open>
##StdioException signal: ('cannot open ' & filename).
}
"
method _open
{
<primitive: #console.open>
}
method _close: handle
{
<primitive: #console.close>
self primitiveFailed.
}
method _clear: handle
{
<primitive: #console.clear>
self primitiveFailed.
}
method _writeOn: handle text: text
{
<primitive: #console.write>
self primitiveFailed.
}
method _setCursor: handle point: point
{
<primitive: #console.setcursor>
self primitiveFailed.
}
"
method(#class) open
{
<primitive: #console.open>
self primitiveFailed.
}
method close
{
<primitive: #console.close>
self primitiveFailed.
}
method setCursorTo: point
{
<primitive: #console.setcursor>
self primitiveFailed.
}
"
##x := Colsole new.
##x := Console open.
##(x isError) ifTrue: [
## handle error...
## ]
## ifFalse: [
## x setCursor (1, 2).
## x clear.
## x close.
## ]
##x := File open: 'abc.def'
##t := x read: 1000.
##x close.
}
"
Moo define: 'console_write'
forClass: Console
method: 'write: aString upto: length'
returns: 'size_t'
arguments: 'void* size_t'
---> produces a method like this internally...
class Console
{
method write: aString upto: length
{
<ffi: int console_write (int*, char*, [int, int, char]* )> <== parse the string, create a descriptor table, key is console_write, value is resolved to a function pointer.
} }
} }
"

19
moo/kernel/FFI.moo
View File

@ -1,13 +1,11 @@
class _FFI(Object) from 'ffi' class _FFI(Object) from 'ffi'
{ {
(* method(#primitive) open(name).
* the ffi module installs the following methods method(#primitive) close().
* method(#class) _newInstSize method(#primitive) getsym(name).
* method open: name
* method close (* TODO: make call variadic? method(#primitive,#variadic) call (func, sig). *)
* method call method(#primitive) call(func, sig, args).
* method call: func sig: sig with: args.
*)
} }
class FFI(Object) class FFI(Object)
@ -31,7 +29,7 @@ class FFI(Object)
self.funcs removeAllKeys. self.funcs removeAllKeys.
self.name := name. self.name := name.
x := self.ffi open: name. x := self.ffi open(name).
(x isError) ifTrue: [^x]. (x isError) ifTrue: [^x].
^self. ^self.
@ -47,12 +45,11 @@ class FFI(Object)
| f | | f |
f := self.funcs at: name. f := self.funcs at: name.
(f isError) ifTrue: [ (f isError) ifTrue: [
f := self.ffi getsym: name. f := self.ffi getsym(name).
(f isError) ifTrue: [^f]. (f isError) ifTrue: [^f].
self.funcs at: name put: f. self.funcs at: name put: f.
]. ].
(*^self.ffi call: f sig: sig with: args*)
^self.ffi call(f, sig, args) ^self.ffi call(f, sig, args)
} }
} }

1
moo/kernel/Mill.moo
View File

@ -331,6 +331,7 @@ class MyObject(Object)
(System at: #Processor) dump. (System at: #Processor) dump.
System logNl: 'Sleeping start now....'. System logNl: 'Sleeping start now....'.
Processor sleepFor: 2. Processor sleepFor: 2.
} }

14
moo/kernel/Stdio.moo
View File

@ -3,16 +3,15 @@ class Stdio(Object) from 'stdio'
{ {
dcl(#class) in out err. dcl(#class) in out err.
(* method(#primitive) open(name, mode).
* The following methods are generated by the module. method(#primitive) close.
* method(#class) _newInstSize { <primitive: #stdio._newInstSize> } method(#primitive) gets.
* method open: name for: mode { <primitive: #stdio.open> } method(#primitive,#variadic) puts().
* method close { <primitive: #stdio.close> } method(#primitive,#variadic) putc().
*)
method(#class) open: name for: mode method(#class) open: name for: mode
{ {
^(self new) open: name for: mode ^(self new) open(name, mode)
} }
(* --------------------- (* ---------------------
@ -71,5 +70,4 @@ class Stdio2(Stdio)
##raise exception. prohibited... ##raise exception. prohibited...
^(super new). ^(super new).
} }
} }

14
moo/kernel/test-014.moo
View File

@ -51,12 +51,12 @@ class B.TestObject(Object)
pooldic ABC pooldic ABC
{ {
#KKK := 20. KKK := 20.
} }
pooldic SRX.ABC pooldic SRX.ABC
{ {
#JJJ := 1000. JJJ := 1000.
} }
class MyConsole(Console) class MyConsole(Console)
{ {
@ -125,7 +125,7 @@ class MyObject(TestObject)
##v1 := Stdio2 open: '/tmp/1.txt' for: 'w+'. ##v1 := Stdio2 open: '/tmp/1.txt' for: 'w+'.
v1 := Stdio2 new open: '/tmp/1.txt' for: 'w+'. v1 := Stdio2 new open('/tmp/1.txt', 'w+').
(v1 isError) (v1 isError)
ifTrue: [ ifTrue: [
System logNl: ('Error in opening a file....' & v1 asString). System logNl: ('Error in opening a file....' & v1 asString).
@ -195,21 +195,21 @@ class MyObject(TestObject)
v2 dump. v2 dump.
} }
method(#class) varg_test() method(#class,#variadic) varg_test()
{ {
0 to: (thisContext vargCount - 1) do: [:k | 0 to: (thisContext vargCount - 1) do: [:k |
(thisContext vargAt: k) dump. (thisContext vargAt: k) dump.
]. ].
^999 ^999
} }
method(#class) varg_test2(a,b,c) method(#class,#variadic) varg_test2(a,b,c)
{ {
0 to: (thisContext vargCount - 1) do: [:k | 0 to: (thisContext vargCount - 1) do: [:k |
(thisContext vargAt: k) dump. (thisContext vargAt: k) dump.
]. ].
^a ^a
} }
method(#class) varg_test3(a,b,c,d,e,f) method(#class,#variadic) varg_test3(a,b,c,d,e,f)
{ {
0 to: (thisContext vargCount - 1) do: [:k | 0 to: (thisContext vargCount - 1) do: [:k |
(thisContext vargAt: k) dump. (thisContext vargAt: k) dump.
@ -218,7 +218,7 @@ class MyObject(TestObject)
^f ^f
} }
method(#class) t001(a) method(#class,#variadic) t001(a)
{ {
a isNil ifTrue: [^error(10)]. a isNil ifTrue: [^error(10)].
(a = 20) ifTrue: [^error]. (a = 20) ifTrue: [^error].

20
moo/lib/exec.c
View File

@ -3163,7 +3163,7 @@ static int start_method (moo_t* moo, moo_oop_method_t method, moo_oow_t nargs)
{ {
moo_ooi_t pf_name_index; moo_ooi_t pf_name_index;
moo_oop_t name; moo_oop_t name;
moo_pfimpl_t handler; moo_pfbase_t* pfbase;
moo_oow_t w; moo_oow_t w;
stack_base = moo->sp - nargs - 1; /* stack base before receiver and arguments */ stack_base = moo->sp - nargs - 1; /* stack base before receiver and arguments */
@ -3182,22 +3182,22 @@ static int start_method (moo_t* moo, moo_oop_method_t method, moo_oow_t nargs)
/* merge two SmallIntegers to get a full pointer from the cached data */ /* merge two SmallIntegers to get a full pointer from the cached data */
w = (moo_oow_t)MOO_OOP_TO_SMOOI(method->preamble_data[0]) << (MOO_OOW_BITS / 2) | w = (moo_oow_t)MOO_OOP_TO_SMOOI(method->preamble_data[0]) << (MOO_OOW_BITS / 2) |
(moo_oow_t)MOO_OOP_TO_SMOOI(method->preamble_data[1]); (moo_oow_t)MOO_OOP_TO_SMOOI(method->preamble_data[1]);
handler = (moo_pfimpl_t)w; pfbase = (moo_pfbase_t*)w;
if (handler) goto exec_handler; if (pfbase) goto exec_handler;
#if defined(NDEBUG) #if defined(NDEBUG)
pf_name_index = MOO_METHOD_GET_PREAMBLE_INDEX(preamble); pf_name_index = MOO_METHOD_GET_PREAMBLE_INDEX(preamble);
name = method->slot[pf_name_index]; name = method->slot[pf_name_index];
#endif #endif
handler = moo_querymod (moo, ((moo_oop_char_t)name)->slot, MOO_OBJ_GET_SIZE(name)); pfbase = moo_querymod (moo, ((moo_oop_char_t)name)->slot, MOO_OBJ_GET_SIZE(name));
if (handler) if (pfbase)
{ {
int n; int n;
/* split a pointer to two OOP fields as SmallIntegers for storing/caching. */ /* split a pointer to two OOP fields as SmallIntegers for storing/caching. */
method->preamble_data[0] = MOO_SMOOI_TO_OOP((moo_oow_t)handler >> (MOO_OOW_BITS / 2)); method->preamble_data[0] = MOO_SMOOI_TO_OOP((moo_oow_t)pfbase >> (MOO_OOW_BITS / 2));
method->preamble_data[1] = MOO_SMOOI_TO_OOP((moo_oow_t)handler & MOO_LBMASK(moo_oow_t, MOO_OOW_BITS / 2)); method->preamble_data[1] = MOO_SMOOI_TO_OOP((moo_oow_t)pfbase & MOO_LBMASK(moo_oow_t, MOO_OOW_BITS / 2));
exec_handler: exec_handler:
moo_pushtmp (moo, (moo_oop_t*)&method); moo_pushtmp (moo, (moo_oop_t*)&method);
@ -3208,18 +3208,18 @@ static int start_method (moo_t* moo, moo_oop_method_t method, moo_oow_t nargs)
* directly in the stack unlik a normal activated method context where the * directly in the stack unlik a normal activated method context where the
* arguments are copied to the back. */ * arguments are copied to the back. */
n = handler (moo, nargs); n = pfbase->handler (moo, nargs);
moo_poptmp (moo); moo_poptmp (moo);
if (n <= MOO_PF_HARD_FAILURE) if (n <= MOO_PF_HARD_FAILURE)
{ {
MOO_DEBUG4 (moo, "Hard failure indicated by primitive function %p - %.*js - return code %d\n", handler, MOO_OBJ_GET_SIZE(name), ((moo_oop_char_t)name)->slot, n); MOO_DEBUG4 (moo, "Hard failure indicated by primitive function %p - %.*js - return code %d\n", pfbase->handler, MOO_OBJ_GET_SIZE(name), ((moo_oop_char_t)name)->slot, n);
return -1; /* hard primitive failure */ return -1; /* hard primitive failure */
} }
if (n >= MOO_PF_SUCCESS) break; /* primitive ok*/ if (n >= MOO_PF_SUCCESS) break; /* primitive ok*/
/* soft primitive failure */ /* soft primitive failure */
MOO_DEBUG3 (moo, "Soft failure indicated by primitive function %p - %.*js\n", handler, MOO_OBJ_GET_SIZE(name), ((moo_oop_char_t)name)->slot); MOO_DEBUG3 (moo, "Soft failure indicated by primitive function %p - %.*js\n", pfbase->handler, MOO_OBJ_GET_SIZE(name), ((moo_oop_char_t)name)->slot);
} }
else else
{ {

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

@ -1202,7 +1202,7 @@ int moo_importmod (
* The moo_querymod() function finds a primitive function in modules * The moo_querymod() function finds a primitive function in modules
* with a full primitive identifier. * with a full primitive identifier.
*/ */
moo_pfimpl_t moo_querymod ( moo_pfbase_t* moo_querymod (
moo_t* moo, moo_t* moo,
const moo_ooch_t* pfid, const moo_ooch_t* pfid,
moo_oow_t pfidlen moo_oow_t pfidlen

16
moo/lib/moo.c
View File

@ -603,7 +603,7 @@ done2:
return r; return r;
} }
moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen) moo_pfbase_t* moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen)
{ {
/* primitive function identifier /* primitive function identifier
* _funcname * _funcname
@ -614,7 +614,7 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
const moo_ooch_t* sep; const moo_ooch_t* sep;
moo_oow_t mod_name_len; moo_oow_t mod_name_len;
moo_pfimpl_t handler; moo_pfbase_t* pfbase;
sep = moo_rfindoochar (pfid, pfidlen, '.'); sep = moo_rfindoochar (pfid, pfidlen, '.');
if (!sep) if (!sep)
@ -647,7 +647,7 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
if (!mdp) return MOO_NULL; if (!mdp) return MOO_NULL;
} }
if ((handler = mdp->mod.query (moo, &mdp->mod, sep + 1)) == MOO_NULL) if ((pfbase = mdp->mod.query (moo, &mdp->mod, sep + 1)) == MOO_NULL)
{ {
/* the primitive function is not found. but keep the module open even if it's opened above */ /* the primitive function is not found. but keep the module open even if it's opened above */
MOO_DEBUG2 (moo, "Cannot find a primitive function [%js] in a module [%js]\n", sep + 1, mdp->mod.name); MOO_DEBUG2 (moo, "Cannot find a primitive function [%js] in a module [%js]\n", sep + 1, mdp->mod.name);
@ -655,12 +655,13 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
return MOO_NULL; return MOO_NULL;
} }
MOO_DEBUG3 (moo, "Found a primitive function [%js] in a module [%js] - %p\n", sep + 1, mdp->mod.name, handler); MOO_DEBUG3 (moo, "Found a primitive function [%js] in a module [%js] - %p\n", sep + 1, mdp->mod.name, pfbase);
return handler; return pfbase;
} }
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
#if 0
/* add a new primitive method */ /* add a new primitive method */
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) 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)
{ {
@ -792,8 +793,9 @@ int moo_genpfmethods (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class, const
moo_poptmp (moo); moo_poptmp (moo);
return ret; return ret;
} }
#endif
moo_pfimpl_t moo_findpfimpl (moo_t* moo, const moo_pfinfo_t* pfinfo, moo_oow_t pfcount, const moo_ooch_t* name) moo_pfbase_t* moo_findpfbase (moo_t* moo, const moo_pfinfo_t* pfinfo, moo_oow_t pfcount, const moo_ooch_t* name)
{ {
int left, right, mid, n; int left, right, mid, n;
@ -808,7 +810,7 @@ moo_pfimpl_t moo_findpfimpl (moo_t* moo, const moo_pfinfo_t* pfinfo, moo_oow_t p
else if (n > 0) left = mid + 1; else if (n > 0) left = mid + 1;
else else
{ {
return pfinfo[mid].handler; return &pfinfo[mid].base;
} }
} }

16
moo/lib/moo.h
View File

@ -831,13 +831,21 @@ typedef moo_pfrc_t (*moo_pfimpl_t) (
moo_ooi_t nargs moo_ooi_t nargs
); );
typedef struct moo_pfbase_t moo_pfbase_t;
struct moo_pfbase_t
{
moo_pfimpl_t handler;
moo_oow_t minargs;
moo_oow_t maxargs;
};
typedef struct moo_pfinfo_t moo_pfinfo_t; typedef struct moo_pfinfo_t moo_pfinfo_t;
struct moo_pfinfo_t struct moo_pfinfo_t
{ {
moo_method_type_t type; moo_method_type_t type;
moo_ooch_t mthname[32]; moo_ooch_t mthname[32];
int variadic; int variadic;
moo_pfimpl_t handler; moo_pfbase_t base;
}; };
typedef struct moo_mod_t moo_mod_t; typedef struct moo_mod_t moo_mod_t;
@ -859,7 +867,7 @@ typedef int (*moo_mod_import_t) (
moo_oop_class_t _class moo_oop_class_t _class
); );
typedef moo_pfimpl_t (*moo_mod_query_t) ( typedef moo_pfbase_t* (*moo_mod_query_t) (
moo_t* moo, moo_t* moo,
moo_mod_t* mod, moo_mod_t* mod,
const moo_ooch_t* name const moo_ooch_t* name
@ -1559,6 +1567,7 @@ MOO_EXPORT int moo_genpfmethod (
const moo_ooch_t* name const moo_ooch_t* name
); );
/*
MOO_EXPORT int moo_genpfmethods ( MOO_EXPORT int moo_genpfmethods (
moo_t* moo, moo_t* moo,
moo_mod_t* mod, moo_mod_t* mod,
@ -1566,8 +1575,9 @@ MOO_EXPORT int moo_genpfmethods (
const moo_pfinfo_t* pfinfo, const moo_pfinfo_t* pfinfo,
moo_oow_t pfcount moo_oow_t pfcount
); );
*/
MOO_EXPORT moo_pfimpl_t moo_findpfimpl ( MOO_EXPORT moo_pfbase_t* moo_findpfbase (
moo_t* moo, moo_t* moo,
const moo_pfinfo_t* pfinfo, const moo_pfinfo_t* pfinfo,
moo_oow_t pfcount, moo_oow_t pfcount,

73
moo/mod/console.c
View File

@ -79,8 +79,7 @@ static moo_pfrc_t pf_open (moo_t* moo, moo_ooi_t nargs)
int err; int err;
char* term; char* term;
con = moo_callocmem (moo, MOO_SIZEOF(*con)); con = (console_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
if (!con) return 0;
if (isatty(1)) if (isatty(1))
{ {
@ -122,7 +121,7 @@ static moo_pfrc_t pf_open (moo_t* moo, moo_ooi_t nargs)
} }
#endif #endif
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP((moo_oow_t)con)); MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(con->fd));
#endif #endif
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
} }
@ -140,12 +139,10 @@ static moo_pfrc_t pf_close (moo_t* moo, moo_ooi_t nargs)
#else #else
console_t* con; console_t* con;
con = (console_t*)MOO_OOP_TO_SMOOI(MOO_STACK_GETARG (moo, nargs, 0)); con = (console_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
/* TODO: sanity check */
if (con->fd_opened) close (con->fd); if (con->fd_opened) close (con->fd);
moo_freemem (moo, con);
MOO_STACK_SETRETTORCV (moo, nargs); MOO_STACK_SETRETTORCV (moo, nargs);
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
#endif #endif
@ -158,29 +155,25 @@ static moo_pfrc_t pf_write (moo_t* moo, moo_ooi_t nargs)
#else #else
console_t* con; console_t* con;
moo_oop_char_t oomsg; moo_oop_char_t msg;
moo_oow_t ucspos, ucsrem, ucslen, bcslen; moo_oow_t ucspos, ucsrem, ucslen, bcslen;
moo_bch_t bcs[1024]; moo_bch_t bcs[1024];
int n; int n;
con = MOO_OOP_TO_SMOOI(MOO_STACK_GETARG (moo, nargs, 0)); con = (console_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
oomsg = (moo_oop_char_t)MOO_STACK_GETARG (moo, nargs, 1); msg = (moo_oop_char_t)MOO_STACK_GETARG (moo, nargs, 0);
if (MOO_CLASSOF(moo,oomsg) != moo->_string) if (!MOO_OBJ_IS_CHAR_POINTER(msg)) goto einval;
{
/* TODO: invalid message */
return MOO_PF_FAILURE;
}
#if defined(MOO_OOCH_IS_UCH) #if defined(MOO_OOCH_IS_UCH)
ucspos = 0; ucspos = 0;
ucsrem = MOO_OBJ_GET_SIZE(oomsg); ucsrem = MOO_OBJ_GET_SIZE(msg);
while (ucsrem > 0) while (ucsrem > 0)
{ {
ucslen = ucsrem; ucslen = ucsrem;
bcslen = MOO_COUNTOF(bcs); bcslen = MOO_COUNTOF(bcs);
if ((n = moo_convootobchars (moo, &oomsg->slot[ucspos], &ucslen, bcs, &bcslen)) <= -1) if ((n = moo_convootobchars (moo, &msg->slot[ucspos], &ucslen, bcs, &bcslen)) <= -1)
{ {
if (n != -2 || ucslen <= 0) return MOO_PF_HARD_FAILURE; if (n != -2 || ucslen <= 0) return MOO_PF_HARD_FAILURE;
} }
@ -191,11 +184,15 @@ static moo_pfrc_t pf_write (moo_t* moo, moo_ooi_t nargs)
ucsrem -= ucslen; ucsrem -= ucslen;
} }
#else #else
write (con->fd, oomsg->slot, MOO_OBJ_GET_SIZE(oomsg)); /* TODO: error handling. incomplete write handling */ write (con->fd, MOO_GET_OBJ_CHAR_SLOT(msg), MOO_OBJ_GET_SIZE(msg)); /* TODO: error handling. incomplete write handling */
#endif #endif
MOO_STACK_SETRETTORCV (moo, nargs); /* TODO: change return code */ MOO_STACK_SETRETTORCV (moo, nargs); /* TODO: change return code */
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
einval:
MOO_STACK_SETRETTOERROR (moo, nargs); /* TODO: be more specific about the error code */
return MOO_PF_SUCCESS;
#endif #endif
} }
@ -207,7 +204,7 @@ static moo_pfrc_t pf_clear (moo_t* moo, moo_ooi_t nargs)
#else #else
console_t* con; console_t* con;
con = MOO_OOP_TO_SMOOI(MOO_STACK_GETARG(moo, nargs, 0)); con = (console_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
write (con->fd, con->clear, strlen(con->clear)); write (con->fd, con->clear, strlen(con->clear));
@ -223,23 +220,24 @@ static moo_pfrc_t pf_setcursor (moo_t* moo, moo_ooi_t nargs)
#else #else
console_t* con; console_t* con;
moo_oop_oop_t point; moo_oop_t x, y;
char* cup; char* cup;
con = MOO_OOP_TO_SMOOI(MOO_STACK_GETARG(moo, nargs, 0)); con = (console_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
point = MOO_STACK_GETARG(moo, nargs, 1); x = MOO_STACK_GETARG(moo, nargs, 0);
y = MOO_STACK_GETARG(moo, nargs, 1);
/* TODO: error check, class check, size check.. */ if (!MOO_OOP_IS_SMOOI(x) || !MOO_OOP_IS_SMOOI(y)) goto einval;
if (MOO_OBJ_GET_SIZE(point) != 2)
{
return MOO_PF_FAILURE;
}
cup = tiparm (con->cup, MOO_OOP_TO_SMOOI(point->slot[1]), MOO_OOP_TO_SMOOI(point->slot[0])); cup = tiparm (con->cup, MOO_OOP_TO_SMOOI(y), MOO_OOP_TO_SMOOI(x));
write (con->fd, cup, strlen(cup)); /* TODO: error check */ write (con->fd, cup, strlen(cup)); /* TODO: error check */
MOO_STACK_SETRETTORCV (moo, nargs); MOO_STACK_SETRETTORCV (moo, nargs);
return MOO_PF_SUCCESS; return MOO_PF_SUCCESS;
einval:
MOO_STACK_SETRETTOERROR (moo, nargs); /* TODO: be more specific about the error code */
return MOO_PF_SUCCESS;
#endif #endif
} }
@ -250,18 +248,24 @@ static moo_pfrc_t pf_setcursor (moo_t* moo, moo_ooi_t nargs)
static moo_pfinfo_t pfinfos[] = static moo_pfinfo_t pfinfos[] =
{ {
{ I, { 'c','l','e','a','r','\0' }, 0, pf_clear }, { I, { '_','c','l','e','a','r','\0' }, 0, { pf_clear, 0, 0 } },
{ I, { 'c','l','o','s','e','\0' }, 0, pf_close }, { I, { '_','c','l','o','s','e','\0' }, 0, { pf_close, 0, 0 } },
{ I, { 'o','p','e','n','\0' }, 0, pf_open }, { I, { '_','o','p','e','n','\0' }, 0, { pf_open, 0, 0 } },
{ I, { 's','e','t','c','u','r','s','o','r','\0' }, 0, pf_setcursor }, { I, { '_','s','e','t','c','u','r','s','o','r','\0' }, 0, { pf_setcursor, 2, 2 } },
{ I, { 'w','r','i','t','e','\0' }, 0, pf_write } { I, { '_','w','r','i','t','e','\0' }, 0, { pf_write, 1, 1 } }
}; };
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static moo_pfimpl_t query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name) static int import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
{ {
return moo_findpfimpl(moo, pfinfos, MOO_COUNTOF(pfinfos), name); if (moo_setclasstrsize (moo, _class, MOO_SIZEOF(console_t)) <= -1) return -1;
return 0;
}
static moo_pfbase_t* query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{
return moo_findpfbase(moo, pfinfos, MOO_COUNTOF(pfinfos), name);
} }
@ -272,6 +276,7 @@ static void unload (moo_t* moo, moo_mod_t* mod)
int moo_mod_console (moo_t* moo, moo_mod_t* mod) int moo_mod_console (moo_t* moo, moo_mod_t* mod)
{ {
mod->import = import;
mod->query = query; mod->query = query;
mod->unload = unload; mod->unload = unload;
mod->ctx = MOO_NULL; mod->ctx = MOO_NULL;

37
moo/mod/ffi.c
View File

@ -83,11 +83,7 @@ static moo_pfrc_t pf_open (moo_t* moo, moo_ooi_t nargs)
DCCallVM* dc; DCCallVM* dc;
#endif #endif
if (nargs != 1) MOO_ASSERT (moo, nargs == 1);
{
moo_seterrnum (moo, MOO_EINVAL);
goto softfail;
}
ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL); ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
name = MOO_STACK_GETARG(moo, nargs, 0); name = MOO_STACK_GETARG(moo, nargs, 0);
@ -142,11 +138,7 @@ static moo_pfrc_t pf_close (moo_t* moo, moo_ooi_t nargs)
{ {
ffi_t* ffi; ffi_t* ffi;
if (nargs != 0) MOO_ASSERT (moo, nargs == 0);
{
moo_seterrnum (moo, MOO_EINVAL);
goto softfail;
}
ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL); ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
@ -188,7 +180,7 @@ static moo_pfrc_t pf_call (moo_t* moo, moo_ooi_t nargs)
ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL); ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
if (nargs < 3) goto inval; MOO_ASSERT (moo, nargs == 3);
fun = MOO_STACK_GETARG(moo, nargs, 0); fun = MOO_STACK_GETARG(moo, nargs, 0);
sig = MOO_STACK_GETARG(moo, nargs, 1); sig = MOO_STACK_GETARG(moo, nargs, 1);
args = MOO_STACK_GETARG(moo, nargs, 2); args = MOO_STACK_GETARG(moo, nargs, 2);
@ -490,11 +482,7 @@ static moo_pfrc_t pf_getsym (moo_t* moo, moo_ooi_t nargs)
moo_oop_t name; moo_oop_t name;
void* sym; void* sym;
if (nargs != 1) MOO_ASSERT (moo, nargs == 1);
{
moo_seterrnum (moo, MOO_EINVAL);
goto softfail;
}
ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL); ffi = (ffi_t*)moo_getobjtrailer(moo, MOO_STACK_GETRCV(moo, nargs), MOO_NULL);
name = MOO_STACK_GETARG(moo, nargs, 0); name = MOO_STACK_GETARG(moo, nargs, 0);
@ -539,13 +527,14 @@ struct fnctab_t
#define C MOO_METHOD_CLASS #define C MOO_METHOD_CLASS
#define I MOO_METHOD_INSTANCE #define I MOO_METHOD_INSTANCE
#define MA MOO_TYPE_MAX(moo_oow_t)
static moo_pfinfo_t pfinfos[] = static moo_pfinfo_t pfinfos[] =
{ {
{ I, { 'c','a','l','l','\0' }, 1, pf_call }, { I, { 'c','a','l','l','\0' }, 0, { pf_call, 3, 3 } },
{ I, { 'c','a','l','l',':','s','i','g',':','w','i','t','h',':','\0' }, 0, pf_call }, { I, { 'c','l','o','s','e','\0' }, 0, { pf_close, 0, 0 } },
{ I, { 'c','l','o','s','e','\0' }, 0, pf_close }, { I, { 'g','e','t','s','y','m','\0' }, 0, { pf_getsym, 1, 1 } },
{ I, { 'g','e','t','s','y','m',':','\0' }, 0, pf_getsym }, { I, { 'o','p','e','n','\0' }, 0, { pf_open, 1, 1 } }
{ I, { 'o','p','e','n',':','\0' }, 0, pf_open }
}; };
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
@ -553,12 +542,12 @@ static moo_pfinfo_t pfinfos[] =
static int import (moo_t* moo, moo_mod_t* mod, moo_oop_class_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 0;
} }
static moo_pfimpl_t query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name) static moo_pfbase_t* query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{ {
return moo_findpfimpl (moo, pfinfos, MOO_COUNTOF(pfinfos), name); return moo_findpfbase (moo, pfinfos, MOO_COUNTOF(pfinfos), name);
} }
static void unload (moo_t* moo, moo_mod_t* mod) static void unload (moo_t* moo, moo_mod_t* mod)

20
moo/mod/stdio.c
View File

@ -208,28 +208,28 @@ static moo_pfrc_t pf_puts (moo_t* moo, moo_ooi_t nargs)
#define C MOO_METHOD_CLASS #define C MOO_METHOD_CLASS
#define I MOO_METHOD_INSTANCE #define I MOO_METHOD_INSTANCE
#define MA MOO_TYPE_MAX(moo_oow_t)
static moo_pfinfo_t pfinfos[] = static moo_pfinfo_t pfinfos[] =
{ {
{ I, { 'c','l','o','s','e','\0' }, 0, pf_close }, { I, { 'c','l','o','s','e','\0' }, 0, { pf_close, 0, 0 } },
{ I, { 'g','e','t','s','\0' }, 0, pf_gets }, { I, { 'g','e','t','s','\0' }, 0, { pf_gets, 0, 0 } },
{ I, { 'o','p','e','n',':','f','o','r',':','\0' }, 0, pf_open }, { I, { 'o','p','e','n','\0' }, 0, { pf_open, 2, 2 } },
{ I, { 'p','u','t','c','\0' }, 1, pf_putc }, { I, { 'p','u','t','c','\0' }, 1, { pf_putc, 0, MA } },
{ I, { 'p','u','t','c',':','\0' }, 0, pf_putc }, { I, { 'p','u','t','s','\0' }, 1, { pf_puts, 0, MA } }
{ I, { 'p','u','t','s','\0' }, 1, pf_puts },
{ I, { 'p','u','t','s',':','\0' }, 0, pf_puts }
}; };
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */
static int import (moo_t* moo, moo_mod_t* mod, moo_oop_class_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 0;
/*return moo_genpfmethods (moo, mod, _class, pfinfos, MOO_COUNTOF(pfinfos));*/
} }
static moo_pfimpl_t query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name) static moo_pfbase_t* query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{ {
return moo_findpfimpl (moo, pfinfos, MOO_COUNTOF(pfinfos), name); return moo_findpfbase (moo, pfinfos, MOO_COUNTOF(pfinfos), name);
} }
#if 0 #if 0

41
moo/mod/x11.c
View File

@ -486,10 +486,10 @@ reterr:
static moo_pfinfo_t x11_pfinfo[] = static moo_pfinfo_t x11_pfinfo[] =
{ {
{ I, { '_','c','o','n','n','e','c','t','\0' }, 0, pf_connect }, { I, { '_','c','o','n','n','e','c','t','\0' }, 0, { pf_connect, 0, 0 } },
{ 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, 0, 0 } },
{ I, { '_','g','e','t','_','e','v','e','n','t','\0'}, 0, pf_getevent }, { I, { '_','g','e','t','_','e','v','e','n','t','\0'}, 0, { pf_getevent, 0, 0 } },
{ I, { '_','g','e','t','_','f','d','\0' }, 0, pf_get_fd } { I, { '_','g','e','t','_','f','d','\0' }, 0, { pf_get_fd, 0, 0 } }
}; };
static int x11_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class) static int x11_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
@ -499,9 +499,9 @@ static int x11_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
return 0; return 0;
} }
static moo_pfimpl_t x11_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name) static moo_pfbase_t* x11_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{ {
return moo_findpfimpl (moo, x11_pfinfo, MOO_COUNTOF(x11_pfinfo), name); return moo_findpfbase (moo, x11_pfinfo, MOO_COUNTOF(x11_pfinfo), name);
} }
static void x11_unload (moo_t* moo, moo_mod_t* mod) static void x11_unload (moo_t* moo, moo_mod_t* mod)
@ -558,12 +558,12 @@ int moo_mod_x11 (moo_t* moo, moo_mod_t* mod)
static moo_pfinfo_t x11_gc_pfinfo[] = static moo_pfinfo_t x11_gc_pfinfo[] =
{ {
{ I, { '_','d','r','a','w','L','i','n','e' }, 0, pf_gc_draw_line }, { I, { '_','d','r','a','w','L','i','n','e' }, 0, { pf_gc_draw_line, 4, 4 } },
{ I, { '_','d','r','a','w','R','e','c','t' }, 0, pf_gc_draw_rect }, { I, { '_','d','r','a','w','R','e','c','t' }, 0, { pf_gc_draw_rect, 4, 4 } },
{ I, { '_','f','o','r','e','g','r','o','u','n','d',':','\0' }, 0, pf_gc_set_foreground }, { I, { '_','f','o','r','e','g','r','o','u','n','d',':','\0' }, 0, { pf_gc_set_foreground, 1, 1 } },
{ I, { '_','g','e','t','_','i','d','\0' }, 0, pf_gc_get_id }, { I, { '_','g','e','t','_','i','d','\0' }, 0, { pf_gc_get_id, 0, 0 } },
{ I, { '_','k','i','l','l','\0' }, 0, pf_gc_kill }, { I, { '_','k','i','l','l','\0' }, 0, { pf_gc_kill, 0, 0 } },
{ I, { '_','m','a','k','e','_','o','n',':','\0' }, 0, pf_gc_make } { I, { '_','m','a','k','e','_','o','n',':','\0' }, 0, { pf_gc_make, 1, 1 } }
}; };
@ -573,9 +573,9 @@ static int x11_gc_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
return 0; return 0;
} }
static moo_pfimpl_t x11_gc_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name) static moo_pfbase_t* x11_gc_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{ {
return moo_findpfimpl(moo, x11_gc_pfinfo, MOO_COUNTOF(x11_gc_pfinfo), name); return moo_findpfbase(moo, x11_gc_pfinfo, MOO_COUNTOF(x11_gc_pfinfo), name);
} }
static void x11_gc_unload (moo_t* moo, moo_mod_t* mod) static void x11_gc_unload (moo_t* moo, moo_mod_t* mod)
@ -599,11 +599,12 @@ int moo_mod_x11_gc (moo_t* moo, moo_mod_t* mod)
static moo_pfinfo_t x11_win_pfinfo[] = static moo_pfinfo_t x11_win_pfinfo[] =
{ {
{ I, { '_','g','e','t','_','d','w','a','t','o','m','\0'}, 0, pf_win_get_dwatom }, { I, { '_','g','e','t','_','d','w','a','t','o','m','\0'}, 0, { pf_win_get_dwatom, 0, 0 } },
{ I, { '_','g','e','t','_','i','d','\0' }, 0, pf_win_get_id }, { I, { '_','g','e','t','_','i','d','\0' }, 0, { pf_win_get_id, 0, 0 } },
{ I, { '_','k','i','l','l','\0' }, 0, pf_win_kill }, { I, { '_','k','i','l','l','\0' }, 0, { pf_win_kill, 0, 0 } },
{ I, { '_','m','a','k','e','_','o','n',':','\0' }, 0, pf_win_make } { I, { '_','m','a','k','e','\0' }, 0, { pf_win_make, 1, 1 } },
{ I, { '_','m','a','k','e','_','o','n',':','\0' }, 0, { pf_win_make, 1, 1 } }
}; };
static int x11_win_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class) static int x11_win_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
@ -613,9 +614,9 @@ static int x11_win_import (moo_t* moo, moo_mod_t* mod, moo_oop_class_t _class)
return 0; return 0;
} }
static moo_pfimpl_t x11_win_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name) static moo_pfbase_t* x11_win_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{ {
return moo_findpfimpl(moo, x11_win_pfinfo, MOO_COUNTOF(x11_win_pfinfo), name); return moo_findpfbase(moo, x11_win_pfinfo, MOO_COUNTOF(x11_win_pfinfo), name);
} }
static void x11_win_unload (moo_t* moo, moo_mod_t* mod) static void x11_win_unload (moo_t* moo, moo_mod_t* mod)