From 2cbfdfd6dd27bc0d7b87da64d1a4a4c683b5df83 Mon Sep 17 00:00:00 2001 From: "hyunghwan.chung" Date: Fri, 21 Jun 2019 07:21:58 +0000 Subject: [PATCH] added the _instsize field to moo_t. changed moo_getxtn() to utilize this new field. remove moo_getxtnstd() as it's not needed any more for the added field --- moo/kernel/test-002.moo | 32 ++++++++++++++++++++++++++++++++ moo/lib/comp.c | 2 +- moo/lib/err.c | 4 ++-- moo/lib/fmt.c | 12 ++++++------ moo/lib/moo-std.h | 4 ---- moo/lib/moo.c | 26 +++++++++++++------------- moo/lib/moo.h | 21 +++++++++++---------- moo/lib/rbt.c | 22 +++++++++++----------- moo/lib/std.c | 10 ++++------ moo/lib/utl.c | 8 ++++---- 10 files changed, 84 insertions(+), 57 deletions(-) diff --git a/moo/kernel/test-002.moo b/moo/kernel/test-002.moo index 3b6f423..3794122 100644 --- a/moo/kernel/test-002.moo +++ b/moo/kernel/test-002.moo @@ -103,6 +103,34 @@ class MyObject(Object) } */ + method(#class) test_quicksort: anArray + { + | quicksort | + quicksort := nil. + quicksort := [ :data :from :to | + (from < to) + ifTrue: [ | pivot index | + pivot := data at: from. + data swap: from with: to. + index := from. + from to: (to - 1) do: [ :each | + (data at: each) < pivot + ifTrue: [ + data swap: each with: index. + index := index + 1 + ] + ]. + + data swap: to with: index. + quicksort value: data value: from value: index - 1. + quicksort value: data value: index + 1 value: to + ]. + data + ]. + + ^(quicksort value: anArray value: 0 value: (anArray size - 1)) + } + method(#class) main { | tc limit | @@ -114,6 +142,8 @@ class MyObject(Object) [ self test_semaphore_heap == true ], [ self test_mutex = #(2000 6000) ], ####[ self test_sem_sig ], + [ (self test_quicksort: #(7 12 3 20 5 8 2) copy) = #(2 3 5 7 8 12 20)], + [ (self test_quicksort: %(99, 12, 18, 7, 12, 3, 20, 5, 8, 2)) = #(2 3 5 7 8 12 12 18 20 99)], [ System sleepForSecs: 2. self.a == 300 ] ## sleep before checking self.a to prevent different result depending on process switching frequency and speed ). @@ -125,6 +155,8 @@ class MyObject(Object) tb := tc at: idx. System log(System.Log.INFO, idx asString, (if (tb value) { ' PASS' } else { ' FAIL' }), S'\n'). ]. + +'AAAAAAAAAAAAAAAAAAAAAaa' dump. } } diff --git a/moo/lib/comp.c b/moo/lib/comp.c index bff286e..e195411 100644 --- a/moo/lib/comp.c +++ b/moo/lib/comp.c @@ -9524,7 +9524,7 @@ oops: prev = moo->c->curinp->includer; MOO_ASSERT (moo, moo->c->curinp->name != MOO_NULL); - MOO_MMGR_FREE (moo->mmgr, moo->c->curinp); + moo_freemem (moo, moo->c->curinp); moo->c->curinp = prev; } diff --git a/moo/lib/err.c b/moo/lib/err.c index 22957d8..537315f 100644 --- a/moo/lib/err.c +++ b/moo/lib/err.c @@ -225,7 +225,7 @@ static int err_bcs (moo_fmtout_t* fmtout, const moo_bch_t* ptr, moo_oow_t len) #if defined(MOO_OOCH_IS_UCH) if (max <= 0) return 1; - moo_conv_bchars_to_uchars_with_cmgr (ptr, &len, &moo->errmsg.buf[moo->errmsg.len], &max, moo->cmgr, 1); + moo_conv_bchars_to_uchars_with_cmgr (ptr, &len, &moo->errmsg.buf[moo->errmsg.len], &max, moo_getcmgr(moo), 1); moo->errmsg.len += max; #else if (len > max) len = max; @@ -253,7 +253,7 @@ static int err_ucs (moo_fmtout_t* fmtout, const moo_uch_t* ptr, moo_oow_t len) moo->errmsg.len += len; #else if (max <= 0) return 1; - moo_conv_uchars_to_bchars_with_cmgr (ptr, &len, &moo->errmsg.buf[moo->errmsg.len], &max, moo->cmgr); + moo_conv_uchars_to_bchars_with_cmgr (ptr, &len, &moo->errmsg.buf[moo->errmsg.len], &max, moo_getcmgr(moo)); moo->errmsg.len += max; #endif moo->errmsg.buf[moo->errmsg.len] = '\0'; diff --git a/moo/lib/fmt.c b/moo/lib/fmt.c index 5bf5139..a1882be 100644 --- a/moo/lib/fmt.c +++ b/moo/lib/fmt.c @@ -1683,7 +1683,7 @@ static int log_ucs (moo_fmtout_t* fmtout, const moo_uch_t* ptr, moo_oow_t len) { len = rem; bcslen = MOO_COUNTOF(bcs); - moo_conv_uchars_to_bchars_with_cmgr(ptr, &len, bcs, &bcslen, moo->cmgr); + moo_conv_uchars_to_bchars_with_cmgr(ptr, &len, bcs, &bcslen, moo_getcmgr(moo)); log_bcs(fmtout, bcs, bcslen); rem -= len; ptr += len; @@ -1707,7 +1707,7 @@ static int log_bcs (moo_fmtout_t* fmtout, const moo_bch_t* ptr, moo_oow_t len) { len = rem; ucslen = MOO_COUNTOF(ucs); - moo_conv_bchars_to_uchars_with_cmgr(ptr, &len, ucs, &ucslen, moo->cmgr, 1); + moo_conv_bchars_to_uchars_with_cmgr(ptr, &len, ucs, &ucslen, moo_getcmgr(moo), 1); log_ucs(fmtout, ucs, ucslen); rem -= len; ptr += len; @@ -1837,7 +1837,7 @@ static int sprint_bcs (moo_fmtout_t* fmtout, const moo_bch_t* ptr, moo_oow_t len #if defined(MOO_OOCH_IS_UCH) blen = len; - moo_conv_bchars_to_uchars_with_cmgr (ptr, &blen, MOO_NULL, &oolen, moo->cmgr, 1); + moo_conv_bchars_to_uchars_with_cmgr (ptr, &blen, MOO_NULL, &oolen, moo_getcmgr(moo), 1); #else oolen = len; #endif @@ -1858,7 +1858,7 @@ static int sprint_bcs (moo_fmtout_t* fmtout, const moo_bch_t* ptr, moo_oow_t len } #if defined(MOO_OOCH_IS_UCH) - moo_conv_bchars_to_uchars_with_cmgr (ptr, &len, &moo->sprintf.xbuf.ptr[moo->sprintf.xbuf.len], &oolen, moo->cmgr, 1); + moo_conv_bchars_to_uchars_with_cmgr (ptr, &len, &moo->sprintf.xbuf.ptr[moo->sprintf.xbuf.len], &oolen, moo_getcmgr(moo), 1); #else MOO_MEMCPY (&moo->sprintf.xbuf.ptr[moo->sprintf.xbuf.len], ptr, len * MOO_SIZEOF(*ptr)); #endif @@ -1878,7 +1878,7 @@ static int sprint_ucs (moo_fmtout_t* fmtout, const moo_uch_t* ptr, moo_oow_t len oolen = len; #else ulen = len; - moo_conv_uchars_to_bchars_with_cmgr (ptr, &ulen, MOO_NULL, &oolen, moo->cmgr); + moo_conv_uchars_to_bchars_with_cmgr (ptr, &ulen, MOO_NULL, &oolen, moo_getcmgr(moo)); #endif if (oolen > unused) @@ -1899,7 +1899,7 @@ static int sprint_ucs (moo_fmtout_t* fmtout, const moo_uch_t* ptr, moo_oow_t len #if defined(MOO_OOCH_IS_UCH) MOO_MEMCPY (&moo->sprintf.xbuf.ptr[moo->sprintf.xbuf.len], ptr, len * MOO_SIZEOF(*ptr)); #else - moo_conv_uchars_to_bchars_with_cmgr (ptr, &len, &moo->sprintf.xbuf.ptr[moo->sprintf.xbuf.len], &oolen, moo->cmgr); + moo_conv_uchars_to_bchars_with_cmgr (ptr, &len, &moo->sprintf.xbuf.ptr[moo->sprintf.xbuf.len], &oolen, moo_getcmgr(moo)); #endif moo->sprintf.xbuf.len += oolen; diff --git a/moo/lib/moo-std.h b/moo/lib/moo-std.h index 38bd683..eb70da8 100644 --- a/moo/lib/moo-std.h +++ b/moo/lib/moo-std.h @@ -104,10 +104,6 @@ MOO_EXPORT moo_t* moo_openstd ( moo_errinf_t* errinfo ); -MOO_EXPORT void* moo_getxtnstd ( - moo_t* moo -); - MOO_EXPORT void moo_abortstd ( moo_t* moo ); diff --git a/moo/lib/moo.c b/moo/lib/moo.c index a244e5f..e66cb3e 100644 --- a/moo/lib/moo.c +++ b/moo/lib/moo.c @@ -56,7 +56,7 @@ moo_t* moo_open (moo_mmgr_t* mmgr, moo_oow_t xtnsize, moo_cmgr_t* cmgr, const mo void moo_close (moo_t* moo) { moo_fini (moo); - MOO_MMGR_FREE (moo->mmgr, moo); + MOO_MMGR_FREE (moo_getmmgr(moo), moo); } static void fill_bigint_tables (moo_t* moo) @@ -86,16 +86,14 @@ static void fill_bigint_tables (moo_t* moo) } } -static void* alloc_heap (moo_t* moo, moo_oow_t size) +static MOO_INLINE void* alloc_heap (moo_t* moo, moo_oow_t size) { - void* ptr = MOO_MMGR_ALLOC(moo->mmgr, size); - if (!ptr) moo_seterrnum (moo, MOO_ESYSMEM); - return ptr; + return moo_allocmem(moo, size); } -static void free_heap (moo_t* moo, void* ptr) +static MOO_INLINE void free_heap (moo_t* moo, void* ptr) { - MOO_MMGR_FREE(moo->mmgr, ptr); + moo_freemem (moo, ptr); } int moo_init (moo_t* moo, moo_mmgr_t* mmgr, moo_cmgr_t* cmgr, const moo_vmprim_t* vmprim) @@ -109,8 +107,10 @@ int moo_init (moo_t* moo, moo_mmgr_t* mmgr, moo_cmgr_t* cmgr, const moo_vmprim_t } MOO_MEMSET (moo, 0, MOO_SIZEOF(*moo)); - moo->mmgr = mmgr; - moo->cmgr = cmgr; + moo->_instsize = MOO_SIZEOF(*moo); + moo->_mmgr = mmgr; + moo->_cmgr = cmgr; + moo->vmprim = *vmprim; if (!moo->vmprim.alloc_heap) moo->vmprim.alloc_heap = alloc_heap; if (!moo->vmprim.free_heap) moo->vmprim.free_heap = free_heap; @@ -427,7 +427,7 @@ void* moo_allocmem (moo_t* moo, moo_oow_t size) { void* ptr; - ptr = MOO_MMGR_ALLOC (moo->mmgr, size); + ptr = MOO_MMGR_ALLOC(moo_getmmgr(moo), size); if (!ptr) moo_seterrnum (moo, MOO_ESYSMEM); return ptr; } @@ -436,7 +436,7 @@ void* moo_callocmem (moo_t* moo, moo_oow_t size) { void* ptr; - ptr = MOO_MMGR_ALLOC (moo->mmgr, size); + ptr = MOO_MMGR_ALLOC(moo_getmmgr(moo), size); if (!ptr) moo_seterrnum (moo, MOO_ESYSMEM); else MOO_MEMSET (ptr, 0, size); return ptr; @@ -444,14 +444,14 @@ void* moo_callocmem (moo_t* moo, moo_oow_t size) void* moo_reallocmem (moo_t* moo, void* ptr, moo_oow_t size) { - ptr = MOO_MMGR_REALLOC (moo->mmgr, ptr, size); + ptr = MOO_MMGR_REALLOC (moo_getmmgr(moo), ptr, size); if (!ptr) moo_seterrnum (moo, MOO_ESYSMEM); return ptr; } void moo_freemem (moo_t* moo, void* ptr) { - MOO_MMGR_FREE (moo->mmgr, ptr); + MOO_MMGR_FREE (moo_getmmgr(moo), ptr); } /* -------------------------------------------------------------------------- */ diff --git a/moo/lib/moo.h b/moo/lib/moo.h index f3cefd8..1734164 100644 --- a/moo/lib/moo.h +++ b/moo/lib/moo.h @@ -1351,8 +1351,9 @@ typedef struct moo_errinf_t moo_errinf_t; struct moo_t { - moo_mmgr_t* mmgr; - moo_cmgr_t* cmgr; + moo_oow_t _instsize; + moo_mmgr_t* _mmgr; + moo_cmgr_t* _cmgr; moo_errnum_t errnum; struct { @@ -1844,19 +1845,19 @@ MOO_EXPORT void moo_fini ( ); #if defined(MOO_HAVE_INLINE) - static MOO_INLINE moo_mmgr_t* moo_getmmgr (moo_t* moo) { return moo->mmgr; } - static MOO_INLINE void* moo_getxtn (moo_t* moo) { return (void*)(moo + 1); } + static MOO_INLINE moo_mmgr_t* moo_getmmgr (moo_t* moo) { return moo->_mmgr; } + static MOO_INLINE void* moo_getxtn (moo_t* moo) { return (void*)((moo_uint8_t*)moo + moo->_instsize); } - static MOO_INLINE moo_cmgr_t* moo_getcmgr (moo_t* moo) { return moo->cmgr; } - static MOO_INLINE void moo_setcmgr (moo_t* moo, moo_cmgr_t* cmgr) { moo->cmgr = cmgr; } + static MOO_INLINE moo_cmgr_t* moo_getcmgr (moo_t* moo) { return moo->_cmgr; } + static MOO_INLINE void moo_setcmgr (moo_t* moo, moo_cmgr_t* cmgr) { moo->_cmgr = cmgr; } static MOO_INLINE moo_errnum_t moo_geterrnum (moo_t* moo) { return moo->errnum; } #else -# define moo_getmmgr(moo) (((moo_t*)(moo))->mmgr) -# define moo_getxtn(moo) ((void*)((moo_t*)(moo) + 1)) +# define moo_getmmgr(moo) (((moo_t*)(moo))->_mmgr) +# define moo_getxtn(moo) ((void*)((moo_uint8_t*)moo + ((moo_t*)moo)->_instsize)) -# define moo_getcmgr(moo) (((moo_t*)(moo))->cmgr) -# define moo_setcmgr(moo,mgr) (((moo_t*)(moo))->cmgr = (mgr)) +# define moo_getcmgr(moo) (((moo_t*)(moo))->_cmgr) +# define moo_setcmgr(moo,cmgr) (((moo_t*)(moo))->_cmgr = (cmgr)) # define moo_geterrnum(moo) (((moo_t*)(moo))->errnum) #endif diff --git a/moo/lib/rbt.c b/moo/lib/rbt.c index 83ae026..5d5feca 100644 --- a/moo/lib/rbt.c +++ b/moo/lib/rbt.c @@ -67,8 +67,8 @@ MOO_INLINE moo_rbt_pair_t* moo_rbt_allocpair ( if (kcop == MOO_RBT_COPIER_INLINE) as += MOO_ALIGN_POW2(KTOB(rbt,klen), MOO_SIZEOF_VOID_P); if (vcop == MOO_RBT_COPIER_INLINE) as += VTOB(rbt,vlen); - pair = (moo_rbt_pair_t*) MOO_MMGR_ALLOC (rbt->moo->mmgr, as); - if (pair == MOO_NULL) return MOO_NULL; + pair = (moo_rbt_pair_t*)moo_allocmem(rbt->moo, as); + if (!pair) return MOO_NULL; pair->color = MOO_RBT_RED; pair->parent = MOO_NULL; @@ -87,10 +87,10 @@ MOO_INLINE moo_rbt_pair_t* moo_rbt_allocpair ( } else { - KPTR(pair) = kcop (rbt, kptr, klen); + KPTR(pair) = kcop(rbt, kptr, klen); if (KPTR(pair) == MOO_NULL) { - MOO_MMGR_FREE (rbt->moo->mmgr, pair); + moo_freemem (rbt->moo, pair); return MOO_NULL; } } @@ -114,7 +114,7 @@ MOO_INLINE moo_rbt_pair_t* moo_rbt_allocpair ( { if (rbt->style->freeer[MOO_RBT_KEY] != MOO_NULL) rbt->style->freeer[MOO_RBT_KEY] (rbt, KPTR(pair), KLEN(pair)); - MOO_MMGR_FREE (rbt->moo->mmgr, pair); + moo_freemem (rbt->moo, pair); return MOO_NULL; } } @@ -128,7 +128,7 @@ MOO_INLINE void moo_rbt_freepair (moo_rbt_t* rbt, moo_rbt_pair_t* pair) rbt->style->freeer[MOO_RBT_KEY] (rbt, KPTR(pair), KLEN(pair)); if (rbt->style->freeer[MOO_RBT_VAL] != MOO_NULL) rbt->style->freeer[MOO_RBT_VAL] (rbt, VPTR(pair), VLEN(pair)); - MOO_MMGR_FREE (rbt->moo->mmgr, pair); + moo_freemem (rbt->moo, pair); } static moo_rbt_style_t style[] = @@ -195,12 +195,12 @@ moo_rbt_t* moo_rbt_open (moo_t* moo, moo_oow_t xtnsize, int kscale, int vscale) { moo_rbt_t* rbt; - rbt = (moo_rbt_t*) MOO_MMGR_ALLOC (moo->mmgr, MOO_SIZEOF(moo_rbt_t) + xtnsize); - if (rbt == MOO_NULL) return MOO_NULL; + rbt = (moo_rbt_t*)moo_allocmem(moo, MOO_SIZEOF(moo_rbt_t) + xtnsize); + if (!rbt) return MOO_NULL; - if (moo_rbt_init (rbt, moo, kscale, vscale) <= -1) + if (moo_rbt_init(rbt, moo, kscale, vscale) <= -1) { - MOO_MMGR_FREE (moo->mmgr, rbt); + moo_freemem (moo, rbt); return MOO_NULL; } @@ -211,7 +211,7 @@ moo_rbt_t* moo_rbt_open (moo_t* moo, moo_oow_t xtnsize, int kscale, int vscale) void moo_rbt_close (moo_rbt_t* rbt) { moo_rbt_fini (rbt); - MOO_MMGR_FREE (rbt->moo->mmgr, rbt); + moo_freemem (rbt->moo, rbt); } int moo_rbt_init (moo_rbt_t* rbt, moo_t* moo, int kscale, int vscale) diff --git a/moo/lib/std.c b/moo/lib/std.c index b51e739..68bb0ce 100644 --- a/moo/lib/std.c +++ b/moo/lib/std.c @@ -379,7 +379,7 @@ struct xtn_t } ev; }; -#define GET_XTN(moo) ((xtn_t*)moo_getxtn(moo)) +#define GET_XTN(moo) ((xtn_t*)((moo_uint8_t*)moo_getxtn(moo) - MOO_SIZEOF(xtn_t))) static moo_t* g_moo = MOO_NULL; @@ -3649,6 +3649,9 @@ static void fini_moo (moo_t* moo) moo = moo_open(&sys_mmgr, MOO_SIZEOF(xtn_t) + xtnsize, ((cfg && cfg->cmgr)? cfg->cmgr: moo_get_utf8_cmgr()), &vmprim, errinfo); if (!moo) return MOO_NULL; + /* adjust the object size by the sizeof xtn_t so that qse_getxtn() returns the right pointer. */ + moo->_instsize += MOO_SIZEOF(xtn_t); + xtn = GET_XTN(moo); if (cfg) xtn->input_cmgr = cfg->input_cmgr; if (!xtn->input_cmgr) xtn->input_cmgr = moo_getcmgr(moo); @@ -3691,11 +3694,6 @@ static void fini_moo (moo_t* moo) return moo; } -void* moo_getxtnstd (moo_t* moo) -{ - return (void*)((moo_uint8_t*)GET_XTN(moo) + MOO_SIZEOF(xtn_t)); -} - void moo_abortstd (moo_t* moo) { #if defined(USE_THREAD) diff --git a/moo/lib/utl.c b/moo/lib/utl.c index 092b2d3..982db29 100644 --- a/moo/lib/utl.c +++ b/moo/lib/utl.c @@ -879,7 +879,7 @@ int moo_convbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* bcslen, moo_ { /* length bound */ int n; - n = moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, moo->cmgr, 0); + n = moo_conv_bchars_to_uchars_with_cmgr(bcs, bcslen, ucs, ucslen, moo_getcmgr(moo), 0); /* -1: illegal character, -2: buffer too small, -3: incomplete sequence */ if (n <= -1) moo_seterrnum (moo, (n == -2)? MOO_EBUFFULL: MOO_EECERR); return n; @@ -889,7 +889,7 @@ int moo_convutobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_ { /* length bound */ int n; - n = moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, moo->cmgr); + n = moo_conv_uchars_to_bchars_with_cmgr(ucs, ucslen, bcs, bcslen, moo_getcmgr(moo)); if (n <= -1) moo_seterrnum (moo, (n == -2)? MOO_EBUFFULL: MOO_EECERR); return n; } @@ -898,7 +898,7 @@ int moo_convbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* bcslen, moo_u { /* null-terminated. */ int n; - n = moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, moo->cmgr, 0); + n = moo_conv_bcstr_to_ucstr_with_cmgr(bcs, bcslen, ucs, ucslen, moo_getcmgr(moo), 0); if (n <= -1) moo_seterrnum (moo, (n == -2)? MOO_EBUFFULL: MOO_EECERR); return n; } @@ -907,7 +907,7 @@ int moo_convutobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_b { /* null-terminated */ int n; - n = moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, moo->cmgr); + n = moo_conv_ucstr_to_bcstr_with_cmgr(ucs, ucslen, bcs, bcslen, moo_getcmgr(moo)); if (n <= -1) moo_seterrnum (moo, (n == -2)? MOO_EBUFFULL: MOO_EECERR); return n; }