* Common types. These types should be the same for most of the architectures.
*/
typedef long rlong;
-typedef int rint;
+typedef int rinteger;
typedef short rshort;
typedef char rchar;
typedef unsigned long rulong;
-typedef unsigned int ruint;
+typedef unsigned int ruinteger;
typedef unsigned short rushort;
typedef unsigned char ruchar;
typedef ruchar rbyte;
typedef double rdouble;
typedef float rfloat;
-typedef rint rboolean;
+typedef rinteger rboolean;
typedef void *rpointer;
typedef const void *rconstpointer;
typedef struct {ruint32 p1; ruint32 p2;} rpair_t;
+make -C $(SRCDIR)/tests/testrpa/build/$(OS)/$(ARCHDIR) clean
+make -C $(SRCDIR)/tests/testrjs/build/$(OS)/$(ARCHDIR) clean
+make -C $(SRCDIR)/rgrep/build/$(OS)/$(ARCHDIR) clean
-
dnl If your extension references something external, use with:
PHP_ARG_WITH(prpa, for prpa support,
+dnl Make sure that the comment is aligned:
[ --with-prpa Include prpa support])
dnl Otherwise use enable:
dnl Make sure that the comment is aligned:
dnl [ --enable-prpa Enable prpa support])
+
+PHP_ARG_WITH(rtk, path to the rtk dir,
+[ --with-rtk Path to the RTK base dir])
+
if test "$PHP_PRPA" != "no"; then
dnl Write more examples of tests here...
- dnl # --with-prpa -> check with-path
- MACHDIR=`uname -m 2>/dev/null`
- OS=linux
-
- SEARCH_PATH="../../arch/$OS/$MACHDIR" # you might want to change this
- SEARCH_FOR="rtypes.h" # you most likely want to change this
- if test -r $PHP_PRPA/arch/$OS/$MACHDIR/$SEARCH_FOR; then # path given as parameter
- RTYPES_DIR=$PHP_PRPA/arch/$OS/$MACHDIR
+ dnl # --with-rtk -> check with-path
+ SEARCH_PATH="/usr/local /usr ../../.." # you might want to change this
+ SEARCH_FOR="rpa/rpadbex.h" # you most likely want to change this
+ AC_MSG_CHECKING([for $PHP_RTK/$SEARCH_FOR files in default path])
+ if test -r $PHP_RTK/$SEARCH_FOR; then # path given as parameter
+ AC_MSG_RESULT([found])
+ RTK_DIR=$PHP_RTK
else # search default path list
- AC_MSG_CHECKING([for arch files in default path])
- for i in $SEARCH_PATH; do
- if test -r $i/$SEARCH_FOR; then
- RTYPES_DIR=$i
- AC_MSG_RESULT(found in $i)
- fi
- done
-
+ AC_MSG_RESULT([not found])
+ AC_MSG_CHECKING([for rtk/$SEARCH_FOR in default path])
+ for i in $SEARCH_PATH ; do
+ if test -r $i/rtk/$SEARCH_FOR; then
+ RTK_DIR=$i/rtk
+ AC_MSG_RESULT(found in $i)
+ fi
+ done
fi
-
- if test -z "$RTYPES_DIR"; then
- AC_MSG_RESULT([not found])
- AC_MSG_ERROR([arch dir not found in $SEARCH_PATH . Please reinstall the prpa distribution])
- else
- AC_MSG_RESULT([found])
- PHP_ADD_INCLUDE($RTYPES_DIR)
+ if test -z "$RTK_DIR"; then
+ AC_MSG_RESULT([not found])
+ AC_MSG_ERROR([RTK dir not found in $SEARCH_PATH])
fi
- SEARCH_PATH="../../rpa" # you might want to change this
- SEARCH_FOR="rpadbex.h" # you most likely want to change this
- if test -r $PHP_PRPA/$SEARCH_FOR; then # path given as parameter
- PRPA_DIR=$PHP_PRPA
- else # search default path list
- AC_MSG_CHECKING([for prpa files in default path])
- for i in $SEARCH_PATH ; do
- if test -r $i/$SEARCH_FOR; then
- PRPA_DIR=$i
- AC_MSG_RESULT(found in $i)
- fi
- done
- fi
-
- if test -z "$PRPA_DIR"; then
- AC_MSG_RESULT([not found])
- AC_MSG_ERROR([RPA dir not found. Please reinstall the prpa distribution])
- fi
+ OS_DIR=linux
+ MACH=`uname -m`
+ ARCH_DIR=$RTK_DIR/arch/$OS_DIR/$MACH
+ RLIB_DIR=$RTK_DIR/rlib
+ RVM_DIR=$RTK_DIR/rvm
+ RPA_DIR=$RTK_DIR/rpa
+ RLIB_LIBDIR=$RTK_DIR/rlib/build/$OS_DIR/$MACH/out
+ RVM_LIBDIR=$RTK_DIR/rvm/build/$OS_DIR/$MACH/out
+ RPA_LIBDIR=$RTK_DIR/rpa/build/$OS_DIR/$MACH/out
+
+
+ AC_MSG_RESULT([RTK dir is: $RTK_DIR])
+ AC_MSG_RESULT([ARCH dir is: $ARCH_DIR])
+ AC_MSG_RESULT([RLIB dir is: $RLIB_DIR])
+ AC_MSG_RESULT([RVM dir is: $RVM_DIR])
+ AC_MSG_RESULT([RPA dir is: $RPA_DIR])
+ AC_MSG_RESULT([RLIB lib dir is: $RLIB_LIBDIR])
+ AC_MSG_RESULT([RVM lib dir is: $RVM_LIBDIR])
+ AC_MSG_RESULT([RPA lib dir is: $RPA_LIBDIR])
+
+
+ # --with-rtk -> add include path
+ PHP_ADD_INCLUDE($ARCH_DIR)
+ PHP_ADD_INCLUDE($RLIB_DIR)
+ PHP_ADD_INCLUDE($RVM_DIR)
+ PHP_ADD_INCLUDE($RPA_DIR)
+ dnl # --with-prpa -> check with-path
+ dnl SEARCH_PATH="/usr/local /usr" # you might want to change this
+ dnl SEARCH_FOR="/include/prpa.h" # you most likely want to change this
+ dnl if test -r $PHP_PRPA/$SEARCH_FOR; then # path given as parameter
+ dnl PRPA_DIR=$PHP_PRPA
+ dnl else # search default path list
+ dnl AC_MSG_CHECKING([for prpa files in default path])
+ dnl for i in $SEARCH_PATH ; do
+ dnl if test -r $i/$SEARCH_FOR; then
+ dnl PRPA_DIR=$i
+ dnl AC_MSG_RESULT(found in $i)
+ dnl fi
+ dnl done
+ dnl fi
+ dnl
+ dnl if test -z "$PRPA_DIR"; then
+ dnl AC_MSG_RESULT([not found])
+ dnl AC_MSG_ERROR([Please reinstall the prpa distribution])
+ dnl fi
+
+ dnl # --with-rtk -> check for lib and symbol presence
+ LIBNAME=rlib # you may want to change this
+ LIBSYMBOL=r_utf8_mbtowc # you most likely want to change this
+
+ PRPA_SHARED_LIBADD=""
+ PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
+ [
+ PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $RPA_LIBDIR, PRPA_SHARED_LIBADD)
+ AC_DEFINE(HAVE_RPALIB,1,[ ])
+ ],[
+ AC_MSG_RESULT([RPA lib not found])
+ ],[
+ -L$RPA_LIBDIR -L$RVM_LIBDIR -L$RLIB_LIBDIR -lrvm -lrlib -lrpa -lm
+ ])
+
+ PHP_ADD_LIBRARY_WITH_PATH(rpa, $RPA_LIBDIR, PRPA_SHARED_LIBADD)
+ PHP_ADD_LIBRARY_WITH_PATH(rvm, $RVM_LIBDIR, PRPA_SHARED_LIBADD)
+ PHP_ADD_LIBRARY_WITH_PATH(rlib, $RLIB_LIBDIR, PRPA_SHARED_LIBADD)
+ PHP_SUBST(PRPA_SHARED_LIBADD)
- dnl # --with-prpa -> add include path
- PHP_ADD_INCLUDE($PRPA_DIR)
-
-
- dnl # --with-prpa -> check for lib and symbol presence
- LIBNAME=rpa
- LIBSYMBOL=rpa_dbex_create
-
- if test -e "$PRPA_DIR/librpasc.so.1.0" ; then
- PHP_ADD_LIBRARY_WITH_PATH(rpasc, $PRPA_DIR, PRPA_SHARED_LIBADD)
- else
- PHP_ADD_LIBRARY_WITH_PATH(rpasx, $PRPA_DIR, PRPA_SHARED_LIBADD)
- fi
- PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $PRPA_DIR, PRPA_SHARED_LIBADD)
-
-
-# PHP_CHECK_LIBRARY(,$LIBSYMBOL,
-# [
-# AC_DEFINE(HAVE_PRPALIB,1,[ ])
-# ],[
-# AC_MSG_ERROR([wrong rpa lib version or lib not found])
-# ],[
-# -LPRPA_DIR -lrpa -lrpasx -lm
-# ])
- PHP_SUBST(PRPA_SHARED_LIBADD)
PHP_NEW_EXTENSION(prpa, prpa.c, $ext_shared)
-
fi
#include "php_prpa.h"
#include "TSRM/TSRM.h"
#include "rpadbex.h"
-
+#include "rpastat.h"
+#include "rpaerror.h"
+#include "rparecord.h"
typedef struct _php_rpa_dbex {
- rpa_dbex_handle hDbex;
+ rpadbex_t* hDbex;
zval *zinput;
#ifdef ZTS
TSRMLS_D;
typedef struct _php_rpa_pattern {
- rpa_pattern_handle hPattern;
+ rlong hPattern;
} php_rpa_pattern;
#define PHP_RPA_PATTERN_RES_NAME "php rpa pattern"
* Every user visible function must have an entry in prpa_functions[].
*/
zend_function_entry prpa_functions[] = {
- PHP_FE(confirm_prpa_compiled, NULL) /* For testing, remove later. */
PHP_FE(rpa_dbex_version, NULL)
#if 0
PHP_FE(rpa_dbex_strmatch, NULL)
/* If you have INI entries, uncomment these lines
REGISTER_INI_ENTRIES();
*/
- le_rpa_dbex = zend_register_list_destructors_ex(php_rpa_dbex_dtor, NULL, PHP_RPA_DBEX_RES_NAME, module_number);
- le_rpa_pattern = zend_register_list_destructors_ex(php_rpa_pattern_dtor, NULL, PHP_RPA_PATTERN_RES_NAME, module_number);
+// le_rpa_dbex = zend_register_list_destructors_ex(php_rpa_dbex_dtor, NULL, PHP_RPA_DBEX_RES_NAME, module_number);
+// le_rpa_pattern = zend_register_list_destructors_ex(php_rpa_pattern_dtor, NULL, PHP_RPA_PATTERN_RES_NAME, module_number);
REGISTER_LONG_CONSTANT("RPA_ENCODING_BYTE", RPA_ENCODING_BYTE, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("RPA_ENCODING_UTF8", RPA_ENCODING_UTF8, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("RPA_ENCODING_ICASE_UTF8", RPA_ENCODING_ICASE_UTF8, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("RPA_ENCODING_UTF16LE", RPA_ENCODING_UTF16LE, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("RPA_ENCODING_ICASE_UTF16LE", RPA_ENCODING_ICASE_UTF16LE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_PATTERN_SINGLE", RPA_PATTERN_SINGLE, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_PATTERN_BEST", RPA_PATTERN_BEST, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_PATTERN_OR", RPA_PATTERN_OR, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_REASON_START", RPA_REASON_START, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_REASON_END", RPA_REASON_END, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_REASON_MATCHED", RPA_REASON_MATCHED, CONST_CS | CONST_PERSISTENT);
- REGISTER_LONG_CONSTANT("RPA_REASON_ALL", RPA_REASON_ALL, CONST_CS | CONST_PERSISTENT);
-
+ REGISTER_LONG_CONSTANT("RPA_RECORD_START", RPA_RECORD_START, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("RPA_RECORD_END", RPA_RECORD_END, CONST_CS | CONST_PERSISTENT);
return SUCCESS;
}
/* }}} */
fwprintf(stderr, L" OPTIONS:\n");
fwprintf(stderr, L"\t-e patterns execute pattern\n");
fwprintf(stderr, L"\t-f patternfile read the patterns from a file, the last pattern will be executed\n");
- fwprintf(stderr, L"\t-c printpatterns print these patterns when there is a match.\n");
+ fwprintf(stderr, L"\t-c printpatterns printeger these patterns when there is a match.\n");
fwprintf(stderr, L"\t-i ignore case.\n");
fwprintf(stderr, L"\t-m match only from the beginning.\n");
fwprintf(stderr, L"\t-p parse the stream.\n");
}
-rint rjs_engine_open(rjs_engine_t *jse)
+rinteger rjs_engine_open(rjs_engine_t *jse)
{
return 0;
}
-rint rjs_engine_addswitable(rjs_engine_t *jse, const rchar *tabname, rvm_switable_t *switalbe)
+rinteger rjs_engine_addswitable(rjs_engine_t *jse, const rchar *tabname, rvm_switable_t *switalbe)
{
return rvm_cpu_addswitable(jse->cpu, tabname, switalbe);
}
-static rint rjs_engine_parse(rjs_engine_t *jse, const rchar *script, rsize_t size, rarray_t *records, rjs_error_t *error)
+static rinteger rjs_engine_parse(rjs_engine_t *jse, const rchar *script, rsize_t size, rarray_t *records, rjs_error_t *error)
{
rlong res = 0;
}
-rint rjs_engine_compile(rjs_engine_t *jse, const rchar *script, rsize_t size)
+rinteger rjs_engine_compile(rjs_engine_t *jse, const rchar *script, rsize_t size)
{
rvm_codegen_t *topcg = NULL;
rarray_t *records = rpa_records_create();
}
-rint rjs_engine_dumpast(rjs_engine_t *jse, const rchar *script, rsize_t size)
+rinteger rjs_engine_dumpast(rjs_engine_t *jse, const rchar *script, rsize_t size)
{
rjs_error_t error;
rarray_t *records = rpa_records_create();
}
-rint rjs_engine_compile_s(rjs_engine_t *jse, const rchar *script)
+rinteger rjs_engine_compile_s(rjs_engine_t *jse, const rchar *script)
{
return rjs_engine_compile(jse, script, r_strlen(script));
}
-rint rjs_engine_close(rjs_engine_t *jse)
+rinteger rjs_engine_close(rjs_engine_t *jse)
{
return 0;
}
-rint rjs_engine_run(rjs_engine_t *jse)
+rinteger rjs_engine_run(rjs_engine_t *jse)
{
- rint res = 0;
+ rinteger res = 0;
rvm_codegen_t *cg = r_array_empty(jse->cgs) ? NULL : r_array_last(jse->cgs, rvm_codegen_t*);
if (!cg) {
}
-static rint rjs_compiler_argarray_setup(rjs_compiler_t *co)
+static rinteger rjs_compiler_argarray_setup(rjs_compiler_t *co)
{
rvm_varmap_t *v;
rvmreg_t count = rvm_reg_create_long(0);
}
-static rint rjs_compiler_addarg(rjs_compiler_t *co, rvmreg_t *arg)
+static rinteger rjs_compiler_addarg(rjs_compiler_t *co, rvmreg_t *arg)
{
rvm_varmap_t *v;
rmap_t *a;
rjs_engine_t *rjs_engine_create();
void rjs_engine_destroy(rjs_engine_t *jse);
-rint rjs_engine_open(rjs_engine_t *jse);
-rint rjs_engine_compile(rjs_engine_t *jse, const rchar *script, rsize_t size);
-rint rjs_engine_compile_s(rjs_engine_t *jse, const rchar *script);
-rint rjs_engine_close(rjs_engine_t *jse);
-rint rjs_engine_run(rjs_engine_t *jse);
-rint rjs_engine_addswitable(rjs_engine_t *jse, const rchar *tabname, rvm_switable_t *switalbe);
-rint rjs_engine_dumpast(rjs_engine_t *jse, const rchar *script, rsize_t size);
+rinteger rjs_engine_open(rjs_engine_t *jse);
+rinteger rjs_engine_compile(rjs_engine_t *jse, const rchar *script, rsize_t size);
+rinteger rjs_engine_compile_s(rjs_engine_t *jse, const rchar *script);
+rinteger rjs_engine_close(rjs_engine_t *jse);
+rinteger rjs_engine_run(rjs_engine_t *jse);
+rinteger rjs_engine_addswitable(rjs_engine_t *jse, const rchar *tabname, rvm_switable_t *switalbe);
+rinteger rjs_engine_dumpast(rjs_engine_t *jse, const rchar *script, rsize_t size);
rvmreg_t *rjs_engine_exec(rjs_engine_t *jse, const rchar *script, rsize_t size);
rvmreg_t *rjs_engine_vexec(rjs_engine_t *jse, const rchar *script, rsize_t size, rsize_t nargs, va_list args);
rvmreg_t *rjs_engine_args_exec(rjs_engine_t *jse, const rchar *script, rsize_t size, rsize_t nargs, ...);
#include "rjsparser.h"
-rint rjs_compiler_playreversechildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec);
-static rint rjs_compiler_playrecord(rjs_compiler_t *co, rarray_t *records, rlong rec);
-static rint rjs_compiler_playchildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec);
+rinteger rjs_compiler_playreversechildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec);
+static rinteger rjs_compiler_playrecord(rjs_compiler_t *co, rarray_t *records, rlong rec);
+static rinteger rjs_compiler_playchildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec);
void rjs_compiler_debughead(rjs_compiler_t *co, rarray_t *records, rlong rec)
}
-static rint rjs_compiler_internalvars_setup(rjs_compiler_t *co)
+static rinteger rjs_compiler_internalvars_setup(rjs_compiler_t *co)
{
rvm_varmap_t *v;
}
-rint rjs_compiler_rh_program(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_program(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rjs_coctx_global_t ctx;
rparecord_t *prec;
}
-rint rjs_compiler_rh_varalloc(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_varalloc(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_varallocinit(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_varallocinit(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_initializer(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_initializer(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_identifier(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_identifier(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rvm_varmap_t *v;
rparecord_t *prec;
}
-rint rjs_compiler_rh_expression(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_expression(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_lefthandsideexpression(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_lefthandsideexpression(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_lefthandsideexpressionaddr(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_lefthandsideexpressionaddr(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_decimalintegerliteral(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_decimalintegerliteral(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_decimalnonintegerliteral(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_decimalnonintegerliteral(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_stringcharacters(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_stringcharacters(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_stringliteral(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_stringliteral(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_binaryexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_binaryexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_operation_t ctx;
}
-rint rjs_compiler_rh_unaryexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_unaryexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_operation_t ctx;
}
-rint rjs_compiler_rh_assignmentexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_assignmentexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_operation_t ctx;
}
-rint rjs_compiler_rh_newarrayexpression(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_newarrayexpression(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_memberexpressiondotop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_memberexpressiondotop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rjs_coctx_t *ctx = rjs_compiler_gettopctx(co);
rparecord_t *prec;
}
-rint rjs_compiler_rh_memberexpressionindexop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_memberexpressionindexop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rjs_coctx_t *ctx = rjs_compiler_gettopctx(co);
rparecord_t *prec;
}
-rint rjs_compiler_rh_functiondeclaration(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_functiondeclaration(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rjs_coctx_function_t ctx;
rparecord_t *prec;
}
-rint rjs_compiler_rh_functionparameter(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_functionparameter(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rjs_coctx_t *ctx = NULL;
rjs_coctx_function_t *functx = NULL;
}
-rint rjs_compiler_rh_functioncall(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_functioncall(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_functioncall_t ctx;
}
-rint rjs_compiler_rh_argument(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_argument(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_functioncall_t *ctx = (rjs_coctx_functioncall_t *)rjs_compiler_getctx(co, RJS_COCTX_FUNCTIONCALL);
}
-rint rjs_compiler_rh_arguments(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_arguments(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_functioncall_t *ctx = (rjs_coctx_functioncall_t *)rjs_compiler_getctx(co, RJS_COCTX_FUNCTIONCALL);
}
-rint rjs_compiler_rh_returnstatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_returnstatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_ifstatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_ifstatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_ifstatement_t ctx;
}
-rint rjs_compiler_rh_ifconditionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_ifconditionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_ifstatement_t *ctx = (rjs_coctx_ifstatement_t *)rjs_compiler_getctx(co, RJS_COCTX_IFSTATEMENT);
}
-rint rjs_compiler_rh_iftruestatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_iftruestatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_ifstatement_t *ctx = (rjs_coctx_ifstatement_t *)rjs_compiler_getctx(co, RJS_COCTX_IFSTATEMENT);
}
-rint rjs_compiler_rh_iffalsestatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_iffalsestatement(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_ifstatement_t *ctx = (rjs_coctx_ifstatement_t *)rjs_compiler_getctx(co, RJS_COCTX_IFSTATEMENT);
}
-rint rjs_compiler_rh_iterationfor(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_iterationfor(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rlong childrec;
rparecord_t *prec;
}
-rint rjs_compiler_rh_iterationwhile(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_iterationwhile(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_iteration_t ctx;
}
-rint rjs_compiler_rh_iterationdo(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_iterationdo(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_iteration_t ctx;
}
-rint rjs_compiler_rh_dowhileexpressioncompare(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_dowhileexpressioncompare(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_iteration_t *ctx = (rjs_coctx_iteration_t *)rjs_compiler_getctx(co, RJS_COCTX_ITERATION);
}
-rint rjs_compiler_rh_forexpressioncompare(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_forexpressioncompare(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_iteration_t *ctx = (rjs_coctx_iteration_t *)rjs_compiler_getctx(co, RJS_COCTX_ITERATION);
}
-rint rjs_compiler_rh_forexpressionincrement(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_forexpressionincrement(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_iteration_t *ctx = (rjs_coctx_iteration_t *)rjs_compiler_getctx(co, RJS_COCTX_ITERATION);
}
-rint rjs_compiler_rh_postfixexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_postfixexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rlong opcode;
}
-rint rjs_compiler_rh_prefixexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_prefixexpressionop(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rlong opcode;
}
-rint rjs_compiler_rh_newexpressioncall(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_newexpressioncall(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_functioncall_t ctx;
}
-rint rjs_compiler_rh_this(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_this(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_binaryoperator(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_binaryoperator(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_t *ctx = rjs_compiler_gettopctx(co);
}
-rint rjs_compiler_rh_unaryoperator(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_unaryoperator(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_t *ctx = rjs_compiler_gettopctx(co);
}
-rint rjs_compiler_rh_identifiername(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_identifiername(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_continue(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_continue(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_t *ctx;
}
-rint rjs_compiler_rh_break(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_break(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
rjs_coctx_t *ctx;
}
-rint rjs_compiler_rh_syntaxerror(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_syntaxerror(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_block(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_block(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_rh_(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_rh_(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-static rint rjs_compiler_rh_default(rjs_compiler_t *co, rarray_t *records, rlong rec)
+static rinteger rjs_compiler_rh_default(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
}
-static rint rjs_compiler_playchildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec)
+static rinteger rjs_compiler_playchildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rlong child;
}
-rint rjs_compiler_playreversechildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec)
+rinteger rjs_compiler_playreversechildrecords(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rlong child;
}
-static rint rjs_compiler_playrecord(rjs_compiler_t *co, rarray_t *records, rlong rec)
+static rinteger rjs_compiler_playrecord(rjs_compiler_t *co, rarray_t *records, rlong rec)
{
rparecord_t *prec;
prec = (rparecord_t *)r_array_slot(records, rec);
}
-rint rjs_compiler_compile(rjs_compiler_t *co, const rchar *script, rsize_t scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error)
+rinteger rjs_compiler_compile(rjs_compiler_t *co, const rchar *script, rsize_t scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error)
{
rlong i;
rvm_codelabel_t *labelerr;
typedef struct rjs_compiler_s rjs_compiler_t;
-typedef rint (*RJS_COMPILER_RH)(rjs_compiler_t *co, rarray_t *records, rlong rec);
+typedef rinteger (*RJS_COMPILER_RH)(rjs_compiler_t *co, rarray_t *records, rlong rec);
struct rjs_compiler_s {
rvmcpu_t *cpu;
rjs_compiler_t *rjs_compiler_create(rvmcpu_t *cpu);
void rjs_compiler_destroy(rjs_compiler_t *co);
-rint rjs_compiler_compile(rjs_compiler_t *co, const rchar *script, rsize_t scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error);
+rinteger rjs_compiler_compile(rjs_compiler_t *co, const rchar *script, rsize_t scriptsize, rarray_t *records, rvm_codegen_t *cg, rjs_error_t *error);
rjs_coctx_t *rjs_compiler_getctx(rjs_compiler_t *co, rulong type);
#ifdef __cplusplus
int main(int argc, char *argv[])
{
- rint i;
+ rinteger i;
rstr_t *script = NULL, *unmapscript = NULL;
rstr_t line;
rjs_engine_t *jse;
+RTK_LIB_INSTALL=/usr/lib
RLIB_SRCDIR = $(SRCDIR)/rlib
-RLIB_LIB = $(OUTDIR)/librlib.a
-RLIB_SO = $(OUTDIR)/librlib.so.1.0
+RLIB_LIB = librlib.a
+RLIB_SO = librlib.so.1.0
+TARGET_RLIB_LIB = $(OUTDIR)/$(RLIB_LIB)
+TARGET_RLIB_SO = $(OUTDIR)/$(RLIB_SO)
RLIB_OBJECTS += $(OUTDIR)/rref.o
ifeq ($(OS), linux)
-all: $(OUTDIR) $(RLIB_LIB) $(RLIB_SO)
+all: $(OUTDIR) $(TARGET_RLIB_LIB) $(TARGET_RLIB_SO)
else
-all: $(OUTDIR) $(RLIB_LIB)
+all: $(OUTDIR) $(TARGET_RLIB_LIB)
endif
$(OUTDIR)/%.o: $(RLIB_SRCDIR)/%.c
+ $(CC) $(CFLAGS) -o $(OUTDIR)/$*.o -c $(RLIB_SRCDIR)/$*.c
-$(RLIB_LIB): $(RLIB_OBJECTS)
+$(TARGET_RLIB_LIB): $(RLIB_OBJECTS)
$(AR) -cr $@ $^
-$(RLIB_SO): $(RLIB_OBJECTS)
+$(TARGET_RLIB_SO): $(RLIB_OBJECTS)
$(CC) $(LDFLAGS) -shared -Wl,-soname,librlib.so -o $@ $^
$(OUTDIR):
@rm -rf $(OUTDIR)
clean:
- @rm -f $(RLIB_LIB)
- @rm -f $(RLIB_SO)
+ @rm -f $(TARGET_RLIB_LIB)
+ @rm -f $(TARGET_RLIB_SO)
@rm -f $(RLIB_OBJECTS)
@rm -f *~
@rm -f $(SRCDIR)/*~
+install:
+ cp $(TARGET_RLIB_SO) $(RTK_LIB_INSTALL)
+ cp $(TARGET_RLIB_LIB) $(RTK_LIB_INSTALL)
+
+uninstall:
+ rm $(RTK_LIB_INSTALL)/$(RLIB_LIB)
+ rm $(RTK_LIB_INSTALL)/$(RLIB_SO)
}
-rint r_array_move(rarray_t *array, rlong dest, rlong src, rlong size)
+rinteger r_array_move(rarray_t *array, rlong dest, rlong src, rlong size)
{
rlong i;
if (src == dest)
rarray_t *r_array_create(rsize_t elt_size);
void r_array_destroy(rarray_t *array);
rsize_t r_array_add(rarray_t *array, rconstpointer data);
-rint r_array_move(rarray_t *array, rlong dest, rlong src, rlong size);
+rinteger r_array_move(rarray_t *array, rlong dest, rlong src, rlong 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);
}
-rint r_carray_replace(rcarray_t *carray, rsize_t index, rconstpointer data)
+rinteger r_carray_replace(rcarray_t *carray, rsize_t index, rconstpointer data)
{
if (data)
r_memcpy(r_carray_slot_expand(carray, index), data, carray->elt_size);
}
-rint r_carray_add(rcarray_t *carray, rconstpointer data)
+rinteger r_carray_add(rcarray_t *carray, rconstpointer data)
{
rsize_t index = r_carray_length(carray);
r_carray_inclength(carray);
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);
void r_carray_destroy(rcarray_t *array);
-rint r_carray_replace(rcarray_t *carray, rsize_t index, rconstpointer data);
-rint r_carray_add(rcarray_t *carray, rconstpointer data);
+rinteger r_carray_replace(rcarray_t *carray, rsize_t index, rconstpointer data);
+rinteger r_carray_add(rcarray_t *carray, rconstpointer data);
void r_carray_setlength(rcarray_t *carray, rsize_t len);
void r_carray_inclength(rcarray_t *carray);
void r_carray_inclength(rcarray_t *carray);
typedef struct rgc_s {
robject_t obj;
rhead_t head[2];
- ruint active;
+ ruinteger active;
} rgc_t;
*/
static void r_array_oncopy_rstr(rarray_t *array)
{
- ruint index;
+ ruinteger index;
rstr_t *src, *dst;
for (index = 0; index < r_array_length(array); index++) {
*/
static void r_array_oncleanup_rstr(rarray_t *array)
{
- ruint index;
+ ruinteger index;
rstr_t *src;
for (index = 0; index < r_array_length(array); index++) {
}
-robject_t *r_harray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, ruint elt_size)
+robject_t *r_harray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, ruinteger elt_size)
{
rharray_t *harray = (rharray_t*)obj;
r_object_init(obj, type, cleanup, copy);
return obj;
}
-rharray_t *r_harray_create(ruint elt_size)
+rharray_t *r_harray_create(ruinteger elt_size)
{
rharray_t *harray;
}
-rint r_harray_set(rharray_t *harray, rlong index, rconstpointer pval)
+rinteger r_harray_set(rharray_t *harray, rlong index, rconstpointer pval)
{
if (index < 0)
return -1;
} rharray_t;
-rharray_t *r_harray_create(ruint elt_size);
+rharray_t *r_harray_create(ruinteger elt_size);
void r_harray_destroy(rharray_t *array);
-robject_t *r_harray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, ruint elt_size);
+robject_t *r_harray_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, ruinteger elt_size);
rlong r_harray_add(rharray_t *harray, const rchar *name, rsize_t namesize, rconstpointer pval);
rlong r_harray_add_s(rharray_t *harray, const rchar *name, rconstpointer pval);
rlong r_harray_replace(rharray_t *harray, const rchar *name, rsize_t namesize, rconstpointer pval);
rhash_node_t* r_harray_nodetaillookup(rharray_t *harray, rhash_node_t *cur, const rchar *name, rsize_t namesize);
rhash_node_t* r_harray_nodetaillookup_s(rharray_t *harray, rhash_node_t *cur, const rchar *name);
rpointer r_harray_get(rharray_t *harray, rsize_t index);
-rint r_harray_set(rharray_t *harray, rlong index, rconstpointer pval);
+rinteger r_harray_set(rharray_t *harray, rlong index, rconstpointer pval);
robject_t *r_harray_copy(const robject_t *obj);
void r_harray_cleanup(robject_t *obj);
rhash_node_t *r_hash_nodetaillookup(rhash_t* hash, rhash_node_t *cur, rconstpointer key)
{
- ruint nbucket = hash->hfunc(key) & r_hash_mask(hash);
+ ruinteger nbucket = hash->hfunc(key) & r_hash_mask(hash);
rhead_t *bucket = &hash->buckets[nbucket];
rhash_node_t *node;
rlink_t *pos;
rhash_node_t *r_hash_nodelookup(rhash_t* hash, rhash_node_t *cur, rconstpointer key)
{
- ruint nbucket = hash->hfunc(key) & r_hash_mask(hash);
+ ruinteger nbucket = hash->hfunc(key) & r_hash_mask(hash);
rhead_t *bucket = &hash->buckets[nbucket];
rhash_node_t *node;
rlink_t *pos;
}
-ruint r_hash_strhash(rconstpointer key)
+ruinteger r_hash_strhash(rconstpointer key)
{
const rchar *str = (const rchar*) key;
- ruint hash = 0;
+ ruinteger hash = 0;
int c;
while ((c = *str++))
}
-ruint r_hash_rstrhash(rconstpointer key)
+ruinteger r_hash_rstrhash(rconstpointer key)
{
const rstr_t *k = (const rstr_t *)key;
const rchar *str = (const rchar*) k->str;
- ruint i;
- ruint size = k->size;
- ruint hash = 0;
+ ruinteger i;
+ ruinteger size = k->size;
+ ruinteger hash = 0;
for (i = 0; i < size; i++, str++) {
hash = *str + (hash << 6) + (hash << 16) - hash;
}
-rhash_t *r_hash_create(ruint nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc)
+rhash_t *r_hash_create(ruinteger nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc)
{
rhash_t *hash;
robject_t *r_hash_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy,
- ruint nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc)
+ ruinteger nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc)
{
- ruint i;
+ ruinteger i;
rsize_t size;
rhash_t *hash = (rhash_t *)obj;
void r_hash_insert(rhash_t* hash, rconstpointer key, rpointer value)
{
- ruint nbucket = hash->hfunc(key) & r_hash_mask(hash);
+ ruinteger nbucket = hash->hfunc(key) & r_hash_mask(hash);
rhash_node_t *node = r_hash_node_create();
rhead_t *buckethead = &hash->buckets[nbucket];
if (node) {
void r_hash_removeall(rhash_t* hash)
{
- ruint nbucket;
+ ruinteger nbucket;
rhead_t *head;
rhash_node_t *node;
void r_hash_insert_indexval(rhash_t* hash, rconstpointer key, rulong index)
{
- ruint nbucket = hash->hfunc(key) & r_hash_mask(hash);
+ ruinteger nbucket = hash->hfunc(key) & r_hash_mask(hash);
rhash_node_t *node = r_hash_node_create();
rhead_t *buckethead = &hash->buckets[nbucket];
if (node) {
typedef struct rhash_node_s rhash_node_t;
typedef struct rhash_s rhash_t;
typedef rboolean (*r_hash_equalfunc)(rconstpointer key1, rconstpointer key2);
-typedef ruint (*r_hash_hashfun)(rconstpointer key);
+typedef ruinteger (*r_hash_hashfun)(rconstpointer key);
struct rhash_s {
robject_t obj;
rlist_t *buckets;
- ruint nbits;
+ ruinteger nbits;
r_hash_equalfunc eqfunc;
r_hash_hashfun hfunc;
};
#define r_hash_size(__h__) (1 << (__h__)->nbits)
#define r_hash_mask(__h__) (r_hash_size(__h__) - 1)
-rhash_t *r_hash_create(ruint nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc);
+rhash_t *r_hash_create(ruinteger nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc);
void r_hash_destroy(rhash_t* hash);
robject_t *r_hash_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy,
- ruint nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc);
+ ruinteger nbits, r_hash_equalfunc eqfunc, r_hash_hashfun hfunc);
void r_hash_insert(rhash_t* hash, rconstpointer key, rpointer value);
void r_hash_remove(rhash_t* hash, rconstpointer key);
rpointer r_hash_value(rhash_node_t *node);
rulong r_hash_indexval(rhash_node_t *node);
-ruint r_hash_strhash(rconstpointer key);
+ruinteger r_hash_strhash(rconstpointer key);
rboolean r_hash_strequal(rconstpointer key1, rconstpointer key2);
-ruint r_hash_rstrhash(rconstpointer key);
+ruinteger r_hash_rstrhash(rconstpointer key);
rboolean r_hash_rstrequal(rconstpointer key1, rconstpointer key2);
}
-robject_t *r_map_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, ruint elt_size, ruint nbits)
+robject_t *r_map_init(robject_t *obj, ruint32 type, r_object_cleanupfun cleanup, r_object_copyfun copy, ruinteger elt_size, ruinteger nbits)
{
rsize_t elt_realsize = R_SIZE_ALIGN(elt_size + sizeof(r_mapnode_t), sizeof(rword));
rsize_t hashsize, i;
return obj;
}
-rmap_t *r_map_create(ruint elt_size, ruint nbits)
+rmap_t *r_map_create(ruinteger elt_size, ruinteger nbits)
{
rmap_t *map;
map = (rmap_t*)r_object_create(sizeof(*map));
}
-rint r_map_delete(rmap_t *map, rulong index)
+rinteger r_map_delete(rmap_t *map, rulong index)
{
r_mapnode_t *node = r_map_node(map, index);
if (!node)
typedef struct rmap_s {
robject_t obj;
- ruint nbits;
- ruint elt_size;
+ ruinteger nbits;
+ ruinteger elt_size;
rcarray_t *data;
rlist_t *hash;
rlist_t active;
} rmap_t;
-rmap_t *r_map_create(ruint elt_size, ruint nbits);
+rmap_t *r_map_create(ruinteger elt_size, ruinteger nbits);
void r_map_destroy(rmap_t *array);
rlong r_map_lookup(rmap_t *map, rlong current, const rchar *name, rsize_t namesize);
rlong r_map_lookup_s(rmap_t *map, rlong current, const rchar *name);
rlong r_map_setvalue(rmap_t *map, rlong index, rconstpointer pval);
rstring_t *r_map_key(rmap_t *map, rulong index);
rpointer r_map_value(rmap_t *map, rulong index);
-rint r_map_delete(rmap_t *map, rulong index);
+rinteger r_map_delete(rmap_t *map, rulong index);
rlong r_map_first(rmap_t *map);
rlong r_map_last(rmap_t *map);
}
-rpointer r_memset(rpointer s, rint c, rsize_t n)
+rpointer r_memset(rpointer s, rinteger c, rsize_t n)
{
return memset((void*)s, (int)c, (size_t)n);
}
rpointer r_calloc(rsize_t nmemb, rsize_t size);
void r_free(rpointer ptr);
rpointer r_zmalloc(rsize_t size);
-rpointer r_memset(rpointer s, rint c, rsize_t n);
+rpointer r_memset(rpointer s, rinteger 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();
#include "rmem.h"
-rint r_strcmp(const rchar *s1, const rchar *s2)
+rinteger r_strcmp(const rchar *s1, const rchar *s2)
{
return strcmp(s1, s2);
}
-rint r_strncmp(const rchar *s1, const rchar *s2, rsize_t n)
+rinteger r_strncmp(const rchar *s1, const rchar *s2, rsize_t n)
{
int ret = strncmp(s1, s2, (size_t)n);
return ret;
}
-rchar *r_strchr(const rchar *s, rint c)
+rchar *r_strchr(const rchar *s, rinteger c)
{
return strchr(s, c);
}
}
-rstr_t *r_rstrdup(const rchar *s, ruint size)
+rstr_t *r_rstrdup(const rchar *s, ruinteger size)
{
rsize_t allocsize = sizeof(rstr_t) + size + sizeof(rchar);
rstr_t *d = (rstr_t*)r_malloc(allocsize);
}
-rint r_vsnprintf(rchar *str, ruint size, const rchar *format, va_list ap)
+rinteger r_vsnprintf(rchar *str, ruinteger size, const rchar *format, va_list ap)
{
return vsnprintf(str, size, format, ap);
}
}
-rchar *r_strncat(rchar *dest, const rchar *src, ruint n)
+rchar *r_strncat(rchar *dest, const rchar *src, ruinteger n)
{
return strncat(dest, src, n);
}
-rint r_snprintf(rchar *str, ruint size, const rchar *format, ...)
+rinteger r_snprintf(rchar *str, ruinteger size, const rchar *format, ...)
{
va_list ap;
int ret;
}
-rint r_printf(const rchar *format, ...)
+rinteger r_printf(const rchar *format, ...)
{
va_list ap;
int ret;
}
-rulong r_strtoul(const rchar *nptr, rchar **endptr, rint base)
+rulong r_strtoul(const rchar *nptr, rchar **endptr, rinteger base)
{
return strtoul(nptr, endptr,base);
}
-rlong r_strtol(const rchar *s, rchar **endptr, rint base)
+rlong r_strtol(const rchar *s, rchar **endptr, rinteger base)
{
return strtol(s, endptr, base);
}
rstring_t *r_string_create_from_double(rdouble d)
{
char temp[128];
- rint size;
+ rinteger size;
r_memset(temp, 0, sizeof(temp));
size = r_snprintf(temp, sizeof(temp) - 1, "%f", d);
rstring_t *r_string_create_from_long(rlong l)
{
char temp[128];
- rint size;
+ rinteger size;
r_memset(temp, 0, sizeof(temp));
size = r_snprintf(temp, sizeof(temp) - 1, "%ld", l);
}
-rstring_t *r_string_create_strsize(const rchar *str, ruint size)
+rstring_t *r_string_create_strsize(const rchar *str, ruinteger size)
{
rstr_t rstr;
} rstr_t;
-rint r_strcmp(const rchar *s1, const rchar *s2);
-rint r_strncmp(const rchar *s1, const rchar *s2, rsize_t n);
+rinteger r_strcmp(const rchar *s1, const rchar *s2);
+rinteger r_strncmp(const rchar *s1, const rchar *s2, rsize_t n);
rboolean r_stringncmp(const rchar *str, const rchar *s2, rsize_t n);
rsize_t r_strlen(const rchar *s);
rchar *r_strstr(const rchar *haystack, const rchar *needle);
-rchar *r_strchr(const rchar *s, rint c);
+rchar *r_strchr(const rchar *s, rinteger c);
rchar *r_strdup(const rchar *s);
rchar *r_strndup(const rchar *s, rsize_t size);
rchar *r_strcpy(rchar *dest, const rchar *src);
rchar *r_strncpy(rchar *dest, const rchar *src, rsize_t n);
rchar *r_strcat(rchar *dest, const rchar *src);
-rchar *r_strncat(rchar *dest, const rchar *src, ruint n);
-rint r_snprintf(rchar *str, ruint size, const rchar *format, ...);
-rint r_printf(const rchar *format, ...);
+rchar *r_strncat(rchar *dest, const rchar *src, ruinteger n);
+rinteger r_snprintf(rchar *str, ruinteger size, const rchar *format, ...);
+rinteger r_printf(const rchar *format, ...);
-rulong r_strtoul(const rchar *nptr, rchar **endptr, rint base);
-rlong r_strtol(const rchar *s, rchar **endptr, rint base);
+rulong r_strtoul(const rchar *nptr, rchar **endptr, rinteger base);
+rlong r_strtol(const rchar *s, rchar **endptr, rinteger base);
rdouble r_strtod(const rchar *s, rchar **endptr);
-rstr_t *r_rstrdup(const rchar *s, ruint size);
+rstr_t *r_rstrdup(const rchar *s, ruinteger size);
typedef struct rstring_s {
rstring_t *r_string_create_from_ansistr(const rchar *str);
rstring_t *r_string_create_from_double(rdouble d);
rstring_t *r_string_create_from_long(rlong l);
-rstring_t *r_string_create_strsize(const char *str, ruint size);
+rstring_t *r_string_create_strsize(const char *str, ruinteger 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);
#include "rutf.h"
-rint r_utf8_mbtowc(ruint32 *pwc, const ruchar *input, const ruchar *end)
+rinteger r_utf8_mbtowc(ruint32 *pwc, const ruchar *input, const ruchar *end)
{
- rint n;
+ rinteger n;
ruchar c;
if (input >= end) {
*pwc = c;
return 1;
}
- n = (rint)(end - input);
+ n = (rinteger)(end - input);
if (c == 0xC0 || c == 0xC1 || (c >= 0xF5 && c <= 0xFF))
goto error;
if ((c >> 5) == 6) {
}
-rint r_utf8_wctomb(ruint32 wc, ruchar *output, ruint32 size)
+rinteger r_utf8_wctomb(ruint32 wc, ruchar *output, ruint32 size)
{
ruint32 count;
if (wc <= 0x007F)
}
-rint r_utf16_mbtowc(ruint32 *pwc, const ruchar *s, const ruchar *end)
+rinteger r_utf16_mbtowc(ruint32 *pwc, const ruchar *s, const ruchar *end)
{
- rint n = (rint)(end - s);
+ rinteger n = (rinteger)(end - s);
ruint32 wc1, wc2;
if (s >= end) {
}
-rint r_utf16_wctomb(ruint32 wc, ruchar *output, ruint32 size)
+rinteger r_utf16_wctomb(ruint32 wc, ruchar *output, ruint32 size)
{
ruint32 wc1, wc2;
#endif
-rint r_utf8_mbtowc(ruint32 *pwc, const ruchar *input, const ruchar *end);
-rint r_utf8_wctomb(ruint32 wc, ruchar *output, ruint32 size);
-rint r_utf16_mbtowc(ruint32 *pwc, const ruchar *s, const ruchar *end);
-rint r_utf16_wctomb(ruint32 wc, ruchar *output, ruint32 size);
+rinteger r_utf8_mbtowc(ruint32 *pwc, const ruchar *input, const ruchar *end);
+rinteger r_utf8_wctomb(ruint32 wc, ruchar *output, ruint32 size);
+rinteger r_utf16_mbtowc(ruint32 *pwc, const ruchar *s, const ruchar *end);
+rinteger r_utf16_wctomb(ruint32 wc, ruchar *output, ruint32 size);
#ifdef __cplusplus
}
-void rpa_compiler_index_reference(rpa_compiler_t *co, rulong index, ruint qflag)
+void rpa_compiler_index_reference(rpa_compiler_t *co, rulong index, ruinteger qflag)
{
if (qflag == RPA_MATCH_OPTIONAL) {
rpa_compiler_index_reference_opt(co, index);
}
-void rpa_compiler_reference(rpa_compiler_t *co, const rchar *name, rsize_t namesize, ruint qflag)
+void rpa_compiler_reference(rpa_compiler_t *co, const rchar *name, rsize_t namesize, ruinteger qflag)
{
rpa_compiler_index_reference(co, rvm_codemap_lookupadd(co->cg->codemap, name, namesize), qflag);
}
-void rpa_compiler_reference_s(rpa_compiler_t *co, const rchar *name, ruint qflag)
+void rpa_compiler_reference_s(rpa_compiler_t *co, const rchar *name, ruinteger qflag)
{
rpa_compiler_reference(co, name, r_strlen(name), qflag);
}
}
-rpa_rulepref_t *rpa_compiler_rulepref_lookup(rpa_compiler_t *co, const rchar *name, ruint namesize)
+rpa_rulepref_t *rpa_compiler_rulepref_lookup(rpa_compiler_t *co, const rchar *name, ruinteger namesize)
{
rlong index = r_harray_lookup(co->ruleprefs, name, namesize);
if (index < 0)
}
-rpa_rulepref_t *rpa_compiler_rulepref(rpa_compiler_t *co, const rchar *name, ruint namesize)
+rpa_rulepref_t *rpa_compiler_rulepref(rpa_compiler_t *co, const rchar *name, ruinteger namesize)
{
rlong index = r_harray_lookup(co->ruleprefs, name, namesize);
if (index < 0)
}
-void rpa_compiler_rulepref_set_ruleuid(rpa_compiler_t *co, const rchar *name, ruint namesize, rlong ruleuid)
+void rpa_compiler_rulepref_set_ruleuid(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid)
{
rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
}
-void rpa_compiler_rulepref_set_flag(rpa_compiler_t *co, const rchar *name, ruint namesize, rulong flag)
+void rpa_compiler_rulepref_set_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag)
{
rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
}
-void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruint namesize, rulong flag)
+void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag)
{
rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
}
-void rpa_compiler_rulepref_set_ruleuid_flags(rpa_compiler_t *co, const rchar *name, ruint namesize, rlong ruleuid, rulong flags)
+void rpa_compiler_rulepref_set_ruleuid_flags(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid, rulong flags)
{
rpa_rulepref_t *rulepref = rpa_compiler_rulepref(co, name, namesize);
}
-rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesize)
+rinteger rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize)
{
rpa_ruledef_t exp;
rlong ruleuid = RPA_RECORD_INVALID_UID;
}
-rint rpa_compiler_loop_begin_s(rpa_compiler_t *co, const rchar *name)
+rinteger rpa_compiler_loop_begin_s(rpa_compiler_t *co, const rchar *name)
{
return rpa_compiler_loop_begin(co, name, r_strlen(name));
}
-rint rpa_compiler_loop_end(rpa_compiler_t *co)
+rinteger rpa_compiler_loop_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruint namesize)
+rinteger rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize)
{
rpa_ruledef_t exp;
rlong ruleuid = RPA_RECORD_INVALID_UID;
}
-rint rpa_compiler_rule_begin_s(rpa_compiler_t *co, const rchar *name)
+rinteger rpa_compiler_rule_begin_s(rpa_compiler_t *co, const rchar *name)
{
return rpa_compiler_rule_begin(co, name, r_strlen(name));
}
-rint rpa_compiler_rule_end(rpa_compiler_t *co)
+rinteger rpa_compiler_rule_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_inlinerule_begin(rpa_compiler_t *co, const rchar *name, ruint namesize, ruint flags)
+rinteger rpa_compiler_inlinerule_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize, ruinteger flags)
{
rpa_ruledef_t exp;
rlong ruleuid = RPA_RECORD_INVALID_UID;
}
-rint rpa_compiler_inlinerule_begin_s(rpa_compiler_t *co, const rchar *name, ruint flags)
+rinteger rpa_compiler_inlinerule_begin_s(rpa_compiler_t *co, const rchar *name, ruinteger flags)
{
return rpa_compiler_inlinerule_begin(co, name, r_strlen(name), flags);
}
-rint rpa_compiler_inlinerule_end(rpa_compiler_t *co)
+rinteger rpa_compiler_inlinerule_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_exp_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_exp_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_exp_end(rpa_compiler_t *co)
+rinteger rpa_compiler_exp_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_altexp_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_altexp_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_altexp_end(rpa_compiler_t *co)
+rinteger rpa_compiler_altexp_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_branch_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_branch_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_branch_end(rpa_compiler_t *co)
+rinteger rpa_compiler_branch_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_nonloopybranch_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_nonloopybranch_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_nonloopybranch_end(rpa_compiler_t *co)
+rinteger rpa_compiler_nonloopybranch_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_class_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_class_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_class_end(rpa_compiler_t *co)
+rinteger rpa_compiler_class_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_notexp_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_notexp_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_notexp_end(rpa_compiler_t *co)
+rinteger rpa_compiler_notexp_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
}
-rint rpa_compiler_negexp_begin(rpa_compiler_t *co, ruint flags)
+rinteger rpa_compiler_negexp_begin(rpa_compiler_t *co, ruinteger flags)
{
rpa_ruledef_t exp;
}
-rint rpa_compiler_negexp_end(rpa_compiler_t *co)
+rinteger rpa_compiler_negexp_end(rpa_compiler_t *co)
{
rpa_ruledef_t exp = r_array_pop(co->expressions, rpa_ruledef_t);
rlong successidx;
rlong failidx;
rlong againidx;
- ruint ruleuid;
- ruint flags;
+ ruinteger ruleuid;
+ ruinteger flags;
rpa_rulepref_t *rulepref;
} rpa_ruledef_t;
rlong rpa_compiler_addblob(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, rulong flags, const rchar *name, rulong namesize);
rlong rpa_compiler_addblob_s(rpa_compiler_t *co, rlong ruleid, rlong ruleuid, rulong flags, const rchar *name);
-rint rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruint namesize);
-rint rpa_compiler_loop_begin_s(rpa_compiler_t *co, const rchar *name);
-rint rpa_compiler_loop_end(rpa_compiler_t *co);
+rinteger rpa_compiler_loop_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize);
+rinteger rpa_compiler_loop_begin_s(rpa_compiler_t *co, const rchar *name);
+rinteger rpa_compiler_loop_end(rpa_compiler_t *co);
-rint rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruint namesize);
-rint rpa_compiler_rule_begin_s(rpa_compiler_t *co, const rchar *name);
-rint rpa_compiler_rule_end(rpa_compiler_t *co);
+rinteger rpa_compiler_rule_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize);
+rinteger rpa_compiler_rule_begin_s(rpa_compiler_t *co, const rchar *name);
+rinteger rpa_compiler_rule_end(rpa_compiler_t *co);
-rint rpa_compiler_inlinerule_begin(rpa_compiler_t *co, const rchar *name, ruint namesize, ruint flags);
-rint rpa_compiler_inlinerule_begin_s(rpa_compiler_t *co, const rchar *name, ruint flags);
-rint rpa_compiler_inlinerule_end(rpa_compiler_t *co);
+rinteger rpa_compiler_inlinerule_begin(rpa_compiler_t *co, const rchar *name, ruinteger namesize, ruinteger flags);
+rinteger rpa_compiler_inlinerule_begin_s(rpa_compiler_t *co, const rchar *name, ruinteger flags);
+rinteger rpa_compiler_inlinerule_end(rpa_compiler_t *co);
-rint rpa_compiler_exp_begin(rpa_compiler_t *co, ruint flags);
-rint rpa_compiler_exp_end(rpa_compiler_t *co);
+rinteger rpa_compiler_exp_begin(rpa_compiler_t *co, ruinteger flags);
+rinteger rpa_compiler_exp_end(rpa_compiler_t *co);
-rint rpa_compiler_altexp_begin(rpa_compiler_t *co, ruint flags);
-rint rpa_compiler_altexp_end(rpa_compiler_t *co);
+rinteger rpa_compiler_altexp_begin(rpa_compiler_t *co, ruinteger flags);
+rinteger rpa_compiler_altexp_end(rpa_compiler_t *co);
-rint rpa_compiler_branch_begin(rpa_compiler_t *co, ruint flags);
-rint rpa_compiler_branch_end(rpa_compiler_t *co);
+rinteger rpa_compiler_branch_begin(rpa_compiler_t *co, ruinteger flags);
+rinteger rpa_compiler_branch_end(rpa_compiler_t *co);
-rint rpa_compiler_nonloopybranch_begin(rpa_compiler_t *co, ruint flags);
-rint rpa_compiler_nonloopybranch_end(rpa_compiler_t *co);
+rinteger rpa_compiler_nonloopybranch_begin(rpa_compiler_t *co, ruinteger flags);
+rinteger rpa_compiler_nonloopybranch_end(rpa_compiler_t *co);
-rint rpa_compiler_class_begin(rpa_compiler_t *co, ruint flags);
-rint rpa_compiler_class_end(rpa_compiler_t *co);
+rinteger rpa_compiler_class_begin(rpa_compiler_t *co, ruinteger flags);
+rinteger rpa_compiler_class_end(rpa_compiler_t *co);
-rint rpa_compiler_notexp_begin(rpa_compiler_t *co, ruint flags);
-rint rpa_compiler_notexp_end(rpa_compiler_t *co);
+rinteger rpa_compiler_notexp_begin(rpa_compiler_t *co, ruinteger flags);
+rinteger rpa_compiler_notexp_end(rpa_compiler_t *co);
-void rpa_compiler_index_reference(rpa_compiler_t *co, rulong index, ruint qflag);
+void rpa_compiler_index_reference(rpa_compiler_t *co, rulong index, ruinteger qflag);
void rpa_compiler_index_reference_nan(rpa_compiler_t *co, rulong index);
void rpa_compiler_index_reference_opt(rpa_compiler_t *co, rulong index);
void rpa_compiler_index_reference_mul(rpa_compiler_t *co, rulong index);
void rpa_compiler_index_reference_mop(rpa_compiler_t *co, rulong index);
-void rpa_compiler_reference(rpa_compiler_t *co, const rchar *name, rsize_t namesize, ruint qflag);
+void rpa_compiler_reference(rpa_compiler_t *co, const rchar *name, rsize_t namesize, ruinteger qflag);
void rpa_compiler_reference_nan(rpa_compiler_t *co, const rchar *name, rsize_t namesize);
void rpa_compiler_reference_opt(rpa_compiler_t *co, const rchar *name, rsize_t namesize);
void rpa_compiler_reference_mul(rpa_compiler_t *co, const rchar *name, rsize_t namesize);
void rpa_compiler_reference_mop(rpa_compiler_t *co, const rchar *name, rsize_t namesize);
-void rpa_compiler_reference_s(rpa_compiler_t *co, const rchar *name, ruint qflag);
+void rpa_compiler_reference_s(rpa_compiler_t *co, const rchar *name, ruinteger qflag);
void rpa_compiler_reference_nan_s(rpa_compiler_t *co, const rchar *name);
void rpa_compiler_reference_opt_s(rpa_compiler_t *co, const rchar *name);
void rpa_compiler_reference_mul_s(rpa_compiler_t *co, const rchar *name);
void rpa_compiler_reference_mop_s(rpa_compiler_t *co, const rchar *name);
-void rpa_compiler_rulepref_set_ruleuid(rpa_compiler_t *co, const rchar *name, ruint namesize, rlong ruleuid);
+void rpa_compiler_rulepref_set_ruleuid(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid);
void rpa_compiler_rulepref_set_ruleuid_s(rpa_compiler_t *co, const rchar *name, rlong ruleuid);
-void rpa_compiler_rulepref_set_flag(rpa_compiler_t *co, const rchar *name, ruint namesize, rulong flag);
+void rpa_compiler_rulepref_set_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag);
void rpa_compiler_rulepref_set_flag_s(rpa_compiler_t *co, const rchar *name, rulong flag);
-void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruint namesize, rulong flag);
+void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag);
void rpa_compiler_rulepref_clear_flag_s(rpa_compiler_t *co, const rchar *name, rulong flag);
-void rpa_compiler_rulepref_set_ruleuid_flags(rpa_compiler_t *co, const rchar *name, ruint namesize, rlong ruleuid, rulong flags);
-void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruint namesize, rulong flag);
+void rpa_compiler_rulepref_set_ruleuid_flags(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rlong ruleuid, rulong flags);
+void rpa_compiler_rulepref_clear_flag(rpa_compiler_t *co, const rchar *name, ruinteger namesize, rulong flag);
void rpa_compiler_rulepref_set_ruleuid_flags_s(rpa_compiler_t *co, const rchar *name, rlong ruleuid, rulong flags);
#ifdef __cplusplus
}
#include "rmem.h"
#include "rutf.h"
-typedef rint (*rpa_dbex_recordhandler)(rpadbex_t *dbex, rlong rec);
+typedef rinteger (*rpa_dbex_recordhandler)(rpadbex_t *dbex, rlong rec);
#define RPA_RULEINFO_NONE 0
#define RPA_RULEINFO_NAMEDRULE 1
static rparecord_t *rpa_dbex_rulerecord(rpadbex_t *dbex, rparule_t rid);
static rparecord_t *rpa_dbex_record(rpadbex_t *dbex, rlong rec);
-static rint rpa_dbex_rulename(rpadbex_t *dbex, rlong rec, const rchar **name, rsize_t *namesize);
-static rint rpa_parseinfo_loopdetect(rpadbex_t *dbex, rlong parent, rlong loopto);
+static rinteger rpa_dbex_rulename(rpadbex_t *dbex, rlong rec, const rchar **name, rsize_t *namesize);
+static rinteger rpa_parseinfo_loopdetect(rpadbex_t *dbex, rlong parent, rlong loopto);
static rlong rpa_dbex_firstinlined(rpadbex_t *dbex);
-static rint rpa_dbex_findinlined(rpadbex_t *dbex, rlong startrec);
-static rint rpa_dbex_playchildrecords(rpadbex_t *dbex, rlong rec);
-static rint rpa_dbex_playreversechildrecords(rpadbex_t *dbex, rlong rec);
-static rint rpa_dbex_playrecord(rpadbex_t *dbex, rlong rec);
-static rint rpa_dbex_rh_default(rpadbex_t *dbex, rlong rec);
+static rinteger rpa_dbex_findinlined(rpadbex_t *dbex, rlong startrec);
+static rinteger rpa_dbex_playchildrecords(rpadbex_t *dbex, rlong rec);
+static rinteger rpa_dbex_playreversechildrecords(rpadbex_t *dbex, rlong rec);
+static rinteger rpa_dbex_playrecord(rpadbex_t *dbex, rlong rec);
+static rinteger rpa_dbex_rh_default(rpadbex_t *dbex, rlong rec);
void rpa_dbex_debug_recordhead(rpadbex_t *dbex, rlong rec)
}
-static rint rpa_dbex_rh_default(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_default(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
-static rint rpa_dbex_playrecord(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_playrecord(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec = (rparecord_t *)r_array_slot(records, rec);
}
-static rint rpa_dbex_playchildrecords(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_playchildrecords(rpadbex_t *dbex, rlong rec)
{
rlong child;
rarray_t *records = dbex->records;
}
-static rint rpa_dbex_playreversechildrecords(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_playreversechildrecords(rpadbex_t *dbex, rlong rec)
{
rlong child;
rarray_t *records = dbex->records;
}
-static rint rpa_record2long(rparecord_t *prec, ruint32 *num)
+static rinteger rpa_record2long(rparecord_t *prec, ruint32 *num)
{
rchar *endptr = NULL;
rchar buffer[64];
}
-static rint rpa_dbex_rh_uid(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_uid(rpadbex_t *dbex, rlong rec)
{
/*
const rchar *name = NULL;
}
-static rint rpa_dbex_rh_abort(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_abort(rpadbex_t *dbex, rlong rec)
{
const rchar *name = NULL;
rsize_t namesize;
}
-static rint rpa_dbex_rh_emit(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_emit(rpadbex_t *dbex, rlong rec)
{
const rchar *name = NULL;
rsize_t namesize;
}
-static rint rpa_dbex_rh_noemit(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_noemit(rpadbex_t *dbex, rlong rec)
{
const rchar *name = NULL;
rsize_t namesize;
}
-static rint rpa_dbex_setemit(rpadbex_t *dbex, rboolean emit)
+static rinteger rpa_dbex_setemit(rpadbex_t *dbex, rboolean emit)
{
rlong i;
rpa_ruleinfo_t *info;
}
-static rint rpa_dbex_rh_emitall(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_emitall(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_emitnone(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_emitnone(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_namedrule(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_namedrule(rpadbex_t *dbex, rlong rec)
{
const rchar *name = NULL;
rsize_t namesize;
}
-static rint rpa_dbex_rh_anonymousrule(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_anonymousrule(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec = (rparecord_t *) r_array_slot(dbex->records, rec);
}
-static rint rpa_dbex_rh_char(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_char(rpadbex_t *dbex, rlong rec)
{
rparecord_t *prec;
rarray_t *records = dbex->records;
}
-static rint rpa_dbex_rh_specialchar(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_specialchar(rpadbex_t *dbex, rlong rec)
{
ruint32 wc = 0;
rarray_t *records = dbex->records;
}
-static rint rpa_dbex_rh_cls(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_cls(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_clschar(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_clschar(rpadbex_t *dbex, rlong rec)
{
ruint32 wc = 0;
rarray_t *records = dbex->records;
}
-static rint rpa_dbex_rh_minexp(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_minexp(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
return 0;
}
-static rint rpa_dbex_rh_exp(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_exp(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_orop(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_orop(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_norop(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_norop(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_notop(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_notop(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_range(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_range(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_numrange(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_numrange(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_clsnum(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_clsnum(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_beginchar(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_beginchar(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_endchar(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_endchar(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_branch(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_branch(rpadbex_t *dbex, rlong rec)
{
rarray_t *records = dbex->records;
rparecord_t *prec;
}
-static rint rpa_dbex_rh_aref(rpadbex_t *dbex, rlong rec)
+static rinteger rpa_dbex_rh_aref(rpadbex_t *dbex, rlong rec)
{
const rchar *name = NULL;
rsize_t namesize;
}
-static rint rpa_parseinfo_loopdetect_do(rpadbex_t *dbex, rlong parent, rlong loopto, rint inderction)
+static rinteger rpa_parseinfo_loopdetect_do(rpadbex_t *dbex, rlong parent, rlong loopto, rinteger inderction)
{
rsize_t namesiz;
const rchar *name;
rlong i;
- rint ret = 0;
+ rinteger ret = 0;
rparecord_t *prec;
if (parent == loopto && inderction > 0)
}
-static rint rpa_parseinfo_loopdetect(rpadbex_t *dbex, rlong parent, rlong loopto)
+static rinteger rpa_parseinfo_loopdetect(rpadbex_t *dbex, rlong parent, rlong loopto)
{
if (parent != loopto) {
/*
}
-static rint rpa_parseinfo_rule_checkforloop(rpadbex_t *dbex, const char *name, rsize_t namesize, rlong loopto)
+static rinteger rpa_parseinfo_rule_checkforloop(rpadbex_t *dbex, const char *name, rsize_t namesize, rlong loopto)
{
rpa_ruleinfo_t *info = info = (rpa_ruleinfo_t *)r_harray_get(dbex->rules, rpa_dbex_lookup(dbex, name, namesize));
static void rpa_dbex_buildloopinfo(rpadbex_t *dbex)
{
- ruint i, p;
+ ruinteger i, p;
rharray_t *rules = dbex->rules;
rpa_ruleinfo_t *info;
{
rparecord_t *rec;
rpa_ruleinfo_t info;
- ruint nrecords;
+ ruinteger nrecords;
rlong i;
const rchar *name = NULL;
rsize_t namesize = 0;
static void rpa_dbex_copyrecords(rpadbex_t *dbex)
{
- rint i;
+ rinteger i;
rarray_t *records = dbex->temprecords;
for (i = rpa_recordtree_get(records, 0, RPA_RECORD_START); i >= 0; i = rpa_recordtree_next(records, i, RPA_RECORD_START))
}
-static rint rpa_dbex_rulename(rpadbex_t *dbex, rlong rec, const rchar **name, rsize_t *namesize)
+static rinteger rpa_dbex_rulename(rpadbex_t *dbex, rlong rec, const rchar **name, rsize_t *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))
}
-rint rpa_dbex_open(rpadbex_t *dbex)
+rinteger rpa_dbex_open(rpadbex_t *dbex)
{
if (!dbex)
return -1;
}
-void rpa_dbex_dumpindented(rpadbex_t *dbex, rlong rec, rint level, const rchar *rulelabel)
+void rpa_dbex_dumpindented(rpadbex_t *dbex, rlong rec, rinteger level, const rchar *rulelabel)
{
rchar buffer[1024];
- rint i, size;
+ rinteger i, size;
rparecord_t *prec = rpa_dbex_record(dbex, rpa_recordtree_get(dbex->records, rec, RPA_RECORD_END));
if (!prec)
}
-static rint rpa_dbex_findinlined(rpadbex_t *dbex, rlong startrec)
+static rinteger rpa_dbex_findinlined(rpadbex_t *dbex, rlong startrec)
{
rlong i;
for (i = 0; i < r_array_length(dbex->inlinestack); i++) {
}
-static void rpa_dbex_dumptree_do(rpadbex_t *dbex, rlong rec, rint level)
+static void rpa_dbex_dumptree_do(rpadbex_t *dbex, rlong rec, rinteger level)
{
rparecord_t *prec = rpa_dbex_record(dbex, rec);
if (prec && prec->ruleuid == RPA_PRODUCTION_RULENAME)
if (prec && (prec->ruleuid == RPA_PRODUCTION_AREF || prec->ruleuid == RPA_PRODUCTION_CREF)) {
const rchar *name = NULL;
rsize_t namesize = 0;
- rint loop = 0;
+ rinteger loop = 0;
rpa_ruleinfo_t *info;
if (rpa_dbex_rulename(dbex, rec, &name, &namesize) >= 0) {
}
-rint rpa_dbex_dumptree(rpadbex_t *dbex, rparule_t rid)
+rinteger rpa_dbex_dumptree(rpadbex_t *dbex, rparule_t rid)
{
rpa_ruleinfo_t *info;
}
-rint rpa_dbex_dumpproductions(rpadbex_t *dbex)
+rinteger rpa_dbex_dumpproductions(rpadbex_t *dbex)
{
- rint ret = 0;
+ rinteger ret = 0;
rparule_t rid;
rchar buffer[512];
}
-rint rpa_dbex_dumprecords(rpadbex_t *dbex)
+rinteger rpa_dbex_dumprecords(rpadbex_t *dbex)
{
rlong i;
}
-rint rpa_dbex_dumpinfo(rpadbex_t *dbex)
+rinteger rpa_dbex_dumpinfo(rpadbex_t *dbex)
{
rlong i;
rpa_ruleinfo_t *info;
}
-rint rpa_dbex_dumpuids(rpadbex_t *dbex)
+rinteger rpa_dbex_dumpuids(rpadbex_t *dbex)
{
rlong i;
rlong rec;
}
-rint rpa_dbex_dumpcode(rpadbex_t* dbex, rparule_t rid)
+rinteger rpa_dbex_dumpcode(rpadbex_t* dbex, rparule_t rid)
{
rpa_ruleinfo_t *info;
if (!dbex)
}
-static rint rpa_dbex_compile_rule(rpadbex_t *dbex, rparule_t rid)
+static rinteger rpa_dbex_compile_rule(rpadbex_t *dbex, rparule_t rid)
{
rlong codeoff;
rpa_ruleinfo_t *info = (rpa_ruleinfo_t *)r_harray_get(dbex->rules, rid);
}
-rint rpa_dbex_compile(rpadbex_t *dbex)
+rinteger rpa_dbex_compile(rpadbex_t *dbex)
{
rparule_t rid;
rvm_codelabel_t *labelerr;
* Use \ref rpa_dbex_lasterror or \ref rpa_dbex_lasterrorinfo to retrieve the error
* information.
*/
-rint rpa_dbex_open(rpadbex_t *dbex);
+rinteger rpa_dbex_open(rpadbex_t *dbex);
/**
* Use \ref rpa_dbex_lasterror or \ref rpa_dbex_lasterrorinfo to retrieve the error
* information.
*/
-rint rpa_dbex_compile(rpadbex_t *dbex);
+rinteger rpa_dbex_compile(rpadbex_t *dbex);
/**
/**
- * \brief Print a BNF production in a tree format
+ * \brief Printeger a BNF production in a tree format
*
* Use \ref rpa_dbex_lookup to find the ID of a BNF production
* \param dbex Pointer to \ref rpadbex_t object.
* \param rid production ID.
* \return Return 0 on success or negative if error occurred.
*/
-rint rpa_dbex_dumptree(rpadbex_t *dbex, rparule_t rid);
+rinteger rpa_dbex_dumptree(rpadbex_t *dbex, rparule_t rid);
/**
* \brief Dump the compiled byte code for the specified production ID
* \param rid production ID.
* \return Return 0 on success or negative if error occurred.
*/
-rint rpa_dbex_dumpcode(rpadbex_t* dbex, rparule_t rid);
+rinteger rpa_dbex_dumpcode(rpadbex_t* dbex, rparule_t rid);
/*
- * \brief Print the AST of the parsed BNF productions.
+ * \brief Printeger the AST of the parsed BNF productions.
*
* This function is a debug helper, you shouldn't need it.
* unless you are debugging this library.
* \param dbex Pointer to \ref rpadbex_t object.
* \return Return 0 on success or negative if error occurred.
*/
-rint rpa_dbex_dumprecords(rpadbex_t *dbex);
+rinteger rpa_dbex_dumprecords(rpadbex_t *dbex);
/*
- * \brief Print the content of BNF productions database.
+ * \brief Printeger the content of BNF productions database.
*
- * Enumerate all BNF productions and print them in a text format.
+ * Enumerate all BNF productions and printeger them in a text format.
* \param dbex Pointer to \ref rpadbex_t object.
* \return Return 0 on success or negative if error occurred.
*/
-rint rpa_dbex_dumpproductions(rpadbex_t *dbex);
+rinteger rpa_dbex_dumpproductions(rpadbex_t *dbex);
/*
- * \brief Print debug information about the state of the BNF productions database.
+ * \brief Printeger debug information about the state of the BNF productions database.
*
* This is a debug helper, you shouldn't need it.
* \param dbex Pointer to \ref rpadbex_t object.
* \return Return 0 on success or negative if error occurred.
*/
-rint rpa_dbex_dumpinfo(rpadbex_t *dbex);
+rinteger rpa_dbex_dumpinfo(rpadbex_t *dbex);
/*
- * \brief Print the production user IDs in a format suitable to be
+ * \brief Printeger the production user IDs in a format suitable to be
* included in source code.
*
* If you define user IDs for your productions you can dump all user IDs
* in a format suitable to be included in a C/C++ source code.
*/
-rint rpa_dbex_dumpuids(rpadbex_t *dbex);
+rinteger rpa_dbex_dumpuids(rpadbex_t *dbex);
#include "rpaparser.h"
#include "rpastatpriv.h"
-static rint rpa_parser_init(rpa_parser_t *pa);
+static rinteger rpa_parser_init(rpa_parser_t *pa);
rpa_parser_t *rpa_parser_create()
}
-static rint rpa_parser_init(rpa_parser_t *pa)
+static rinteger rpa_parser_init(rpa_parser_t *pa)
{
rvm_codelabel_t *err;
rpa_compiler_t *co = pa->co;
rlong rpa_recordtree_get(rarray_t *records, rlong rec, rulong type)
{
rlong i, s = 0;
- ruint startrec = (type & RPA_RECORD_START) ? 1 : 0;
+ ruinteger startrec = (type & RPA_RECORD_START) ? 1 : 0;
rparecord_t *prec;
if (rec < 0 || rec >= r_array_length(records))
}
-rint rpa_record_optchar(rparecord_t *prec, rint defc)
+rinteger rpa_record_optchar(rparecord_t *prec, rinteger defc)
{
- rint optc = defc;
+ rinteger optc = defc;
if ((prec->usertype & RPA_MATCH_MASK) == RPA_MATCH_OPTIONAL)
optc = '?';
}
-rint rpa_record_loopchar(rparecord_t *prec, rint defc)
+rinteger rpa_record_loopchar(rparecord_t *prec, rinteger defc)
{
- rint loopc = defc;
+ rinteger loopc = defc;
if ((prec->usertype & RPA_LOOP_PATH) && (prec->usertype & RPA_NONLOOP_PATH)) {
/*
rparecord_t *prec;
rlong start, end, first, last, next, prev, parent;
rchar buf[240];
- rint bufsize = sizeof(buf) - 1;
- rint n = 0, size;
+ rinteger bufsize = sizeof(buf) - 1;
+ rinteger n = 0, size;
rchar optc = ' ';
if (rec < 0 || rec >= r_array_length(records))
}
-void rpa_record_dumpindented(rarray_t *records, rlong rec, rint level)
+void rpa_record_dumpindented(rarray_t *records, rlong rec, rinteger level)
{
rchar buffer[1024];
rparecord_t *prec;
- rint i, size;
+ rinteger i, size;
if (rec < 0 || rec >= r_array_length(records))
return;
rlong rpa_recordtree_copy(rarray_t *dst, rarray_t *src, rlong rec);
rparecord_t *rpa_record_get(rarray_t *records, rlong rec);
-void rpa_record_dumpindented(rarray_t *records, rlong rec, rint level);
+void rpa_record_dumpindented(rarray_t *records, rlong rec, rinteger level);
void rpa_record_dump(rarray_t *records, rlong rec);
rlong rpa_record_getruleuid(rarray_t *records, rlong rec);
void rpa_record_setusertype(rarray_t *records, rlong rec, ruint32 usertype, rvalset_t op);
rlong rpa_record_getusertype(rarray_t *records, rlong rec);
-rint rpa_record_optchar(rparecord_t *prec, rint defc);
-rint rpa_record_loopchar(rparecord_t *prec, rint defc);
+rinteger rpa_record_optchar(rparecord_t *prec, rinteger defc);
+rinteger rpa_record_loopchar(rparecord_t *prec, rinteger defc);
rarray_t *rpa_records_create();
void rpa_records_destroy(rarray_t *records);
rlong rpa_records_length(rarray_t *records);
}
-void rpa_stat_cachedisable(rpastat_t *stat, ruint disable)
+void rpa_stat_cachedisable(rpastat_t *stat, ruinteger disable)
{
rpa_cache_disable(stat->cache, disable);
}
-rint rpa_stat_init(rpastat_t *stat, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
+rinteger rpa_stat_init(rpastat_t *stat, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
{
rulong size;
}
-rlong rpa_stat_exec(rpastat_t *stat, rvm_asmins_t *prog, rword off, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
+rlong rpa_stat_exec(rpastat_t *stat, rvm_asmins_t *prog, rword off, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
{
rlong ret;
}
-static rlong rpa_stat_exec_rid(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
+static rlong rpa_stat_exec_rid(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
{
rlong topsiz = 0;
rpainput_t *ptp;
}
-rlong rpa_stat_scan(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end, const rchar **where)
+rlong rpa_stat_scan(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, const rchar **where)
{
rlong ret;
}
-rlong rpa_stat_match(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end)
+rlong rpa_stat_match(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end)
{
return rpa_stat_exec_rid(stat, rid, encoding, input, start, end, NULL);
}
-rlong rpa_stat_parse(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
+rlong rpa_stat_parse(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records)
{
return rpa_stat_exec_rid(stat, rid, encoding, input, start, end, records);
}
-rint rpa_stat_abort(rpastat_t *stat)
+rinteger rpa_stat_abort(rpastat_t *stat)
{
if (!stat) {
return -1;
}
-rint rpa_stat_matchchr(rpastat_t *stat, rssize_t top, rulong wc)
+rinteger rpa_stat_matchchr(rpastat_t *stat, rssize_t top, rulong wc)
{
- rint ret = 0;
+ rinteger ret = 0;
rpainput_t *in = &stat->instack[top];
if (in->eof)
}
-rint rpa_stat_matchspchr(rpastat_t *stat, rssize_t top, rulong wc)
+rinteger rpa_stat_matchspchr(rpastat_t *stat, rssize_t top, rulong wc)
{
- rint ret = 0;
+ rinteger ret = 0;
rpainput_t *in = &stat->instack[top];
if (in->eof)
}
-rint rpa_stat_matchrng(rpastat_t *stat, rssize_t top, rulong wc1, rulong wc2)
+rinteger rpa_stat_matchrng(rpastat_t *stat, rssize_t top, rulong wc1, rulong wc2)
{
- rint ret = 0;
+ rinteger ret = 0;
rpainput_t *in = &stat->instack[top];
if (in->eof)
}
-static rint rpa_stat_utf8_getchar(ruint32 *pwc, rpastat_t *stat, const rchar *input)
+static rinteger rpa_stat_utf8_getchar(ruint32 *pwc, rpastat_t *stat, const rchar *input)
{
return r_utf8_mbtowc(pwc, (const ruchar*)input, (const ruchar*)stat->end);
}
-static rint rpa_stat_byte_getchar(ruint32 *pwc, rpastat_t *stat, const rchar *input)
+static rinteger rpa_stat_byte_getchar(ruint32 *pwc, rpastat_t *stat, const rchar *input)
{
if (input >= stat->end) {
*pwc = (unsigned int)0;
ptp++;
top++;
if (top >= (rlong)stat->ip.serial) {
- rint inc = 0;
+ rinteger inc = 0;
ptp->input = stat->ip.input;
if (ptp->input < stat->end) {
switch (stat->encoding & RPA_ENCODING_MASK) {
* \return If successful return the size of the matched string in bytes, if no match was found
* return 0, return negative in case of error.
*/
-rlong rpa_stat_scan(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end, const rchar **where);
+rlong rpa_stat_scan(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, const rchar **where);
/**
* \brief Parse an input stream
* \return If successful return the size of the matched string in bytes, if the input stream cannot be matched against the BNF
* return 0, return negative in case of error.
*/
-rlong rpa_stat_parse(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records);
+rlong rpa_stat_parse(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records);
/**
* \brief Match an input stream
* \return If successful return the size of the matched string in bytes, if the input stream cannot be matched against the BNF
* return 0, return negative in case of error.
*/
-rlong rpa_stat_match(rpastat_t *stat, rparule_t rid, ruint encoding, const rchar *input, const rchar *start, const rchar *end);
+rlong rpa_stat_match(rpastat_t *stat, rparule_t rid, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end);
/**
* \return If successful return the size of the matched string in bytes, if the input stream cannot be matched against the BNF
* return 0, return negative in case of error.
*/
-rlong rpa_stat_exec(rpastat_t *stat, rvm_asmins_t *prog, rword off, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records);
+rlong rpa_stat_exec(rpastat_t *stat, rvm_asmins_t *prog, rword off, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records);
/**
* \param stat Pointer to object of type \ref rpastat_t
* \return If sucessful return 0, otherwise return negative.
*/
-rint rpa_stat_abort(rpastat_t *stat);
+rinteger rpa_stat_abort(rpastat_t *stat);
/**
const rchar *start;
const rchar *end;
rpa_errinfo_t err;
- ruint encoding;
- ruint debug;
+ ruinteger encoding;
+ ruinteger debug;
rarray_t *records;
rpainput_t *instackbuffer;
rpainput_t *instack; /* instack = &instackbuffer[1]; This allows R_TOP = -1, without any additional checks */
rvmcpu_t *cpu;
};
-rint rpa_stat_init(rpastat_t *stat, ruint encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records);
-void rpa_stat_cachedisable(rpastat_t *stat, ruint disable);
+rinteger rpa_stat_init(rpastat_t *stat, ruinteger encoding, const rchar *input, const rchar *start, const rchar *end, rarray_t *records);
+void rpa_stat_cachedisable(rpastat_t *stat, ruinteger disable);
void rpa_stat_cacheinvalidate(rpastat_t *stat);
-rint rpa_stat_matchchr(rpastat_t *stat, rssize_t top, rulong wc);
-rint rpa_stat_matchspchr(rpastat_t *stat, rssize_t top, rulong wc);
-rint rpa_stat_matchrng(rpastat_t *stat, rssize_t top, rulong wc1, rulong wc2);
+rinteger rpa_stat_matchchr(rpastat_t *stat, rssize_t top, rulong wc);
+rinteger rpa_stat_matchspchr(rpastat_t *stat, rssize_t top, rulong wc);
+rinteger rpa_stat_matchrng(rpastat_t *stat, rssize_t top, rulong wc1, rulong wc2);
rlong rpa_stat_shift(rpastat_t *stat, rssize_t top);
rvmcpu_t *rpavm_cpu_create(rulong stacksize)
{
rvmcpu_t *cpu = rvm_cpu_create(stacksize);
- rint tableid = rvm_cpu_addswitable(cpu, "rpavm_swi_table", rpavm_swi_table);
+ rinteger tableid = rvm_cpu_addswitable(cpu, "rpavm_swi_table", rpavm_swi_table);
if (tableid != RPAVM_SWI_TABLEID) {
rpavm_cpu_destroy(cpu);
}
-rvm_asmins_t *rvm_codegen_getcode(rvm_codegen_t *cg, ruint index)
+rvm_asmins_t *rvm_codegen_getcode(rvm_codegen_t *cg, ruinteger index)
{
return (rvm_asmins_t *)r_array_slot(cg->code, index);
}
return r_array_length(cg->code);
}
-void rvm_codegen_setcodesize(rvm_codegen_t *cg, ruint size)
+void rvm_codegen_setcodesize(rvm_codegen_t *cg, ruinteger size)
{
r_array_setlength(cg->code, size);
}
}
-rlong rvm_codegen_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize, rulong offset)
+rlong rvm_codegen_addlabel(rvm_codegen_t *cg, const rchar* name, ruinteger namesize, rulong offset)
{
return rvm_codemap_addoffset(cg->codemap, name, namesize, rvm_codemap_lookupadd_s(cg->codemap, ".code"), RVM_CODE2BYTE_OFFSET(offset));
}
}
-rlong rvm_codegen_addlabel_default(rvm_codegen_t *cg, const rchar* name, ruint namesize)
+rlong rvm_codegen_addlabel_default(rvm_codegen_t *cg, const rchar* name, ruinteger namesize)
{
return rvm_codegen_addlabel(cg, name, namesize, rvm_codegen_getcodesize(cg));
}
}
-rlong rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize)
+rlong rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const rchar* name, ruinteger namesize)
{
return rvm_codemap_invalid_add(cg->codemap, name, namesize);
}
}
-rsize_t rvm_codegen_addlabelins(rvm_codegen_t *cg, const rchar* name, ruint namesize, rvm_asmins_t ins)
+rsize_t rvm_codegen_addlabelins(rvm_codegen_t *cg, const rchar* name, ruinteger 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_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const rchar* name, ruint namesize, rvm_asmins_t ins)
+rsize_t rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const rchar* name, ruinteger namesize, rvm_asmins_t ins)
{
return rvm_codegen_index_addrelocins(cg, type, rvm_codemap_lookupadd(cg->codemap, name, namesize), ins);
}
}
-rint rvm_codegen_relocate(rvm_codegen_t *cg, rvm_codelabel_t **err)
+rinteger rvm_codegen_relocate(rvm_codegen_t *cg, rvm_codelabel_t **err)
{
rvm_codemap_addpointer_s(cg->codemap, ".code", r_array_slot(cg->code, 0));
rvm_codemap_addpointer_s(cg->codemap, ".data", r_array_slot(cg->data, 0));
}
-rsize_t rvm_codegen_insertins(rvm_codegen_t *cg, ruint index, rvm_asmins_t ins)
+rsize_t rvm_codegen_insertins(rvm_codegen_t *cg, ruinteger index, rvm_asmins_t ins)
{
return r_array_insert(cg->code, index, &ins);
}
-rsize_t rvm_codegen_replaceins(rvm_codegen_t *cg, ruint index, rvm_asmins_t ins)
+rsize_t rvm_codegen_replaceins(rvm_codegen_t *cg, ruinteger index, rvm_asmins_t ins)
{
return r_array_replace(cg->code, index, &ins);
}
-ruint rvm_codegen_funcstart(rvm_codegen_t *cg, const rchar* name, ruint namesize, ruint args)
+ruinteger rvm_codegen_funcstart(rvm_codegen_t *cg, const rchar* name, ruinteger namesize, ruinteger args)
{
- ruint start;
+ ruinteger start;
rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
start = rvm_codegen_addlabelins(cg, name, namesize, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(FP)|BIT(SP)|BIT(LR)));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
}
-ruint rvm_codegen_funcstart_s(rvm_codegen_t *cg, const rchar* name, ruint args)
+ruinteger rvm_codegen_funcstart_s(rvm_codegen_t *cg, const rchar* name, ruinteger args)
{
return rvm_codegen_funcstart(cg, name, r_strlen(name), args);
}
-ruint rvm_codegen_vargs_funcstart(rvm_codegen_t *cg, const rchar* name, ruint namesize)
+ruinteger rvm_codegen_vargs_funcstart(rvm_codegen_t *cg, const rchar* name, ruinteger namesize)
{
- ruint start;
+ ruinteger start;
rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
start = rvm_codegen_addlabelins(cg, name, namesize, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(FP)|BIT(SP)|BIT(LR)));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
}
-ruint rvm_codegen_vargs_funcstart_s(rvm_codegen_t *cg, const rchar* name)
+ruinteger rvm_codegen_vargs_funcstart_s(rvm_codegen_t *cg, const rchar* name)
{
return rvm_codegen_vargs_funcstart(cg, name, r_strlen(name));
}
rvm_codegen_addins(cg, rvm_asm(RVM_BX, LR, XX, XX, 0));
}
-rlong rvm_codegen_adddata(rvm_codegen_t *cg, const rchar *name, ruint namesize, rconstpointer data, rsize_t size)
+rlong rvm_codegen_adddata(rvm_codegen_t *cg, const rchar *name, ruinteger namesize, rconstpointer data, rsize_t size)
{
rpointer buffer;
rulong cursize = R_SIZE_ALIGN(r_array_length(cg->data), sizeof(rword));
}
-rlong rvm_codegen_addstring(rvm_codegen_t *cg, const rchar *name, ruint namesize, const rchar* data)
+rlong rvm_codegen_addstring(rvm_codegen_t *cg, const rchar *name, ruinteger namesize, const rchar* data)
{
return rvm_codegen_adddata(cg, name, namesize, data, r_strlen(data) + 1);
}
typedef struct rvm_codegen_s {
rarray_t *code;
rarray_t *data;
- ruint codeoff;
+ ruinteger codeoff;
rarray_t *sourceidx;
rvm_codemap_t *codemap;
rvm_relocmap_t *relocmap;
void rvm_codegen_destroy(rvm_codegen_t *cg);
void rvm_codegen_setsource(rvm_codegen_t *cg, rsize_t srcidx);
rlong rvm_codegen_getsource(rvm_codegen_t *cg, rsize_t codeidx);
-ruint rvm_codegen_funcstart(rvm_codegen_t *cg, const rchar* name, ruint namesize, ruint args);
-ruint rvm_codegen_funcstart_s(rvm_codegen_t *cg, const rchar* name, ruint args);
-ruint rvm_codegen_vargs_funcstart(rvm_codegen_t *cg, const rchar* name, ruint namesize);
-ruint rvm_codegen_vargs_funcstart_s(rvm_codegen_t *cg, const rchar* name);
+ruinteger rvm_codegen_funcstart(rvm_codegen_t *cg, const rchar* name, ruinteger namesize, ruinteger args);
+ruinteger rvm_codegen_funcstart_s(rvm_codegen_t *cg, const rchar* name, ruinteger args);
+ruinteger rvm_codegen_vargs_funcstart(rvm_codegen_t *cg, const rchar* name, ruinteger namesize);
+ruinteger rvm_codegen_vargs_funcstart_s(rvm_codegen_t *cg, const rchar* 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 rchar* name, ruint namesize, rvm_asmins_t ins);
+rsize_t rvm_codegen_addlabelins(rvm_codegen_t *cg, const rchar* name, ruinteger namesize, rvm_asmins_t ins);
rsize_t rvm_codegen_addlabelins_s(rvm_codegen_t *cg, const rchar* name, rvm_asmins_t ins);
rsize_t rvm_codegen_index_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, rulong index, rvm_asmins_t ins);
-rsize_t rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const rchar* name, ruint namesize, rvm_asmins_t ins);
+rsize_t rvm_codegen_addrelocins(rvm_codegen_t *cg, rvm_reloctype_t type, const rchar* name, ruinteger namesize, rvm_asmins_t ins);
rsize_t rvm_codegen_addrelocins_s(rvm_codegen_t *cg, rvm_reloctype_t type, const rchar* name, rvm_asmins_t ins);
-rsize_t rvm_codegen_insertins(rvm_codegen_t *cg, ruint index, rvm_asmins_t ins);
-rsize_t rvm_codegen_replaceins(rvm_codegen_t *cg, ruint index, rvm_asmins_t ins);
-rvm_asmins_t *rvm_codegen_getcode(rvm_codegen_t *cg, ruint index);
+rsize_t rvm_codegen_insertins(rvm_codegen_t *cg, ruinteger index, rvm_asmins_t ins);
+rsize_t rvm_codegen_replaceins(rvm_codegen_t *cg, ruinteger index, rvm_asmins_t ins);
+rvm_asmins_t *rvm_codegen_getcode(rvm_codegen_t *cg, ruinteger index);
rsize_t rvm_codegen_getcodesize(rvm_codegen_t *cg);
-void rvm_codegen_setcodesize(rvm_codegen_t *cg, ruint size);
+void rvm_codegen_setcodesize(rvm_codegen_t *cg, ruinteger size);
void rvm_codegen_clear(rvm_codegen_t *cg);
-rint rvm_codegen_relocate(rvm_codegen_t *cg, rvm_codelabel_t **err);
+rinteger rvm_codegen_relocate(rvm_codegen_t *cg, rvm_codelabel_t **err);
rlong rvm_codegen_validlabel(rvm_codegen_t *cg, rlong index);
rlong rvm_codegen_redefinelabel(rvm_codegen_t *cg, rlong index, rulong offset);
rlong rvm_codegen_redefinelabel_default(rvm_codegen_t *cg, rlong index);
rlong rvm_codegen_redefinepointer(rvm_codegen_t *cg, rlong index, rpointer data);
-rlong rvm_codegen_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize, rulong offset);
+rlong rvm_codegen_addlabel(rvm_codegen_t *cg, const rchar* name, ruinteger namesize, rulong offset);
rlong rvm_codegen_addlabel_s(rvm_codegen_t *cg, const rchar* name, rulong offset);
-rlong rvm_codegen_addlabel_default(rvm_codegen_t *cg, const rchar* name, ruint namesize);
+rlong rvm_codegen_addlabel_default(rvm_codegen_t *cg, const rchar* name, ruinteger namesize);
rlong rvm_codegen_addlabel_default_s(rvm_codegen_t *cg, const rchar* name);
-rlong rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const rchar* name, ruint namesize);
+rlong rvm_codegen_invalid_addlabel(rvm_codegen_t *cg, const rchar* name, ruinteger namesize);
rlong rvm_codegen_invalid_addlabel_s(rvm_codegen_t *cg, const rchar* name);
-rlong rvm_codegen_adddata(rvm_codegen_t *cg, const rchar *name, ruint namesize, rconstpointer data, rsize_t size);
+rlong rvm_codegen_adddata(rvm_codegen_t *cg, const rchar *name, ruinteger namesize, rconstpointer data, rsize_t size);
rlong rvm_codegen_adddata_s(rvm_codegen_t *cg, const rchar *name, rconstpointer data, rsize_t size);
-rlong rvm_codegen_addstring(rvm_codegen_t *cg, const rchar *name, ruint namesize, const rchar* data);
+rlong rvm_codegen_addstring(rvm_codegen_t *cg, const rchar *name, ruinteger namesize, const rchar* data);
rlong rvm_codegen_addstring_s(rvm_codegen_t *cg, const rchar *name, const rchar* data);
rlong rvm_codegen_add_numlabel_s(rvm_codegen_t *cg, const rchar *alphaname, rlong numname);
rlong rvm_codegen_invalid_add_numlabel_s(rvm_codegen_t *cg, const rchar *alphaname, rlong numname);
}
-static rlong rvm_codemap_dolookup(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
+static rlong rvm_codemap_dolookup(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize)
{
rstr_t lookupstr = {(char*)name, namesize};
return r_hash_lookup_indexval(codemap->hash, &lookupstr);
}
-static rlong rvm_codemap_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
+static rlong rvm_codemap_add(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize)
{
rvm_codelabel_t *label = NULL;
rlong labelidx = -1;
}
-rlong rvm_codemap_addoffset(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rulong base, rulong offset)
+rlong rvm_codemap_addoffset(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize, rulong base, rulong offset)
{
rlong labelidx = rvm_codemap_add(codemap, name, namesize);
rvm_codelabel_t *label = rvm_codemap_label(codemap, labelidx);
}
-rlong rvm_codemap_addpointer(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rpointer ptr)
+rlong rvm_codemap_addpointer(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize, rpointer ptr)
{
rlong labelidx = rvm_codemap_add(codemap, name, namesize);
rvm_codelabel_t *label = rvm_codemap_label(codemap, labelidx);
}
-rlong rvm_codemap_invalid_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
+rlong rvm_codemap_invalid_add(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize)
{
rlong labelidx = rvm_codemap_add(codemap, name, namesize);
rvm_codelabel_t *label = rvm_codemap_label(codemap, labelidx);
}
-rlong rvm_codemap_lookupadd(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
+rlong rvm_codemap_lookupadd(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize)
{
rstr_t lookupstr = {(char*)name, namesize};
rlong labelidx = r_hash_lookup_indexval(codemap->hash, &lookupstr);
}
-rlong rvm_codemap_lookup(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
+rlong rvm_codemap_lookup(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize)
{
rstr_t lookupstr = {(char*)name, namesize};
rlong labelidx = r_hash_lookup_indexval(codemap->hash, &lookupstr);
void rvm_codemap_dump(rvm_codemap_t *codemap)
{
- rint i = 0;
+ rinteger i = 0;
for (i = 0; i < r_array_length(codemap->labels); i++) {
rvm_codelabel_t *label = rvm_codemap_label(codemap, i);
rvm_codemap_t *rvm_codemap_create();
void rvm_codemap_destroy(rvm_codemap_t *codemap);
void rvm_codemap_clear(rvm_codemap_t *codemap);
-rlong rvm_codemap_invalid_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize);
+rlong rvm_codemap_invalid_add(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize);
rlong rvm_codemap_invalid_add_s(rvm_codemap_t *codemap, const rchar *name);
-rlong rvm_codemap_addoffset(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rulong base, rulong offset);
+rlong rvm_codemap_addoffset(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize, rulong base, rulong offset);
rlong rvm_codemap_addoffset_s(rvm_codemap_t *codemap, const rchar *name, rulong base, rulong offset);
-rlong rvm_codemap_addpointer(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rpointer ptr);
+rlong rvm_codemap_addpointer(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize, rpointer ptr);
rlong rvm_codemap_addpointer_s(rvm_codemap_t *codemap, const rchar *name, rpointer ptr);
-rlong rvm_codemap_lookupadd(rvm_codemap_t *codemap, const rchar *name, ruint namesize);
+rlong rvm_codemap_lookupadd(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize);
rlong rvm_codemap_lookupadd_s(rvm_codemap_t *codemap, const rchar *name);
-rlong rvm_codemap_lookup(rvm_codemap_t *codemap, const rchar *name, ruint namesize);
+rlong rvm_codemap_lookup(rvm_codemap_t *codemap, const rchar *name, ruinteger namesize);
rlong rvm_codemap_lookup_s(rvm_codemap_t *codemap, const rchar *name);
rlong rvm_codemap_lastlabel(rvm_codemap_t *codemap);
rvm_codelabel_t *rvm_codemap_label(rvm_codemap_t *codemap, rlong index);
static void rvm_op_ror(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
- ruint i;
+ ruinteger i;
rword res, op2 = RVM_CPUREG_GETU(cpu, ins->op2), op3 = RVM_CPUREG_GETU(cpu, ins->op3);
res = op2;
{
rvmcpu_swi swi;
rvm_switable_t *switable;
- ruint ntable = (ruint) RVM_SWI_TABLE(ins->swi);
- ruint nswi = (ruint) RVM_SWI_NUM(ins->swi);
+ ruinteger ntable = (ruinteger) RVM_SWI_TABLE(ins->swi);
+ ruinteger nswi = (ruinteger) RVM_SWI_NUM(ins->swi);
if (r_harray_length(cpu->switables) <= ntable)
RVM_ABORT(cpu, RVM_E_SWITABLE);
{
rvmcpu_swi swi;
rvm_switable_t *switable;
- ruint ntable = (ruint) RVM_SWI_TABLE(RVM_CPUREG_GETU(cpu, ins->op1));
- ruint nswi = (ruint) RVM_SWI_NUM(RVM_CPUREG_GETU(cpu, ins->op1));
+ ruinteger ntable = (ruinteger) RVM_SWI_TABLE(RVM_CPUREG_GETU(cpu, ins->op1));
+ ruinteger nswi = (ruinteger) RVM_SWI_NUM(RVM_CPUREG_GETU(cpu, ins->op1));
if (r_harray_length(cpu->switables) <= ntable)
RVM_ABORT(cpu, RVM_E_SWITABLE);
}
-static int rvm_vsnprintf(char *str, ruint size, const char *format, va_list ap)
+static int rvm_vsnprintf(char *str, ruinteger size, const char *format, va_list ap)
{
return vsnprintf(str, size, format, ap);
}
-static int rvm_snprintf(char *str, ruint size, const char *format, ...)
+static int rvm_snprintf(char *str, ruinteger size, const char *format, ...)
{
va_list ap;
int ret;
}
-int rvm_asm_dump_reg_to_str(unsigned char reg, char *str, ruint size)
+int rvm_asm_dump_reg_to_str(unsigned char reg, char *str, ruinteger size)
{
int ret = 0;
}
-int rvm_asm_dump_pi_to_str(rvmcpu_t *vm, rvm_asmins_t *pi, char *str, ruint size)
+int rvm_asm_dump_pi_to_str(rvmcpu_t *vm, rvm_asmins_t *pi, char *str, ruinteger size)
{
int ret = 0, sz = size;
rvm_snprintf(szSwi, sizeof(szSwi) - 1, "%s(%x)", stropcalls[pi->opcode], (ruint32)pi->swi);
} else {
rvm_switable_t *switable;
- ruint ntable = (ruint) RVM_SWI_TABLE(pi->swi);
- ruint nswi = (ruint) RVM_SWI_NUM(pi->swi);
+ ruinteger ntable = (ruinteger) RVM_SWI_TABLE(pi->swi);
+ ruinteger nswi = (ruinteger) RVM_SWI_NUM(pi->swi);
if (ntable < r_harray_length(vm->switables)) {
switable = r_harray_index(vm->switables, ntable, rvm_switable_t*);
}
-void rvm_asm_dump(rvm_asmins_t *pi, ruint count)
+void rvm_asm_dump(rvm_asmins_t *pi, ruinteger count)
{
char buffer[256];
while (count) {
static void rvm_op_allocarr(rvmcpu_t *cpu, rvm_asmins_t *ins)
{
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
- ruint size = RVM_CPUREG_GETU(cpu, ins->op2);
+ ruinteger size = RVM_CPUREG_GETU(cpu, ins->op2);
rcarray_t *a = r_carray_create_rvmreg();
if (!a) {
RVM_ABORT(cpu, RVM_E_ILLEGAL);
{
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
- ruint index = RVM_CPUREG_GETU(cpu, ins->op3);
+ ruinteger index = RVM_CPUREG_GETU(cpu, ins->op3);
rcarray_t *a = RVM_REG_GETP(arg2);
if (rvm_reg_gettype(arg2) != RVM_DTYPE_ARRAY) {
{
rvmreg_t *arg1 = RVM_CPUREG_PTR(cpu, ins->op1);
rvmreg_t *arg2 = RVM_CPUREG_PTR(cpu, ins->op2);
- ruint index = RVM_CPUREG_GETU(cpu, ins->op3);
+ ruinteger index = RVM_CPUREG_GETU(cpu, ins->op3);
rcarray_t *a = RVM_REG_GETP(arg2);
if (rvm_reg_gettype(arg2) != RVM_DTYPE_ARRAY) {
}
-rint rvm_cpu_exec(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off)
+rinteger rvm_cpu_exec(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off)
{
rvm_asmins_t *pi;
rvmreg_t *regda = RVM_CPUREG_PTR(cpu, DA);
}
-rint rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off)
+rinteger rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off)
{
rlong line = 0;
rvm_asmins_t *pi;
}
-rint rvm_cpu_global_swilookup(rvmcpu_t *cpu, const rchar *swiname, rsize_t size)
+rinteger rvm_cpu_global_swilookup(rvmcpu_t *cpu, const rchar *swiname, rsize_t size)
{
- rint nswi;
+ rinteger nswi;
rvm_switable_t *swientry;
rlong ntable;
return -1;
for (nswi = 0; swientry[nswi].name; nswi++) {
if (r_strncmp(swientry[nswi].name, swiname, size) == 0 && r_strlen(swientry[nswi].name) == size)
- return (rint)RVM_SWI_ID(ntable, nswi);
+ return (rinteger)RVM_SWI_ID(ntable, nswi);
}
}
return -1;
}
-rint rvm_cpu_table_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size)
+rinteger rvm_cpu_table_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size)
{
- rint nswi;
+ rinteger nswi;
rvm_switable_t *swientry;
rlong ntable = r_harray_lookup_s(cpu->switables, tabname);
return -1;
for (nswi = 0; swientry[nswi].name; nswi++) {
if (r_strncmp(swientry[nswi].name, swiname, size) == 0 && r_strlen(swientry[nswi].name) == size)
- return (rint)RVM_SWI_ID(ntable, nswi);
+ return (rinteger)RVM_SWI_ID(ntable, nswi);
}
return -1;
}
-rint rvm_cpu_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size)
+rinteger rvm_cpu_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size)
{
return tabname ? rvm_cpu_table_swilookup(cpu, tabname, swiname, size) : rvm_cpu_global_swilookup(cpu, swiname, size);
}
-rint rvm_cpu_swilookup_s(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname)
+rinteger rvm_cpu_swilookup_s(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname)
{
return rvm_cpu_swilookup(cpu, tabname, swiname, r_strlen(swiname));
}
-rint rvm_cpu_addswitable(rvmcpu_t *cpu, const rchar *tabname, rvm_switable_t *switable)
+rinteger rvm_cpu_addswitable(rvmcpu_t *cpu, const rchar *tabname, rvm_switable_t *switable)
{
return r_harray_replace_s(cpu->switables, tabname, &switable);
}
-rint rvm_cpu_abort(rvmcpu_t *cpu)
+rinteger rvm_cpu_abort(rvmcpu_t *cpu)
{
if (!cpu)
return -1;
}
-rvm_asmins_t rvm_cond_asmb(rword cond, rword opcode, rword op1, rword op2, rword op3, ruint data)
+rvm_asmins_t rvm_cond_asmb(rword cond, rword opcode, rword op1, rword op2, rword op3, ruinteger data)
{
rvm_asmins_t a;
}
-rvm_asmins_t rvm_asmb(rword opcode, rword op1, rword op2, rword op3, ruint data)
+rvm_asmins_t rvm_asmb(rword opcode, rword op1, rword op2, rword op3, ruinteger data)
{
return rvm_cond_asmb(0, opcode, op1, op2, op3, data);
}
rvmreg_t *rvm_cpu_alloc_global(rvmcpu_t *cpu)
{
rvmreg_t *global;
- rint index = r_carray_add(cpu->data, NULL);
+ rinteger index = r_carray_add(cpu->data, NULL);
global = (rvmreg_t*)r_carray_slot(cpu->data, index);
RVM_REG_CLEAR(global);
rvmcpu_t *rvm_cpu_create_default();
rvmcpu_t *rvm_cpu_create(rulong stacksize);
void rvm_cpu_destroy(rvmcpu_t * vm);
-rint rvm_cpu_abort(rvmcpu_t *cpu);
-rint rvm_cpu_exec(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
-rint rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
-rint rvm_cpu_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size);
-rint rvm_cpu_swilookup_s(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname);
-rint rvm_cpu_addswitable(rvmcpu_t * cpu, const rchar *tabname, rvm_switable_t *switalbe);
+rinteger rvm_cpu_abort(rvmcpu_t *cpu);
+rinteger rvm_cpu_exec(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
+rinteger rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
+rinteger rvm_cpu_swilookup(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname, rsize_t size);
+rinteger rvm_cpu_swilookup_s(rvmcpu_t *cpu, const rchar *tabname, const rchar *swiname);
+rinteger rvm_cpu_addswitable(rvmcpu_t * cpu, const rchar *tabname, rvm_switable_t *switalbe);
rvmreg_t *rvm_cpu_alloc_global(rvmcpu_t *cpu);
int rvm_cpu_setreg(rvmcpu_t *cpu, rword regnum, const rvmreg_t *src);
rvmreg_t *rvm_cpu_getreg(rvmcpu_t *cpu, rword regnum);
rvm_asmins_t rvm_asm(rword opcode, rword op1, rword op2, rword op3, rword data);
rvm_asmins_t rvm_asma(rword opcode, rword op1, rword op2, rword op3, rchar *data, rulong size);
rvm_asmins_t rvm_asml(rword opcode, rword op1, rword op2, rword op3, rlong data);
-rvm_asmins_t rvm_asmb(rword opcode, rword op1, rword op2, rword op3, ruint data);
+rvm_asmins_t rvm_asmb(rword opcode, rword op1, rword op2, rword op3, ruinteger data);
rvm_asmins_t rvm_asmd(rword opcode, rword op1, rword op2, rword op3, rdouble data);
rvm_asmins_t rvm_asmp(rword opcode, rword op1, rword op2, rword op3, rpointer data);
rvm_asmins_t rvm_asms(rword opcode, rword op1, rword op2, rword op3, rword data);
rvm_asmins_t rvm_cond_asm(rword cond, rword opcode, rword op1, rword op2, rword op3, rword data);
rvm_asmins_t rvm_cond_asma(rword cond, rword opcode, rword op1, rword op2, rword op3, rchar *data, rulong size);
rvm_asmins_t rvm_cond_asml(rword cond, rword opcode, rword op1, rword op2, rword op3, rlong data);
-rvm_asmins_t rvm_cond_asmb(rword cond, rword opcode, rword op1, rword op2, rword op3, ruint data);
+rvm_asmins_t rvm_cond_asmb(rword cond, rword opcode, rword op1, rword op2, rword op3, ruinteger data);
rvm_asmins_t rvm_cond_asmp(rword cond, rword opcode, rword op1, rword op2, rword op3, rpointer data);
rvm_asmins_t rvm_cond_asms(rword cond, rword opcode, rword op1, rword op2, rword op3, rword data);
rvm_asmins_t rvm_cond_asmd(rword cond, rword opcode, rword op1, rword op2, rword op3, rdouble data);
rvm_asmins_t rvm_cond_asm2(rword cond, rword opcode, rword op1, rword op2, rword op3, ruint32 p1, ruint32 p2);
-void rvm_asm_dump(rvm_asmins_t *pi, ruint count);
+void rvm_asm_dump(rvm_asmins_t *pi, ruinteger count);
#ifdef __cplusplus
#include "rtypes.h"
-typedef ruint rvm_error_t;
+typedef ruinteger rvm_error_t;
#define RVM_ERROR_BITS 16
#define RVM_ERROR_MASK ((1 << RVM_ERROR_BITS) - 1)
}
-rint rvm_opmap_set_binary_handler(rvm_opmap_t *opmap, rushort opid, rvm_binaryop_handler func, ruchar firstType, ruchar secondType)
+rinteger rvm_opmap_set_binary_handler(rvm_opmap_t *opmap, rushort opid, rvm_binaryop_handler func, ruchar firstType, ruchar secondType)
{
rvm_ophandler_t *h;
- ruint index = RVM_OP_HANDLER(firstType, secondType);
+ ruinteger index = RVM_OP_HANDLER(firstType, secondType);
rvm_opinfo_t *opinfo = ((rvm_opinfo_t*)r_array_slot(opmap->operators, opid));
if (!opinfo->handlers)
return -1;
}
-rint rvm_opmap_set_unary_handler(rvm_opmap_t *opmap, rushort opid, rvm_unaryop_handler func, ruchar type)
+rinteger rvm_opmap_set_unary_handler(rvm_opmap_t *opmap, rushort opid, rvm_unaryop_handler func, ruchar type)
{
rvm_ophandler_t *h;
rvm_opinfo_t *opinfo = ((rvm_opinfo_t*)r_array_slot(opmap->operators, opid));
{
rvm_ophandler_t *h;
rvm_opinfo_t *opinfo;
- ruint index;
+ ruinteger index;
rstring_t tempstr1, tempstr2;
rvmreg_t temparg1, temparg2;
{
rvm_ophandler_t *h;
rvm_opinfo_t *opinfo;
- ruint index;
+ ruinteger index;
rstring_t tempstr;
rvmreg_t temparg;
void rvm_opmap_destroy(rvm_opmap_t *opmap);
void rvm_opmap_add_binary_operator(rvm_opmap_t *opmap, rushort opid);
void rvm_opmap_add_unary_operator(rvm_opmap_t *opmap, rushort opid);
-rint rvm_opmap_set_binary_handler(rvm_opmap_t *opmap, rushort opid, rvm_binaryop_handler func, ruchar firstType, ruchar secondType);
-rint rvm_opmap_set_unary_handler(rvm_opmap_t *opmap, rushort opid, rvm_unaryop_handler func, ruchar type);
+rinteger rvm_opmap_set_binary_handler(rvm_opmap_t *opmap, rushort opid, rvm_binaryop_handler func, ruchar firstType, ruchar secondType);
+rinteger rvm_opmap_set_unary_handler(rvm_opmap_t *opmap, rushort opid, rvm_unaryop_handler func, ruchar type);
void rvm_opmap_invoke_binary_handler(rvm_opmap_t *opmap, rushort opid, rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg1, const rvmreg_t *arg2);
void rvm_opmap_invoke_unary_handler(rvm_opmap_t *opmap, rushort opid, rvmcpu_t *cpu, rvmreg_t *res, const rvmreg_t *arg);
static void rvm_reg_array_oncopy(rarray_t *array)
{
- ruint index;
+ ruinteger index;
rvmreg_t *r;
for (index = 0; index < r_array_length(array); index++) {
static void rvm_reg_array_oncleanup(rarray_t *array)
{
- ruint index;
+ ruinteger index;
rvmreg_t *r;
for (index = 0; index < r_array_length(array); index++) {
static void rvm_reg_carray_oncopy(rcarray_t *array)
{
- ruint index;
+ ruinteger index;
rvmreg_t *r;
- ruint len = r_carray_length(array);
+ ruinteger len = r_carray_length(array);
for (index = 0; index < len; index++) {
static void rvm_reg_carray_oncleanup(rcarray_t *array)
{
- ruint index;
+ ruinteger index;
rvmreg_t *r;
- ruint len = r_carray_length(array);
+ ruinteger len = r_carray_length(array);
for (index = 0; index < len; index++) {
*/
void rvm_reg_array_unref_gcdata(robject_t *obj)
{
- ruint size;
+ ruinteger size;
int i;
rvmreg_t *r;
}
-void rvm_reg_setpair(rvmreg_t *r, ruint p1, ruint p2)
+void rvm_reg_setpair(rvmreg_t *r, ruinteger p1, ruinteger p2)
{
RVM_REG_SETPAIR(r, p1, p2);
}
-void rvm_reg_setstrptr(rvmreg_t *r, rchar *s, ruint size)
+void rvm_reg_setstrptr(rvmreg_t *r, rchar *s, ruinteger size)
{
RVM_REG_SETSTR(r, s, size);
RVM_REG_SETTYPE(r, RVM_DTYPE_STRPTR);
RVM_REG_SETFLAG(r, RVM_INFOBIT_ROBJECT);
}
-rvmreg_t rvm_reg_create_pair(ruint p1, ruint p2)
+rvmreg_t rvm_reg_create_pair(ruinteger p1, ruinteger p2)
{
rvmreg_t r;
r_memset(&r, 0, sizeof(r));
}
-rvmreg_t rvm_reg_create_strptr(rchar *s, ruint size)
+rvmreg_t rvm_reg_create_strptr(rchar *s, ruinteger size)
{
rvmreg_t r;
r_memset(&r, 0, sizeof(r));
}
-void rvm_reg_settype(rvmreg_t *r, ruint type)
+void rvm_reg_settype(rvmreg_t *r, ruinteger type)
{
RVM_REG_SETTYPE(r, type);
}
-ruint rvm_reg_gettype(const rvmreg_t *r)
+ruinteger rvm_reg_gettype(const rvmreg_t *r)
{
rulong type = RVM_REG_GETTYPE(r);
return type;
}
-void rvm_reg_setboolean(rvmreg_t *r, ruint b)
+void rvm_reg_setboolean(rvmreg_t *r, ruinteger b)
{
RVM_REG_SETU(r, b ? 1 : 0);
RVM_REG_SETTYPE(r, RVM_DTYPE_BOOLEAN);
}
-rint rvm_reg_int(const rvmreg_t *src)
+rinteger rvm_reg_int(const rvmreg_t *src)
{
R_ASSERT(src);
return (int)RVM_REG_GETL(src);
#define RVM_CPUREG_SETPAIR(__cpu__, __r__, __val1__, __val2__) RVM_REG_SETPAIR(RVM_CPUREG_PTR(__cpu__, __r__), __val1__, __val2__)
#define RVM_REG_GETSTR(__r__) (__r__)->v.s
-#define RVM_REG_SETSTR(__r__, __str__, __size__) do { (__r__)->v.s = (__str__); if ((__size__) == (ruint)-1) (__r__)->size = r_strlen(__str__); else (__r__)->size = (__size__);} while (0)
+#define RVM_REG_SETSTR(__r__, __str__, __size__) do { (__r__)->v.s = (__str__); if ((__size__) == (ruinteger)-1) (__r__)->size = r_strlen(__str__); else (__r__)->size = (__size__);} while (0)
#define RVM_CPUREG_GETSTR(__cpu__, __r__) RVM_REG_GETSTR(RVM_CPUREG_PTR(__cpu__, __r__))
#define RVM_CPUREG_SETSTR(__cpu__, __r__, __str__, __size__) RVM_REG_SETSTR(RVM_CPUREG_PTR(__cpu__, __r__), __str__, __size__)
rvmreg_t rvm_reg_create_harray();
rvmreg_t rvm_reg_create_double(rdouble d);
rvmreg_t rvm_reg_create_long(rlong l);
-rvmreg_t rvm_reg_create_pair(ruint p1, ruint p2);
-rvmreg_t rvm_reg_create_strptr(rchar *s, ruint size);
+rvmreg_t rvm_reg_create_pair(ruinteger p1, ruinteger p2);
+rvmreg_t rvm_reg_create_strptr(rchar *s, ruinteger size);
void rvm_reg_init(rvmreg_t *reg);
void rvm_reg_cleanup(rvmreg_t *reg);
rvmreg_t *rvm_reg_copy(rvmreg_t *dst, const rvmreg_t *src);
void rvm_reg_array_unref_gcdata(robject_t *obj);
-void rvm_reg_settype(rvmreg_t *r, ruint type);
-ruint rvm_reg_gettype(const rvmreg_t *r);
+void rvm_reg_settype(rvmreg_t *r, ruinteger type);
+ruinteger rvm_reg_gettype(const rvmreg_t *r);
rboolean rvm_reg_tstflag(const rvmreg_t *r, ruint16 flag);
void rvm_reg_setflag(rvmreg_t *r, ruint16 flag);
void rvm_reg_clrflag(rvmreg_t *r, ruint16 flag);
void rvm_reg_setundef(rvmreg_t *r);
void rvm_reg_setunsigned(rvmreg_t *r, rword u);
-void rvm_reg_setboolean(rvmreg_t *r, ruint b);
+void rvm_reg_setboolean(rvmreg_t *r, ruinteger b);
void rvm_reg_setlong(rvmreg_t *r, rlong l);
void rvm_reg_setdouble(rvmreg_t *r, rdouble d);
void rvm_reg_setpointer(rvmreg_t *r, rpointer p);
-void rvm_reg_setpair(rvmreg_t *r, ruint p1, ruint p2);
-void rvm_reg_setstrptr(rvmreg_t *r, rchar *s, ruint size);
+void rvm_reg_setpair(rvmreg_t *r, ruinteger p1, ruinteger p2);
+void rvm_reg_setstrptr(rvmreg_t *r, rchar *s, ruinteger size);
void rvm_reg_setstring(rvmreg_t *r, rstring_t *ptr);
void rvm_reg_setarray(rvmreg_t *r, robject_t *ptr);
void rvm_reg_setharray(rvmreg_t *r, robject_t *ptr);
int rvm_reg_str2long(rvmreg_t *dst, const rvmreg_t *ssrc);
int rvm_reg_str2double(rvmreg_t *dst, const rvmreg_t *ssrc);
-rint rvm_reg_int(const rvmreg_t *src);
+rinteger rvm_reg_int(const rvmreg_t *src);
rlong rvm_reg_long(const rvmreg_t *src);
ruchar rvm_reg_boolean(const rvmreg_t *src);
rdouble rvm_reg_double(const rvmreg_t *src);
}
-rint rvm_relocmap_relocate(rvm_relocmap_t *relocmap, rvm_codemap_t *codemap, rvm_asmins_t *code, rvm_codelabel_t **err)
+rinteger rvm_relocmap_relocate(rvm_relocmap_t *relocmap, rvm_codemap_t *codemap, rvm_asmins_t *code, rvm_codelabel_t **err)
{
rlong index;
rvm_relocrecord_t *reloc;
rlong rvm_relocmap_add(rvm_relocmap_t *relocmap, rvm_reloctarget_t target, rvm_reloctype_t type, rulong offset, rulong label);
rvm_relocrecord_t *rvm_relocmap_get(rvm_relocmap_t *relocmap, rulong index);
rulong rvm_relocmap_length(rvm_relocmap_t *relocmap);
-rint rvm_relocmap_relocate(rvm_relocmap_t *relocmap, rvm_codemap_t *codemap, rvm_asmins_t *code, rvm_codelabel_t **err);
+rinteger rvm_relocmap_relocate(rvm_relocmap_t *relocmap, rvm_codemap_t *codemap, rvm_asmins_t *code, rvm_codelabel_t **err);
#ifdef __cplusplus
}
-rchar *rvm_scope_addname(rvm_scope_t *scope, const rchar* name, ruint namesize)
+rchar *rvm_scope_addname(rvm_scope_t *scope, const rchar* name, ruinteger namesize)
{
rstr_t namestr = {(rchar*)name, namesize};
rstr_t *dupname = r_hash_lookup(scope->nameshash, &namestr);
}
-ruint rvm_scope_count(rvm_scope_t* scope)
+ruinteger rvm_scope_count(rvm_scope_t* scope)
{
return r_array_length(scope->scopestack);
}
}
-void rvm_scope_addoffset(rvm_scope_t *scope, const rchar *name, ruint namesize, ruint32 off)
+void rvm_scope_addoffset(rvm_scope_t *scope, const rchar *name, ruinteger namesize, ruint32 off)
{
rvm_varmap_t vmap;
}
-ruint rvm_scope_numentries(rvm_scope_t *scope)
+ruinteger rvm_scope_numentries(rvm_scope_t *scope)
{
return r_array_length(scope->varstack);
}
-void rvm_scope_addpointer(rvm_scope_t *scope, const rchar *name, ruint namesize, rpointer ptr)
+void rvm_scope_addpointer(rvm_scope_t *scope, const rchar *name, ruinteger namesize, rpointer ptr)
{
rvm_varmap_t vmap;
}
-rvm_varmap_t *rvm_scope_lookup(rvm_scope_t *scope, const rchar *name, ruint namesize)
+rvm_varmap_t *rvm_scope_lookup(rvm_scope_t *scope, const rchar *name, ruinteger namesize)
{
rsize_t scopelen = r_array_length(scope->varstack);
rvm_varmap_t *varmap;
- rint i;
+ rinteger i;
if (!scopelen)
return NULL;
}
-rvm_varmap_t *rvm_scope_tiplookup(rvm_scope_t *scope, const rchar *name, ruint namesize)
+rvm_varmap_t *rvm_scope_tiplookup(rvm_scope_t *scope, const rchar *name, ruinteger namesize)
{
rsize_t scopelen = r_array_length(scope->varstack);
- ruint tipstart = r_array_empty(scope->scopestack) ? 0 : r_array_last(scope->scopestack, ruint);
+ ruinteger tipstart = r_array_empty(scope->scopestack) ? 0 : r_array_last(scope->scopestack, ruinteger);
rvm_varmap_t *varmap;
- rint i;
+ rinteger i;
if (!scopelen)
return NULL;
- for (i = scopelen - 1; i >= (rint)tipstart; i--) {
+ for (i = scopelen - 1; i >= (rinteger)tipstart; i--) {
varmap = (rvm_varmap_t*)r_array_slot(scope->varstack, i);
if (r_strlen(varmap->name) == namesize && r_strncmp(varmap->name, name, namesize) == 0)
return varmap;
rvm_scope_t *rvm_scope_create();
void rvm_scope_destroy(rvm_scope_t *scope);
-rchar *rvm_scope_addname(rvm_scope_t *scope, const rchar *name, ruint namesize);
+rchar *rvm_scope_addname(rvm_scope_t *scope, const rchar *name, ruinteger namesize);
rchar *rvm_scope_addstrname(rvm_scope_t *scope, const rchar *name);
-void rvm_scope_addoffset(rvm_scope_t *scope, const rchar *name, ruint namesize, ruint32 off);
-void rvm_scope_addpointer(rvm_scope_t *scope, const rchar *name, ruint namesize, rpointer ptr);
+void rvm_scope_addoffset(rvm_scope_t *scope, const rchar *name, ruinteger namesize, ruint32 off);
+void rvm_scope_addpointer(rvm_scope_t *scope, const rchar *name, ruinteger namesize, rpointer ptr);
void rvm_scope_addoffset_s(rvm_scope_t *scope, const rchar *name, ruint32 off);
void rvm_scope_addpointer_s(rvm_scope_t *scope, const rchar *name, rpointer ptr);
void rvm_scope_push(rvm_scope_t* scope);
void rvm_scope_pop(rvm_scope_t* scope);
-ruint rvm_scope_count(rvm_scope_t* scope);
-ruint rvm_scope_numentries(rvm_scope_t *scope);
-rvm_varmap_t *rvm_scope_lookup(rvm_scope_t *scope, const rchar *name, ruint namesize);
+ruinteger rvm_scope_count(rvm_scope_t* scope);
+ruinteger rvm_scope_numentries(rvm_scope_t *scope);
+rvm_varmap_t *rvm_scope_lookup(rvm_scope_t *scope, const rchar *name, ruinteger namesize);
rvm_varmap_t *rvm_scope_lookup_s(rvm_scope_t *scope, const rchar *name);
-rvm_varmap_t *rvm_scope_tiplookup(rvm_scope_t *scope, const rchar *name, ruint namesize);
+rvm_varmap_t *rvm_scope_tiplookup(rvm_scope_t *scope, const rchar *name, ruinteger namesize);
rvm_varmap_t *rvm_scope_tiplookup_s(rvm_scope_t *scope, const rchar *name);
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvm_codelabel_t *err = NULL;
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- rint table1, table2, table3;
- ruint ret = 0;
- ruint off = 0;
+ rinteger table1, table2, table3;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvmreg_t d1 = rvm_reg_create_double(1.0);
rvmreg_t d2 = rvm_reg_create_double(-1.0);
rvmreg_t ds = rvm_reg_create_string_ansi("-3.5785");
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvmreg_t d1 = rvm_reg_create_double(2.0);
rvmreg_t d1s = rvm_reg_create_string_ansi("2.0");
rvmreg_t d2 = rvm_reg_create_double(3.0);
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvmreg_t d1 = rvm_reg_create_double(1.0);
rvmreg_t d1s = rvm_reg_create_string_ansi("2.0");
rvm_asmins_t vmcode[256];
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvmreg_t d1 = rvm_reg_create_double(-2.0);
rvmreg_t d1s = rvm_reg_create_string_ansi("-2.0");
rvmreg_t d2 = rvm_reg_create_double(3.0);
int main(int argc, char *argv[])
{
- ruint ret = 0;
+ ruinteger ret = 0;
rword s = -2;
rword d = 0;
- ruint off = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
- ruint i, ret = 0;
- ruint off = 0;
+ ruinteger i, ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[1024];
rvmcpu_t *vm = rvm_cpu_create_default();
rvmcpu_t *cpu;
rvm_codegen_t *cg;
rvm_codelabel_t *err;
- ruint ntable;
+ ruinteger ntable;
cg = rvm_codegen_create();
cpu = rvm_cpu_create_default();
rvmcpu_t *cpu;
rvm_codegen_t *cg;
rvm_codelabel_t *err;
- ruint ntable;
+ ruinteger ntable;
cg = rvm_codegen_create();
cpu = rvm_cpu_create_default();
int main(int argc, char *argv[])
{
rlong iter = 1;
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
{
rvmcpu_t *cpu;
rvm_asmins_t code[1024];
- ruint off = 0;
+ ruinteger off = 0;
cpu = rvm_cpu_create_default();
#include "rmem.h"
-static void r_carray_replaceint(rcarray_t *carray, ruint index, rint elt)
+static void r_carray_replaceint(rcarray_t *carray, ruinteger index, rinteger elt)
{
r_carray_replace(carray, index, &elt);
}
{
rhash_t *h;
rhash_node_t *node = NULL;
- ruint idig[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
+ ruinteger idig[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
rchar *sdig[] = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};
h = r_hash_create(5, r_hash_strequal, r_hash_strhash);
r_hash_insert(h, sdig[7], &idig[8]);
r_hash_insert(h, sdig[7], &idig[7]);
r_hash_insert(h, sdig[5], &idig[5]);
- fprintf(stdout, "key: %s, value: %d\n", "seven", *((ruint*)r_hash_lookup(h, "seven")));
+ fprintf(stdout, "key: %s, value: %d\n", "seven", *((ruinteger*)r_hash_lookup(h, "seven")));
r_hash_remove(h, sdig[7]);
if (!r_hash_lookup(h, "seven")) {
r_hash_insert(h, sdig[7], &idig[7]);
r_hash_insert(h, sdig[7], &idig[9]);
}
for (node = r_hash_nodelookup(h, node, "seven"); node; node = r_hash_nodelookup(h, node, "seven"))
- fprintf(stdout, "key: %s, value: %d\n", "seven", *((ruint*)r_hash_value(node)));
- fprintf(stdout, "key: %s, value: %d\n", sdig[5], *((ruint*)r_hash_lookup(h, sdig[5])));
- fprintf(stdout, "key: %s, value: %d\n", sdig[0], *((ruint*)r_hash_lookup(h, sdig[0])));
+ fprintf(stdout, "key: %s, value: %d\n", "seven", *((ruinteger*)r_hash_value(node)));
+ fprintf(stdout, "key: %s, value: %d\n", sdig[5], *((ruinteger*)r_hash_lookup(h, sdig[5])));
+ fprintf(stdout, "key: %s, value: %d\n", sdig[0], *((ruinteger*)r_hash_lookup(h, sdig[0])));
r_object_destroy((robject_t*)h);
typedef struct rvm_vardeclaration_s {
const rchar *varname;
- ruint varnamesiz;
+ ruinteger varnamesiz;
const rchar *val;
- ruint valsiz;
+ ruinteger valsiz;
} rvm_vardeclaration_t;
typedef struct rvm_costat_s rvm_costat_t;
struct rvm_costat_s {
- ruint binaryop;
- ruint level;
- ruint dirty;
- ruint funcalls;
+ ruinteger binaryop;
+ ruinteger level;
+ ruinteger dirty;
+ ruinteger funcalls;
rvm_costat_t *root;
};
}
-ruint rvm_costat_getdebth(rvm_compiler_t *co)
+ruinteger rvm_costat_getdebth(rvm_compiler_t *co)
{
return r_array_length(co->stat);
}
-ruint rvm_costat_getlevel(rvm_compiler_t *co)
+ruinteger rvm_costat_getlevel(rvm_compiler_t *co)
{
if (!rvm_costat_current(co))
return 0;
}
-ruint rvm_costat_getbinaryop(rvm_compiler_t *co)
+ruinteger rvm_costat_getbinaryop(rvm_compiler_t *co)
{
if (!rvm_costat_current(co))
return 0;
rvm_costat_current(co)->binaryop -= 1;
}
-ruint rvm_costat_getdirty(rvm_compiler_t *co)
+ruinteger rvm_costat_getdirty(rvm_compiler_t *co)
{
if (!rvm_costat_current(co))
return 0;
r_memset(co, 0, sizeof(*co));
co->cg = rvm_codegen_create();
co->scope = rvm_scope_create();
- co->opcodes = r_array_create(sizeof(ruint));
+ co->opcodes = r_array_create(sizeof(ruinteger));
co->fp = r_array_create(sizeof(rword));
co->funcall = r_array_create(sizeof(rvm_funcall_t));
co->stat = r_array_create(sizeof(rvm_costat_t));
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
if (r_stringncmp("-", input, size))
- r_array_push(co->opcodes, RVM_OPSWI(rvm_cpu_swilookup_s(co->cpu, NULL, "RVM_SWI_NEG")), ruint);
+ r_array_push(co->opcodes, RVM_OPSWI(rvm_cpu_swilookup_s(co->cpu, NULL, "RVM_SWI_NEG")), ruinteger);
else if (r_stringncmp("+", input, size))
- r_array_push(co->opcodes, RVM_NOP, ruint);
+ r_array_push(co->opcodes, RVM_NOP, ruinteger);
else if (r_stringncmp("!", input, size))
- r_array_push(co->opcodes, RVM_ELNOT, ruint);
+ r_array_push(co->opcodes, RVM_ELNOT, ruinteger);
else if (r_stringncmp("~", input, size))
- r_array_push(co->opcodes, RVM_ENOT, ruint);
+ r_array_push(co->opcodes, RVM_ENOT, ruinteger);
else if (r_stringncmp("delete", input, size))
- r_array_push(co->opcodes, RVM_NOP, ruint);
+ r_array_push(co->opcodes, RVM_NOP, ruinteger);
else if (r_stringncmp("void", input, size))
- r_array_push(co->opcodes, RVM_NOP, ruint);
+ r_array_push(co->opcodes, RVM_NOP, ruinteger);
else if (r_stringncmp("typeof", input, size))
- r_array_push(co->opcodes, RVM_NOP, ruint);
+ r_array_push(co->opcodes, RVM_NOP, ruinteger);
else
- r_array_push(co->opcodes, RVM_ABORT, ruint);
+ r_array_push(co->opcodes, RVM_ABORT, ruinteger);
codegen_print_callback(stat, name, userdata, input, size, reason);
return size;
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
if (r_stringncmp("++", input, size))
- r_array_push(co->opcodes, RVM_EADD, ruint);
+ r_array_push(co->opcodes, RVM_EADD, ruinteger);
else if (r_stringncmp("+", input, size))
- r_array_push(co->opcodes, RVM_EADD, ruint);
+ r_array_push(co->opcodes, RVM_EADD, ruinteger);
else if (r_stringncmp("+=", input, size))
- r_array_push(co->opcodes, RVM_EADD, ruint);
+ r_array_push(co->opcodes, RVM_EADD, ruinteger);
else if (r_stringncmp("--", input, size))
- r_array_push(co->opcodes, RVM_ESUB, ruint);
+ r_array_push(co->opcodes, RVM_ESUB, ruinteger);
else if (r_stringncmp("-", input, size))
- r_array_push(co->opcodes, RVM_ESUB, ruint);
+ r_array_push(co->opcodes, RVM_ESUB, ruinteger);
else if (r_stringncmp("-=", input, size))
- r_array_push(co->opcodes, RVM_ESUB, ruint);
+ r_array_push(co->opcodes, RVM_ESUB, ruinteger);
else if (r_stringncmp("*", input, size))
- r_array_push(co->opcodes, RVM_EMUL, ruint);
+ r_array_push(co->opcodes, RVM_EMUL, ruinteger);
else if (r_stringncmp("*=", input, size))
- r_array_push(co->opcodes, RVM_EMUL, ruint);
+ r_array_push(co->opcodes, RVM_EMUL, ruinteger);
else if (r_stringncmp("/", input, size))
- r_array_push(co->opcodes, RVM_EDIV, ruint);
+ r_array_push(co->opcodes, RVM_EDIV, ruinteger);
else if (r_stringncmp("/=", input, size))
- r_array_push(co->opcodes, RVM_EDIV, ruint);
+ r_array_push(co->opcodes, RVM_EDIV, ruinteger);
else if (r_stringncmp("%", input, size))
- r_array_push(co->opcodes, RVM_EMOD, ruint);
+ r_array_push(co->opcodes, RVM_EMOD, ruinteger);
else if (r_stringncmp("%=", input, size))
- r_array_push(co->opcodes, RVM_EMOD, ruint);
+ r_array_push(co->opcodes, RVM_EMOD, ruinteger);
else if (r_stringncmp("&&", input, size))
- r_array_push(co->opcodes, RVM_ELAND, ruint);
+ r_array_push(co->opcodes, RVM_ELAND, ruinteger);
else if (r_stringncmp("||", input, size))
- r_array_push(co->opcodes, RVM_ELOR, ruint);
+ r_array_push(co->opcodes, RVM_ELOR, ruinteger);
else if (r_stringncmp("&", input, size))
- r_array_push(co->opcodes, RVM_EAND, ruint);
+ r_array_push(co->opcodes, RVM_EAND, ruinteger);
else if (r_stringncmp("&=", input, size))
- r_array_push(co->opcodes, RVM_EAND, ruint);
+ r_array_push(co->opcodes, RVM_EAND, ruinteger);
else if (r_stringncmp("|", input, size))
- r_array_push(co->opcodes, RVM_EORR, ruint);
+ r_array_push(co->opcodes, RVM_EORR, ruinteger);
else if (r_stringncmp("|=", input, size))
- r_array_push(co->opcodes, RVM_EORR, ruint);
+ r_array_push(co->opcodes, RVM_EORR, ruinteger);
else if (r_stringncmp("^", input, size))
- r_array_push(co->opcodes, RVM_EXOR, ruint);
+ r_array_push(co->opcodes, RVM_EXOR, ruinteger);
else if (r_stringncmp("^=", input, size))
- r_array_push(co->opcodes, RVM_EXOR, ruint);
+ r_array_push(co->opcodes, RVM_EXOR, ruinteger);
else if (r_stringncmp(">>", input, size))
- r_array_push(co->opcodes, RVM_ELSR, ruint);
+ r_array_push(co->opcodes, RVM_ELSR, ruinteger);
else if (r_stringncmp(">>=", input, size))
- r_array_push(co->opcodes, RVM_ELSR, ruint);
+ r_array_push(co->opcodes, RVM_ELSR, ruinteger);
else if (r_stringncmp("<<", input, size))
- r_array_push(co->opcodes, RVM_ELSL, ruint);
+ r_array_push(co->opcodes, RVM_ELSL, ruinteger);
else if (r_stringncmp("<<=", input, size))
- r_array_push(co->opcodes, RVM_ELSL, ruint);
+ r_array_push(co->opcodes, RVM_ELSL, ruinteger);
else if (r_stringncmp(">>>", input, size))
- r_array_push(co->opcodes, RVM_ELSRU, ruint);
+ r_array_push(co->opcodes, RVM_ELSRU, ruinteger);
else if (r_stringncmp(">>>=", input, size))
- r_array_push(co->opcodes, RVM_ELSRU, ruint);
+ r_array_push(co->opcodes, RVM_ELSRU, ruinteger);
else if (r_stringncmp("<=", input, size))
- r_array_push(co->opcodes, RVM_ELESSEQ, ruint);
+ r_array_push(co->opcodes, RVM_ELESSEQ, ruinteger);
else if (r_stringncmp(">=", input, size))
- r_array_push(co->opcodes, RVM_EGREATEQ, ruint);
+ r_array_push(co->opcodes, RVM_EGREATEQ, ruinteger);
else if (r_stringncmp("<", input, size))
- r_array_push(co->opcodes, RVM_ELESS, ruint);
+ r_array_push(co->opcodes, RVM_ELESS, ruinteger);
else if (r_stringncmp(">", input, size))
- r_array_push(co->opcodes, RVM_EGREAT, ruint);
+ r_array_push(co->opcodes, RVM_EGREAT, ruinteger);
else if (r_stringncmp("===", input, size))
- r_array_push(co->opcodes, RVM_EEQ, ruint);
+ r_array_push(co->opcodes, RVM_EEQ, ruinteger);
else if (r_stringncmp("==", input, size))
- r_array_push(co->opcodes, RVM_EEQ, ruint);
+ r_array_push(co->opcodes, RVM_EEQ, ruinteger);
else if (r_stringncmp("!==", input, size))
- r_array_push(co->opcodes, RVM_ENOTEQ, ruint);
+ r_array_push(co->opcodes, RVM_ENOTEQ, ruinteger);
else if (r_stringncmp("!=", input, size))
- r_array_push(co->opcodes, RVM_ENOTEQ, ruint);
+ r_array_push(co->opcodes, RVM_ENOTEQ, ruinteger);
else if (r_stringncmp("!", input, size))
- r_array_push(co->opcodes, RVM_ELNOT, ruint);
+ r_array_push(co->opcodes, RVM_ELNOT, ruinteger);
else if (r_stringncmp("~", input, size))
- r_array_push(co->opcodes, RVM_ENOT, ruint);
+ r_array_push(co->opcodes, RVM_ENOT, ruinteger);
else if (r_stringncmp("=", input, size))
- r_array_push(co->opcodes, RVM_NOP, ruint);
+ r_array_push(co->opcodes, RVM_NOP, ruinteger);
else
- r_array_push(co->opcodes, RVM_ABORT, ruint);
+ r_array_push(co->opcodes, RVM_ABORT, ruinteger);
codegen_print_callback(stat, name, userdata, input, size, reason);
return size;
rvm_costat_inclevel(co);
rvm_costat_incbinaryop(co);
} else if (reason & RPA_REASON_MATCHED) {
- ruint op1;
- ruint opcode = r_array_pop(co->opcodes, ruint);
+ ruinteger op1;
+ ruinteger opcode = r_array_pop(co->opcodes, ruinteger);
if (rvm_costat_getlevel(co) < RVM_SAVEDREGS_MAX) {
op1 = rvm_costat_getlevel(co) + RVM_SAVEDREGS_FIRST - 1;
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
rulong off = rvm_codegen_getcodesize(co->cg);
- ruint op1 = rvm_costat_getlevel(co) ? RVM_SAVEDREGS_FIRST - 1 + rvm_costat_getlevel(co) : R0;
+ ruinteger op1 = rvm_costat_getlevel(co) ? RVM_SAVEDREGS_FIRST - 1 + rvm_costat_getlevel(co) : R0;
if (reason & RPA_REASON_START) {
}
if (reason & RPA_REASON_MATCHED) {
- ruint opcode = r_array_pop(co->opcodes, ruint);
+ ruinteger opcode = r_array_pop(co->opcodes, ruinteger);
rvm_codegen_addins(co->cg, rvm_asm(opcode, op1, op1, XX, 0));
}
int codegen_program_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
- ruint off;
+ ruinteger off;
if (reason & RPA_REASON_START) {
off = rvm_codegen_getcodesize(co->cg);
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
rulong off = rvm_codegen_getcodesize(co->cg);
- ruint opcode = r_array_pop(co->opcodes, ruint);
+ ruinteger opcode = r_array_pop(co->opcodes, ruinteger);
rvm_codegen_addins(co->cg, rvm_asm(RVM_POP, R1, XX, XX, 0));
if (opcode != RVM_NOP) {
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
rulong off = rvm_codegen_getcodesize(co->cg);
- ruint opcode = r_array_pop(co->opcodes, ruint);
+ ruinteger opcode = r_array_pop(co->opcodes, ruinteger);
rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R1, R0, XX, 0));
rvm_codegen_addins(co->cg, rvm_asm(RVM_LDRR, R0, R1, XX, 0));
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
rulong off = rvm_codegen_getcodesize(co->cg);
- ruint opcode = r_array_pop(co->opcodes, ruint);
+ ruinteger opcode = r_array_pop(co->opcodes, ruinteger);
rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, R1, R0, XX, 0));
rvm_codegen_addins(co->cg, rvm_asm(RVM_LDRR, R0, R1, XX, 0));
int codegen_swiidexist_callback(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
- rint swi = rvm_cpu_swilookup(co->cpu, NULL, input, size);
+ rinteger swi = rvm_cpu_swilookup(co->cpu, NULL, input, size);
if (swi < 0)
return 0;
{
rvm_compiler_t *co = (rvm_compiler_t *)userdata;
rulong off = rvm_codegen_getcodesize(co->cg);
- rint swi = rvm_cpu_swilookup(co->cpu, NULL, input, size);
+ rinteger swi = rvm_cpu_swilookup(co->cpu, NULL, input, size);
if (swi < 0)
return 0;
rstr_t *script = NULL, *unmapscript = NULL;
rvmcpu_t *cpu;
rvmreg_t *thisptr;
- ruint ntable;
+ ruinteger ntable;
rpa_dbex_handle dbex = rpa_dbex_create();
rvm_compiler_t *co = rvm_compiler_create(dbex);
{
rvmcpu_t *cpu;
rvm_asmins_t code[1024];
- ruint off = 0;
- ruint ntable;
+ ruinteger off = 0;
+ ruinteger ntable;
cpu = rvm_cpu_create_default();
ntable = rvm_cpu_addswitable(cpu, "switable", switable);
int main(int argc, char *argv[])
{
rlong i, iter = 1;
- ruint ret = 0;
- ruint off = 0;
+ ruinteger ret = 0;
+ ruinteger off = 0;
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
rvm_codelabel_t *err;
rvmcpu_t *cpu;
rvm_opmap_t *opmap;
- ruint ntable;
+ ruinteger ntable;
ctx.opmap = opmap = rvm_opmap_create();
cpu = rvm_cpu_create_default();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcdefghiabc";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcabcabcabc";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcabcabcabc";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcabcabcdefghiabc";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "xyzxyzxyzxyz";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcabcabcabc";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
- rint i;
+ ruinteger mainoff;
+ rinteger i;
rarray_t *records = rpa_records_create();
char teststr[] = "123-4567ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
- rint i;
+ ruinteger mainoff;
+ rinteger i;
char teststr[] = "XYZabcabcabcXXXabcabcXXXabcabcabcabcZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
- rint i;
+ ruinteger mainoff;
+ rinteger i;
char teststr[] = "1*v23*z457/(((((((((((((89^233)))))))))*2)/33)+23)*457)/89+233*2/33*23*457/89+233*2/33*23*457/89+233*2/33*23*457/89+233*2/33*23*457/89+233*2/33|5&77^37 ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
// char teststr[] = "1/23+45##ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
- rint i;
+ ruinteger mainoff;
+ rinteger i;
rarray_t *records = rpa_records_create();
char teststr[] = "abcabcxyzabc";
int main(int argc, char *argv[])
{
- rint ret = 0, i;
+ rinteger ret = 0, i;
rpadbex_t *dbex = rpa_dbex_create();
// rpa_parser_t *pa = rpa_parser_create();
{
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "aaaaa";
co = rpa_compiler_create();
{
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abaaa";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcabcabcabc";
co = rpa_compiler_create();
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
- ruint mainoff;
+ ruinteger mainoff;
char teststr[] = "abcabcabcabc";
co = rpa_compiler_create();
