diff --git a/moo/bin/main.c b/moo/bin/main.c index ee78f8e..d062f22 100644 --- a/moo/bin/main.c +++ b/moo/bin/main.c @@ -202,11 +202,11 @@ int main (int argc, char* argv[]) moo_oow_t tab_size; tab_size = 5000; - moo_setoption (moo, MOO_SYMTAB_SIZE, &tab_size); + moo_setoption (moo, MOO_OPTION_SYMTAB_SIZE, &tab_size); tab_size = 5000; - moo_setoption (moo, MOO_SYSDIC_SIZE, &tab_size); + moo_setoption (moo, MOO_OPTION_SYSDIC_SIZE, &tab_size); tab_size = 600; - moo_setoption (moo, MOO_PROCSTK_SIZE, &tab_size); + moo_setoption (moo, MOO_OPTION_PROCSTK_SIZE, &tab_size); } if (moo_ignite(moo, memsize) <= -1) @@ -226,7 +226,6 @@ int main (int argc, char* argv[]) for (i = opt.ind; i < argc; i++) { moo_iostd_t in; - #if 1 in.type = MOO_IOSTD_FILEB; in.u.fileb.path = argv[i]; diff --git a/moo/lib/exec.c b/moo/lib/exec.c index db6bd75..461ece0 100644 --- a/moo/lib/exec.c +++ b/moo/lib/exec.c @@ -4835,7 +4835,7 @@ static MOO_INLINE int do_return (moo_t* moo, moo_oob_t bcode, moo_oop_t return_v /* the stack contains the final return value so the stack pointer must be 0. */ MOO_ASSERT (moo, moo->sp == 0); - if (moo->option.trait & MOO_AWAIT_PROCS) + if (moo->option.trait & MOO_TRAIT_AWAIT_PROCS) { terminate_process (moo, moo->processor->active); } diff --git a/moo/lib/moo-utl.h b/moo/lib/moo-utl.h index a151fc2..d25bcce 100644 --- a/moo/lib/moo-utl.h +++ b/moo/lib/moo-utl.h @@ -283,6 +283,16 @@ #define MOO_HASH_UCSTR(hv, ptr) MOO_HASH_VPTR(hv, ptr, const moo_uch_t) #define MOO_HASH_MORE_UCSTR(hv, ptr) MOO_HASH_MORE_VPTR(hv, ptr, const moo_uch_t) +/* ========================================================================= + * CMGR + * ========================================================================= */ +enum moo_cmgr_id_t +{ + MOO_CMGR_UTF8, + MOO_CMGR_UTF16, + MOO_CMGR_MB8, +}; +typedef enum moo_cmgr_id_t moo_cmgr_id_t; #if defined(__cplusplus) extern "C" { @@ -590,10 +600,30 @@ MOO_EXPORT int moo_conv_uchars_to_bchars_with_cmgr ( /* ------------------------------------------------------------------------- */ -MOO_EXPORT moo_cmgr_t* moo_get_utf8_cmgr ( - void +MOO_EXPORT moo_cmgr_t* moo_get_cmgr_by_id ( + moo_cmgr_id_t id ); +MOO_EXPORT moo_cmgr_t* moo_get_cmgr_by_bcstr ( + const moo_bch_t* name +); + +MOO_EXPORT moo_cmgr_t* moo_get_cmgr_by_ucstr ( + const moo_uch_t* name +); + +#if defined(MOO_OOCH_IS_UCH) +# define moo_get_cmgr_by_name(name) moo_get_cmgr_by_ucstr(name) +#else +# define moo_get_cmgr_by_name(name) moo_get_cmgr_by_bcstr(name) +#endif + +#define moo_get_utf8_cmgr() moo_get_cmgr_by_id(MOO_CMGR_UTF8) +#define moo_get_utf16_cmgr() moo_get_cmgr_by_id(MOO_CMGR_UTF16) +#define moo_get_mb8_cmgr() moo_get_cmgr_by_id(MOO_CMGR_MB8) + +/* ------------------------------------------------------------------------- */ + /** * The moo_conv_uchars_to_utf8() function converts a unicode character string \a ucs * to a UTF8 string and writes it into the buffer pointed to by \a bcs, but @@ -691,10 +721,6 @@ MOO_EXPORT moo_oow_t moo_utf8_to_uc ( /* ------------------------------------------------------------------------- */ -MOO_EXPORT moo_cmgr_t* moo_get_utf16_cmgr ( - void -); - MOO_EXPORT int moo_conv_uchars_to_utf16 ( const moo_uch_t* ucs, moo_oow_t* ucslen, @@ -738,10 +764,6 @@ MOO_EXPORT moo_oow_t moo_utf16_to_uc ( /* ------------------------------------------------------------------------- */ -MOO_EXPORT moo_cmgr_t* moo_get_mb8_cmgr ( - void -); - MOO_EXPORT int moo_conv_uchars_to_mb8 ( const moo_uch_t* ucs, moo_oow_t* ucslen, diff --git a/moo/lib/moo.c b/moo/lib/moo.c index cd67e99..a244e5f 100644 --- a/moo/lib/moo.c +++ b/moo/lib/moo.c @@ -297,22 +297,22 @@ int moo_setoption (moo_t* moo, moo_option_t id, const void* value) { switch (id) { - case MOO_TRAIT: + case MOO_OPTION_TRAIT: moo->option.trait = *(moo_bitmask_t*)value; #if defined(MOO_BUILD_DEBUG) - moo->option.karatsuba_cutoff = ((moo->option.trait & MOO_DEBUG_BIGINT)? MOO_KARATSUBA_CUTOFF_DEBUG: MOO_KARATSUBA_CUTOFF); + moo->option.karatsuba_cutoff = ((moo->option.trait & MOO_TRAIT_DEBUG_BIGINT)? MOO_KARATSUBA_CUTOFF_DEBUG: MOO_KARATSUBA_CUTOFF); #endif return 0; - case MOO_LOG_MASK: + case MOO_OPTION_LOG_MASK: moo->option.log_mask = *(moo_bitmask_t*)value; return 0; - case MOO_LOG_MAXCAPA: + case MOO_OPTION_LOG_MAXCAPA: moo->option.log_maxcapa = *(moo_oow_t*)value; return 0; - case MOO_SYMTAB_SIZE: + case MOO_OPTION_SYMTAB_SIZE: { moo_oow_t w; @@ -323,7 +323,7 @@ int moo_setoption (moo_t* moo, moo_option_t id, const void* value) return 0; } - case MOO_SYSDIC_SIZE: + case MOO_OPTION_SYSDIC_SIZE: { moo_oow_t w; @@ -334,7 +334,7 @@ int moo_setoption (moo_t* moo, moo_option_t id, const void* value) return 0; } - case MOO_PROCSTK_SIZE: + case MOO_OPTION_PROCSTK_SIZE: { moo_oow_t w; @@ -345,7 +345,7 @@ int moo_setoption (moo_t* moo, moo_option_t id, const void* value) return 0; } - case MOO_MOD_INCTX: + case MOO_OPTION_MOD_INCTX: moo->option.mod_inctx = *(void**)value; return 0; } @@ -357,33 +357,33 @@ einval: int moo_getoption (moo_t* moo, moo_option_t id, void* value) { - switch (id) + switch (id) { - case MOO_TRAIT: + case MOO_OPTION_TRAIT: *(moo_bitmask_t*)value = moo->option.trait; return 0; - case MOO_LOG_MASK: + case MOO_OPTION_LOG_MASK: *(moo_bitmask_t*)value = moo->option.log_mask; return 0; - case MOO_LOG_MAXCAPA: + case MOO_OPTION_LOG_MAXCAPA: *(moo_oow_t*)value = moo->option.log_maxcapa; return 0; - case MOO_SYMTAB_SIZE: + case MOO_OPTION_SYMTAB_SIZE: *(moo_oow_t*)value = moo->option.dfl_symtab_size; return 0; - case MOO_SYSDIC_SIZE: + case MOO_OPTION_SYSDIC_SIZE: *(moo_oow_t*)value = moo->option.dfl_sysdic_size; return 0; - case MOO_PROCSTK_SIZE: + case MOO_OPTION_PROCSTK_SIZE: *(moo_oow_t*)value = moo->option.dfl_procstk_size; return 0; - case MOO_MOD_INCTX: + case MOO_OPTION_MOD_INCTX: *(void**)value = moo->option.mod_inctx; return 0; }; @@ -392,14 +392,14 @@ int moo_getoption (moo_t* moo, moo_option_t id, void* value) return -1; } -moo_evtcb_t* moo_regevtcb (moo_t* moo, moo_evtcb_t* tmpl) +moo_evtcb_t* moo_regevtcb (moo_t* moo, moo_evtcb_t* cb) { moo_evtcb_t* actual; actual = (moo_evtcb_t*)moo_allocmem(moo, MOO_SIZEOF(*actual)); if (!actual) return MOO_NULL; - *actual = *tmpl; + *actual = *cb; actual->next = moo->evtcb_list; actual->prev = MOO_NULL; moo->evtcb_list = actual; diff --git a/moo/lib/moo.h b/moo/lib/moo.h index 48d9c49..e1debe7 100644 --- a/moo/lib/moo.h +++ b/moo/lib/moo.h @@ -95,13 +95,13 @@ typedef enum moo_errnum_t moo_errnum_t; enum moo_option_t { - MOO_TRAIT, - MOO_LOG_MASK, - MOO_LOG_MAXCAPA, - MOO_SYMTAB_SIZE, /* default system table size */ - MOO_SYSDIC_SIZE, /* default system dictionary size */ - MOO_PROCSTK_SIZE, /* default process stack size */ - MOO_MOD_INCTX + MOO_OPTION_TRAIT, + MOO_OPTION_LOG_MASK, + MOO_OPTION_LOG_MAXCAPA, + MOO_OPTION_SYMTAB_SIZE, /* default system table size */ + MOO_OPTION_SYSDIC_SIZE, /* default system dictionary size */ + MOO_OPTION_PROCSTK_SIZE, /* default process stack size */ + MOO_OPTION_MOD_INCTX }; typedef enum moo_option_t moo_option_t; @@ -119,15 +119,15 @@ typedef enum moo_option_dflval_t moo_option_dflval_t; enum moo_trait_t { - MOO_DEBUG_GC = (1u << 0), - MOO_DEBUG_BIGINT = (1u << 1), + MOO_TRAIT_DEBUG_GC = (1u << 0), + MOO_TRAIT_DEBUG_BIGINT = (1u << 1), /* perform no garbage collection when the heap is full. * you still can use moo_gc() explicitly. */ - MOO_NOGC = (1u << 8), + MOO_TRAIT_NOGC = (1u << 8), /* wait for running process when exiting from the main method */ - MOO_AWAIT_PROCS = (1u << 9) + MOO_TRAIT_AWAIT_PROCS = (1u << 9) }; typedef enum moo_trait_t moo_trait_t; @@ -1940,7 +1940,7 @@ MOO_EXPORT int moo_setoption ( MOO_EXPORT moo_evtcb_t* moo_regevtcb ( moo_t* moo, - moo_evtcb_t* tmpl + moo_evtcb_t* cb ); MOO_EXPORT void moo_deregevtcb ( @@ -1950,7 +1950,7 @@ MOO_EXPORT void moo_deregevtcb ( /** * The moo_gc() function performs garbage collection. - * It is not affected by #MOO_NOGC. + * It is not affected by #MOO_TRAIT_NOGC. */ MOO_EXPORT void moo_gc ( moo_t* moo diff --git a/moo/lib/obj.c b/moo/lib/obj.c index a7dcd23..9d455c7 100644 --- a/moo/lib/obj.c +++ b/moo/lib/obj.c @@ -31,7 +31,7 @@ void* moo_allocbytes (moo_t* moo, moo_oow_t size) moo_uint8_t* ptr; #if defined(MOO_BUILD_DEBUG) - if ((moo->option.trait & MOO_DEBUG_GC) && !(moo->option.trait & MOO_NOGC)) moo_gc (moo); + if ((moo->option.trait & MOO_TRAIT_DEBUG_GC) && !(moo->option.trait & MOO_TRAIT_NOGC)) moo_gc (moo); #endif if (MOO_UNLIKELY(moo->igniting)) @@ -42,7 +42,7 @@ void* moo_allocbytes (moo_t* moo, moo_oow_t size) else { ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->curspace, size); - if (!ptr && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_NOGC)) + if (!ptr && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC)) { moo_gc (moo); MOO_LOG4 (moo, MOO_LOG_GC | MOO_LOG_INFO, diff --git a/moo/lib/std.c b/moo/lib/std.c index 4c3519e..02ff469 100644 --- a/moo/lib/std.c +++ b/moo/lib/std.c @@ -258,6 +258,7 @@ struct bb_t FILE* fp; moo_bch_t* fn; + moo_cmgr_t* cmgr; }; #if defined(USE_SELECT) @@ -431,6 +432,7 @@ static MOO_INLINE moo_ooi_t open_input (moo_t* moo, moo_ioarg_t* arg) { xtn_t* xtn = GET_XTN(moo); bb_t* bb = MOO_NULL; + moo_bch_t* at; /* TOOD: support predefined include directory as well */ if (arg->includer) @@ -480,6 +482,7 @@ static MOO_INLINE moo_ooi_t open_input (moo_t* moo, moo_ioarg_t* arg) bb->fn = (moo_bch_t*)(bb + 1); moo_copy_bcstr (bb->fn, bcslen + 1, xtn->in->u.fileb.path); + break; #if defined(MOO_OOCH_IS_UCH) @@ -499,6 +502,7 @@ static MOO_INLINE moo_ooi_t open_input (moo_t* moo, moo_ioarg_t* arg) bb->fn = (moo_bch_t*)(bb + 1); bcslen += 1; moo_convutobcstr (moo, xtn->in->u.fileu.path, &ucslen, bb->fn, &bcslen); + break; default: @@ -507,6 +511,23 @@ static MOO_INLINE moo_ooi_t open_input (moo_t* moo, moo_ioarg_t* arg) } } + /* the path name can be appened with @encoding */ + at = moo_find_bchar_in_bcstr(bb->fn, '@'); + if (at && at[1] != '\0') + { + *at = '\0'; + bb->cmgr = moo_get_cmgr_by_bcstr(at + 1); + if (!bb->cmgr) bb->cmgr = moo_getcmgr(moo); + } + else if (arg->includer) + { + bb->cmgr = ((bb_t*)arg->includer->handle)->cmgr; + } + else + { + bb->cmgr = moo_getcmgr(moo); + } + /* TODO: support _wfopen or the like */ #if defined(_WIN32) || defined(__OS2__) || defined(__DOS__) bb->fp = fopen(bb->fn, "rb"); @@ -575,8 +596,13 @@ static MOO_INLINE moo_ooi_t read_input (moo_t* moo, moo_ioarg_t* arg) ucslen = MOO_COUNTOF(arg->buf); /* TODO: use the default cmgr first. * then fallback to utf8, mb8, etc */ - x = moo_convbtooochars(moo, bb->buf, &bcslen, arg->buf, &ucslen); - if (x <= -1 /*&& ucslen <= 0 */) return -1; + /*x = moo_convbtooochars(moo, bb->buf, &bcslen, arg->buf, &ucslen);*/ + x = moo_conv_bchars_to_uchars_with_cmgr(bb->buf, &bcslen, arg->buf, &ucslen, bb->cmgr, 0); + if (x <= -1 /*&& ucslen <= 0 */) + { + moo_seterrbfmt (moo, (x == -2)? MOO_EBUFFULL: MOO_EECERR, "unable to convert source input - %.*hs", bcslen, bb->buf); + return -1; + } /* if ucslen is greater than 0, i see that some characters have been * converted properly */ @@ -3235,8 +3261,8 @@ static struct moo_bitmask_t mask; } dbg_mask_table[] = { - { "bigint", MOO_DEBUG_BIGINT }, - { "gc", MOO_DEBUG_GC } + { "bigint", MOO_TRAIT_DEBUG_BIGINT }, + { "gc", MOO_TRAIT_DEBUG_GC } }; static int parse_logoptb (moo_t* moo, const moo_bch_t* str, moo_oow_t* xpathlen, moo_bitmask_t* xlogmask) @@ -3377,7 +3403,7 @@ static int handle_logoptb (moo_t* moo, const moo_bch_t* str) #endif if (str != xstr) moo_freemem (moo, xstr); - moo_setoption (moo, MOO_LOG_MASK, &logmask); + moo_setoption (moo, MOO_OPTION_LOG_MASK, &logmask); return 0; } @@ -3407,7 +3433,7 @@ static int handle_logoptu (moo_t* moo, const moo_uch_t* str) #endif moo_freemem (moo, xstr); - moo_setoption (moo, MOO_LOG_MASK, &logmask); + moo_setoption (moo, MOO_OPTION_LOG_MASK, &logmask); return 0; } @@ -3441,9 +3467,9 @@ static int handle_dbgoptb (moo_t* moo, const moo_bch_t* str) } while (cm); - moo_getoption (moo, MOO_TRAIT, &trait); + moo_getoption (moo, MOO_OPTION_TRAIT, &trait); trait |= dbgopt; - moo_setoption (moo, MOO_TRAIT, &trait); + moo_setoption (moo, MOO_OPTION_TRAIT, &trait); return 0; } @@ -3478,9 +3504,9 @@ static int handle_dbgoptu (moo_t* moo, const moo_uch_t* str) } while (cm); - moo_getoption (moo, MOO_TRAIT, &trait); + moo_getoption (moo, MOO_OPTION_TRAIT, &trait); trait |= dbgopt; - moo_setoption (moo, MOO_TRAIT, &trait); + moo_setoption (moo, MOO_OPTION_TRAIT, &trait); return 0; } @@ -3612,15 +3638,15 @@ static void fini_moo (moo_t* moo) { moo_bitmask_t bm = 0; - moo_getoption (moo, MOO_TRAIT, &bm); - /*bm |= MOO_NOGC;*/ - bm |= MOO_AWAIT_PROCS; - moo_setoption (moo, MOO_TRAIT, &bm); + moo_getoption (moo, MOO_OPTION_TRAIT, &bm); + /*bm |= MOO_TRAIT_NOGC;*/ + bm |= MOO_TRAIT_AWAIT_PROCS; + moo_setoption (moo, MOO_OPTION_TRAIT, &bm); /* disable GC logs */ - moo_getoption (moo, MOO_LOG_MASK, &bm); + moo_getoption (moo, MOO_OPTION_LOG_MASK, &bm); bm = ~MOO_LOG_GC; - moo_setoption (moo, MOO_LOG_MASK, &bm); + moo_setoption (moo, MOO_OPTION_LOG_MASK, &bm); } if (handle_cfg_options(moo, cfg) <= -1) diff --git a/moo/lib/utl.c b/moo/lib/utl.c index 1f3c991..092b2d3 100644 --- a/moo/lib/utl.c +++ b/moo/lib/utl.c @@ -734,113 +734,143 @@ MOO_INLINE int moo_conv_ucstr_to_bcstr_with_cmgr ( /* ----------------------------------------------------------------------- */ -static moo_cmgr_t utf8_cmgr = +static moo_cmgr_t builtin_cmgr[] = { - moo_utf8_to_uc, - moo_uc_to_utf8 + /* keep the order aligned with moo_cmgr_id_t values in */ + { moo_utf8_to_uc, moo_uc_to_utf8 }, + { moo_utf16_to_uc, moo_uc_to_utf16 }, + { moo_mb8_to_uc, moo_uc_to_mb8 } }; -moo_cmgr_t* moo_get_utf8_cmgr (void) +moo_cmgr_t* moo_get_cmgr_by_id (moo_cmgr_id_t id) { - return &utf8_cmgr; + return &builtin_cmgr[id]; } + +static struct +{ + const moo_bch_t* name; + moo_cmgr_id_t id; +} builtin_cmgr_tab[] = +{ + { "utf8", MOO_CMGR_UTF8 }, + { "utf16", MOO_CMGR_UTF16 }, + { "mb8", MOO_CMGR_MB8 } +}; + +moo_cmgr_t* moo_get_cmgr_by_bcstr (const moo_bch_t* name) +{ + if (name) + { + moo_oow_t i; + + for (i = 0; i < MOO_COUNTOF(builtin_cmgr_tab); i++) + { + if (moo_comp_bcstr(name, builtin_cmgr_tab[i].name) == 0) + { + return &builtin_cmgr[builtin_cmgr_tab[i].id]; + } + } + } + + return MOO_NULL; +} + +moo_cmgr_t* moo_get_cmgr_by_ucstr (const moo_uch_t* name) +{ + if (name) + { + moo_oow_t i; + + for (i = 0; i < MOO_COUNTOF(builtin_cmgr_tab); i++) + { + if (moo_comp_ucstr_bcstr(name, builtin_cmgr_tab[i].name) == 0) + { + return &builtin_cmgr[builtin_cmgr_tab[i].id]; + } + } + } + + return MOO_NULL; +} + +/* ----------------------------------------------------------------------- */ + int moo_conv_utf8_to_uchars (const moo_bch_t* bcs, moo_oow_t* bcslen, moo_uch_t* ucs, moo_oow_t* ucslen) { /* the source is length bound */ - return moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0); + return moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, &builtin_cmgr[MOO_CMGR_UTF8], 0); } int moo_conv_uchars_to_utf8 (const moo_uch_t* ucs, moo_oow_t* ucslen, moo_bch_t* bcs, moo_oow_t* bcslen) { /* length bound */ - return moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, &utf8_cmgr); + return moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, &builtin_cmgr[MOO_CMGR_UTF8]); } int moo_conv_utf8_to_ucstr (const moo_bch_t* bcs, moo_oow_t* bcslen, moo_uch_t* ucs, moo_oow_t* ucslen) { /* null-terminated. */ - return moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, &utf8_cmgr, 0); + return moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, &builtin_cmgr[MOO_CMGR_UTF8], 0); } int moo_conv_ucstr_to_utf8 (const moo_uch_t* ucs, moo_oow_t* ucslen, moo_bch_t* bcs, moo_oow_t* bcslen) { /* null-terminated */ - return moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, &utf8_cmgr); + return moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, &builtin_cmgr[MOO_CMGR_UTF8]); } /* ----------------------------------------------------------------------- */ -static moo_cmgr_t utf16_cmgr = -{ - moo_utf16_to_uc, - moo_uc_to_utf16 -}; - -moo_cmgr_t* moo_get_utf16_cmgr (void) -{ - return &utf16_cmgr; -} - int moo_conv_utf16_to_uchars (const moo_bch_t* bcs, moo_oow_t* bcslen, moo_uch_t* ucs, moo_oow_t* ucslen) { /* the source is length bound */ - return moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, &utf16_cmgr, 0); + return moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, &builtin_cmgr[MOO_CMGR_UTF16], 0); } int moo_conv_uchars_to_utf16 (const moo_uch_t* ucs, moo_oow_t* ucslen, moo_bch_t* bcs, moo_oow_t* bcslen) { /* length bound */ - return moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, &utf16_cmgr); + return moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, &builtin_cmgr[MOO_CMGR_UTF16]); } int moo_conv_utf16_to_ucstr (const moo_bch_t* bcs, moo_oow_t* bcslen, moo_uch_t* ucs, moo_oow_t* ucslen) { /* null-terminated. */ - return moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, &utf16_cmgr, 0); + return moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, &builtin_cmgr[MOO_CMGR_UTF16], 0); } int moo_conv_ucstr_to_utf16 (const moo_uch_t* ucs, moo_oow_t* ucslen, moo_bch_t* bcs, moo_oow_t* bcslen) { /* null-terminated */ - return moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, &utf16_cmgr); + return moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, &builtin_cmgr[MOO_CMGR_UTF16]); } /* ----------------------------------------------------------------------- */ -static moo_cmgr_t mb8_cmgr = -{ - moo_mb8_to_uc, - moo_uc_to_mb8 -}; - -moo_cmgr_t* moo_get_mb8_cmgr (void) -{ - return &mb8_cmgr; -} - int moo_conv_mb8_to_uchars (const moo_bch_t* bcs, moo_oow_t* bcslen, moo_uch_t* ucs, moo_oow_t* ucslen) { /* the source is length bound */ - return moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, &mb8_cmgr, 0); + return moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, &builtin_cmgr[MOO_CMGR_MB8], 0); } int moo_conv_uchars_to_mb8 (const moo_uch_t* ucs, moo_oow_t* ucslen, moo_bch_t* bcs, moo_oow_t* bcslen) { /* length bound */ - return moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, &mb8_cmgr); + return moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, &builtin_cmgr[MOO_CMGR_MB8]); } int moo_conv_mb8_to_ucstr (const moo_bch_t* bcs, moo_oow_t* bcslen, moo_uch_t* ucs, moo_oow_t* ucslen) { /* null-terminated. */ - return moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, &mb8_cmgr, 0); + return moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, &builtin_cmgr[MOO_CMGR_MB8], 0); } int moo_conv_ucstr_to_mb8 (const moo_uch_t* ucs, moo_oow_t* ucslen, moo_bch_t* bcs, moo_oow_t* bcslen) { /* null-terminated */ - return moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, &mb8_cmgr); + return moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, &builtin_cmgr[MOO_CMGR_MB8]); } /* ----------------------------------------------------------------------- */