typedef unsigned long ruword;
typedef long rword;
-
-#ifndef _RSIZE_T_DEFINED
-typedef unsigned long rsize_t;
-#define _RSIZE_T_DEFINED
-#endif
-
-#ifndef _RSSIZE_T_DEFINED
-typedef signed long rssize_t;
-#define _RSSIZE_T_DEFINED
-#endif
-
/*
* Common types. These types should be the same for most of the architectures.
*/
typedef unsigned long ruword;
typedef long rword;
-#ifndef _RSIZE_T_DEFINED
-typedef unsigned long rsize_t;
-#define _RSIZE_T_DEFINED
-#endif
-
-#ifndef _RSSIZE_T_DEFINED
-typedef signed long rssize_t;
-#define _RSSIZE_T_DEFINED
-#endif
-
/*
* Common types. These types should be the same for most of the architectures.
typedef long rword;
typedef unsigned int ratomic_t;
-#ifndef _RSIZE_T_DEFINED
-typedef unsigned long rsize_t;
-#define _RSIZE_T_DEFINED
-#endif
-
-#ifndef _RSSIZE_T_DEFINED
-typedef signed long rssize_t;
-#define _RSSIZE_T_DEFINED
-#endif
-
/*
* Common types. These types should be the same for most of the architectures.
typedef unsigned long ruword;
typedef long rword;
-#ifndef _RSIZE_T_DEFINED
-typedef unsigned long rsize_t;
-#define _RSIZE_T_DEFINED
-#endif
-
-#ifndef _RSSIZE_T_DEFINED
-typedef signed long rssize_t;
-#define _RSSIZE_T_DEFINED
-#endif
-
/*
* Common types. These types should be the same for most of the architectures.
*/
typedef ruint64 ruword;
typedef rint64 rword;
-#ifndef _RSIZE_T_DEFINED
-typedef unsigned long rsize_t;
-#define _RSIZE_T_DEFINED
-#endif
-
-#ifndef _RSSIZE_T_DEFINED
-typedef long rssize_t;
-#define _RSSIZE_T_DEFINED
-#endif
-
/*
* Common types. These types should be the same for most of the architectures.
*/
typedef const void *rconstpointer;
typedef struct {ruint32 p1; ruint32 p2;} rpair_t;
+
/*
* Atomic operations (Architecture Dependent)
*/
}
-rpa_buffer_t * rpa_buffer_alloc(unsigned int size)
+rpa_buffer_t * rpa_buffer_alloc(unsigned long size)
{
rpa_buffer_t * str;
displayed = 1;
rpa_grep_print_filename(pGrep);
}
- rpa_grep_output(pGrep, lstart, lend - lstart, pGrep->encoding);
+ rpa_grep_output(pGrep, lstart, (unsigned long)(lend - lstart), pGrep->encoding);
}
if (lend < end) {
lstart = lend;
rpa_buffer_t *rpa_buffer_loadfile(FILE *pFile)
{
- unsigned int memchunk = 256;
- int ret = 0, inputsize = 0;
+ unsigned long memchunk = 256;
+ long ret = 0, inputsize = 0;
rpa_buffer_t *buf;
buf = rpa_buffer_alloc(2 * memchunk);
exit(1);
}
}
- ret = fread(&buf->s[inputsize], 1, memchunk - 1, pFile);
+ ret = (long)fread(&buf->s[inputsize], 1, memchunk - 1, pFile);
if ((ret <= 0) && ferror(pFile)) {
rpa_buffer_destroy(buf);
return (void*)0;
void rpa_grep_output_utf8_string(rpa_grep_t *pGrep, const char *s)
{
- rpa_grep_output(pGrep, s, strlen(s), RPA_ENCODING_UTF8);
+ rpa_grep_output(pGrep, s, r_strlen(s), RPA_ENCODING_UTF8);
}
void rpa_grep_optimizations(rpa_grep_t *pGrep, unsigned long allow);
void rpa_buffer_destroy(rpa_buffer_t *str);
-rpa_buffer_t * rpa_buffer_alloc(unsigned int size);
+rpa_buffer_t * rpa_buffer_alloc(unsigned long size);
rpa_buffer_t *rpa_buffer_loadfile(FILE *pFile);
rpa_buffer_t * rpa_buffer_load_file_utf8(const char *filename);
{
rpa_buffer_t *buf;
int ret;
- size_t wideLen = wcslen(wstr) + 1;
- size_t sizeNeeded = WideCharToMultiByte(
+ int wideLen = (int)wcslen(wstr) + 1;
+ int sizeNeeded = WideCharToMultiByte(
CP_UTF8,
0,
wstr,
void rjs_engine_destroy(rjs_engine_t *jse)
{
- rsize_t i;
+ unsigned long i;
if (jse) {
if (jse->cgs) {
for (i = 0; i < r_array_length(jse->cgs); i++) {
}
-static int rjs_engine_parse(rjs_engine_t *jse, const char *script, rsize_t size, rarray_t *records, rjs_error_t *error)
+static int rjs_engine_parse(rjs_engine_t *jse, const char *script, unsigned long size, rarray_t *records, rjs_error_t *error)
{
long res = 0;
}
-int rjs_engine_compile(rjs_engine_t *jse, const char *script, rsize_t size)
+int rjs_engine_compile(rjs_engine_t *jse, const char *script, unsigned long size)
{
rvm_codegen_t *topcg = NULL;
rarray_t *records = rpa_records_create();
}
-int rjs_engine_dumpast(rjs_engine_t *jse, const char *script, rsize_t size)
+int rjs_engine_dumpast(rjs_engine_t *jse, const char *script, unsigned long size)
{
rjs_error_t error;
rarray_t *records = rpa_records_create();
}
if (jse->cpu->error == RVM_E_USERABORT) {
- long idx = RVM_CPUREG_GETIP(jse->cpu, PC) - rvm_codegen_getcode(cg, 0);
+ rword idx = RVM_CPUREG_GETIP(jse->cpu, PC) - rvm_codegen_getcode(cg, 0);
if (idx >= 0) {
- r_printf("Aborted at source index: %ld\n", rvm_codegen_getsource(cg, idx));
+ r_printf("Aborted at source index: %ld\n", rvm_codegen_getsource(cg, (unsigned long)idx));
}
}
-
return res;
}
-rvmreg_t * rjs_engine_exec(rjs_engine_t *jse, const char *script, rsize_t size)
+rvmreg_t * rjs_engine_exec(rjs_engine_t *jse, const char *script, unsigned long size)
{
if (rjs_engine_compile(jse, script, size) < 0)
return NULL;
index = r_map_lookup_s(a, -1, "count");
R_ASSERT(index >= 0);
count = (rvmreg_t *)r_map_value(a, index);
- r_map_add_l(a, RVM_REG_GETL(count), arg);
+ r_map_add_l(a, (long)RVM_REG_GETL(count), arg);
rvm_reg_setsigned(count, RVM_REG_GETL(count) + 1);
return 0;
}
-rvmreg_t *rjs_engine_vexec(rjs_engine_t *jse, const char *script, rsize_t size, rsize_t nargs, va_list args)
+rvmreg_t *rjs_engine_vexec(rjs_engine_t *jse, const char *script, unsigned long size, unsigned long nargs, va_list args)
{
rvmreg_t arg;
- rsize_t i = 0;
+ unsigned long i = 0;
if (rjs_engine_compile(jse, script, size) < 0)
return NULL;
}
-rvmreg_t *rjs_engine_args_exec(rjs_engine_t *jse, const char *script, rsize_t size, rsize_t nargs, ...)
+rvmreg_t *rjs_engine_args_exec(rjs_engine_t *jse, const char *script, unsigned long size, unsigned long nargs, ...)
{
rvmreg_t *ret;
va_list args;
}
-rvmreg_t *rjs_engine_args_exec_s(rjs_engine_t *jse, const char *script, rsize_t nargs, ...)
+rvmreg_t *rjs_engine_args_exec_s(rjs_engine_t *jse, const char *script, unsigned long nargs, ...)
{
rvmreg_t *ret;
va_list args;
rjs_engine_t *rjs_engine_create();
void rjs_engine_destroy(rjs_engine_t *jse);
int rjs_engine_open(rjs_engine_t *jse);
-int rjs_engine_compile(rjs_engine_t *jse, const char *script, rsize_t size);
+int rjs_engine_compile(rjs_engine_t *jse, const char *script, unsigned long size);
int rjs_engine_compile_s(rjs_engine_t *jse, const char *script);
int rjs_engine_close(rjs_engine_t *jse);
int rjs_engine_run(rjs_engine_t *jse);
int rjs_engine_addswitable(rjs_engine_t *jse, const char *tabname, rvm_switable_t *switalbe);
-int rjs_engine_dumpast(rjs_engine_t *jse, const char *script, rsize_t size);
-rvmreg_t *rjs_engine_exec(rjs_engine_t *jse, const char *script, rsize_t size);
-rvmreg_t *rjs_engine_vexec(rjs_engine_t *jse, const char *script, rsize_t size, rsize_t nargs, va_list args);
-rvmreg_t *rjs_engine_args_exec(rjs_engine_t *jse, const char *script, rsize_t size, rsize_t nargs, ...);
-rvmreg_t *rjs_engine_args_exec_s(rjs_engine_t *jse, const char *script, rsize_t nargs, ...);
+int rjs_engine_dumpast(rjs_engine_t *jse, const char *script, unsigned long size);
+rvmreg_t *rjs_engine_exec(rjs_engine_t *jse, const char *script, unsigned long size);
+rvmreg_t *rjs_engine_vexec(rjs_engine_t *jse, const char *script, unsigned long size, unsigned long nargs, va_list args);
+rvmreg_t *rjs_engine_args_exec(rjs_engine_t *jse, const char *script, unsigned long size, unsigned long nargs, ...);
+rvmreg_t *rjs_engine_args_exec_s(rjs_engine_t *jse, const char *script, unsigned long nargs, ...);
rvmreg_t *rjs_engine_exec_s(rjs_engine_t *jse, const char *script);
void rjs_engine_abort(rjs_engine_t *jse, rjs_error_t *error);
rjs_engine_t *rjs_engine_get(rvmcpu_t *cpu);
static const char *rjs_compiler_record2str(rjs_compiler_t *co, rarray_t *records, long rec)
{
rparecord_t *prec = (rparecord_t *)r_array_slot(records, rpa_recordtree_get(records, rec, RPA_RECORD_END));
- rsize_t size = 16; /* Min size */
+ unsigned long size = 16; /* Min size */
if (prec && prec->inputsiz) {
size = prec->inputsiz + 1;
long rjs_compiler_record2opcode(rparecord_t *prec)
{
const char *input = prec->input;
- rsize_t size = prec->inputsiz;
+ unsigned long size = prec->inputsiz;
if (r_stringncmp("++", input, size))
return RVM_EADD;
long rjs_compiler_record2unaryopcode(rparecord_t *prec)
{
const char *input = prec->input;
- rsize_t size = prec->inputsiz;
+ unsigned long size = prec->inputsiz;
if (r_stringncmp("+", input, size))
return RVM_NOP;
rjs_compiler_debughead(co, records, rec);
rvm_codegen_addins(co->cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
rvm_codegen_redefinelabel_default(co->cg, mainidx);
- rvm_codegen_addins(co->cg, rvm_asm(RVM_BL, DA, XX, XX, start - rvm_codegen_getcodesize(co->cg)));
+ rvm_codegen_addins(co->cg, rvm_asm(RVM_BL, DA, XX, XX, start - (long)rvm_codegen_getcodesize(co->cg)));
rvm_codegen_addins(co->cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
rjs_compiler_debugtail(co, records, rec);
r_array_removelast(co->coctx);
}
-int rjs_compiler_compile(rjs_compiler_t *co, const char *script, rsize_t scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error)
+int rjs_compiler_compile(rjs_compiler_t *co, const char *script, unsigned long scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error)
{
long i;
rvm_codelabel_t *labelerr;
typedef struct rjs_coctx_global_s {
rjs_coctx_t base;
- rsize_t stackallocs;
+ unsigned long stackallocs;
} rjs_coctx_global_t;
long endidx;
long allocsidx;
long execoff;
- rsize_t stackallocs;
+ unsigned long stackallocs;
} rjs_coctx_function_t;
typedef struct rjs_coctx_functioncall_s {
rjs_coctx_t base;
- rsize_t arguments;
+ unsigned long arguments;
unsigned char setthis;
} rjs_coctx_functioncall_t;
char *temp;
rstr_t stringcharacters;
const char *script;
- rsize_t scriptsize;
+ unsigned long scriptsize;
long headoff;
long opcode;
unsigned long debug:1;
rjs_compiler_t *rjs_compiler_create(rvmcpu_t *cpu);
void rjs_compiler_destroy(rjs_compiler_t *co);
-int rjs_compiler_compile(rjs_compiler_t *co, const char *script, rsize_t scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error);
+int rjs_compiler_compile(rjs_compiler_t *co, const char *script, unsigned long scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error);
rjs_coctx_t *rjs_compiler_getctx(rjs_compiler_t *co, unsigned long type);
#ifdef __cplusplus
static void rjs_exec_ltrim(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
const char *ptr, *list;
- rsize_t size;
+ unsigned long size;
rvmreg_t *r = NULL, *l = NULL;
rstring_t *src, *dest;
static void rjs_exec_rtrim(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
const char *ptr, *list;
- rsize_t size;
+ unsigned long size;
rvmreg_t *r = NULL, *l = NULL;
rstring_t *src, *dest;
static void rjs_exec_trim(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
const char *start, *ptr, *list;
- rsize_t size;
+ unsigned long size;
rvmreg_t *r = NULL, *l = NULL;
rstring_t *src, *dest;
void rjs_display_errors(rjs_engine_t *jse, rstr_t *script)
{
- rsize_t i;
+ unsigned long i;
rjs_error_t *err;
for (i = 0; i < r_array_length(jse->errors); i++) {
}
-long rjs_parser_exec(rjs_parser_t *parser, const char *script, rsize_t size, rarray_t *ast, rjs_error_t *error)
+long rjs_parser_exec(rjs_parser_t *parser, const char *script, unsigned long size, rarray_t *ast, rjs_error_t *error)
{
long res = 0;
rpastat_t *stat = rpa_stat_create(parser->dbex, 4096);
rjs_parser_t *rjs_parser_create();
void rjs_parser_destroy(rjs_parser_t *parser);
-long rjs_parser_exec(rjs_parser_t *parser, const char *script, rsize_t size, rarray_t *ast, rjs_error_t *error);
+long rjs_parser_exec(rjs_parser_t *parser, const char *script, unsigned long size, rarray_t *ast, rjs_error_t *error);
long rjs_parser_offset2line(const char *script, long offset);
long rjs_parser_offset2lineoffset(const char *script, long offset);
#include "rtypes.h"
const char *rjs_rules_get();
-rsize_t rjs_rules_size();
+unsigned long rjs_rules_size();
#ifdef __cplusplus
}
-rsize_t rjs_rules_size()
+unsigned long rjs_rules_size()
{
- rsize_t size = _binary_____________rjs_ecma262_rpa_end - _binary_____________rjs_ecma262_rpa_start;
+ unsigned long size = _binary_____________rjs_ecma262_rpa_end - _binary_____________rjs_ecma262_rpa_start;
return size;
}
pMappedView = (char*)MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
if (NULL == pMappedView)
goto error;
- buf->size = (rsize_t)fileSize;
- buf->str = (char*)r_zmalloc((rsize_t)fileSize + 1);
+ buf->size = (unsigned long)fileSize;
+ buf->str = (char*)r_zmalloc((unsigned long)fileSize + 1);
if (!buf->str)
goto error;
- r_memcpy(buf->str, pMappedView, (rsize_t)fileSize);
+ r_memcpy(buf->str, pMappedView, (unsigned long)fileSize);
if (hMapping)
CloseHandle(hMapping);
if (hFile != INVALID_HANDLE_VALUE)
}
-rsize_t rjs_rules_size()
+unsigned long rjs_rules_size()
{
if (!rules)
LoadRulesFromResource(IDR_ECMA262, TEXTFILE, &rules_size, &rules);
#define MIN_ARRAY_LEN 2
-static void r_array_checkexpand(rarray_t *array, rsize_t index);
+static void r_array_checkexpand(rarray_t *array, unsigned long index);
void r_array_cleanup(robject_t *obj)
}
-robject_t *r_array_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, rsize_t elt_size)
+robject_t *r_array_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, unsigned long elt_size)
{
rarray_t *array = (rarray_t*)obj;
}
-rarray_t *r_array_create(rsize_t elt_size)
+rarray_t *r_array_create(unsigned long elt_size)
{
rarray_t *array;
array = (rarray_t*)r_object_create(sizeof(*array));
robject_t *r_array_copy(const robject_t *obj)
{
- rsize_t i;
+ unsigned long i;
rarray_t *dst;
const rarray_t *array = (const rarray_t *)obj;
}
-static void r_array_exist_replace(rarray_t *array, rsize_t index, rconstpointer data)
+static void r_array_exist_replace(rarray_t *array, unsigned long index, rconstpointer data)
{
if (data)
r_memcpy(r_array_slot(array, index), data, array->elt_size);
}
-rsize_t r_array_add(rarray_t *array, rconstpointer data)
+unsigned long r_array_add(rarray_t *array, rconstpointer data)
{
- rsize_t index = r_array_length(array);
+ unsigned long index = r_array_length(array);
r_array_setlength(array, index + 1);
r_array_exist_replace(array, index, data);
}
-rsize_t r_array_removelast(rarray_t *array)
+unsigned long r_array_removelast(rarray_t *array)
{
if (!r_array_empty(array))
r_array_setlength(array, r_array_length(array) - 1);
}
-rsize_t r_array_insert(rarray_t *array, rsize_t index, rconstpointer data)
+unsigned long r_array_insert(rarray_t *array, unsigned long index, rconstpointer data)
{
r_array_checkexpand(array, index + 1);
if (index < r_array_length(array)) {
- rsize_t curlen = r_array_length(array);
+ unsigned long curlen = r_array_length(array);
r_array_setlength(array, r_array_length(array) + 1);
r_memmove(r_array_slot(array, index + 1), r_array_slot(array, index), (curlen - index) * array->elt_size);
} else {
}
-rsize_t r_array_replace(rarray_t *array, rsize_t index, rconstpointer data)
+unsigned long r_array_replace(rarray_t *array, unsigned long index, rconstpointer data)
{
if (index >= r_array_length(array))
return r_array_insert(array, index, data);
}
-rsize_t r_array_setlength(rarray_t *array, rsize_t len)
+unsigned long r_array_setlength(rarray_t *array, unsigned long len)
{
r_array_checkexpand(array, len);
r_array_length(array) = len;
}
-rsize_t r_array_expand(rarray_t *array, rsize_t len)
+unsigned long r_array_expand(rarray_t *array, unsigned long len)
{
return r_array_setlength(array, r_array_length(array) + len);
}
-static void r_array_checkexpand(rarray_t *array, rsize_t len)
+static void r_array_checkexpand(rarray_t *array, unsigned long len)
{
- rsize_t nalloc_size;
+ unsigned long nalloc_size;
rpointer data;
if (array->alloc_size < len) {
nalloc_size = 2 * nalloc_size + 1;
data = r_realloc(array->data, nalloc_size * array->elt_size);
if (data) {
- rsize_t old_len = array->alloc_size;
+ unsigned long old_len = array->alloc_size;
array->data = data;
array->alloc_size = nalloc_size;
}
-void *r_array_slot_expand(rarray_t *array, rsize_t index)
+void *r_array_slot_expand(rarray_t *array, unsigned long index)
{
r_array_checkexpand(array, index+1);
return (void*) r_array_slot(array, index);
}
-int r_array_move(rarray_t *array, rsize_t dest, rsize_t src, rsize_t size)
+int r_array_move(rarray_t *array, unsigned long dest, unsigned long src, unsigned long size)
{
- rsize_t i;
+ unsigned long i;
if (src == dest)
return 0;
if (r_array_length(array) <= src || size <= 0)
}
-void r_array_delete(rarray_t *array, rsize_t index)
+void r_array_delete(rarray_t *array, unsigned long index)
{
- rsize_t movesize;
- rsize_t moveindex;
+ unsigned long movesize;
+ unsigned long moveindex;
if (r_array_length(array) <= index)
return;
struct rarray_s {
robject_t obj;
rpointer *data;
- rsize_t len;
- rsize_t alloc_size;
- rsize_t elt_size;
+ unsigned long len;
+ unsigned long alloc_size;
+ unsigned long elt_size;
r_array_callback oncleanup;
r_array_callback oncopy;
rpointer *user;
};
-#define r_array_size(__array__) ((__array__)->alloc_size)
-#define r_array_length(__array__) ((__array__)->len)
+#define r_array_size(__array__) (__array__)->alloc_size
+#define r_array_length(__array__) (__array__)->len
#define r_array_empty(__array__) ((r_array_length(__array__)) ? 0 : 1)
#define r_array_last(__array__, __type__) (r_array_index(__array__, (__array__)->len - 1, __type__))
#define r_array_inclast(__array__, __type__) (*((__type__*)(r_array_lastslot(__array__))) += 1)
#define r_array_push(__array__, __val__, __type__) do {__type__ __v__ = (__type__)__val__; r_array_add(__array__, &__v__); } while(0)
#define r_array_pop(__array__, __type__) (r_array_index(__array__, (__array__)->len ? --(__array__)->len : 0, __type__))
-robject_t *r_array_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, rsize_t elt_size);
-rarray_t *r_array_create(rsize_t elt_size);
+robject_t *r_array_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, unsigned long elt_size);
+rarray_t *r_array_create(unsigned long elt_size);
void r_array_destroy(rarray_t *array);
-rsize_t r_array_add(rarray_t *array, rconstpointer data);
-int r_array_move(rarray_t *array, rsize_t dest, rsize_t src, rsize_t size);
-rsize_t r_array_removelast(rarray_t *array);
-rsize_t r_array_insert(rarray_t *array, rsize_t index, rconstpointer data);
-rsize_t r_array_replace(rarray_t *array, rsize_t index, rconstpointer data);
-rsize_t r_array_setlength(rarray_t *array, rsize_t len);
-rsize_t r_array_expand(rarray_t *array, rsize_t len);
-void *r_array_slot_expand(rarray_t *array, rsize_t index);
-void r_array_delete(rarray_t *array, rsize_t index);
+unsigned long r_array_add(rarray_t *array, rconstpointer data);
+int r_array_move(rarray_t *array, unsigned long dest, unsigned long src, unsigned long size);
+unsigned long r_array_removelast(rarray_t *array);
+unsigned long r_array_insert(rarray_t *array, unsigned long index, rconstpointer data);
+unsigned long r_array_replace(rarray_t *array, unsigned long index, rconstpointer data);
+unsigned long r_array_setlength(rarray_t *array, unsigned long len);
+unsigned long r_array_expand(rarray_t *array, unsigned long len);
+void *r_array_slot_expand(rarray_t *array, unsigned long index);
+void r_array_delete(rarray_t *array, unsigned long index);
/*
* Virtual methods implementation
#include "rlib/rmem.h"
-static rpointer r_carray_allocate_chunk(rsize_t elt_size)
+static rpointer r_carray_allocate_chunk(unsigned long elt_size)
{
return r_zmalloc(R_CARRAY_CHUNKSIZE * elt_size);
}
-static rpointer r_carray_get_chunk(const rcarray_t *carray, rsize_t nchunk)
+static rpointer r_carray_get_chunk(const rcarray_t *carray, unsigned long nchunk)
{
return r_array_index(carray->array, nchunk, rpointer);
}
-static void r_carray_add_chunks(rcarray_t *carray, rsize_t nchunks)
+static void r_carray_add_chunks(rcarray_t *carray, unsigned long nchunks)
{
rpointer chunk;
void r_carray_cleanup(robject_t *obj)
{
- rsize_t i;
+ unsigned long i;
rcarray_t *carray = (rcarray_t *)obj;
if (carray->oncleanup)
carray->oncleanup(carray);
}
-robject_t *r_carray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, rsize_t elt_size)
+robject_t *r_carray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, unsigned long elt_size)
{
rcarray_t *carray = (rcarray_t*)obj;
}
-rcarray_t *r_carray_create(rsize_t elt_size)
+rcarray_t *r_carray_create(unsigned long elt_size)
{
rcarray_t *carray;
carray = (rcarray_t*)r_object_create(sizeof(*carray));
robject_t *r_carray_copy(const robject_t *obj)
{
- rsize_t i;
+ unsigned long i;
rcarray_t *dst;
const rcarray_t *carray = (const rcarray_t *)obj;
}
-int r_carray_replace(rcarray_t *carray, rsize_t index, rconstpointer data)
+int r_carray_replace(rcarray_t *carray, unsigned long index, rconstpointer data)
{
if (data)
r_memcpy(r_carray_slot_expand(carray, index), data, carray->elt_size);
int r_carray_add(rcarray_t *carray, rconstpointer data)
{
- rsize_t index = r_carray_length(carray);
+ unsigned long index = r_carray_length(carray);
r_carray_inclength(carray);
return r_carray_replace(carray, index, data);
}
-void r_carray_setlength(rcarray_t *carray, rsize_t len)
+void r_carray_setlength(rcarray_t *carray, unsigned long len)
{
r_carray_checkexpand(carray, len);
r_carray_length(carray) = len;
}
-void r_carray_checkexpand(rcarray_t *carray, rsize_t size)
+void r_carray_checkexpand(rcarray_t *carray, unsigned long size)
{
- rsize_t chunks;
+ unsigned long chunks;
if (r_carray_size(carray) < size) {
chunks = (size - r_carray_size(carray) + R_CARRAY_CHUNKSIZE) / R_CARRAY_CHUNKSIZE;
}
-rpointer r_carray_slot_expand(rcarray_t *carray, rsize_t index)
+rpointer r_carray_slot_expand(rcarray_t *carray, unsigned long index)
{
r_carray_checkexpand(carray, index+1);
return (void*) r_carray_slot(carray, index);
}
-rpointer r_carray_slot_notused(rcarray_t *carray, rsize_t index)
+rpointer r_carray_slot_notused(rcarray_t *carray, unsigned long index)
{
- rsize_t nchunk = index >> R_CARRAY_CHUNKBITS;
- rsize_t offset = index & R_CARRAY_CHUNKMASK;
+ unsigned long nchunk = index >> R_CARRAY_CHUNKBITS;
+ unsigned long offset = index & R_CARRAY_CHUNKMASK;
rpointer chunk = r_array_index(carray->array, nchunk, rpointer);
rpointer v = (rpointer)(((char*)chunk) + (offset * carray->elt_size));
struct rcarray_s {
robject_t obj;
rarray_t *array;
- rsize_t alloc_size;
- rsize_t len;
- rsize_t elt_size;
+ unsigned long alloc_size;
+ unsigned long len;
+ unsigned long elt_size;
r_carray_callback oncleanup;
r_carray_callback oncopy;
rpointer *userdata;
#define r_carray_slot(__carray__, __index__)(((char*)r_array_index((__carray__)->array, (__index__) >> R_CARRAY_CHUNKBITS, rpointer)) + ((__index__) & R_CARRAY_CHUNKMASK) * (__carray__)->elt_size)
#define r_carray_index(__carray__, __index__, __type__) *((__type__*)r_carray_slot(__carray__, __index__))
-robject_t *r_carray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, rsize_t elt_size);
-rcarray_t *r_carray_create(rsize_t elt_size);
+robject_t *r_carray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, unsigned long elt_size);
+rcarray_t *r_carray_create(unsigned long elt_size);
void r_carray_destroy(rcarray_t *array);
-int r_carray_replace(rcarray_t *carray, rsize_t index, rconstpointer data);
+int r_carray_replace(rcarray_t *carray, unsigned long index, rconstpointer data);
int r_carray_add(rcarray_t *carray, rconstpointer data);
-void r_carray_setlength(rcarray_t *carray, rsize_t len);
+void r_carray_setlength(rcarray_t *carray, unsigned long len);
void r_carray_inclength(rcarray_t *carray);
void r_carray_inclength(rcarray_t *carray);
-void r_carray_checkexpand(rcarray_t *carray, rsize_t size);
-rpointer r_carray_slot_expand(rcarray_t *carray, rsize_t index);
+void r_carray_checkexpand(rcarray_t *carray, unsigned long size);
+rpointer r_carray_slot_expand(rcarray_t *carray, unsigned long index);
/*
* Virtual methods implementation
long r_harray_lookup(rharray_t *harray, const char *name, unsigned int namesize)
{
- rsize_t found;
+ unsigned long found;
rstr_t lookupstr = {(char*)name, namesize};
found = r_hash_lookup_indexval(harray->hash, &lookupstr);
long r_harray_taillookup(rharray_t *harray, const char *name, unsigned int namesize)
{
- rsize_t found;
+ unsigned long found;
rstr_t lookupstr = {(char*)name, namesize};
found = r_hash_taillookup_indexval(harray->hash, &lookupstr);
}
-rpointer r_harray_get(rharray_t *harray, rsize_t index)
+rpointer r_harray_get(rharray_t *harray, unsigned long index)
{
if (index >= r_carray_length(harray->members) || index < 0)
return NULL;
rhash_node_t* r_harray_nodelookup_s(rharray_t *harray, rhash_node_t *cur, const char *name);
rhash_node_t* r_harray_nodetaillookup(rharray_t *harray, rhash_node_t *cur, const char *name, unsigned int namesize);
rhash_node_t* r_harray_nodetaillookup_s(rharray_t *harray, rhash_node_t *cur, const char *name);
-rpointer r_harray_get(rharray_t *harray, rsize_t index);
+rpointer r_harray_get(rharray_t *harray, unsigned long index);
int r_harray_set(rharray_t *harray, long index, rconstpointer pval);
robject_t *r_harray_copy(const robject_t *obj);
robject_t *r_hash_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy,
unsigned int nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc)
{
- unsigned int i;
- rsize_t size;
+ unsigned long i;
+ unsigned long size;
rhash_t *hash = (rhash_t *)obj;
hash->nbits = nbits;
void r_hash_removeall(rhash_t* hash)
{
- rsize_t nbucket;
+ unsigned long nbucket;
rhead_t *head;
rhash_node_t *node;
#define R_HASH_INVALID_INDEXVAL ((unsigned long)-1)
-#define r_hash_size(__h__) (((rsize_t)1) << (__h__)->nbits)
+#define r_hash_size(__h__) (((unsigned long)1) << (__h__)->nbits)
#define r_hash_mask(__h__) (r_hash_size(__h__) - 1)
rhash_t *r_hash_create(unsigned int nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc);
void r_hash_destroy(rhash_t* hash);
typedef struct r_mapnode_s {
rlink_t active;
rlink_t hash;
- rsize_t index;
- long nbucket;
rstring_t *key;
+ unsigned long index;
+ unsigned long nbucket;
union {
rpointer p;
char data[0];
return hash;
}
-void r_mapnode_init(r_mapnode_t *node, const char *key, rsize_t size)
+void r_mapnode_init(r_mapnode_t *node, const char *key, unsigned long size)
{
// node->key = r_rstrdup(key, size);
node->key = r_string_create_strsize(key, size);
}
-r_mapnode_t *r_map_getfreenode(rmap_t *map, const char *key, rsize_t size)
+r_mapnode_t *r_map_getfreenode(rmap_t *map, const char *key, unsigned long size)
{
r_mapnode_t *node = NULL;
robject_t *r_map_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, unsigned int elt_size, unsigned int nbits)
{
- rsize_t elt_realsize = R_SIZE_ALIGN(elt_size + sizeof(r_mapnode_t), sizeof(ruword));
- rsize_t hashsize, i;
+ unsigned long elt_realsize = R_SIZE_ALIGN(elt_size + sizeof(r_mapnode_t), sizeof(ruword));
+ unsigned long hashsize, i;
rmap_t *map = (rmap_t*)obj;
if (nbits == 0 || nbits > 16) {
R_ASSERT(0);
for (i = 0; i < hashsize; i++) {
r_list_init(&map->hash[i]);
}
-
return obj;
}
#endif
-#define r_map_hashsize(__m__) (1 << (__m__)->nbits)
+#define r_map_hashsize(__m__) ((unsigned long)((unsigned long)1 << (__m__)->nbits))
#define r_map_hashmask(__m__) (r_map_hashsize(__m__) - 1)
typedef struct rmap_s {
robject_t obj;
- unsigned int nbits;
- unsigned int elt_size;
+ unsigned long nbits;
+ unsigned long elt_size;
rcarray_t *data;
rlist_t *hash;
rlist_t active;
#include "rlib/rmem.h"
static rspinlock_t g_lock = R_SPINLOCK_INIT;
-static rsize_t g_allocmem = 0;
-static rsize_t g_maxmem = 0;
+static rword g_allocmem = 0;
+static rword g_maxmem = 0;
typedef struct rmallocvtable_s {
- rpointer (*malloc)(rsize_t size);
+ rpointer (*malloc)(unsigned long size);
void (*free)(rpointer ptr);
- rpointer (*realloc)(rpointer ptr, rsize_t size);
- rpointer (*calloc)(rsize_t nmemb, rsize_t size);
+ rpointer (*realloc)(rpointer ptr, unsigned long size);
+ rpointer (*calloc)(unsigned long nmemb, unsigned long size);
} rmallocvtable_t;
-static rpointer r_std_malloc(rsize_t size)
+static rpointer r_std_malloc(unsigned long size)
{
return malloc((size_t)size);
}
-static rpointer r_std_calloc(rsize_t nmemb, rsize_t size)
+static rpointer r_std_calloc(unsigned long nmemb, unsigned long size)
{
return calloc((size_t)nmemb, (size_t)size);
}
}
-static rpointer r_std_realloc(rpointer ptr, rsize_t size)
+static rpointer r_std_realloc(rpointer ptr, unsigned long size)
{
return realloc((void*)ptr, (size_t)size);
}
-static rpointer r_dbg_calloc(rsize_t nmemb, rsize_t size)
+static rpointer r_dbg_calloc(unsigned long nmemb, unsigned long size)
{
ruword *mem = NULL;
}
-static rpointer r_dbg_malloc(rsize_t size)
+static rpointer r_dbg_malloc(unsigned long size)
{
ruword *mem = NULL;
size += sizeof(ruword);
}
-static rpointer r_dbg_realloc(rpointer ptr, rsize_t size)
+static rpointer r_dbg_realloc(rpointer ptr, unsigned long size)
{
ruword *mem = (void*)(((ruword*)ptr) - 1);
ruword csize;
#endif
-rpointer r_malloc(rsize_t size)
+rpointer r_malloc(unsigned long size)
{
return g_pMemAlloc->malloc(size);
}
-rpointer r_realloc(rpointer ptr, rsize_t size)
+rpointer r_realloc(rpointer ptr, unsigned long size)
{
return g_pMemAlloc->realloc(ptr, size);
}
-rpointer r_calloc(rsize_t nmemb, rsize_t size)
+rpointer r_calloc(unsigned long nmemb, unsigned long size)
{
return g_pMemAlloc->calloc(nmemb, size);
}
}
-rpointer r_zmalloc(rsize_t size)
+rpointer r_zmalloc(unsigned long size)
{
void *mem;
}
-rpointer r_memset(rpointer s, int c, rsize_t n)
+rpointer r_memset(rpointer s, int c, unsigned long n)
{
return memset((void*)s, (int)c, (size_t)n);
}
-rpointer r_memcpy(rpointer dest, rconstpointer src, rsize_t n)
+rpointer r_memcpy(rpointer dest, rconstpointer src, unsigned long n)
{
return memcpy((void*)dest, (const void*)src, (size_t)n);
}
-rpointer r_memmove(rpointer dest, rconstpointer src, rsize_t n)
+rpointer r_memmove(rpointer dest, rconstpointer src, unsigned long n)
{
return memmove((void*)dest, (const void*)src, (size_t)n);
}
-rsize_t r_debug_get_allocmem()
+unsigned long r_debug_get_allocmem()
{
- return g_allocmem;
+ return (unsigned long)g_allocmem;
}
-rsize_t r_debug_get_maxmem()
+unsigned long r_debug_get_maxmem()
{
- return g_maxmem;
+ return (unsigned long)g_maxmem;
}
#endif
-rpointer r_malloc(rsize_t size);
-rpointer r_realloc(rpointer ptr, rsize_t size);
-rpointer r_calloc(rsize_t nmemb, rsize_t size);
+rpointer r_malloc(unsigned long size);
+rpointer r_realloc(rpointer ptr, unsigned long size);
+rpointer r_calloc(unsigned long nmemb, unsigned long size);
void r_free(rpointer ptr);
-rpointer r_zmalloc(rsize_t size);
-rpointer r_memset(rpointer s, int c, rsize_t n);
-rpointer r_memcpy(rpointer dest, rconstpointer src, rsize_t n);
-rpointer r_memmove(rpointer dest, rconstpointer src, rsize_t n);
-rsize_t r_debug_get_allocmem();
-rsize_t r_debug_get_maxmem();
+rpointer r_zmalloc(unsigned long size);
+rpointer r_memset(rpointer s, int c, unsigned long n);
+rpointer r_memcpy(rpointer dest, rconstpointer src, unsigned long n);
+rpointer r_memmove(rpointer dest, rconstpointer src, unsigned long n);
+unsigned long r_debug_get_allocmem();
+unsigned long r_debug_get_maxmem();
void r_debug_reset_maxmem();
#include "rlib/robject.h"
-robject_t *r_object_create(rsize_t size)
+robject_t *r_object_create(unsigned long size)
{
robject_t *object;
r_object_copyfun copy;
};
-robject_t *r_object_create(rsize_t size);
+robject_t *r_object_create(unsigned long size);
robject_t *r_object_copy(const robject_t *obj);
void r_object_destroy(robject_t *obj);
void r_object_cleanup(robject_t *obj);
}
-int r_strncmp(const char *s1, const char *s2, rsize_t n)
+int r_strncmp(const char *s1, const char *s2, unsigned long n)
{
int ret = strncmp(s1, s2, (size_t)n);
return ret;
}
-rboolean r_stringncmp(const char *str, const char *s2, rsize_t n)
+rboolean r_stringncmp(const char *str, const char *s2, unsigned long n)
{
if (r_strlen(str) == n && r_strncmp(str, s2, (size_t)n) == 0)
return 1;
}
-rsize_t r_strlen(const char *s)
+unsigned long r_strlen(const char *s)
{
- return s ? strlen(s) : 0;
+ return s ? (unsigned long)strlen(s) : 0;
}
}
-char *r_strncpy(char *dest, const char *src, rsize_t n)
+char *r_strncpy(char *dest, const char *src, unsigned long n)
{
return (char*) strncpy(dest, src, n);
}
char *r_strdup(const char *s)
{
- rsize_t size = r_strlen(s);
+ unsigned long size = r_strlen(s);
char *dupstr = (char*)r_zmalloc(size + 1);
if (dupstr) {
}
-char *r_strndup(const char *s, rsize_t size)
+char *r_strndup(const char *s, unsigned long size)
{
char *dupstr = (char*)r_zmalloc(size + 1);
rstr_t *r_rstrdup(const char *s, unsigned int size)
{
- rsize_t allocsize = sizeof(rstr_t) + size + sizeof(char);
+ unsigned long allocsize = sizeof(rstr_t) + size + sizeof(char);
rstr_t *d = (rstr_t*)r_malloc(allocsize);
if (d) {
r_memset(d, 0, allocsize);
}
-rstring_t *r_string_create_strsize(const char *str, unsigned int size)
+rstring_t *r_string_create_strsize(const char *str, unsigned long size)
{
rstr_t rstr;
typedef struct rstr_s {
char *str;
- rsize_t size;
+ unsigned long size;
} rstr_t;
int r_strcmp(const char *s1, const char *s2);
-int r_strncmp(const char *s1, const char *s2, rsize_t n);
-rboolean r_stringncmp(const char *str, const char *s2, rsize_t n);
-rsize_t r_strlen(const char *s);
+int r_strncmp(const char *s1, const char *s2, unsigned long n);
+rboolean r_stringncmp(const char *str, const char *s2, unsigned long n);
+unsigned long r_strlen(const char *s);
char *r_strstr(const char *haystack, const char *needle);
char *r_strchr(const char *s, int c);
char *r_strdup(const char *s);
-char *r_strndup(const char *s, rsize_t size);
+char *r_strndup(const char *s, unsigned long size);
char *r_strcpy(char *dest, const char *src);
-char *r_strncpy(char *dest, const char *src, rsize_t n);
+char *r_strncpy(char *dest, const char *src, unsigned long n);
char *r_strcat(char *dest, const char *src);
char *r_strncat(char *dest, const char *src, unsigned int n);
int r_snprintf(char *str, unsigned int size, const char *format, ...);
rstring_t *r_string_create_from_ansistr(const char *str);
rstring_t *r_string_create_from_double(double d);
rstring_t *r_string_create_from_signed(rword l);
-rstring_t *r_string_create_strsize(const char *str, unsigned int size);
+rstring_t *r_string_create_strsize(const char *str, unsigned long size);
rstring_t *r_string_create_from_rstr(const rstr_t *str);
void r_string_destroy(rstring_t *string);
robject_t *r_string_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy);
return -1;
r_memset(pblob, 0, RPA_RULEBLOB_SIZE);
ptr = blob + sizeof(rpa_ruledata_t);
- pblob->name = ptr - blob;
+ pblob->name = (unsigned long)(ptr - blob);
pblob->ruleid = ruleid;
pblob->ruleuid = ruleuid;
pblob->flags = flags;
static rparecord_t *rpa_dbex_rulerecord(rpadbex_t *dbex, rparule_t rid);
static rparecord_t *rpa_dbex_record(rpadbex_t *dbex, long rec);
-static int rpa_dbex_rulename(rpadbex_t *dbex, long rec, const char **name, rsize_t *namesize);
+static int rpa_dbex_rulename(rpadbex_t *dbex, long rec, const char **name, unsigned long *namesize);
static int rpa_parseinfo_loopdetect(rpadbex_t *dbex, long parent, long loopto);
static long rpa_dbex_firstinlined(rpadbex_t *dbex);
static int rpa_dbex_findinlined(rpadbex_t *dbex, long startrec);
static int rpa_dbex_rh_uid(rpadbex_t *dbex, long rec)
{
const char *name = NULL;
- rsize_t namesize;
+ unsigned long namesize;
ruint32 uid = 0;
rparecord_t *pnumrec;
rarray_t *records = dbex->records;
static int rpa_dbex_rh_abort(rpadbex_t *dbex, long rec)
{
const char *name = NULL;
- rsize_t namesize;
+ unsigned long namesize;
rarray_t *records = dbex->records;
rparecord_t *prec;
static int rpa_dbex_rh_emit(rpadbex_t *dbex, long rec)
{
const char *name = NULL;
- rsize_t namesize;
+ unsigned long namesize;
rarray_t *records = dbex->records;
rparecord_t *prec;
static int rpa_dbex_rh_noemit(rpadbex_t *dbex, long rec)
{
const char *name = NULL;
- rsize_t namesize;
+ unsigned long namesize;
rarray_t *records = dbex->records;
rparecord_t *prec;
static int rpa_dbex_setemit(rpadbex_t *dbex, rboolean emit)
{
- rsize_t i;
+ unsigned long i;
rpa_ruleinfo_t *info;
for (i = 0; i < r_array_length(dbex->rules->names); i++) {
static int rpa_dbex_rh_namedrule(rpadbex_t *dbex, long rec)
{
const char *name = NULL;
- rsize_t namesize;
+ unsigned long namesize;
rarray_t *records = dbex->records;
rparecord_t *prec = (rparecord_t *) r_array_slot(dbex->records, rec);
static int rpa_dbex_rh_aref(rpadbex_t *dbex, long rec)
{
const char *name = NULL;
- rsize_t namesize;
+ unsigned long namesize;
rpa_ruleinfo_t *info;
rarray_t *records = dbex->records;
rparecord_t *prec;
void rpa_dbex_destroy(rpadbex_t *dbex)
{
- rsize_t i;
+ unsigned long i;
if (dbex) {
for (i = 0; i < r_array_length(dbex->text); i++)
r_free(r_array_index(dbex->text, i, char*));
static int rpa_parseinfo_loopdetect_do(rpadbex_t *dbex, long parent, long loopto, int inderction)
{
- rsize_t namesiz;
+ unsigned long namesiz;
const char *name;
long i;
int ret = 0;
rpa_ruleinfo_t info;
unsigned int nrecords;
const char *name = NULL;
- rsize_t namesize = 0;
- rsize_t i;
+ unsigned long namesize = 0;
+ unsigned long i;
if (dbex->rules) {
r_object_destroy((robject_t *)dbex->rules);
}
-static int rpa_dbex_rulename(rpadbex_t *dbex, long rec, const char **name, rsize_t *namesize)
+static int rpa_dbex_rulename(rpadbex_t *dbex, long rec, const char **name, unsigned long *namesize)
{
rparecord_t *pnamerec = rpa_dbex_record(dbex, rpa_recordtree_firstchild(dbex->records, rpa_recordtree_get(dbex->records, rec, RPA_RECORD_START), RPA_RECORD_END));
if (!pnamerec || !(pnamerec->ruleuid & RPA_PRODUCTION_RULENAME))
}
-long rpa_dbex_load(rpadbex_t *dbex, const char *rules, rsize_t size)
+long rpa_dbex_load(rpadbex_t *dbex, const char *rules, unsigned long size)
{
long ret;
char *text;
static int rpa_dbex_findinlined(rpadbex_t *dbex, long startrec)
{
- rsize_t i;
+ unsigned long i;
for (i = 0; i < r_array_length(dbex->inlinestack); i++) {
if (r_array_index(dbex->inlinestack, i, long) == startrec)
return 1;
return;
if (prec && (prec->ruleuid == RPA_PRODUCTION_AREF || prec->ruleuid == RPA_PRODUCTION_CREF)) {
const char *name = NULL;
- rsize_t namesize = 0;
+ unsigned long namesize = 0;
int loop = 0;
rpa_ruleinfo_t *info;
int rpa_dbex_dumprecords(rpadbex_t *dbex)
{
- rsize_t i;
+ unsigned long i;
if (!dbex)
return -1;
int rpa_dbex_dumpinfo(rpadbex_t *dbex)
{
- rsize_t i;
+ unsigned long i;
rpa_ruleinfo_t *info;
if (!dbex)
int rpa_dbex_dumpuids(rpadbex_t *dbex)
{
- rsize_t i;
+ unsigned long i;
long rec;
rpa_ruleinfo_t *info;
char *buffer = r_zmalloc(32 * sizeof(char));
}
-rsize_t rpa_dbex_strlen(rpadbex_t *dbex, rparule_t rid)
+unsigned long rpa_dbex_strlen(rpadbex_t *dbex, rparule_t rid)
{
rparecord_t *prec;
- rsize_t size;
+ unsigned long size;
if (!dbex)
return -1;
}
-rsize_t rpa_dbex_strncpy(rpadbex_t *dbex, char *dst, rparule_t rid, rsize_t n)
+unsigned long rpa_dbex_strncpy(rpadbex_t *dbex, char *dst, rparule_t rid, unsigned long n)
{
rparecord_t *prec;
- rsize_t size;
+ unsigned long size;
if (!dbex)
return -1;
* Use @ref rpa_dbex_lasterror or @ref rpa_dbex_lasterrorinfo to retrieve the error
* information.
*/
-long rpa_dbex_load(rpadbex_t *dbex, const char *buffer, rsize_t size);
+long rpa_dbex_load(rpadbex_t *dbex, const char *buffer, unsigned long size);
/**
* @param rid production ID.
* @return the string length of the specified production
*/
-rsize_t rpa_dbex_strlen(rpadbex_t *dbex, rparule_t rid);
+unsigned long rpa_dbex_strlen(rpadbex_t *dbex, rparule_t rid);
/**
* @param size to be copied
* @return Return the number of bytes written in the buffer.
*/
-rsize_t rpa_dbex_strncpy(rpadbex_t *dbex, char *dest, rparule_t rid, rsize_t size);
+unsigned long rpa_dbex_strncpy(rpadbex_t *dbex, char *dest, rparule_t rid, unsigned long size);
/**
}
-long rpa_parser_load(rpa_parser_t *pa, const char *prods, rsize_t size, rarray_t *records)
+long rpa_parser_load(rpa_parser_t *pa, const char *prods, unsigned long size, rarray_t *records)
{
long ret = 0;
rpainput_t *ptp;
if (ret < 0)
return 0;
ptp = &stat->instack[ret];
- return (ptp->input - prods);
+ return (long)(ptp->input - prods);
}
rpa_parser_t *rpa_parser_create();
void rpa_parser_destroy(rpa_parser_t *pa);
-long rpa_parser_load(rpa_parser_t *pa, const char *prods, rsize_t size, rarray_t *records);
+long rpa_parser_load(rpa_parser_t *pa, const char *prods, unsigned long size, rarray_t *records);
long rpa_parser_load_s(rpa_parser_t *pa, const char *prods, rarray_t *records);
#ifdef __cplusplus
* inside @ref rpadbex_t, so make sure rpadbex_t object is still valid while accessing this pointer. */
const char *input; /**< Pointer in the input stream. This pointer points to memory inside the input buffer
* passed to @ref rpa_stat_parse, make sure this memory is still valid while accessing this pointer. */
- rsize_t inputoff; /**< Input offset, calculated from the start parameter passed to @ref rpa_stat_parse */
- rsize_t inputsiz; /**< Size of input */
+ unsigned long inputoff; /**< Input offset, calculated from the start parameter passed to @ref rpa_stat_parse */
+ unsigned long inputsiz; /**< Size of input */
ruint32 type; /**< Record Type: @ref RPA_RECORD_START or @ref RPA_RECORD_END */
ruint32 ruleid; /**< Unique ID, identifying the BNF rule that created the record */
ruint32 ruleuid; /**< User specified Rule ID. If you used directive @ref emitid for this rulename, this member will contain the specified ID */
int rpa_stat_init(rpastat_t *stat, unsigned int encoding, const char *input, const char *start, const char *end, rarray_t *records)
{
- long size;
+ unsigned long size;
if (!stat) {
return -1;
if (topsiz <= 0)
return 0;
ptp = &stat->instack[topsiz];
- return (ptp->input - input);
+ return (long)(ptp->input - input);
}
}
-rboolean rpa_stat_matchbitmap(rpastat_t *stat, rssize_t top, rpabitmap_t bitmap)
+rboolean rpa_stat_matchbitmap(rpastat_t *stat, long top, rpabitmap_t bitmap)
{
int ret = FALSE;
rpainput_t *in = &stat->instack[top];
}
-int rpa_stat_matchchr(rpastat_t *stat, rssize_t top, unsigned long wc)
+int rpa_stat_matchchr(rpastat_t *stat, long top, unsigned long wc)
{
int ret = 0;
rpainput_t *in = &stat->instack[top];
}
-int rpa_stat_matchspchr(rpastat_t *stat, rssize_t top, unsigned long wc)
+int rpa_stat_matchspchr(rpastat_t *stat, long top, unsigned long wc)
{
int ret = 0;
rpainput_t *in = &stat->instack[top];
}
-int rpa_stat_matchrng(rpastat_t *stat, rssize_t top, unsigned long wc1, unsigned long wc2)
+int rpa_stat_matchrng(rpastat_t *stat, long top, unsigned long wc1, unsigned long wc2)
{
int ret = 0;
rpainput_t *in = &stat->instack[top];
}
-long rpa_stat_shift(rpastat_t *stat, rssize_t top)
+long rpa_stat_shift(rpastat_t *stat, long top)
{
rpainput_t * ptp = &stat->instack[top];
int rpa_stat_init(rpastat_t *stat, unsigned int encoding, const char *input, const char *start, const char *end, rarray_t *records);
void rpa_stat_cachedisable(rpastat_t *stat, unsigned int disable);
void rpa_stat_cacheinvalidate(rpastat_t *stat);
-rboolean rpa_stat_matchbitmap(rpastat_t *stat, rssize_t top, rpabitmap_t bitmap);
-int rpa_stat_matchchr(rpastat_t *stat, rssize_t top, unsigned long wc);
-int rpa_stat_matchspchr(rpastat_t *stat, rssize_t top, unsigned long wc);
-int rpa_stat_matchrng(rpastat_t *stat, rssize_t top, unsigned long wc1, unsigned long wc2);
-long rpa_stat_shift(rpastat_t *stat, rssize_t top);
+rboolean rpa_stat_matchbitmap(rpastat_t *stat, long top, rpabitmap_t bitmap);
+int rpa_stat_matchchr(rpastat_t *stat, long top, unsigned long wc);
+int rpa_stat_matchspchr(rpastat_t *stat, long top, unsigned long wc);
+int rpa_stat_matchrng(rpastat_t *stat, long top, unsigned long wc1, unsigned long wc2);
+long rpa_stat_shift(rpastat_t *stat, long top);
unsigned long rpa_special_char(unsigned long special);
#ifdef __cplusplus
rpastat_t *stat = (rpastat_t *)cpu->userdata1;
rword top = RVM_CPUREG_GETL(cpu, R_TOP);
- if ((top = rpa_stat_shift(stat, top)) >= 0)
+ if ((top = rpa_stat_shift(stat, (long)top)) >= 0)
RVM_CPUREG_SETL(cpu, R_TOP, top);
}
rpastat_t *stat = (rpastat_t *)cpu->userdata1;
rpabitmap_t bitmap = RVM_CPUREG_GETU(cpu, ins->op1);
- if (rpa_stat_matchbitmap(stat, RVM_CPUREG_GETL(cpu, R_TOP), bitmap)) {
+ if (rpa_stat_matchbitmap(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), bitmap)) {
cpu->status = 0;
} else {
cpu->status = RVM_STATUS_N;
rpastat_t *stat = (rpastat_t *)cpu->userdata1;
rpabitmap_t bitmap = RVM_CPUREG_GETU(cpu, ins->op1);
- if (rpa_stat_matchbitmap(stat, RVM_CPUREG_GETL(cpu, R_TOP), bitmap)) {
+ if (rpa_stat_matchbitmap(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), bitmap)) {
cpu->status = 0;
} else {
cpu->status = RVM_STATUS_N;
ruword r0 = RVM_CPUREG_GETU(cpu, R0);
if (bitmap && r0 > 0) {
- if (!rpa_stat_matchbitmap(stat, RVM_CPUREG_GETL(cpu, R_TOP) - r0, bitmap)) {
+ if (!rpa_stat_matchbitmap(stat, (long)(RVM_CPUREG_GETL(cpu, R_TOP) - r0), bitmap)) {
if ((cpu->status & RVM_STATUS_N) == 0)
rvm_cpu_abort(cpu);
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ if (rpa_stat_matchchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched = 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ if (rpa_stat_matchchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched = 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- while (rpa_stat_matchchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ while (rpa_stat_matchchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched += 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- while (rpa_stat_matchchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ while (rpa_stat_matchchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched += 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchspchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ if (rpa_stat_matchspchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched = 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchspchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ if (rpa_stat_matchspchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched = 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- while (rpa_stat_matchspchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ while (rpa_stat_matchspchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched += 1;
}
ruword wc = RVM_CPUREG_GETU(cpu, ins->op1);
ruword matched = 0;
- while (rpa_stat_matchspchr(stat, RVM_CPUREG_GETL(cpu, R_TOP), wc) > 0) {
+ while (rpa_stat_matchspchr(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), (unsigned long)wc) > 0) {
rpavm_swi_shift(cpu, ins);
matched += 1;
}
rpair_t pr = RVM_CPUREG_GETPAIR(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchrng(stat, RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) <= 0) {
+ if (rpa_stat_matchrng(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) <= 0) {
cpu->status = matched ? 0 : RVM_STATUS_N;
RVM_CPUREG_SETU(cpu, R0, matched ? matched : (ruword)-1);
}
rpair_t pr = RVM_CPUREG_GETPAIR(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchrng(stat, RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
+ if (rpa_stat_matchrng(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
rpavm_swi_shift(cpu, ins);
matched = 1;
}
rpair_t pr = RVM_CPUREG_GETPAIR(cpu, ins->op1);
ruword matched = 0;
- if (rpa_stat_matchrng(stat, RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
+ if (rpa_stat_matchrng(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
rpavm_swi_shift(cpu, ins);
matched = 1;
}
rpair_t pr = RVM_CPUREG_GETPAIR(cpu, ins->op1);
ruword matched = 0;
- while (rpa_stat_matchrng(stat, RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
+ while (rpa_stat_matchrng(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
rpavm_swi_shift(cpu, ins);
matched += 1;
}
rpair_t pr = RVM_CPUREG_GETPAIR(cpu, ins->op1);
ruword matched = 0;
- while (rpa_stat_matchrng(stat, RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
+ while (rpa_stat_matchrng(stat, (long)RVM_CPUREG_GETL(cpu, R_TOP), pr.p1, pr.p2) > 0) {
rpavm_swi_shift(cpu, ins);
matched += 1;
}
rword index = RVM_CPUREG_GETL(cpu, R_REC);
if (stat->records)
- r_array_setlength(stat->records, index + 1);
+ r_array_setlength(stat->records, (unsigned long)(index + 1));
}
if (stat->records)
- r_array_setlength(stat->records, index + 1);
+ r_array_setlength(stat->records, (long)(index + 1));
RPA_STAT_SETERROR_CODE(stat, RPA_E_RULEABORT);
RPA_STAT_SETERRINFO_RULEUID(stat, ruledata->ruleuid);
if (name.str) {
r_printf("%ld: %s, %s, tp = %ld\n", RVM_CPUREG_GETU(cpu, FP), "START", name.str, tp);
if (!stat->records || !(ruledata->flags & RPA_RFLAG_EMITRECORD))
return;
- index = r_array_replace(stat->records, index + 1, NULL);
+ index = r_array_replace(stat->records, (unsigned long)(index + 1), NULL);
/*
* Important: get the pointer to crec after modifying the array, because if
rec->ruleuid = (ruint32)ruledata->ruleuid;
rec->type = RPA_RECORD_START;
rec->input = stat->instack[tp].input;
- rec->inputoff = stat->instack[tp].input - stat->start;
+ rec->inputoff = (unsigned long)(stat->instack[tp].input - stat->start);
rec->inputsiz = 0;
}
if (!stat->records || !(ruledata->flags & RPA_RFLAG_EMITRECORD))
return;
- index = r_array_replace(stat->records, index + 1, NULL);
+ index = r_array_replace(stat->records, (unsigned long)(index + 1), NULL);
RVM_CPUREG_SETL(cpu, R_REC, index);
rec = (rparecord_t *)r_array_slot(stat->records, index);
startrec = (rparecord_t *)r_array_slot(stat->records, startindex);
rec->ruleid = (ruint32)ruledata->ruleid;
rec->ruleuid = (ruint32)ruledata->ruleuid;
rec->input = stat->instack[tp].input;
- rec->inputsiz = stat->instack[tp + tplen].input - stat->instack[tp].input;
- rec->inputoff = stat->instack[tp].input - stat->start;
+ rec->inputsiz = (unsigned long)(stat->instack[tp + tplen].input - stat->instack[tp].input);
+ rec->inputoff = (unsigned long)(stat->instack[tp].input - stat->start);
startrec->size = (ruint32)tplen;
startrec->inputsiz = rec->inputsiz;
}
if (r0 > 0 && prevrec != endrec) {
startrec = prevrec + 1;
- rpa_cache_set(stat->cache, top, ruleid, r0, stat->records, startrec, endrec - prevrec);
+ rpa_cache_set(stat->cache, (long)top, (long)ruleid, (long)r0, stat->records, (long)startrec, (long)(endrec - prevrec));
} else {
- rpa_cache_set(stat->cache, top, ruleid, r0, stat->records, 0, 0);
+ rpa_cache_set(stat->cache, (long)top, (long)ruleid, (long)r0, stat->records, 0, 0);
}
}
rword ruleid = RVM_CPUREG_GETL(cpu, ins->op1);
rword top = RVM_CPUREG_GETL(cpu, ins->op2);
rword r0 = 0;
- entry = rpa_cache_lookup(stat->cache, top, ruleid);
+ entry = rpa_cache_lookup(stat->cache, (long)top, (long)ruleid);
if (entry) {
r0 = entry->ret;
if (r0 > 0) {
if (entry->recsize) {
- rsize_t i;
+ unsigned long i;
if (stat->records) {
- r_array_setlength(stat->records, RVM_CPUREG_GETL(cpu, R_REC) + 1);
+ r_array_setlength(stat->records, (unsigned long)(RVM_CPUREG_GETL(cpu, R_REC) + 1));
for (i = 0; i < r_array_length(entry->records); i++) {
r_array_add(stat->records, r_array_slot(entry->records, i));
}
typedef struct rpa_ruledata_s {
- ruword size;
- ruword ruleid;
- ruword ruleuid;
- ruword flags;
- ruword namesize;
- ruword name;
+ unsigned long size;
+ unsigned long ruleid;
+ unsigned long ruleuid;
+ unsigned long flags;
+ unsigned long namesize;
+ unsigned long name;
} rpa_ruledata_t;
cg->data = r_array_create(sizeof(ruint8));
cg->codemap = rvm_codemap_create();
cg->relocmap = rvm_relocmap_create();
- cg->sourceidx = r_array_create(sizeof(rsize_t));
+ cg->sourceidx = r_array_create(sizeof(unsigned long));
return cg;
}
}
-void rvm_codegen_setsource(rvm_codegen_t *cg, rsize_t srcidx)
+void rvm_codegen_setsource(rvm_codegen_t *cg, unsigned long srcidx)
{
cg->cursrcidx = srcidx;
}
-long rvm_codegen_getsource(rvm_codegen_t *cg, rsize_t codeidx)
+long rvm_codegen_getsource(rvm_codegen_t *cg, unsigned long codeidx)
{
if (codeidx >= r_array_length(cg->sourceidx))
return -1;
}
-rsize_t rvm_codegen_getcodesize(rvm_codegen_t *cg)
+unsigned long rvm_codegen_getcodesize(rvm_codegen_t *cg)
{
return r_array_length(cg->code);
}
}
-rsize_t rvm_codegen_addins(rvm_codegen_t *cg, rvm_asmins_t ins)
+unsigned long rvm_codegen_addins(rvm_codegen_t *cg, rvm_asmins_t ins)
{
- rsize_t codeidx;
+ unsigned long codeidx;
codeidx = r_array_add(cg->code, &ins);
r_array_replace(cg->sourceidx, codeidx, &cg->cursrcidx);
}
-rsize_t rvm_codegen_addlabelins(rvm_codegen_t *cg, const char* name, unsigned int namesize, rvm_asmins_t ins)
+unsigned long rvm_codegen_addlabelins(rvm_codegen_t *cg, const char* name, unsigned int namesize, rvm_asmins_t ins)
{
rvm_codemap_addoffset(cg->codemap, name, namesize, rvm_codemap_lookupadd_s(cg->codemap, ".code"), RVM_CODE2BYTE_OFFSET(rvm_codegen_getcodesize(cg)));
return rvm_codegen_addins(cg, ins);
}
-rsize_t rvm_codegen_addlabelins_s(rvm_codegen_t *cg, const char* name, rvm_asmins_t ins)
+unsigned long rvm_codegen_addlabelins_s(rvm_codegen_t *cg, const char* name, rvm_asmins_t ins)
{
return rvm_codegen_addlabelins(cg, name, r_strlen(name), ins);
}
-rsize_t rvm_codegen_index_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, unsigned long index, rvm_asmins_t ins)
+unsigned long rvm_codegen_index_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, unsigned long index, rvm_asmins_t ins)
{
rvm_relocmap_add(cg->relocmap, RVM_RELOC_CODE, type, rvm_codegen_getcodesize(cg), index);
return rvm_codegen_addins(cg, ins);
}
-rsize_t rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, unsigned int namesize, rvm_asmins_t ins)
+unsigned long rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, unsigned int namesize, rvm_asmins_t ins)
{
return rvm_codegen_index_addrelocins(cg, type, rvm_codemap_lookupadd(cg->codemap, name, namesize), ins);
}
-rsize_t rvm_codegen_addrelocins_s(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, rvm_asmins_t ins)
+unsigned long rvm_codegen_addrelocins_s(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, rvm_asmins_t ins)
{
return rvm_codegen_addrelocins(cg, type, name, r_strlen(name), ins);
}
}
-rsize_t rvm_codegen_insertins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins)
+unsigned long rvm_codegen_insertins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins)
{
return r_array_insert(cg->code, index, &ins);
}
-rsize_t rvm_codegen_replaceins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins)
+unsigned long rvm_codegen_replaceins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins)
{
return r_array_replace(cg->code, index, &ins);
rvm_codegen_addins(cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
}
-long rvm_codegen_adddata(rvm_codegen_t *cg, const char *name, unsigned int namesize, rconstpointer data, rsize_t size)
+long rvm_codegen_adddata(rvm_codegen_t *cg, const char *name, unsigned int namesize, rconstpointer data, unsigned long size)
{
rpointer buffer;
unsigned long cursize = R_SIZE_ALIGN(r_array_length(cg->data), sizeof(ruword));
}
-long rvm_codegen_adddata_s(rvm_codegen_t *cg, const char *name, rconstpointer data, rsize_t size)
+long rvm_codegen_adddata_s(rvm_codegen_t *cg, const char *name, rconstpointer data, unsigned long size)
{
return rvm_codegen_adddata(cg, name, r_strlen(name), data, size);
}
rarray_t *sourceidx;
rvm_codemap_t *codemap;
rvm_relocmap_t *relocmap;
- rsize_t cursrcidx;
+ unsigned long cursrcidx;
unsigned long userdata;
} rvm_codegen_t;
rvm_codegen_t *rvm_codegen_create();
void rvm_codegen_destroy(rvm_codegen_t *cg);
-void rvm_codegen_setsource(rvm_codegen_t *cg, rsize_t srcidx);
-long rvm_codegen_getsource(rvm_codegen_t *cg, rsize_t codeidx);
+void rvm_codegen_setsource(rvm_codegen_t *cg, unsigned long srcidx);
+long rvm_codegen_getsource(rvm_codegen_t *cg, unsigned long codeidx);
unsigned int rvm_codegen_funcstart(rvm_codegen_t *cg, const char* name, unsigned int namesize, unsigned int args);
unsigned int rvm_codegen_funcstart_s(rvm_codegen_t *cg, const char* name, unsigned int args);
unsigned int rvm_codegen_vargs_funcstart(rvm_codegen_t *cg, const char* name, unsigned int namesize);
unsigned int rvm_codegen_vargs_funcstart_s(rvm_codegen_t *cg, const char* name);
void rvm_codegen_funcend(rvm_codegen_t *cg);
-rsize_t rvm_codegen_addins(rvm_codegen_t *cg, rvm_asmins_t ins);
-rsize_t rvm_codegen_addlabelins(rvm_codegen_t *cg, const char* name, unsigned int namesize, rvm_asmins_t ins);
-rsize_t rvm_codegen_addlabelins_s(rvm_codegen_t *cg, const char* name, rvm_asmins_t ins);
-rsize_t rvm_codegen_index_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, unsigned long index, rvm_asmins_t ins);
-rsize_t rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, unsigned int namesize, rvm_asmins_t ins);
-rsize_t rvm_codegen_addrelocins_s(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, rvm_asmins_t ins);
-rsize_t rvm_codegen_insertins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins);
-rsize_t rvm_codegen_replaceins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins);
+unsigned long rvm_codegen_addins(rvm_codegen_t *cg, rvm_asmins_t ins);
+unsigned long rvm_codegen_addlabelins(rvm_codegen_t *cg, const char* name, unsigned int namesize, rvm_asmins_t ins);
+unsigned long rvm_codegen_addlabelins_s(rvm_codegen_t *cg, const char* name, rvm_asmins_t ins);
+unsigned long rvm_codegen_index_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, unsigned long index, rvm_asmins_t ins);
+unsigned long rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, unsigned int namesize, rvm_asmins_t ins);
+unsigned long rvm_codegen_addrelocins_s(rvm_codegen_t *cg, rvm_reloctype_t type, const char* name, rvm_asmins_t ins);
+unsigned long rvm_codegen_insertins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins);
+unsigned long rvm_codegen_replaceins(rvm_codegen_t *cg, unsigned int index, rvm_asmins_t ins);
rvm_asmins_t *rvm_codegen_getcode(rvm_codegen_t *cg, unsigned int index);
-rsize_t rvm_codegen_getcodesize(rvm_codegen_t *cg);
+unsigned long rvm_codegen_getcodesize(rvm_codegen_t *cg);
void rvm_codegen_setcodesize(rvm_codegen_t *cg, unsigned int size);
void rvm_codegen_clear(rvm_codegen_t *cg);
int rvm_codegen_relocate(rvm_codegen_t *cg, rvm_codelabel_t **err);
long rvm_codegen_addlabel_default_s(rvm_codegen_t *cg, const char* name);
long rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const char* name, unsigned int namesize);
long rvm_codegen_invalid_addlabel_s(rvm_codegen_t *cg, const char* name);
-long rvm_codegen_adddata(rvm_codegen_t *cg, const char *name, unsigned int namesize, rconstpointer data, rsize_t size);
-long rvm_codegen_adddata_s(rvm_codegen_t *cg, const char *name, rconstpointer data, rsize_t size);
+long rvm_codegen_adddata(rvm_codegen_t *cg, const char *name, unsigned int namesize, rconstpointer data, unsigned long size);
+long rvm_codegen_adddata_s(rvm_codegen_t *cg, const char *name, rconstpointer data, unsigned long size);
long rvm_codegen_addstring(rvm_codegen_t *cg, const char *name, unsigned int namesize, const char* data);
long rvm_codegen_addstring_s(rvm_codegen_t *cg, const char *name, const char* data);
long rvm_codegen_add_numlabel_s(rvm_codegen_t *cg, const char *alphaname, long numname);
void rvm_codemap_destroy(rvm_codemap_t *codemap)
{
rvm_codelabel_t *label;
- rsize_t i, len = r_array_length(codemap->labels);
+ unsigned long i, len = r_array_length(codemap->labels);
for (i = 0; i < len; i++) {
label = (rvm_codelabel_t*)r_array_slot(codemap->labels, i);
void rvm_codemap_clear(rvm_codemap_t *codemap)
{
- rsize_t i;
+ unsigned long i;
rvm_codelabel_t *label;
for (i = 0; i < r_array_length(codemap->labels); i++) {
static void rvm_op_allocstr(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
-
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
- rstring_t *s = r_string_create_strsize((const char*)RVM_CPUREG_GETP(cpu, ins->op2), RVM_CPUREG_GETU(cpu, ins->op3));
+ rstring_t *s = r_string_create_strsize((const char*)RVM_CPUREG_GETP(cpu, ins->op2), (unsigned long)RVM_CPUREG_GETU(cpu, ins->op3));
if (!s) {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
static void rvm_op_allocarr(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
- unsigned int size = RVM_CPUREG_GETU(cpu, ins->op2);
+ ruword size = RVM_CPUREG_GETU(cpu, ins->op2);
rcarray_t *a = r_carray_create_rvmreg();
if (!a) {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
- r_carray_setlength(a, size);
+ r_carray_setlength(a, (unsigned long)size);
r_gc_add(cpu->gc, (robject_t*)a);
rvm_reg_setarray(arg1, (robject_t*)a);
}
RVM_ABORT(cpu, RVM_E_NOTOBJECT);
}
if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_SINGED || RVM_REG_GETTYPE(arg3) == RVM_DTYPE_UNSIGNED) {
- index = r_map_lookup_l(a, -1, RVM_REG_GETL(arg3));
+ index = r_map_lookup_l(a, -1, (long)RVM_REG_GETL(arg3));
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_DOUBLE) {
index = r_map_lookup_d(a, -1, RVM_REG_GETD(arg3));
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_STRING) {
index = r_map_lookup(a, -1, ((rstring_t *)RVM_CPUREG_GETP(cpu, ins->op3))->s.str, ((rstring_t *)RVM_CPUREG_GETP(cpu, ins->op3))->s.size);
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_POINTER) {
- index = r_map_lookup(a, -1, (char*)RVM_CPUREG_GETP(cpu, ins->op3), RVM_CPUREG_GETL(cpu, ins->op1));
+ index = r_map_lookup(a, -1, (char*)RVM_CPUREG_GETP(cpu, ins->op3), (unsigned int)RVM_CPUREG_GETL(cpu, ins->op1));
} else {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
RVM_ABORT(cpu, RVM_E_NOTOBJECT);
}
if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_SINGED || RVM_REG_GETTYPE(arg3) == RVM_DTYPE_UNSIGNED) {
- index = r_map_gckey_add_l(a, cpu->gc, RVM_REG_GETL(arg3), NULL);
+ index = r_map_gckey_add_l(a, cpu->gc, (long)RVM_REG_GETL(arg3), NULL);
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_DOUBLE) {
index = r_map_gckey_add_d(a, cpu->gc, RVM_REG_GETD(arg3), NULL);
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_STRING) {
index = r_map_gckey_add(a, cpu->gc, ((rstring_t *)RVM_CPUREG_GETP(cpu, ins->op3))->s.str, ((rstring_t *)RVM_CPUREG_GETP(cpu, ins->op3))->s.size, NULL);
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_POINTER) {
- index = r_map_gckey_add(a, cpu->gc, (char*)RVM_CPUREG_GETP(cpu, ins->op3), RVM_CPUREG_GETL(cpu, ins->op1), NULL);
+ index = r_map_gckey_add(a, cpu->gc, (char*)RVM_CPUREG_GETP(cpu, ins->op3), (unsigned int)RVM_CPUREG_GETL(cpu, ins->op1), NULL);
} else {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
RVM_ABORT(cpu, RVM_E_NOTOBJECT);
}
if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_SINGED || RVM_REG_GETTYPE(arg3) == RVM_DTYPE_UNSIGNED) {
- index = r_map_lookup_l(a, -1, RVM_REG_GETL(arg3));
+ index = r_map_lookup_l(a, -1, (long)RVM_REG_GETL(arg3));
if (index < 0)
- index = r_map_gckey_add_l(a, cpu->gc, RVM_REG_GETL(arg3), NULL);
+ index = r_map_gckey_add_l(a, cpu->gc, (long)RVM_REG_GETL(arg3), NULL);
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_DOUBLE) {
index = r_map_lookup_d(a, -1, RVM_REG_GETD(arg3));
if (index < 0)
if (index < 0)
index = r_map_gckey_add(a, cpu->gc, ((rstring_t *)RVM_CPUREG_GETP(cpu, ins->op3))->s.str, ((rstring_t *)RVM_CPUREG_GETP(cpu, ins->op3))->s.size, NULL);
} else if (RVM_REG_GETTYPE(arg3) == RVM_DTYPE_POINTER) {
- index = r_map_lookup(a, -1, (char*)RVM_CPUREG_GETP(cpu, ins->op3), RVM_CPUREG_GETL(cpu, ins->op1));
+ index = r_map_lookup(a, -1, (char*)RVM_CPUREG_GETP(cpu, ins->op3), (unsigned int)RVM_CPUREG_GETL(cpu, ins->op1));
if (index < 0)
- index = r_map_gckey_add(a, cpu->gc, (char*)RVM_CPUREG_GETP(cpu, ins->op3), RVM_CPUREG_GETL(cpu, ins->op1), NULL);
+ index = r_map_gckey_add(a, cpu->gc, (char*)RVM_CPUREG_GETP(cpu, ins->op3), (unsigned int)RVM_CPUREG_GETL(cpu, ins->op1), NULL);
} else {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
{
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
- unsigned int index = RVM_CPUREG_GETU(cpu, ins->op3);
+ ruword index = RVM_CPUREG_GETU(cpu, ins->op3);
rcarray_t *a = RVM_REG_GETP(arg2);
if (rvm_reg_gettype(arg2) != RVM_DTYPE_ARRAY) {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
- *arg1 = *((rvmreg_t*)r_carray_slot_expand(a, index));
+ *arg1 = *((rvmreg_t*)r_carray_slot_expand(a, (unsigned long)index));
}
{
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
- unsigned int index = RVM_CPUREG_GETU(cpu, ins->op3);
+ ruword index = RVM_CPUREG_GETU(cpu, ins->op3);
rcarray_t *a = RVM_REG_GETP(arg2);
if (rvm_reg_gettype(arg2) != RVM_DTYPE_ARRAY) {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
}
- r_carray_replace(a, index, arg1);
+ r_carray_replace(a, (unsigned long)index, arg1);
}
}
-int rvm_cpu_global_swilookup(rvmcpu_t *cpu, const char *swiname, rsize_t size)
+int rvm_cpu_global_swilookup(rvmcpu_t *cpu, const char *swiname, unsigned long size)
{
int nswi;
rvm_switable_t *swientry;
- rsize_t ntable;
+ unsigned long ntable;
for (ntable = 0; ntable < r_harray_length(cpu->switables); ntable++) {
swientry = r_harray_index(cpu->switables, ntable, rvm_switable_t*);
}
-int rvm_cpu_table_swilookup(rvmcpu_t *cpu, const char *tabname, const char *swiname, rsize_t size)
+int rvm_cpu_table_swilookup(rvmcpu_t *cpu, const char *tabname, const char *swiname, unsigned long size)
{
int nswi;
rvm_switable_t *swientry;
}
-int rvm_cpu_swilookup(rvmcpu_t *cpu, const char *tabname, const char *swiname, rsize_t size)
+int rvm_cpu_swilookup(rvmcpu_t *cpu, const char *tabname, const char *swiname, unsigned long size)
{
return tabname ? rvm_cpu_table_swilookup(cpu, tabname, swiname, size) : rvm_cpu_global_swilookup(cpu, swiname, size);
}
int rvm_cpu_abort(rvmcpu_t *cpu);
int rvm_cpu_exec(rvmcpu_t *cpu, rvm_asmins_t *prog, ruword off);
int rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, ruword off);
-int rvm_cpu_swilookup(rvmcpu_t *cpu, const char *tabname, const char *swiname, rsize_t size);
+int rvm_cpu_swilookup(rvmcpu_t *cpu, const char *tabname, const char *swiname, unsigned long size);
int rvm_cpu_swilookup_s(rvmcpu_t *cpu, const char *tabname, const char *swiname);
int rvm_cpu_addswitable(rvmcpu_t * cpu, const char *tabname, rvm_switable_t *switalbe);
rvmreg_t *rvm_cpu_alloc_global(rvmcpu_t *cpu);
void rvm_opmap_destroy(rvm_opmap_t *opmap)
{
- rsize_t i;
+ unsigned long i;
rvm_opinfo_t *opinfo;
if (!opmap)
*/
void rvm_reg_array_unref_gcdata(robject_t *obj)
{
- rsize_t i, size;
+ unsigned long i, size;
rvmreg_t *r;
if (obj->type == R_OBJECT_ARRAY) {
int rvm_relocmap_relocate(rvm_relocmap_t *relocmap, rvm_codemap_t *codemap, rvm_asmins_t *code, rvm_codelabel_t **err)
{
- rsize_t index;
+ unsigned long index;
rvm_relocrecord_t *reloc;
ruword value;
void rvm_scope_push(rvm_scope_t* scope)
{
- rsize_t scopelen = r_array_length(scope->varstack);
+ unsigned long scopelen = r_array_length(scope->varstack);
// r_printf("SCOPE FRAME: %d, PUSH: %d\n", r_array_length(scope->scopestack), scopelen);
r_array_add(scope->scopestack, &scopelen);
}
void rvm_scope_pop(rvm_scope_t* scope)
{
- rsize_t scopelen = r_array_index(scope->scopestack, r_array_length(scope->scopestack) - 1, rsize_t);
+ unsigned long scopelen = r_array_index(scope->scopestack, r_array_length(scope->scopestack) - 1, unsigned long);
r_array_removelast(scope->scopestack);
r_array_setlength(scope->varstack, scopelen);
// r_printf("SCOPE FRAME: %d, POP: %d\n", r_array_length(scope->scopestack), scopelen);
rvm_varmap_t *rvm_scope_lookup(rvm_scope_t *scope, const char *name, unsigned int namesize)
{
- rsize_t scopelen = r_array_length(scope->varstack);
+ unsigned long scopelen = r_array_length(scope->varstack);
rvm_varmap_t *varmap;
int i;
rvm_varmap_t *rvm_scope_tiplookup(rvm_scope_t *scope, const char *name, unsigned int namesize)
{
- rsize_t scopelen = r_array_length(scope->varstack);
+ unsigned long scopelen = r_array_length(scope->varstack);
unsigned int tipstart = r_array_empty(scope->scopestack) ? 0 : r_array_last(scope->scopestack, unsigned int);
rvm_varmap_t *varmap;
int i;
