1338 lines
35 KiB
C
1338 lines
35 KiB
C
/*
|
|
* $Id$
|
|
*
|
|
Copyright (c) 2014-2017 Chung, Hyung-Hwan. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WAfRRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "moo-prv.h"
|
|
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
moo_pfrc_t moo_pf_system_toggle_process_switching (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t v;
|
|
int oldnps;
|
|
|
|
oldnps = moo->no_proc_switch;
|
|
|
|
v = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (v == moo->_false)
|
|
{
|
|
/* disable process switching */
|
|
moo->no_proc_switch = 1;
|
|
}
|
|
else
|
|
{
|
|
/* enable process switching */
|
|
moo->no_proc_switch = 0;
|
|
}
|
|
|
|
MOO_STACK_SETRET (moo, nargs, (oldnps? moo->_false: moo->_true));
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_halting (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_evtcb_t* cb;
|
|
for (cb = moo->evtcb_list; cb; cb = cb->next)
|
|
{
|
|
if (cb->halting) cb->halting (moo);
|
|
}
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_find_process_by_id (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t /*rcv,*/ id;
|
|
|
|
/*rcv = MOO_STACK_GETRCV(moo, nargs);*/
|
|
id = MOO_STACK_GETARG(moo, nargs, 0);
|
|
|
|
/*MOO_PF_CHECK_RCV (moo, rcv == (moo_oop_t)moo->processor);*/
|
|
|
|
if (MOO_OOP_IS_SMOOI(id))
|
|
{
|
|
moo_ooi_t index = MOO_OOP_TO_SMOOI(id);
|
|
if (index >= 0)
|
|
{
|
|
if (MOO_CLASSOF(moo, moo->proc_map[index]) == moo->_process)
|
|
{
|
|
MOO_STACK_SETRET (moo, nargs, moo->proc_map[index]);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
/* it must be in a free list since the pid slot is not allocated. see alloc_pid() and free_pid() */
|
|
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(moo->proc_map[index]));
|
|
}
|
|
}
|
|
|
|
MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
|
|
static MOO_INLINE moo_oop_t __find_adjacent_process_by_id_noseterr (moo_t* moo, moo_ooi_t index, int find_next)
|
|
{
|
|
if (find_next)
|
|
{
|
|
moo_ooi_t end_index;
|
|
MOO_ASSERT (moo, moo->proc_map_capa <= MOO_SMOOI_MAX);
|
|
|
|
end_index = moo->proc_map_capa - 1;
|
|
if (index < -1) index = -1;
|
|
|
|
/* TOOD: enhance alloc_pid() and free_pid() to maintain the hightest pid number so that this loop can stop before reaching proc_map_capa */
|
|
while (index < end_index)
|
|
{
|
|
/* note the free slot contains a small integer which indicate the next slot index in proc_map.
|
|
* if the slot it taken, it should point to a process object. read the comment at end of this loop. */
|
|
moo_oop_t tmp;
|
|
|
|
tmp = moo->proc_map[++index];
|
|
if (MOO_CLASSOF(moo, tmp) == moo->_process) return tmp;
|
|
|
|
/* it must be in a free list since the pid slot is not allocated. see alloc_pid() and free_pid() */
|
|
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(tmp));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* find the previous one */
|
|
|
|
if (index > moo->proc_map_capa || index <= -1) index = moo->proc_map_capa;
|
|
while (index > 0)
|
|
{
|
|
moo_oop_t tmp;
|
|
|
|
tmp = moo->proc_map[--index];
|
|
if (MOO_CLASSOF(moo, tmp) == moo->_process) return tmp;
|
|
|
|
/* it must be in a free list since the pid slot is not allocated. see alloc_pid() and free_pid() */
|
|
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(tmp));
|
|
}
|
|
}
|
|
|
|
return MOO_NULL;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_find_first_process (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t tmp;
|
|
|
|
tmp = __find_adjacent_process_by_id_noseterr(moo, -1, 1);
|
|
if (tmp)
|
|
{
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_find_last_process (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t tmp;
|
|
|
|
tmp = __find_adjacent_process_by_id_noseterr(moo, moo->proc_map_capa, 0);
|
|
if (tmp)
|
|
{
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_find_previous_process (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t /*rcv,*/ id;
|
|
|
|
/*rcv = MOO_STACK_GETRCV(moo, nargs);*/
|
|
id = MOO_STACK_GETARG(moo, nargs, 0);
|
|
|
|
/*MOO_PF_CHECK_RCV (moo, rcv == (moo_oop_t)moo->processor);*/
|
|
|
|
if (id == moo->_nil)
|
|
{
|
|
id = MOO_SMOOI_TO_OOP(-1);
|
|
}
|
|
else if (MOO_CLASSOF(moo, id) == moo->_process)
|
|
{
|
|
/* the argument is a process object */
|
|
id = ((moo_oop_process_t)id)->id;
|
|
}
|
|
|
|
if (MOO_OOP_IS_SMOOI(id))
|
|
{
|
|
moo_oop_t tmp;
|
|
|
|
tmp = __find_adjacent_process_by_id_noseterr(moo, MOO_OOP_TO_SMOOI(id), 0);
|
|
if (tmp)
|
|
{
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
}
|
|
|
|
MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_find_next_process (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t /*rcv,*/ id;
|
|
|
|
/*rcv = MOO_STACK_GETRCV(moo, nargs);*/
|
|
id = MOO_STACK_GETARG(moo, nargs, 0);
|
|
|
|
/*MOO_PF_CHECK_RCV (moo, rcv == (moo_oop_t)moo->processor);*/
|
|
|
|
if (id == moo->_nil)
|
|
{
|
|
id = MOO_SMOOI_TO_OOP(-1);
|
|
}
|
|
else if (MOO_CLASSOF(moo, id) == moo->_process)
|
|
{
|
|
/* the argument is a process object */
|
|
id = ((moo_oop_process_t)id)->id;
|
|
}
|
|
|
|
if (MOO_OOP_IS_SMOOI(id))
|
|
{
|
|
moo_oop_t tmp;
|
|
|
|
tmp = __find_adjacent_process_by_id_noseterr(moo, MOO_OOP_TO_SMOOI(id), 1);
|
|
if (tmp)
|
|
{
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
}
|
|
|
|
MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
moo_pfrc_t moo_pf_system_collect_garbage (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_gc (moo, 1);
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_pop_collectable (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
if (moo->collectable.first)
|
|
{
|
|
moo_finalizable_t* first;
|
|
|
|
first = moo->collectable.first;
|
|
|
|
/* TODO: if it's already fininalized, delete it from collectable */
|
|
MOO_ASSERT (moo, MOO_OOP_IS_POINTER(first->oop));
|
|
MOO_ASSERT (moo, MOO_OBJ_GET_FLAGS_GCFIN(first->oop) & MOO_GCFIN_FINALIZABLE);
|
|
|
|
MOO_STACK_SETRET (moo, nargs, first->oop);
|
|
MOO_OBJ_SET_FLAGS_GCFIN (first->oop, MOO_OBJ_GET_FLAGS_GCFIN(first->oop) | MOO_GCFIN_FINALIZED);
|
|
|
|
MOO_DELETE_FROM_LIST (&moo->collectable, first);
|
|
moo_freemem (moo, first); /* TODO: move it to the free list instead... */
|
|
}
|
|
else
|
|
{
|
|
/*MOO_STACK_SETRET (moo, nargs, moo->_nil);*/
|
|
MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
}
|
|
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
moo_pfrc_t moo_pf_system_get_sigfd (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_ooi_t fd;
|
|
fd = moo->vmprim.vm_getsigfd(moo);
|
|
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(fd));
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_sig (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_uint8_t sig;
|
|
int n;
|
|
|
|
n = moo->vmprim.vm_getsig(moo, &sig);
|
|
if (n <= -1) return MOO_PF_FAILURE;
|
|
|
|
if (n == 0) MOO_STACK_SETRETTOERROR (moo, nargs, MOO_ENOENT);
|
|
else MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP((moo_ooi_t)sig));
|
|
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_set_sig (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t tmp;
|
|
moo_uint8_t sig;
|
|
int n;
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
MOO_PF_CHECK_ARGS (moo, nargs, MOO_OOP_IS_SMOOI(tmp));
|
|
|
|
sig = (moo_uint8_t)MOO_OOP_TO_SMOOI(tmp);
|
|
n = moo->vmprim.vm_setsig(moo, sig);
|
|
if (n <= -1) return MOO_PF_FAILURE;
|
|
|
|
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP((moo_ooi_t)sig));
|
|
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
static MOO_INLINE moo_pfrc_t _system_alloc (moo_t* moo, moo_ooi_t nargs, int clear)
|
|
{
|
|
moo_oop_t tmp;
|
|
void* ptr;
|
|
|
|
MOO_ASSERT (moo, nargs == 1);
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (!MOO_OOP_IS_SMOOI(tmp) || MOO_OOP_TO_SMOOI(tmp) < 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid size %O for raw memory allocation", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
ptr = clear? moo_callocmem(moo, MOO_OOP_TO_SMOOI(tmp)):
|
|
moo_allocmem(moo, MOO_OOP_TO_SMOOI(tmp));
|
|
if (!ptr) return MOO_PF_FAILURE;
|
|
|
|
tmp = moo_oowtoptr(moo, (moo_oow_t)ptr);
|
|
if (!tmp)
|
|
{
|
|
moo_freemem (moo, ptr);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_calloc (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
/*MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system);*/
|
|
return _system_alloc(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_malloc (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
/*MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system);*/
|
|
return _system_alloc(moo, nargs, 0);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_free (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t tmp;
|
|
moo_oow_t rawptr;
|
|
|
|
/*MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system);*/
|
|
|
|
MOO_ASSERT (moo, nargs == 1);
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, &rawptr) <= -1) return MOO_PF_FAILURE;
|
|
|
|
moo_freemem (moo, (void*)rawptr);
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_free (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t tmp;
|
|
moo_oow_t rawptr;
|
|
|
|
MOO_ASSERT (moo, nargs == 0);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
if (moo_ptrtooow(moo, tmp, &rawptr) <= -1) return MOO_PF_FAILURE;
|
|
|
|
moo_freemem (moo, (void*)rawptr);
|
|
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
#include "pack1.h"
|
|
struct st_int8_t { moo_int8_t v; };
|
|
struct st_int16_t { moo_int16_t v; };
|
|
struct st_int32_t { moo_int32_t v; };
|
|
|
|
struct st_uint8_t { moo_uint8_t v; };
|
|
struct st_uint16_t { moo_uint16_t v; };
|
|
struct st_uint32_t { moo_uint32_t v; };
|
|
|
|
#if defined(MOO_HAVE_UINT64_T)
|
|
struct st_int64_t { moo_int64_t v; };
|
|
struct st_uint64_t { moo_uint64_t v; };
|
|
#endif
|
|
#if defined(MOO_HAVE_UINT128_T)
|
|
struct st_int128_t { moo_int128_t v; };
|
|
struct st_uint128_t { moo_uint128_t v; };
|
|
#endif
|
|
#include "unpack.h"
|
|
|
|
|
|
static MOO_INLINE moo_oop_t _fetch_raw_int (moo_t* moo, moo_int8_t* rawptr, moo_oow_t offset, int size)
|
|
{
|
|
moo_ooi_t v;
|
|
|
|
switch (size)
|
|
{
|
|
case 1:
|
|
v = ((struct st_int8_t*)&rawptr[offset])->v;
|
|
break;
|
|
|
|
case 2:
|
|
v = ((struct st_int16_t*)&rawptr[offset])->v;
|
|
break;
|
|
|
|
case 4:
|
|
v = ((struct st_int32_t*)&rawptr[offset])->v;
|
|
break;
|
|
|
|
#if defined(MOO_HAVE_INT64_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_INT64_T)
|
|
case 8:
|
|
v = ((struct st_int64_t*)&rawptr[offset])->v;
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MOO_HAVE_INT128_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_INT128_T)
|
|
case 16:
|
|
v = ((struct st_int128_t*)&rawptr[offset])->v;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "unsupported size %d for raw signed memory fetch", size);
|
|
return MOO_NULL;
|
|
}
|
|
|
|
return moo_ooitoint(moo, v);
|
|
}
|
|
|
|
|
|
static MOO_INLINE moo_oop_t _fetch_raw_uint (moo_t* moo, moo_uint8_t* rawptr, moo_oow_t offset, int size)
|
|
{
|
|
moo_oow_t v;
|
|
|
|
switch (size)
|
|
{
|
|
case 1:
|
|
v = ((struct st_uint8_t*)&rawptr[offset])->v;
|
|
break;
|
|
|
|
case 2:
|
|
v = ((struct st_uint16_t*)&rawptr[offset])->v;
|
|
break;
|
|
|
|
case 4:
|
|
v = ((struct st_uint32_t*)&rawptr[offset])->v;
|
|
break;
|
|
|
|
#if defined(MOO_HAVE_UINT64_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_UINT64_T)
|
|
case 8:
|
|
v = ((struct st_uint64_t*)&rawptr[offset])->v;
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MOO_HAVE_UINT128_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_UINT128_T)
|
|
case 16:
|
|
v = ((struct st_uint128_t*)&rawptr[offset])->v;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "unsupported size %d for raw unsigned memory fetch", size);
|
|
return MOO_NULL;
|
|
}
|
|
|
|
return moo_oowtoint(moo, v);
|
|
}
|
|
|
|
static MOO_INLINE int _store_raw_int (moo_t* moo, moo_uint8_t* rawptr, moo_oow_t offset, int size, moo_oop_t voop)
|
|
{
|
|
int n;
|
|
moo_ooi_t w, max, min;
|
|
|
|
if ((n = moo_inttoooi_noseterr(moo, voop, &w)) == 0) /* not convertable */
|
|
{
|
|
moo_seterrbfmt (moo, moo_geterrnum(moo), "invalid value %O for raw signed memory store", voop);
|
|
return -1;
|
|
}
|
|
|
|
/* assume 2's complement */
|
|
max = (moo_ooi_t)(~(moo_oow_t)0 >> ((MOO_SIZEOF_OOW_T - size) * MOO_BITS_PER_BYTE + 1));
|
|
min = -max - 1;
|
|
|
|
if (w > max || w < min)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_ERANGE, "value %zd out of supported range for raw signed memory store", w);
|
|
return -1;
|
|
}
|
|
|
|
n = 0;
|
|
switch (size)
|
|
{
|
|
case 1:
|
|
((struct st_int8_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
|
|
case 2:
|
|
((struct st_int16_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
|
|
case 4:
|
|
((struct st_int32_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
|
|
#if defined(MOO_HAVE_INT64_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_INT64_T)
|
|
case 8:
|
|
((struct st_int64_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MOO_HAVE_INT128_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_INT128_T)
|
|
case 16:
|
|
((struct st_int128_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "unsupported size %d for raw signed memory store", size);
|
|
n = -1;
|
|
}
|
|
|
|
|
|
return n;
|
|
}
|
|
|
|
static MOO_INLINE int _store_raw_uint (moo_t* moo, moo_uint8_t* rawptr, moo_oow_t offset, int size, moo_oop_t voop)
|
|
{
|
|
int n;
|
|
moo_oow_t w, max;
|
|
|
|
if ((n = moo_inttooow_noseterr(moo, voop, &w)) <= 0)
|
|
{
|
|
if (n <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_ERANGE, "negative value %O for raw unsigned memory store", voop);
|
|
}
|
|
else
|
|
{
|
|
moo_seterrbfmt (moo, moo_geterrnum(moo), "invalid value %O for raw unsigned memory store", voop);
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
max = (~(moo_oow_t)0 >> ((MOO_SIZEOF_OOW_T - size) * MOO_BITS_PER_BYTE));
|
|
if (w > max)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_ERANGE, "value %ju out of supported range for raw unsigned memory store", w);
|
|
return -1;
|
|
}
|
|
|
|
n = 0;
|
|
switch (size)
|
|
{
|
|
case 1:
|
|
((struct st_uint8_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
|
|
case 2:
|
|
((struct st_uint16_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
|
|
case 4:
|
|
((struct st_uint32_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
|
|
#if defined(MOO_HAVE_UINT64_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_UINT64_T)
|
|
case 8:
|
|
((struct st_uint64_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
#endif
|
|
|
|
#if defined(MOO_HAVE_UINT128_T) && (MOO_SIZEOF_OOW_T >= MOO_SIZEOF_UINT128_T)
|
|
case 16:
|
|
((struct st_uint128_t*)&rawptr[offset])->v = w;
|
|
break;
|
|
#endif
|
|
|
|
default:
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "unsupported size %d for raw unsigned memory store", size);
|
|
n = -1;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
static moo_pfrc_t _get_system_int (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_int8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t tmp;
|
|
|
|
/* MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system); */
|
|
|
|
MOO_ASSERT (moo, nargs == 2);
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw signed memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 1);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw signed memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = _fetch_raw_int(moo, rawptr, offset, size);
|
|
if (!tmp) return MOO_PF_FAILURE;
|
|
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
static moo_pfrc_t _get_system_uint (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t tmp;
|
|
|
|
/* MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system); */
|
|
|
|
MOO_ASSERT (moo, nargs == 2);
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw unsigned memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 1);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw unsigned memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = _fetch_raw_uint(moo, rawptr, offset, size);
|
|
if (!tmp) return MOO_PF_FAILURE;
|
|
|
|
MOO_STACK_SETRET (moo, nargs, tmp);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
|
|
moo_pfrc_t moo_pf_system_get_int8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_int(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_int16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_int(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_int32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_int(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_int64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_int(moo, nargs, 8);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_uint8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_uint(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_uint16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_uint(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_uint32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_uint(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_get_uint64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_system_uint(moo, nargs, 8);
|
|
}
|
|
|
|
static moo_pfrc_t _put_system_int (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t tmp;
|
|
|
|
/* MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system); */
|
|
|
|
MOO_ASSERT (moo, nargs == 3);
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw signed memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 1);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw signed memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
if (_store_raw_int(moo, rawptr, offset, size, MOO_STACK_GETARG(moo, nargs, 2)) <= -1)
|
|
{
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
static moo_pfrc_t _put_system_uint (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t tmp;
|
|
|
|
/* MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system); */
|
|
|
|
MOO_ASSERT (moo, nargs == 3);
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw unsigned memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 1);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw unsigned memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
if (_store_raw_uint(moo, rawptr, offset, size, MOO_STACK_GETARG(moo, nargs, 2)) <= -1)
|
|
{
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_int8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_int(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_int16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_int(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_int32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_int(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_int64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_int(moo, nargs, 8);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_uint8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_uint(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_uint16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_uint(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_uint32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_uint(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_system_put_uint64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_system_uint(moo, nargs, 8);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
|
|
moo_pfrc_t moo_pf_system_get_bytes (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset, offset_in_buffer, len_in_buffer;
|
|
moo_oop_t tmp;
|
|
|
|
/* MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system); */
|
|
|
|
MOO_ASSERT (moo, nargs == 5);
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 1);
|
|
if (moo_inttooow_noseterr(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, 3);
|
|
if (moo_inttooow_noseterr(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, 4);
|
|
if (moo_inttooow_noseterr(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, 2);
|
|
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_OBJ_GET_BYTE_PTR(tmp, 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_system_put_bytes (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset, offset_in_buffer, len_in_buffer;
|
|
moo_oop_t tmp;
|
|
|
|
/* MOO_PF_CHECK_RCV (moo, MOO_STACK_GETRCV(moo, nargs) == (moo_oop_t)moo->_system); */
|
|
|
|
MOO_ASSERT (moo, nargs == 5);
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 1);
|
|
if (moo_inttooow_noseterr(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, 3);
|
|
if (moo_inttooow_noseterr(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, 4);
|
|
if (moo_inttooow_noseterr(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, 2);
|
|
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_OBJ_GET_BYTE_PTR(tmp, offset_in_buffer), len_in_buffer);
|
|
}
|
|
|
|
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(len_in_buffer));
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
static moo_pfrc_t _get_smptr_int (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_oop_t tmp;
|
|
moo_int8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t result;
|
|
|
|
MOO_ASSERT (moo, nargs == 1);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw signed memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
result = _fetch_raw_int(moo, rawptr, offset, size);
|
|
if (!result) return MOO_PF_FAILURE;
|
|
|
|
MOO_STACK_SETRET (moo, nargs, result);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
static moo_pfrc_t _get_smptr_uint (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_oop_t tmp;
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t result;
|
|
|
|
MOO_ASSERT (moo, nargs == 1);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw unsigned memory fetch", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
result = _fetch_raw_uint(moo, rawptr, offset, size);
|
|
if (!result) return MOO_PF_FAILURE;
|
|
|
|
MOO_STACK_SETRET (moo, nargs, result);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_int8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_int(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_int16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_int(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_int32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_int(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_int64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_int(moo, nargs, 8);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_uint8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_uint(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_uint16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_uint(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_uint32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_uint(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_uint64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _get_smptr_uint(moo, nargs, 8);
|
|
}
|
|
|
|
static moo_pfrc_t _put_smptr_int (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t tmp;
|
|
|
|
MOO_ASSERT (moo, nargs == 2);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw signed memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
if (_store_raw_int(moo, rawptr, offset, size, MOO_STACK_GETARG(moo, nargs, 1)) <= -1)
|
|
{
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
static moo_pfrc_t _put_smptr_uint (moo_t* moo, moo_ooi_t nargs, int size)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset;
|
|
moo_oop_t tmp;
|
|
|
|
MOO_ASSERT (moo, nargs == 2);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_inttooow_noseterr(moo, tmp, &offset) <= 0)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid offset %O for raw unsigned memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
if (_store_raw_uint(moo, rawptr, offset, size, MOO_STACK_GETARG(moo, nargs, 1)) <= -1)
|
|
{
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
MOO_STACK_SETRETTORCV (moo, nargs);
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_int8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_int(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_int16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_int(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_int32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_int(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_int64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_int(moo, nargs, 8);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_uint8 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_uint(moo, nargs, 1);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_uint16 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_uint(moo, nargs, 2);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_uint32 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_uint(moo, nargs, 4);
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_put_uint64 (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
return _put_smptr_uint(moo, nargs, 8);
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------------------------- */
|
|
|
|
moo_pfrc_t moo_pf_smptr_get_bytes (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset, offset_in_buffer, len_in_buffer;
|
|
moo_oop_t tmp;
|
|
|
|
MOO_ASSERT (moo, nargs == 4);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_inttooow_noseterr(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_noseterr(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_noseterr(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_OBJ_GET_BYTE_PTR(tmp, 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_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_uint8_t* rawptr;
|
|
moo_oow_t offset, offset_in_buffer, len_in_buffer;
|
|
moo_oop_t tmp;
|
|
|
|
MOO_ASSERT (moo, nargs == 4);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for raw memory store", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
tmp = MOO_STACK_GETARG(moo, nargs, 0);
|
|
if (moo_inttooow_noseterr(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_noseterr(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_noseterr(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_OBJ_GET_BYTE_PTR(tmp, offset_in_buffer), len_in_buffer);
|
|
}
|
|
|
|
MOO_STACK_SETRET (moo, nargs, MOO_SMOOI_TO_OOP(len_in_buffer));
|
|
return MOO_PF_SUCCESS;
|
|
}
|
|
|
|
|
|
static void sprintptr (moo_ooch_t* nbuf, moo_oow_t num, moo_oow_t *lenp)
|
|
{
|
|
static const moo_ooch_t hex2ascii_upper[] =
|
|
{
|
|
'0','1','2','3','4','5','6','7','8','9',
|
|
'A','B','C','D','E','F','G','H','I','J','K','L','M',
|
|
'N','O','P','Q','R','S','T','U','V','W','X','H','Z'
|
|
};
|
|
moo_ooch_t* p, * end, ch;
|
|
|
|
p = nbuf;
|
|
*p = '\0';
|
|
do { *++p = hex2ascii_upper[num % 16]; } while (num /= 16);
|
|
*++p = 'r';
|
|
*++p = '6';
|
|
*++p = '1';
|
|
*lenp = p - nbuf;
|
|
|
|
end = p;
|
|
p = nbuf;
|
|
while (p <= end)
|
|
{
|
|
ch = *p;
|
|
*p++ = *end;
|
|
*end-- = ch;
|
|
}
|
|
}
|
|
|
|
moo_pfrc_t moo_pf_smptr_as_string (moo_t* moo, moo_mod_t* mod, moo_ooi_t nargs)
|
|
{
|
|
moo_oop_t tmp;
|
|
void* rawptr;
|
|
moo_ooch_t buf[MOO_SIZEOF_OOW_T * 2 + 4];
|
|
moo_oow_t len;
|
|
moo_oop_t ss;
|
|
|
|
MOO_ASSERT (moo, nargs == 0);
|
|
|
|
tmp = MOO_STACK_GETRCV(moo, nargs);
|
|
MOO_PF_CHECK_RCV (moo, MOO_OOP_IS_SMPTR(tmp) || MOO_CLASSOF(moo, tmp) == moo->_large_pointer);
|
|
|
|
if (moo_ptrtooow(moo, tmp, (moo_oow_t*)&rawptr) <= -1)
|
|
{
|
|
moo_seterrbfmt (moo, MOO_EINVAL, "invalid pointer %O for string conversion", tmp);
|
|
return MOO_PF_FAILURE;
|
|
}
|
|
|
|
sprintptr (buf, (moo_oow_t)rawptr, &len);
|
|
|
|
ss = moo_makestring(moo, buf, len);
|
|
if (!ss) return MOO_PF_FAILURE;
|
|
|
|
MOO_STACK_SETRET (moo, nargs, ss);
|
|
return MOO_PF_SUCCESS;
|
|
}
|