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

added moo_duputobcharswithheadroom(), moo_dupbtoucharswithheadroom()

Browse Source 
added moo_inttoooi() and made public moo_inttooow()
enhanced the ffi module a bit more
This commit is contained in:
hyunghwan.chung
2017-01-15 17:53:37 +00:00
parent 79198df35b
commit 70f9976af3
12 changed files with 299 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
moo/lib/bigint.c
View File

@ -338,6 +338,18 @@ int moo_inttooow (moo_t* moo, moo_oop_t x, moo_oow_t* w)
return 0; /* not convertable - too big, too small, or not an integer */
}
int moo_inttoooi (moo_t* moo, moo_oop_t x, moo_ooi_t* i)
{
moo_oow_t w;
int n;
n = moo_inttooow (moo, x, &w);
if (n < 0) *i = -w;
else if (n > 0) *i = w;
return n;
}
static MOO_INLINE moo_oop_t make_bigint_with_oow (moo_t* moo, moo_oow_t w)
{
#if (MOO_LIW_BITS == MOO_OOW_BITS)

6
moo/lib/err.c
View File

@ -195,10 +195,16 @@ moo_errnum_t moo_syserrtoerrnum (int e)
{
case ENOMEM: return MOO_ESYSMEM;
case EINVAL: return MOO_EINVAL;
#if defined(EBUSY)
case EBUSY: return MOO_EBUSY;
#endif
case EACCES: return MOO_EACCES;
#if defined(EPERM)
case EPERM: return MOO_EPERM;
#endif
#if defined(ENOTDIR)
case ENOTDIR: return MOO_ENOTDIR;
#endif
case ENOENT: return MOO_ENOENT;
#if defined(EEXIST)
case EEXIST: return MOO_EEXIST;

15
moo/lib/exec.c
View File

@ -122,7 +122,7 @@
# define LOG_INST_3(moo,fmt,a1,a2,a3)
#endif
#if defined(__DOS__) && defined(_INTELC32_)
#if defined(__DOS__) && (defined(_INTELC32_) || (defined(__WATCOMC__) && (__WATCOMC__ <= 1000)))
/* the old intel c code builder doesn't support __FUNCTION__ */
# define __PRIMITIVE_NAME__ "<<primitive>>"
#else
@ -145,13 +145,15 @@ static MOO_INLINE void vm_gettime (moo_t* moo, moo_ntime_t* now)
/* it must return NO_ERROR */
MOO_INITNTIME (now, MOO_MSEC_TO_SEC(out), MOO_MSEC_TO_NSEC(out));
#elif defined(__DOS__) && defined(_INTELC32_)
#elif defined(__DOS__) && (defined(_INTELC32_) || defined(__WATCOMC__))
clock_t c;
/* TODO: handle overflow?? */
c = clock ();
now->sec = c / CLOCKS_PER_SEC;
#if (CLOCKS_PER_SEC == 1000)
#if (CLOCKS_PER_SEC == 100)
now->nsec = MOO_MSEC_TO_NSEC((c % CLOCKS_PER_SEC) * 10);
#elif (CLOCKS_PER_SEC == 1000)
now->nsec = MOO_MSEC_TO_NSEC(c % CLOCKS_PER_SEC);
#elif (CLOCKS_PER_SEC == 1000000L)
now->nsec = MOO_USEC_TO_NSEC(c % CLOCKS_PER_SEC);
@ -218,13 +220,16 @@ static MOO_INLINE void vm_sleep (moo_t* moo, const moo_ntime_t* dur)
/* TODO: ... */
#elif defined(__DOS__) && defined(_INTELC32_)
#elif defined(__DOS__) && (defined(_INTELC32_) || defined(__WATCOMC__))
clock_t c;
c = clock ();
c += dur->sec * CLOCKS_PER_SEC;
#if (CLOCKS_PER_SEC == 1000)
#if (CLOCKS_PER_SEC == 100)
c += MOO_NSEC_TO_MSEC(dur->nsec) / 10;
#elif (CLOCKS_PER_SEC == 1000)
c += MOO_NSEC_TO_MSEC(dur->nsec);
#elif (CLOCKS_PER_SEC == 1000000L)
c += MOO_NSEC_TO_USEC(dur->nsec);

18
moo/lib/main.c
View File

@ -48,6 +48,7 @@
#elif defined(__DOS__)
# include <dos.h>
# include <time.h>
# include <io.h>
#elif defined(macintosh)
# include <Timer.h>
#else
@ -510,11 +511,20 @@ static moo_t* g_moo = MOO_NULL;
/* ========================================================================= */
#if defined(__DOS__) && defined(_INTELC32_)
static void (*prev_timer_intr_handler) (void);
#if defined(__DOS__) && (defined(_INTELC32_) || defined(__WATCOMC__))
#if defined(_INTELC32_)
static void (*prev_timer_intr_handler) (void);
#else
static void (__interrupt *prev_timer_intr_handler) (void);
#endif
#if defined(_INTELC32_)
#pragma interrupt(timer_intr_handler)
static void timer_intr_handler (void)
#else
static void __interrupt timer_intr_handler (void)
#endif
{
/*
_XSTACK *stk;
@ -551,7 +561,7 @@ static void arrange_process_switching (int sig)
static void setup_tick (void)
{
#if defined(__DOS__) && defined(_INTELC32_)
#if defined(__DOS__) && (defined(_INTELC32_) || defined(__WATCOMC__))
prev_timer_intr_handler = _dos_getvect (0x1C);
_dos_setvect (0x1C, timer_intr_handler);
@ -587,7 +597,7 @@ static void setup_tick (void)
static void cancel_tick (void)
{
#if defined(__DOS__) && defined(_INTELC32_)
#if defined(__DOS__) && (defined(_INTELC32_) || defined(__WATCOMC__))
_dos_setvect (0x1C, prev_timer_intr_handler);

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

@ -561,7 +561,7 @@ typedef struct moo_t moo_t;
# define MOO_IMPORT
# define MOO_EXPORT
# define MOO_PRIVATE
#elif defined(_WIN32) || (defined(__WATCOMC__) && !defined(__WINDOWS_386__))
#elif defined(_WIN32) || (defined(__WATCOMC__) && (__WATCOMC__ >= 1000) && !defined(__WINDOWS_386__))
# define MOO_IMPORT __declspec(dllimport)
# define MOO_EXPORT __declspec(dllexport)
# define MOO_PRIVATE

6
moo/lib/moo-dos.h
View File

@ -47,7 +47,11 @@
# define MOO_SIZEOF___INT8 1
# define MOO_SIZEOF___INT16 2
# define MOO_SIZEOF___INT32 4
# define MOO_SIZEOF___INT64 8
# if (__WATCOMC__ < 1000)
# define MOO_SIZEOF___INT64 0
# else
# define MOO_SIZEOF___INT64 8
# endif
# define MOO_SIZEOF___INT128 0
# define MOO_SIZEOF_OFF64_T 0

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

@ -1003,12 +1003,6 @@ int moo_isint (
moo_oop_t x
);
int moo_inttooow (
moo_t* moo,
moo_oop_t x,
moo_oow_t* w
);
moo_oop_t moo_addints (
moo_t* moo,
moo_oop_t x,

56
moo/lib/moo.h
View File

@ -1311,16 +1311,27 @@ MOO_EXPORT moo_oop_t moo_makesymbol (
moo_oow_t len
);
MOO_EXPORT moo_oop_t moo_makestring (
moo_t* moo,
const moo_ooch_t* ptr,
moo_oow_t len
MOO_EXPORT moo_oop_t moo_makestringwithuchars (
moo_t* moo,
const moo_uch_t* ptr,
moo_oow_t len
);
MOO_EXPORT moo_oop_t moo_makestringwithbchars (
moo_t* moo,
const moo_bch_t* ptr,
moo_oow_t len
);
#if defined(MOO_OOCH_IS_UCH)
# define moo_makestring(moo,ptr,len) moo_makestringwithuchars(moo,ptr,len)
#else
# define moo_makestring(moo,ptr,len) moo_makestringwithbchars(moo,ptr,len)
#endif
MOO_EXPORT moo_oop_t moo_oowtoint (
moo_t* moo,
moo_oow_t w
moo_t* moo,
moo_oow_t w
);
MOO_EXPORT moo_oop_t moo_ooitoint (
@ -1328,6 +1339,19 @@ MOO_EXPORT moo_oop_t moo_ooitoint (
moo_ooi_t i
);
MOO_EXPORT int moo_inttooow (
moo_t* moo,
moo_oop_t x,
moo_oow_t* w
);
MOO_EXPORT int moo_inttoooi (
moo_t* moo,
moo_oop_t x,
moo_ooi_t* i
);
/* =========================================================================
* TEMPORARY OOP MANAGEMENT FUNCTIONS
* ========================================================================= */
@ -1443,11 +1467,15 @@ int moo_convutobcstr (
#if defined(MOO_OOCH_IS_UCH)
# define moo_dupootobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen) moo_duputobcharswithheadroom(moo,hrb,oocs,oocslen,bcslen)
# define moo_dupbtooocharswithheadroom(moo,hrb,bcs,bcslen,oocslen) moo_dupbtoucharswithheadroom(moo,hrb,bcs,bcslen,oocslen)
# define moo_dupootobchars(moo,oocs,oocslen,bcslen) moo_duputobchars(moo,oocs,oocslen,bcslen)
# define moo_dupbtooochars(moo,bcs,bcslen,oocslen) moo_dupbtouchars(moo,bcs,bcslen,oocslen)
# define moo_dupootobcstr(moo,oocs,bcslen) moo_duputobcstr(moo,oocs,bcslen)
# define moo_dupbtooocstr(moo,bcs,oocslen) moo_dupbtoucstr(moo,bcs,oocslen)
#else
# define moo_dupootoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen) moo_dupbtoucharswithheadroom(moo,hrb,oocs,oocslen,ucslen)
# define moo_duputooocharswithheadroom(moo,hrb,ucs,ucslen,oocslen) moo_duputobcharswithheadroom(moo,hrb,ucs,ucslen,oocslen)
# define moo_dupootouchars(moo,oocs,oocslen,ucslen) moo_dupbtouchars(moo,oocs,oocslen,ucslen)
# define moo_duputooochars(moo,ucs,ucslen,oocslen) moo_duputobchars(moo,ucs,ucslen,oocslen)
# define moo_dupootoucstr(moo,oocs,ucslen) moo_dupbtoucstr(moo,oocs,ucslen)
@ -1455,6 +1483,22 @@ int moo_convutobcstr (
#endif
MOO_EXPORT moo_uch_t* moo_dupbtoucharswithheadroom (
moo_t* moo,
moo_oow_t headroom_bytes,
const moo_bch_t* bcs,
moo_oow_t bcslen,
moo_oow_t* ucslen
);
MOO_EXPORT moo_bch_t* moo_duputobcharswithheadroom (
moo_t* moo,
moo_oow_t headroom_bytes,
const moo_uch_t* ucs,
moo_oow_t ucslen,
moo_oow_t* bcslen
);
MOO_EXPORT moo_uch_t* moo_dupbtouchars (
moo_t* moo,
const moo_bch_t* bcs,

2
moo/lib/obj.c
View File

@ -142,7 +142,7 @@ static MOO_INLINE moo_oop_t alloc_numeric_array (moo_t* moo, const void* ptr, mo
}
else
{
/* initialize with zeros when the string pointer is not given */
/* initialize with zeros when the data pointer is NULL */
MOO_MEMSET ((hdr + 1), 0, nbytes_aligned);
}

35
moo/lib/sym.c
View File

@ -180,7 +180,40 @@ moo_oop_t moo_findsymbol (moo_t* moo, const moo_ooch_t* ptr, moo_oow_t len)
return find_or_make_symbol (moo, ptr, len, 0);
}
moo_oop_t moo_makestring (moo_t* moo, const moo_ooch_t* ptr, moo_oow_t len)
moo_oop_t moo_makestringwithbchars (moo_t* moo, const moo_bch_t* ptr, moo_oow_t len)
{
#if defined(MOO_OOCH_IS_UCH)
moo_oow_t inlen, outlen;
moo_oop_t obj;
inlen = len;
if (moo_convbtouchars (moo, ptr, &inlen, MOO_NULL, &outlen) <= -1) return MOO_NULL;
obj = moo_instantiate (moo, moo->_string, MOO_NULL, outlen);
if (!obj) return MOO_NULL;
inlen = len;
moo_convbtouchars (moo, ptr, &inlen, MOO_OBJ_GET_CHAR_SLOT(obj), &outlen);
return obj;
#else
return moo_instantiate (moo, moo->_string, ptr, len);
#endif
}
moo_oop_t moo_makestringwithuchars (moo_t* moo, const moo_uch_t* ptr, moo_oow_t len)
{
#if defined(MOO_OOCH_IS_UCH)
return moo_instantiate (moo, moo->_string, ptr, len);
#else
moo_oow_t inlen, outlen;
moo_oop_t obj;
inlen = len;
if (moo_convutobchars (moo, ptr, &inlen, MOO_NULL, &outlen) <= -1) return MOO_NULL;
obj = moo_instantiate (moo, moo->_string, MOO_NULL, outlen);
if (!obj) return MOO_NULL;
inlen = len;
moo_convutobchars (moo, ptr, &inlen, MOO_OBJ_GET_CHAR_SLOT(obj), &outlen);
return obj;
#endif
}

22
moo/lib/utl.c
View File

@ -670,7 +670,7 @@ int moo_convutobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* ucslen, moo_b
/* ----------------------------------------------------------------------- */
moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
MOO_INLINE moo_uch_t* moo_dupbtoucharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
{
moo_oow_t inlen, outlen;
moo_uch_t* ptr;
@ -682,10 +682,12 @@ moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen,
return MOO_NULL;
}
ptr = moo_allocmem (moo, (outlen + 1) * MOO_SIZEOF(moo_uch_t));
ptr = moo_allocmem (moo, headroom_bytes + ((outlen + 1) * MOO_SIZEOF(moo_uch_t)));
if (!ptr) return MOO_NULL;
inlen = bcslen;
ptr = (moo_uch_t*)((moo_oob_t*)ptr + headroom_bytes);
moo_convbtouchars (moo, bcs, &inlen, ptr, &outlen);
/* moo_convbtouchars() doesn't null-terminate the target.
@ -696,7 +698,12 @@ moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen,
return ptr;
}
moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
moo_uch_t* moo_dupbtouchars (moo_t* moo, const moo_bch_t* bcs, moo_oow_t bcslen, moo_oow_t* ucslen)
{
return moo_dupbtoucharswithheadroom (moo, 0, bcs, bcslen, ucslen);
}
MOO_INLINE moo_bch_t* moo_duputobcharswithheadroom (moo_t* moo, moo_oow_t headroom_bytes, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
{
moo_oow_t inlen, outlen;
moo_bch_t* ptr;
@ -708,10 +715,11 @@ moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen,
return MOO_NULL;
}
ptr = moo_allocmem (moo, (outlen + 1) * MOO_SIZEOF(moo_bch_t));
ptr = moo_allocmem (moo, headroom_bytes + ((outlen + 1) * MOO_SIZEOF(moo_bch_t)));
if (!ptr) return MOO_NULL;
inlen = ucslen;
ptr = (moo_bch_t*)((moo_oob_t*)ptr + headroom_bytes);
moo_convutobchars (moo, ucs, &inlen, ptr, &outlen);
ptr[outlen] = '\0';
@ -719,6 +727,11 @@ moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen,
return ptr;
}
moo_bch_t* moo_duputobchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen, moo_oow_t* bcslen)
{
return moo_duputobcharswithheadroom (moo, 0, ucs, ucslen, bcslen);
}
moo_uch_t* moo_dupbtoucstr (moo_t* moo, const moo_bch_t* bcs, moo_oow_t* ucslen)
{
moo_oow_t inlen, outlen;
@ -759,7 +772,6 @@ moo_bch_t* moo_duputobcstr (moo_t* moo, const moo_uch_t* ucs, moo_oow_t* bcslen)
return ptr;
}
/* ----------------------------------------------------------------------- */
moo_uch_t* moo_dupuchars (moo_t* moo, const moo_uch_t* ucs, moo_oow_t ucslen)