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

enhanced the primitive module loader such that it can load multiple primitmive groups from a single module file.

Browse Source 
fixed a bug of setting errnum wrongly in character conversion functions
This commit is contained in:
hyunghwan.chung 2017-02-13 13:25:42 +00:00
parent ff122bdcc8
commit 73231a29d7
12 changed files with 218 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
moo/lib/Makefile.am
View File

@ -68,11 +68,12 @@ libmoo_la_LDFLAGS = $(LDFLAGS_LIB_COMMON)
libmoo_la_LIBADD = $(LIBADD_LIB_COMMON)
if ENABLE_STATIC_MODULE
libmoo_la_LIBADD += -lmoo-ffi -lmoo-console -lmoo-stdio
libmoo_la_LIBADD += -lmoo-ffi -lmoo-console -lmoo-stdio -lmoo-x11
libmoo_la_DEPENDENCIES = \
$(abs_builddir)/../mod/libmoo-ffi.la \
$(abs_builddir)/../mod/libmoo-console.la \
$(abs_builddir)/../mod/libmoo-stdio.la
$(abs_builddir)/../mod/libmoo-stdio.la \
$(abs_builddir)/../mod/libmoo-x11.la
endif
bin_PROGRAMS = moo

5
moo/lib/Makefile.in
View File

@ -95,7 +95,7 @@ host_triplet = @host@
# to the first number in -version-info above
@WIN32_TRUE@am__append_3 = -DMOO_DEFAULT_MODPREFIX=\"libmoo-\" -DMOO_DEFAULT_MODPOSTFIX=\"-1\"
@WIN32_FALSE@am__append_4 = -DMOO_DEFAULT_MODPREFIX=\"$(libdir)/libmoo-\" -DMOO_DEFAULT_MODPOSTFIX=\"\"
@ENABLE_STATIC_MODULE_TRUE@am__append_5 = -lmoo-ffi -lmoo-console -lmoo-stdio
@ENABLE_STATIC_MODULE_TRUE@am__append_5 = -lmoo-ffi -lmoo-console -lmoo-stdio -lmoo-x11
@ENABLE_STATIC_MODULE_FALSE@libmoo_la_DEPENDENCIES = \
@ENABLE_STATIC_MODULE_FALSE@ $(am__DEPENDENCIES_3) \
@ENABLE_STATIC_MODULE_FALSE@ $(am__DEPENDENCIES_1)
@ -448,7 +448,8 @@ libmoo_la_LIBADD = $(LIBADD_LIB_COMMON) $(am__append_5)
@ENABLE_STATIC_MODULE_TRUE@libmoo_la_DEPENDENCIES = \
@ENABLE_STATIC_MODULE_TRUE@ $(abs_builddir)/../mod/libmoo-ffi.la \
@ENABLE_STATIC_MODULE_TRUE@ $(abs_builddir)/../mod/libmoo-console.la \
@ENABLE_STATIC_MODULE_TRUE@ $(abs_builddir)/../mod/libmoo-stdio.la
@ENABLE_STATIC_MODULE_TRUE@ $(abs_builddir)/../mod/libmoo-stdio.la \
@ENABLE_STATIC_MODULE_TRUE@ $(abs_builddir)/../mod/libmoo-x11.la
moo_SOURCES = main.c
moo_CPPFLAGS = $(CPPFLAGS_LIB_COMMON)

11
moo/lib/decode.c
View File

@ -26,13 +26,20 @@
#include "moo-prv.h"
#if defined(NDEBUG)
/* get rid of instruction logging regardless of the log mask
* in the release build */
# define LOG_INST_0(moo,fmt)
# define LOG_INST_1(moo,fmt,a1)
# define LOG_INST_2(moo,fmt,a1,a2)
# define LOG_INST_3(moo,fmt,a1,a2,a3)
#else
# define DECODE_LOG_MASK (MOO_LOG_MNEMONIC)
# define LOG_INST_0(moo,fmt) MOO_LOG1(moo, DECODE_LOG_MASK, " %06zd " fmt "\n", fetched_instruction_pointer)
# define LOG_INST_1(moo,fmt,a1) MOO_LOG2(moo, DECODE_LOG_MASK, " %06zd " fmt "\n", fetched_instruction_pointer, a1)
# define LOG_INST_2(moo,fmt,a1,a2) MOO_LOG3(moo, DECODE_LOG_MASK, " %06zd " fmt "\n", fetched_instruction_pointer, a1, a2)
# define LOG_INST_3(moo,fmt,a1,a2,a3) MOO_LOG4(moo, DECODE_LOG_MASK, " %06zd " fmt "\n", fetched_instruction_pointer, a1, a2, a3)
#endif
#define FETCH_BYTE_CODE(moo) (cdptr[ip++])
#define FETCH_BYTE_CODE_TO(moo,v_oow) (v_oow = FETCH_BYTE_CODE(moo))

31
moo/lib/exec.c
View File

@ -2871,31 +2871,34 @@ static int start_method (moo_t* moo, moo_oop_method_t method, moo_oow_t nargs)
/*sp = moo->sp;*/
sb = moo->sp - nargs - 1; /* stack base before receiver and arguments */
#if !defined(NDEBUG)
pf_name_index = MOO_METHOD_GET_PREAMBLE_INDEX(preamble);
LOG_INST_1 (moo, "preamble_named_primitive %zd", pf_name_index);
MOO_ASSERT (moo, pf_name_index >= 0);
/* merge two SmallIntegers to get a full pointer */
name = method->slot[pf_name_index];
MOO_ASSERT (moo, MOO_ISTYPEOF(moo,name,MOO_OBJ_TYPE_CHAR));
MOO_ASSERT (moo, MOO_OBJ_GET_FLAGS_EXTRA(name));
MOO_ASSERT (moo, MOO_CLASSOF(moo,name) == moo->_symbol);
#endif
/* 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) |
(moo_oow_t)MOO_OOP_TO_SMOOI(method->preamble_data[1]);
handler = (moo_pfimpl_t)w;
if (handler) goto exec_handler;
else
{
MOO_ASSERT (moo, pf_name_index >= 0);
name = method->slot[pf_name_index];
MOO_ASSERT (moo, MOO_ISTYPEOF(moo,name,MOO_OBJ_TYPE_CHAR));
MOO_ASSERT (moo, MOO_OBJ_GET_FLAGS_EXTRA(name));
MOO_ASSERT (moo, MOO_CLASSOF(moo,name) == moo->_symbol);
#if defined(NDEBUG)
pf_name_index = MOO_METHOD_GET_PREAMBLE_INDEX(preamble);
name = method->slot[pf_name_index];
#endif
handler = moo_querymod (moo, ((moo_oop_char_t)name)->slot, MOO_OBJ_GET_SIZE(name));
}
if (handler)
{
int n;
/* split a pointer to two OOP fields as SmallIntegers for storing. */
/* 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[1] = MOO_SMOOI_TO_OOP((moo_oow_t)handler & MOO_LBMASK(moo_oow_t, MOO_OOW_BITS / 2));
@ -2913,18 +2916,18 @@ static int start_method (moo_t* moo, moo_oop_method_t method, moo_oow_t nargs)
moo_poptmp (moo);
if (n <= MOO_PF_HARD_FAILURE)
{
MOO_DEBUG2 (moo, "Hard failure indicated by primitive function %p - return code %d\n", handler, n);
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);
return -1; /* hard primitive failure */
}
if (n >= MOO_PF_SUCCESS) break; /* primitive ok*/
/* soft primitive failure */
MOO_DEBUG1 (moo, "Soft failure indicated by primitive function %p\n", handler);
MOO_DEBUG3 (moo, "Soft failure indicated by primitive function %p - %.*js\n", handler, MOO_OBJ_GET_SIZE(name), ((moo_oop_char_t)name)->slot);
}
else
{
/* no handler found */
MOO_DEBUG0 (moo, "Soft failure for non-existent primitive function\n");
MOO_DEBUG2 (moo, "Soft failure for non-existent primitive function - %.*js\n", MOO_OBJ_GET_SIZE(name), ((moo_oop_char_t)name)->slot);
}
#if defined(MOO_USE_OBJECT_TRAILER)

40
moo/lib/main.c
View File

@ -349,7 +349,7 @@ static void* dl_open (moo_t* moo, const moo_ooch_t* name, int flags)
if (flags & MOO_VMPRIM_OPENDL_PFMOD)
{
moo_oow_t len;
moo_oow_t len, i, xlen;
/* opening a primitive function module - mostly libmoo-xxxx */
len = moo_copybcstr (bufptr, bufcapa, MOO_DEFAULT_PFMODPREFIX);
@ -361,15 +361,42 @@ static void* dl_open (moo_t* moo, const moo_ooch_t* name, int flags)
bcslen = moo_copybcstr (&bufptr[len], bcslen, name);
#endif
moo_copybcstr (&bufptr[bcslen + len], bufcapa - bcslen - len, MOO_DEFAULT_PFMODPOSTFIX);
/* length including the prefix and the name. but excluding the postfix */
xlen = len + bcslen;
/* convert a period(.) to a dash(-) */
for (i = len; i < xlen; i++)
{
if (bufptr[i] == '.') bufptr[i] = '-';
}
retry:
moo_copybcstr (&bufptr[xlen], bufcapa - xlen, MOO_DEFAULT_PFMODPOSTFIX);
/* both prefix and postfix attached. for instance, libmoo-xxx */
handle = lt_dlopenext (bufptr);
if (!handle)
{
MOO_DEBUG3 (moo, "Failed to open(ext) DL %hs[%js] - %hs\n", bufptr, name, lt_dlerror());
bufptr[bcslen + len] = '\0';
/* try without prefix and postfix */
bufptr[xlen] = '\0';
handle = lt_dlopenext (&bufptr[len]);
if (!handle) MOO_DEBUG3 (moo, "Failed to open(ext) DL %hs[%js] - %s\n", &bufptr[len], name, lt_dlerror());
if (!handle)
{
moo_bch_t* dash;
MOO_DEBUG3 (moo, "Failed to open(ext) DL %hs[%js] - %s\n", &bufptr[len], name, lt_dlerror());
dash = moo_rfindbchar (bufptr, moo_countbcstr(bufptr), '-');
if (dash)
{
/* remove a segment at the back.
* [NOTE] a dash contained in the original name before
* period-to-dash transformation may cause extraneous/wrong
* loading reattempts. */
xlen = dash - bufptr;
goto retry;
}
}
else MOO_DEBUG3 (moo, "Opened(ext) DL %hs[%js] handle %p\n", &bufptr[len], name, handle);
}
else
@ -429,7 +456,7 @@ static void* dl_getsym (moo_t* moo, void* handle, const moo_ooch_t* name)
{
#if defined(USE_LTDL)
moo_bch_t stabuf[64], * bufptr;
moo_oow_t bufcapa, ucslen, bcslen;
moo_oow_t bufcapa, ucslen, bcslen, i;
const moo_bch_t* symname;
void* sym;
@ -458,6 +485,9 @@ static void* dl_getsym (moo_t* moo, void* handle, const moo_ooch_t* name)
bcslen = moo_copybcstr (&bufptr[1], bcslen, name);
#endif
/* convert a period(.) to an underscore(_) */
for (i = 1; i <= bcslen; i++) if (bufptr[i] == '.') bufptr[i] = '_';
symname = &bufptr[1]; /* try the name as it is */
sym = lt_dlsym (handle, symname);
if (!sym)

20
moo/lib/moo.c
View File

@ -359,6 +359,7 @@ void moo_freemem (moo_t* moo, void* ptr)
#include "../mod/console.h"
#include "../mod/_ffi.h"
#include "../mod/_stdio.h"
#include "../mod/_x11.h"
static struct
{
@ -370,6 +371,8 @@ static_modtab[] =
{ "console", moo_mod_console },
{ "ffi", moo_mod_ffi },
{ "stdio", moo_mod_stdio },
{ "x11", moo_mod_x11 },
{ "x11.win", moo_mod_x11_win }
};
#endif
@ -420,8 +423,10 @@ moo_mod_data_t* moo_openmod (moo_t* moo, const moo_ooch_t* name, moo_oow_t namel
if (n >= MOO_COUNTOF(static_modtab))
{
MOO_DEBUG2 (moo, "Cannot find a static module [%.*js]\n", namelen, name);
moo->errnum = MOO_ENOENT;
return MOO_NULL;
/* TODO: fall back to find dynamic module further on supported platforms instead of returning error here... */
}
if (load)
@ -593,11 +598,11 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
moo_oow_t mod_name_len;
moo_pfimpl_t handler;
sep = moo_findoochar (pfid, pfidlen, '.');
sep = moo_rfindoochar (pfid, pfidlen, '.');
if (!sep)
{
/* i'm writing a conservative code here. the compiler should
* guarantee that an underscore is included in an primitive identifer.
* guarantee that a period is included in an primitive identifer.
* what if the compiler is broken? imagine a buggy compiler rewritten
* in moo itself? */
MOO_DEBUG2 (moo, "Internal error - no period in a primitive function identifier [%.*js] - buggy compiler?\n", pfidlen, pfid);
@ -607,6 +612,10 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
mod_name_len = sep - pfid;
/* the first through the segment before the last compose a module id.
* the last segment is the primitive function name.
* for instance, in con.window.open, con.window is a module id and
* open is the primitive function name. */
pair = moo_rbt_search (&moo->modtab, pfid, mod_name_len);
if (pair)
{
@ -615,13 +624,14 @@ moo_pfimpl_t moo_querymod (moo_t* moo, const moo_ooch_t* pfid, moo_oow_t pfidlen
}
else
{
/* open a module using the part before the last period */
mdp = moo_openmod (moo, pfid, mod_name_len);
if (!mdp) return MOO_NULL;
}
if ((handler = mdp->mod.query (moo, &mdp->mod, sep + 1)) == MOO_NULL)
{
/* the primitive function is not found. keep the module open */
/* 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->errnum = MOO_ENOENT; /* TODO: proper error code and handling */
return MOO_NULL;
@ -696,6 +706,8 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
return -1;
}
MOO_DEBUG3 (moo, ">>>> PFGEN X11 [%.*js] %js\n", moo->sbuf[0].len, moo->sbuf[0].ptr, mod->name);
pfidsym = (moo_oop_char_t)moo_makesymbol (moo, moo->sbuf[0].ptr, moo->sbuf[0].len);
if (!pfidsym)
{
@ -728,7 +740,7 @@ int moo_genpfmethod (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, moo_method_ty
mth->tmpr_count = MOO_SMOOI_TO_OOP(arg_count);
mth->tmpr_nargs = MOO_SMOOI_TO_OOP(arg_count);
/* TODO: emit BCODE_RETURN_NIL ? */
/* 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))
{

14
moo/lib/moo.h
View File

@ -1081,6 +1081,19 @@ typedef enum moo_log_mask_t moo_log_mask_t;
#define MOO_LOG5(moo,mask,fmt,a1,a2,a3,a4,a5) do { if (MOO_LOG_ENABLED(moo,mask)) moo_logbfmt(moo, mask, fmt, a1, a2, a3, a4, a5); } while(0)
#define MOO_LOG6(moo,mask,fmt,a1,a2,a3,a4,a5,a6) do { if (MOO_LOG_ENABLED(moo,mask)) moo_logbfmt(moo, mask, fmt, a1, a2, a3, a4, a5, a6); } while(0)
#if defined(NDEBUG)
/* [NOTE]
* get rid of debugging message totally regardless of
* the log mask in the release build.
*/
# define MOO_DEBUG0(moo,fmt)
# define MOO_DEBUG1(moo,fmt,a1)
# define MOO_DEBUG2(moo,fmt,a1,a2)
# define MOO_DEBUG3(moo,fmt,a1,a2,a3)
# define MOO_DEBUG4(moo,fmt,a1,a2,a3,a4)
# define MOO_DEBUG5(moo,fmt,a1,a2,a3,a4,a5)
# define MOO_DEBUG6(moo,fmt,a1,a2,a3,a4,a5,a6)
#else
# define MOO_DEBUG0(moo,fmt) MOO_LOG0(moo, MOO_LOG_DEBUG, fmt)
# define MOO_DEBUG1(moo,fmt,a1) MOO_LOG1(moo, MOO_LOG_DEBUG, fmt, a1)
# define MOO_DEBUG2(moo,fmt,a1,a2) MOO_LOG2(moo, MOO_LOG_DEBUG, fmt, a1, a2)
@ -1088,6 +1101,7 @@ typedef enum moo_log_mask_t moo_log_mask_t;
# define MOO_DEBUG4(moo,fmt,a1,a2,a3,a4) MOO_LOG4(moo, MOO_LOG_DEBUG, fmt, a1, a2, a3, a4)
# define MOO_DEBUG5(moo,fmt,a1,a2,a3,a4,a5) MOO_LOG5(moo, MOO_LOG_DEBUG, fmt, a1, a2, a3, a4, a5)
# define MOO_DEBUG6(moo,fmt,a1,a2,a3,a4,a5,a6) MOO_LOG6(moo, MOO_LOG_DEBUG, fmt, a1, a2, a3, a4, a5, a6)
#endif
#define MOO_INFO0(moo,fmt) MOO_LOG0(moo, MOO_LOG_INFO, fmt)
#define MOO_INFO1(moo,fmt,a1) MOO_LOG1(moo, MOO_LOG_INFO, fmt, a1)

17
moo/lib/utl.c
View File

@ -631,8 +631,11 @@ int moo_convbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* bcslen, moo_
n = bcsn_to_ucsn_with_cmgr (bcs, bcslen, ucs, ucslen, moo->cmgr, 0);
/* -1: illegal character, -2, buffer too small, -3: incomplete sequence */
if (n <= -1)
{
/* -1: illegal character, -2: buffer too small, -3: incomplete sequence */
moo->errnum = (n == -2)? MOO_EBUFFULL: MOO_EECERR;
}
return n;
}
@ -643,7 +646,11 @@ int moo_convutobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_
int n;
n = ucsn_to_bcsn_with_cmgr (ucs, ucslen, bcs, bcslen, moo->cmgr);
if (n <= -1)
{
moo->errnum = (n == -2)? MOO_EBUFFULL: MOO_EECERR;
}
return n;
}
@ -654,7 +661,11 @@ int moo_convbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* bcslen, moo_u
int n;
n = bcs_to_ucs_with_cmgr (bcs, bcslen, ucs, ucslen, moo->cmgr, 0);
if (n <= -1)
{
moo->errnum = (n == -2)? MOO_EBUFFULL: MOO_EECERR;
}
return n;
}
@ -665,7 +676,11 @@ int moo_convutobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_b
int n;
n = ucs_to_bcs_with_cmgr (ucs, ucslen, bcs, bcslen, moo->cmgr);
if (n <= -1)
{
moo->errnum = (n == -2)? MOO_EBUFFULL: MOO_EECERR;
}
return n;
}

2
moo/mod/Makefile.am
View File

@ -23,7 +23,7 @@ if ENABLE_STATIC_MODULE
LDFLAGS_COMMON =-L$(libdir) -version-info 1:0:0 -no-undefined
LIBADD_COMMON =
noinst_LTLIBRARIES = libmoo-console.la libmoo-ffi.la libmoo-stdio.la
noinst_LTLIBRARIES = libmoo-console.la libmoo-ffi.la libmoo-stdio.la libmoo-x11.la
else

3
moo/mod/Makefile.in
View File

@ -180,6 +180,7 @@ libmoo_x11_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
$(libmoo_x11_la_LDFLAGS) $(LDFLAGS) -o $@
@ENABLE_STATIC_MODULE_FALSE@am_libmoo_x11_la_rpath = -rpath \
@ENABLE_STATIC_MODULE_FALSE@ $(pkgmodexecdir)
@ENABLE_STATIC_MODULE_TRUE@am_libmoo_x11_la_rpath =
AM_V_P = $(am__v_P_@AM_V@)
am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
am__v_P_0 = false
@ -421,7 +422,7 @@ CPPFLAGS_COMMON = -I$(abs_builddir) -I$(abs_builddir)/../lib \
@ENABLE_STATIC_MODULE_TRUE@LDFLAGS_COMMON = -L$(libdir) -version-info 1:0:0 -no-undefined
@ENABLE_STATIC_MODULE_FALSE@LIBADD_COMMON = -lmoo
@ENABLE_STATIC_MODULE_TRUE@LIBADD_COMMON =
@ENABLE_STATIC_MODULE_TRUE@noinst_LTLIBRARIES = libmoo-console.la libmoo-ffi.la libmoo-stdio.la
@ENABLE_STATIC_MODULE_TRUE@noinst_LTLIBRARIES = libmoo-console.la libmoo-ffi.la libmoo-stdio.la libmoo-x11.la
@ENABLE_STATIC_MODULE_FALSE@pkgmodexecdir = $(libdir)
@ENABLE_STATIC_MODULE_FALSE@pkgmodexec_LTLIBRARIES = libmoo-console.la libmoo-ffi.la libmoo-stdio.la libmoo-x11.la
libmoo_console_la_SOURCES = console.c console.h

1
moo/mod/_x11.h
View File

@ -34,6 +34,7 @@ extern "C" {
#endif
MOO_EXPORT int moo_mod_x11 (moo_t* moo, moo_mod_t* mod);
MOO_EXPORT int moo_mod_x11_win (moo_t* moo, moo_mod_t* mod);
#if defined(__cplusplus)
}

128
moo/mod/x11.c
View File

@ -32,6 +32,19 @@
#include <xcb/xcb.h>
#define C MOO_METHOD_CLASS
#define I MOO_METHOD_INSTANCE
typedef struct fnctab_t fnctab_t;
struct fnctab_t
{
moo_method_type_t type;
moo_ooch_t mthname[25];
int variadic;
moo_pfimpl_t handler;
};
typedef struct x11_t x11_t;
struct x11_t
{
@ -39,6 +52,15 @@ struct x11_t
xcb_connection_t* c;
};
typedef struct x11_window_t x11_window_t;
struct x11_window_t
{
MOO_OBJ_HEADER;
xcb_window_t w;
};
/* ------------------------------------------------------------------------ */
static moo_pfrc_t pf_newinstsize (moo_t* moo, moo_ooi_t nargs)
{
moo_ooi_t newinstsize = MOO_SIZEOF(x11_t) - MOO_SIZEOF(moo_obj_t);
@ -113,14 +135,51 @@ softfail:
/* ------------------------------------------------------------------------ */
typedef struct fnctab_t fnctab_t;
struct fnctab_t
static moo_pfrc_t pf_win_newinstsize (moo_t* moo, moo_ooi_t nargs)
{
moo_method_type_t type;
moo_ooch_t mthname[15];
int variadic;
moo_pfimpl_t handler;
};
moo_ooi_t newinstsize = MOO_SIZEOF(x11_window_t) - MOO_SIZEOF(moo_obj_t);
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(newinstsize));
MOO_DEBUG0 (moo, "x11.window.newinstsize....\n");
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);
#if 0
screen = xcb_setup_roots_iterator(xcb_get_setup(x11->c)).data;
x11->mw = xcb_generate_id (xtn->c);
xcb_create_window (x11->c,
XCB_COPY_FROM_PARENT,
xtn->mw,
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);
xcb_generic_event_t* evt;
while ((evt = xcb_poll_for_event(xtn->xcb, 0))
{
/* TODO: dispatch event read */
}
#endif
MOO_DEBUG0 (moo, "x11.window.create....\n");
return MOO_PF_SUCCESS;
}
static moo_pfrc_t pf_win_destroy (moo_t* moo, moo_ooi_t nargs)
{
MOO_STACK_SETRET (moo, nargs, moo->_nil);
MOO_DEBUG0 (moo, "x11.window.destroy....\n");
return MOO_PF_SUCCESS;
}
/* ------------------------------------------------------------------------ */
static moo_pfimpl_t search_fnctab (moo_t* moo, const fnctab_t* fnctab, moo_oow_t fnclen, const moo_ooch_t* name)
@ -167,9 +226,6 @@ static int import_fnctab (moo_t* moo, moo_mod_t* mod, moo_oop_t _class, const fn
}
#define C MOO_METHOD_CLASS
#define I MOO_METHOD_INSTANCE
/* ------------------------------------------------------------------------ */
static fnctab_t x11_fnctab[] =
@ -179,7 +235,6 @@ static fnctab_t x11_fnctab[] =
{ I, { 'd','i','s','c','o','n','n','e','c','t','\0' }, 0, pf_disconnect }
};
static int x11_import (moo_t* moo, moo_mod_t* mod, moo_oop_t _class)
{
return import_fnctab (moo, mod, _class, x11_fnctab, MOO_COUNTOF(x11_fnctab));
@ -204,58 +259,35 @@ int moo_mod_x11 (moo_t* moo, moo_mod_t* mod)
return 0;
}
/* ------------------------------------------------------------------------ */
#if 0
screen = xcb_setup_roots_iterator(xcb_get_setup(x11->c)).data;
x11->mw = xcb_generate_id (xtn->c);
xcb_create_window (x11->c,
XCB_COPY_FROM_PARENT,
xtn->mw,
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);
xcb_generic_event_t* evt;
while ((evt = xcb_poll_for_event(xtn->xcb, 0))
static fnctab_t x11_win_fnctab[] =
{
/* TODO: dispatch event read */
}
static fnctab_t x11_window_fnctab[] =
{
{ C, { '_','n','e','w','I','n','s','t','S','i','z','e','\0' }, 0, pf_newinstsize },
{ 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 }
{ C, { '_','n','e','w','I','n','s','t','S','i','z','e','\0' }, 0, pf_win_newinstsize },
{ I, { 'c','r','e','a','t','e','\0' }, 0, pf_win_create },
{ I, { 'd','i','s','t','r','o','y','\0' }, 0, pf_win_destroy }
};
static int x11_window_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_t _class)
{
return import_fnctab (moo, mod, _class, x11_window_fnctab, MOO_COUNTOF(x11_window_fnctab));
return import_fnctab (moo, mod, _class, x11_win_fnctab, MOO_COUNTOF(x11_win_fnctab));
}
static moo_pfimpl_t x11_window_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
static moo_pfimpl_t x11_win_query (moo_t* moo, moo_mod_t* mod, const moo_ooch_t* name)
{
return search_fnctab (moo, x11_window_fnctab, MOO_COUNTOF(x11_window_fnctab), name);
return search_fnctab (moo, x11_win_fnctab, MOO_COUNTOF(x11_win_fnctab), name);
}
static void windowunload (moo_t* moo, moo_mod_t* mod)
static void x11_win_unload (moo_t* moo, moo_mod_t* mod)
{
/* TODO: anything? */
}
int moo_mod_x11_window (moo_t* moo, moo_mod_t* mod)
int moo_mod_x11_win (moo_t* moo, moo_mod_t* mod)
{
mod->import = x11_window_import;
mod->query = x11_window_query;
mod->unload = x11_window_unload;
mod->import = x11_win_import;
mod->query = x11_win_query;
mod->unload = x11_win_unload;
mod->ctx = MOO_NULL;
return 0;
}
#endif