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

added SmallPointer<<getBytes, SmallPointer<<putBytes

Browse Source
This commit is contained in:
hyunghwan.chung 2017-12-09 16:04:17 +00:00
parent 541ab59028
commit 7c5afe2d5b
4 changed files with 130 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
moo/kernel/System.moo
View File

@ -72,7 +72,7 @@ class System(Apex)
if (gc)
{
System logNl: 'Exiting the GC finalization process ' & (thisProcess id) asString.
break
break.
}.
System logNl: 'Forcing garbage collection before termination in ' & (thisProcess id) asString.
@ -342,5 +342,8 @@ class SmallPointer(Object)
method(#primitive) putUint32 (offset, value).
method(#primitive) putUint64 (offset, value).
method(#primitive) getBytes (offset, byte_array, offset_in_buffer, len_in_buffer).
method(#primitive) putBytes (offset, byte_array, offset_in_buffer, len_in_buffer).
method(#primitive) free.
}

12
moo/lib/exec.c
View File

@ -3254,6 +3254,7 @@ static pf_t pftab[] =
{ "SmallPointer_asString", { pf_smptr_as_string, 0, 0 } },
{ "SmallPointer_free", { moo_pf_smptr_free, 0, 0 } },
{ "SmallPointer_getBytes", { moo_pf_smptr_get_bytes, 4, 4 } },
{ "SmallPointer_getInt16", { moo_pf_smptr_get_int16, 1, 1 } },
{ "SmallPointer_getInt32", { moo_pf_smptr_get_int32, 1, 1 } },
{ "SmallPointer_getInt64", { moo_pf_smptr_get_int64, 1, 1 } },
@ -3262,6 +3263,7 @@ static pf_t pftab[] =
{ "SmallPointer_getUint32", { moo_pf_smptr_get_uint32, 1, 1 } },
{ "SmallPointer_getUint64", { moo_pf_smptr_get_uint64, 1, 1 } },
{ "SmallPointer_getUint8", { moo_pf_smptr_get_uint8, 1, 1 } },
{ "SmallPointer_putBytes", { moo_pf_smptr_put_bytes, 4, 4 } },
{ "SmallPointer_putInt8", { moo_pf_smptr_put_int8, 2, 2 } },
{ "SmallPointer_putInt16", { moo_pf_smptr_put_int16, 2, 2 } },
{ "SmallPointer_putInt32", { moo_pf_smptr_put_int32, 2, 2 } },
@ -3275,6 +3277,7 @@ static pf_t pftab[] =
{ "System_calloc", { moo_pf_system_calloc, 1, 1 } },
{ "System_calloc:", { moo_pf_system_calloc, 1, 1 } },
{ "System_collectGarbage", { pf_system_collect_garbage, 0, 0 } },
{ "System_free", { moo_pf_system_free, 1, 1 } },
{ "System_free:", { moo_pf_system_free, 1, 1 } },
{ "System_getBytes", { moo_pf_system_get_bytes, 5, 5 } },
@ -3286,6 +3289,7 @@ static pf_t pftab[] =
{ "System_getUint32", { moo_pf_system_get_uint32, 2, 2 } },
{ "System_getUint64", { moo_pf_system_get_uint64, 2, 2 } },
{ "System_getUint8", { moo_pf_system_get_uint8, 2, 2 } },
{ "System_log", { pf_system_log, 2, MA } },
{ "System_malloc", { moo_pf_system_malloc, 1, 1 } },
{ "System_malloc:", { moo_pf_system_malloc, 1, 1 } },
{ "System_popCollectable", { pf_system_pop_collectable, 0, 0 } },
@ -3298,18 +3302,14 @@ static pf_t pftab[] =
{ "System_putUint16", { moo_pf_system_put_uint16, 3, 3 } },
{ "System_putUint32", { moo_pf_system_put_uint32, 3, 3 } },
{ "System_putUint64", { moo_pf_system_put_uint64, 3, 3 } },
{ "System_return:to:", { pf_system_return_value_to_context, 2, 2 } },
{ "System_signal:afterSecs:", { pf_system_add_timed_semaphore, 2, 2 } },
{ "System_signal:afterSecs:nanosecs:", { pf_system_add_timed_semaphore, 3, 3 } },
{ "System_signal:onInput:", { pf_system_add_input_semaphore, 2, 2 } },
{ "System_signal:onInOutput:", { pf_system_add_inoutput_semaphore, 2, 2 } },
{ "System_signal:onOutput:", { pf_system_add_output_semaphore, 2, 2 } },
{ "System_signalOnGCFin:", { pf_system_add_gcfin_semaphore, 1, 1 } },
{ "System_unsignal:", { pf_system_remove_semaphore, 1, 1 } },
{ "System_collectGarbage", { pf_system_collect_garbage, 0, 0 } },
{ "System_log", { pf_system_log, 2, MA } },
{ "System_return:to:", { pf_system_return_value_to_context, 2, 2 } }
{ "System_unsignal:", { pf_system_remove_semaphore, 1, 1 } }
};
moo_pfbase_t* moo_getpfnum (moo_t* moo, const moo_ooch_t* ptr, moo_oow_t len, moo_ooi_t* pfnum)

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

@ -1331,8 +1331,6 @@ moo_pfrc_t moo_pf_system_calloc (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_free (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_free (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_get_bytes (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_put_bytes (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_get_int8 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_get_int16 (moo_t* moo, moo_ooi_t nargs);
@ -1354,6 +1352,9 @@ moo_pfrc_t moo_pf_system_put_uint16 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_put_uint32 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_put_uint64 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_get_bytes (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_system_put_bytes (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_get_int8 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_get_int16 (moo_t* moo, moo_ooi_t nargs);
@ -1375,6 +1376,9 @@ moo_pfrc_t moo_pf_smptr_put_uint16 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_put_uint32 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_put_uint64 (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_get_bytes (moo_t* moo, moo_ooi_t nargs);
moo_pfrc_t moo_pf_smptr_put_bytes (moo_t* moo, moo_ooi_t nargs);
/* TODO: remove the following debugging functions */
/* ========================================================================= */
/* debug.c */

114
moo/lib/pf-sys.c
View File

@ -853,3 +853,117 @@ moo_pfrc_t moo_pf_smptr_put_uint64 (moo_t* moo, moo_ooi_t nargs)
/* ------------------------------------------------------------------------------------- */
moo_pfrc_t moo_pf_smptr_get_bytes (moo_t* moo, moo_ooi_t nargs)
{
moo_uint8_t* rawptr;
moo_oow_t offset, offset_in_buffer, len_in_buffer;
moo_oop_t rcv, tmp;
MOO_ASSERT (moo, nargs == 4);
rcv = MOO_STACK_GETRCV(moo, nargs);
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(rcv));
rawptr = MOO_OOP_TO_SMPTR(rcv);
tmp = MOO_STACK_GETARG(moo, nargs, 0);
if (moo_inttooow(moo, tmp, &offset) <= 0)
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw memory fetch", tmp);
return MOO_PF_FAILURE;
}
tmp = MOO_STACK_GETARG(moo, nargs, 2);
if (moo_inttooow(moo, tmp, &offset_in_buffer) <= 0)
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid buffer offset %O for raw memory fetch", tmp);
return MOO_PF_FAILURE;
}
tmp = MOO_STACK_GETARG(moo, nargs, 3);
if (moo_inttooow(moo, tmp, &len_in_buffer) <= 0)
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid buffer length %O for raw memory fetch", tmp);
return MOO_PF_FAILURE;
}
tmp = MOO_STACK_GETARG(moo, nargs, 1);
if (!MOO_OBJ_IS_BYTE_POINTER(tmp))
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid buffer %O for raw memory fetch", tmp);
return MOO_PF_FAILURE;
}
if (offset_in_buffer < MOO_OBJ_GET_SIZE(tmp))
{
moo_oow_t max_len = MOO_OBJ_GET_SIZE(tmp) - offset_in_buffer;
if (len_in_buffer > max_len) len_in_buffer = max_len;
if (len_in_buffer > MOO_SMOOI_MAX) len_in_buffer = MOO_SMOOI_MAX;
}
else len_in_buffer = 0;
if (len_in_buffer > 0)
{
MOO_MEMCPY (&((moo_oop_byte_t)tmp)->slot[offset_in_buffer], &rawptr[offset], len_in_buffer);
}
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(len_in_buffer));
return MOO_PF_SUCCESS;
}
moo_pfrc_t moo_pf_smptr_put_bytes (moo_t* moo, moo_ooi_t nargs)
{
moo_uint8_t* rawptr;
moo_oow_t offset, offset_in_buffer, len_in_buffer;
moo_oop_t rcv, tmp;
MOO_ASSERT (moo, nargs == 4);
rcv = MOO_STACK_GETRCV(moo, nargs);
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(rcv));
rawptr = MOO_OOP_TO_SMPTR(rcv);
tmp = MOO_STACK_GETARG(moo, nargs, 0);
if (moo_inttooow(moo, tmp, &offset) <= 0)
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw memory store", tmp);
return MOO_PF_FAILURE;
}
tmp = MOO_STACK_GETARG(moo, nargs, 2);
if (moo_inttooow(moo, tmp, &offset_in_buffer) <= 0)
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid buffer offset %O for raw memory fetch", tmp);
return MOO_PF_FAILURE;
}
tmp = MOO_STACK_GETARG(moo, nargs, 3);
if (moo_inttooow(moo, tmp, &len_in_buffer) <= 0)
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid buffer length %O for raw memory fetch", tmp);
return MOO_PF_FAILURE;
}
tmp = MOO_STACK_GETARG(moo, nargs, 1);
if (!MOO_OBJ_IS_BYTE_POINTER(tmp))
{
moo_seterrbfmt (moo, MOO_EINVAL, "invalid buffer %O for raw memory store", tmp);
return MOO_PF_FAILURE;
}
if (offset_in_buffer < MOO_OBJ_GET_SIZE(tmp))
{
moo_oow_t max_len = MOO_OBJ_GET_SIZE(tmp) - offset_in_buffer;
if (len_in_buffer > max_len) len_in_buffer = max_len;
if (len_in_buffer > MOO_SMOOI_MAX) len_in_buffer = MOO_SMOOI_MAX;
}
else len_in_buffer = 0;
if (len_in_buffer > 0)
{
MOO_MEMCPY (&rawptr[offset], &((moo_oop_byte_t)tmp)->slot[offset_in_buffer], len_in_buffer);
}
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(len_in_buffer));
return MOO_PF_SUCCESS;
}