/* * $Id$ * Copyright (c) 2014-2016 Chung, Hyung-Hwan. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifndef _STIX_PRV_H_ #define _STIX_PRV_H_ #include "stix.h" #include "stix-utl.h" /* you can define this to either 1 or 2 */ #define STIX_BCODE_LONG_PARAM_SIZE 2 /* this is useful for debugging. stix_gc() can be called * while stix has not been fully initialized when this is defined*/ #define STIX_SUPPORT_GC_DURING_IGNITION /* define this to generate XXXX_CTXTEMVAR instructions */ #define STIX_USE_CTXTEMPVAR /* define this to use the MAKE_BLOCK instruction instead of * PUSH_CONTEXT, PUSH_INTLIT, PUSH_INTLIT, SEND_BLOCK_COPY */ #define STIX_USE_MAKE_BLOCK /* this is for gc debugging */ /*#define STIX_DEBUG_GC*/ #define STIX_DEBUG_COMPILER /*#define STIX_DEBUG_VM_PROCESSOR*/ /*#define STIX_DEBUG_VM_EXEC*/ /*#define STIX_DEBUG_VM_METHOD_LOOKUP*/ #define STIX_PROFILE_VM /* allow the caller to drive process switching by calling * stix_switchprocess(). */ #define STIX_EXTERNAL_PROCESS_SWITCH /* limit the maximum object size such that: * 1. an index to an object field can be represented in a small integer. * 2. the maximum number of bits including bit-shifts can be represented * in the stix_oow_t type. */ #define STIX_LIMIT_OBJ_SIZE /* TODO: delete these header inclusion lines */ #include #include #if defined(__has_builtin) # if __has_builtin(__builtin_memset) # define STIX_MEMSET(dst,src,size) __builtin_memset(dst,src,size) # else # define STIX_MEMSET(dst,src,size) memset(dst,src,size) # endif # if __has_builtin(__builtin_memcpy) # define STIX_MEMCPY(dst,src,size) __builtin_memcpy(dst,src,size) # else # define STIX_MEMCPY(dst,src,size) memcpy(dst,src,size) # endif # if __has_builtin(__builtin_memmove) # define STIX_MEMMOVE(dst,src,size) __builtin_memmove(dst,src,size) # else # define STIX_MEMMOVE(dst,src,size) memmove(dst,src,size) # endif # if __has_builtin(__builtin_memcmp) # define STIX_MEMCMP(dst,src,size) __builtin_memcmp(dst,src,size) # else # define STIX_MEMCMP(dst,src,size) memcmp(dst,src,size) # endif #elif defined(__GNUC__) && (__GNUC__ >= 3 || (defined(__GNUC_MINOR) && __GNUC__ == 2 && __GNUC_MINOR__ >= 91)) /* gcc 2.91 or higher */ # define STIX_MEMSET(dst,src,size) __builtin_memset(dst,src,size) # define STIX_MEMCPY(dst,src,size) __builtin_memcpy(dst,src,size) # define STIX_MEMMOVE(dst,src,size) __builtin_memmove(dst,src,size) # define STIX_MEMCMP(dst,src,size) __builtin_memcmp(dst,src,size) #else # define STIX_MEMSET(dst,src,size) memset(dst,src,size) # define STIX_MEMCPY(dst,src,size) memcpy(dst,src,size) # define STIX_MEMMOVE(dst,src,size) memmove(dst,src,size) # define STIX_MEMCMP(dst,src,size) memcmp(dst,src,size) #endif #define STIX_ASSERT(x) assert(x) #define STIX_ALIGN(x,y) ((((x) + (y) - 1) / (y)) * (y)) /* ========================================================================= */ /* CLASS SPEC ENCODING */ /* ========================================================================= */ /* * The spec field of a class object encodes the number of the fixed part * and the type of the indexed part. The fixed part is the number of * named instance variables. If the spec of a class is indexed, the object * of the class can be i nstantiated with the size of the indexed part. * * For example, on a platform where sizeof(stix_oow_t) is 4, * the layout of the spec field of a class as an OOP value looks like this: * * 31 10 9 8 7 6 5 4 3 2 1 0 * |number of named instance variables|indexed-type|indexability|oop-tag| * * the number of named instance variables is stored in high 23 bits. * the indexed type takes up bit 3 to bit 8 (assuming STIX_OBJ_TYPE_BITS is 6. * STIX_OBJ_TYPE_XXX enumerators are used to represent actual values). * and the indexability is stored in bit 2. * * The maximum number of named(fixed) instance variables for a class is: * 2 ^ ((BITS-IN-OOW - STIX_OOP_TAG_BITS) - STIX_OBJ_TYPE_BITS - 1) - 1 * * STIX_OOP_TAG_BITS are decremented from the number of bits in OOW because * the spec field is always encoded as a small integer. * * The number of named instance variables can be greater than 0 if the * class spec is not indexed or if it's a pointer indexed class * (indexed_type == STIX_OBJ_TYPE_OOP) * * indexed_type is one of the #stix_obj_type_t enumerators. */ /* * The STIX_CLASS_SPEC_MAKE() macro creates a class spec value. * _class->spec = STIX_SMOOI_TO_OOP(STIX_CLASS_SPEC_MAKE(0, 1, STIX_OBJ_TYPE_CHAR)); */ #define STIX_CLASS_SPEC_MAKE(named_instvar,is_indexed,indexed_type) ( \ (((stix_oow_t)(named_instvar)) << (STIX_OBJ_FLAGS_TYPE_BITS + 1)) | \ (((stix_oow_t)(indexed_type)) << 1) | (((stix_oow_t)is_indexed) & 1) ) /* what is the number of named instance variables? * STIX_CLASS_SPEC_NAMED_INSTVAR(STIX_OOP_TO_SMOOI(_class->spec)) */ #define STIX_CLASS_SPEC_NAMED_INSTVAR(spec) \ (((stix_oow_t)(spec)) >> (STIX_OBJ_FLAGS_TYPE_BITS + 1)) /* is it a user-indexable class? * all objects can be indexed with basicAt:. * this indicates if an object can be instantiated with a dynamic size * (new: size) and and can be indexed with at:. */ #define STIX_CLASS_SPEC_IS_INDEXED(spec) (((stix_oow_t)(spec)) & 1) /* if so, what is the indexing type? character? pointer? etc? */ #define STIX_CLASS_SPEC_INDEXED_TYPE(spec) \ ((((stix_oow_t)(spec)) >> 1) & STIX_LBMASK(stix_oow_t, STIX_OBJ_FLAGS_TYPE_BITS)) /* What is the maximum number of named instance variables? * This limit is set so because the number must be encoded into the spec field * of the class with limited number of bits assigned to the number of * named instance variables. the trailing -1 in the calculation of number of * bits is to consider the sign bit of a small-integer which is a typical * type of the spec field in the class object. */ /* #define STIX_MAX_NAMED_INSTVARS \ STIX_BITS_MAX(stix_oow_t, STIX_OOW_BITS - STIX_OOP_TAG_BITS - (STIX_OBJ_FLAGS_TYPE_BITS + 1) - 1) */ #define STIX_MAX_NAMED_INSTVARS \ STIX_BITS_MAX(stix_oow_t, STIX_SMOOI_ABS_BITS - (STIX_OBJ_FLAGS_TYPE_BITS + 1)) /* Given the number of named instance variables, what is the maximum number * of indexed instance variables? The number of indexed instance variables * is not stored in the spec field of the class. It only affects the actual * size of an object(obj->_size) selectively combined with the number of * named instance variables. So it's the maximum value of obj->_size minus * the number of named instance variables. */ #define STIX_MAX_INDEXED_INSTVARS(named_instvar) (STIX_OBJ_SIZE_MAX - named_instvar) /* #define STIX_CLASS_SELFSPEC_MAKE(class_var,classinst_var) \ (((stix_oow_t)class_var) << ((STIX_OOW_BITS - STIX_OOP_TAG_BITS) / 2)) | ((stix_oow_t)classinst_var) */ #define STIX_CLASS_SELFSPEC_MAKE(class_var,classinst_var) \ (((stix_oow_t)class_var) << (STIX_SMOOI_BITS / 2)) | ((stix_oow_t)classinst_var) /* #define STIX_CLASS_SELFSPEC_CLASSVAR(spec) ((stix_oow_t)spec >> ((STIX_OOW_BITS - STIX_OOP_TAG_BITS) / 2)) #define STIX_CLASS_SELFSPEC_CLASSINSTVAR(spec) (((stix_oow_t)spec) & STIX_LBMASK(stix_oow_t, (STIX_OOW_BITS - STIX_OOP_TAG_BITS) / 2)) */ #define STIX_CLASS_SELFSPEC_CLASSVAR(spec) ((stix_oow_t)spec >> (STIX_SMOOI_BITS / 2)) #define STIX_CLASS_SELFSPEC_CLASSINSTVAR(spec) (((stix_oow_t)spec) & STIX_LBMASK(stix_oow_t, (STIX_SMOOI_BITS / 2))) /* * yet another -1 in the calculation of the bit numbers for signed nature of * a small-integer */ /* #define STIX_MAX_CLASSVARS STIX_BITS_MAX(stix_oow_t, (STIX_OOW_BITS - STIX_OOP_TAG_BITS - 1) / 2) #define STIX_MAX_CLASSINSTVARS STIX_BITS_MAX(stix_oow_t, (STIX_OOW_BITS - STIX_OOP_TAG_BITS - 1) / 2) */ #define STIX_MAX_CLASSVARS STIX_BITS_MAX(stix_oow_t, STIX_SMOOI_ABS_BITS / 2) #define STIX_MAX_CLASSINSTVARS STIX_BITS_MAX(stix_oow_t, STIX_SMOOI_ABS_BITS / 2) #if defined(STIX_LIMIT_OBJ_SIZE) /* limit the maximum object size such that: * 1. an index to an object field can be represented in a small integer. * 2. the maximum number of bit shifts can be represented in the stix_oow_t type. */ # define STIX_OBJ_SIZE_MAX ((stix_oow_t)STIX_SMOOI_MAX) # define STIX_OBJ_SIZE_BITS_MAX (STIX_OBJ_SIZE_MAX * 8) #else # define STIX_OBJ_SIZE_MAX ((stix_oow_t)STIX_TYPE_MAX(stix_oow_t)) # define STIX_OBJ_SIZE_BITS_MAX (STIX_OBJ_SIZE_MAX * 8) #endif #if defined(STIX_INCLUDE_COMPILER) /* ========================================================================= */ /* SOURCE CODE I/O FOR COMPILER */ /* ========================================================================= */ enum stix_iocmd_t { STIX_IO_OPEN, STIX_IO_CLOSE, STIX_IO_READ }; typedef enum stix_iocmd_t stix_iocmd_t; struct stix_ioloc_t { unsigned long line; /**< line */ unsigned long colm; /**< column */ const stix_ooch_t* file; /**< file specified in #include */ }; typedef struct stix_ioloc_t stix_ioloc_t; struct stix_iolxc_t { stix_ooci_t c; /**< character */ stix_ioloc_t l; /**< location */ }; typedef struct stix_iolxc_t stix_iolxc_t; /* enum stix_ioarg_flag_t { STIX_IO_INCLUDED = (1 << 0) }; typedef enum stix_ioarg_flag_t stix_ioarg_flag_t; */ typedef struct stix_ioarg_t stix_ioarg_t; struct stix_ioarg_t { /** * [IN] I/O object name. * It is #STIX_NULL for the main stream and points to a non-NULL string * for an included stream. */ const stix_ooch_t* name; /** * [OUT] I/O handle set by an open handler. * [IN] I/O handle referenced in read and close handler. * The source stream handler can set this field when it opens a stream. * All subsequent operations on the stream see this field as set * during opening. */ void* handle; /** * [OUT] place data here */ stix_ooch_t buf[1024]; /** * [IN] points to the data of the includer. It is #STIX_NULL for the * main stream. */ stix_ioarg_t* includer; /*-----------------------------------------------------------------*/ /*----------- from here down, internal use only -------------------*/ struct { int pos, len, state; } b; unsigned long line; unsigned long colm; stix_iolxc_t lxc; /*-----------------------------------------------------------------*/ }; typedef stix_ooi_t (*stix_ioimpl_t) ( stix_t* stix, stix_iocmd_t cmd, stix_ioarg_t* arg ); struct stix_iotok_t { enum { STIX_IOTOK_EOF, STIX_IOTOK_CHARLIT, STIX_IOTOK_STRLIT, STIX_IOTOK_SYMLIT, STIX_IOTOK_NUMLIT, STIX_IOTOK_RADNUMLIT, STIX_IOTOK_NIL, STIX_IOTOK_SELF, STIX_IOTOK_SUPER, STIX_IOTOK_TRUE, STIX_IOTOK_FALSE, STIX_IOTOK_THIS_CONTEXT, STIX_IOTOK_THIS_PROCESS, STIX_IOTOK_IDENT, STIX_IOTOK_IDENT_DOTTED, STIX_IOTOK_BINSEL, STIX_IOTOK_KEYWORD, STIX_IOTOK_ASSIGN, STIX_IOTOK_COLON, STIX_IOTOK_RETURN, STIX_IOTOK_LBRACE, STIX_IOTOK_RBRACE, STIX_IOTOK_LBRACK, STIX_IOTOK_RBRACK, STIX_IOTOK_LPAREN, STIX_IOTOK_RPAREN, STIX_IOTOK_APAREN, /* #( */ STIX_IOTOK_BPAREN, /* #[ */ STIX_IOTOK_PERIOD, STIX_IOTOK_SEMICOLON } type; stix_oocs_t name; stix_oow_t name_capa; stix_ioloc_t loc; }; typedef struct stix_iotok_t stix_iotok_t; enum stix_synerrnum_t { STIX_SYNERR_NOERR, STIX_SYNERR_ILCHR, /* illegal character */ STIX_SYNERR_CMTNC, /* comment not closed */ STIX_SYNERR_STRNC, /* string not closed */ STIX_SYNERR_CLTNT, /* character literal not terminated */ STIX_SYNERR_HLTNT, /* hased literal not terminated */ STIX_SYNERR_CHARLIT, /* wrong character literal */ STIX_SYNERR_COLON, /* : expected */ STIX_SYNERR_STRING, /* string expected */ STIX_SYNERR_RADIX, /* invalid radix */ STIX_SYNERR_RADNUMLIT, /* invalid numeric literal with radix */ STIX_SYNERR_BYTERANGE, /* byte too small or too large */ STIX_SYNERR_LBRACE, /* { expected */ STIX_SYNERR_RBRACE, /* } expected */ STIX_SYNERR_LPAREN, /* ( expected */ STIX_SYNERR_RPAREN, /* ) expected */ STIX_SYNERR_RBRACK, /* ] expected */ STIX_SYNERR_PERIOD, /* . expected */ STIX_SYNERR_VBAR, /* | expected */ STIX_SYNERR_GT, /* > expected */ STIX_SYNERR_ASSIGN, /* := expected */ STIX_SYNERR_IDENT, /* identifier expected */ STIX_SYNERR_INTEGER, /* integer expected */ STIX_SYNERR_PRIMITIVE, /* primitive: expected */ STIX_SYNERR_DIRECTIVE, /* wrong directive */ STIX_SYNERR_CLASSUNDEF, /* undefined class */ STIX_SYNERR_CLASSDUP, /* duplicate class */ STIX_SYNERR_CLASSCONTRA, /* contradictory class */ STIX_SYNERR_DCLBANNED, /* #dcl not allowed */ STIX_SYNERR_MTHNAME, /* wrong method name */ STIX_SYNERR_MTHNAMEDUP, /* duplicate method name */ STIX_SYNERR_ARGNAMEDUP, /* duplicate argument name */ STIX_SYNERR_TMPRNAMEDUP, /* duplicate temporary variable name */ STIX_SYNERR_VARNAMEDUP, /* duplicate variable name */ STIX_SYNERR_BLKARGNAMEDUP, /* duplicate block argument name */ STIX_SYNERR_VARARG, /* cannot assign to argument */ STIX_SYNERR_VARUNDCL, /* undeclared variable */ STIX_SYNERR_VARUNUSE, /* unsuable variable in compiled code */ STIX_SYNERR_VARINACC, /* inaccessible variable - e.g. accessing an instance variable from a class method is not allowed. */ STIX_SYNERR_VARAMBIG, /* ambiguious variable - e.g. the variable is found in multiple pool dictionaries imported */ STIX_SYNERR_PRIMARY, /* wrong expression primary */ STIX_SYNERR_TMPRFLOOD, /* too many temporaries */ STIX_SYNERR_ARGFLOOD, /* too many arguments */ STIX_SYNERR_BLKTMPRFLOOD, /* too many block temporaries */ STIX_SYNERR_BLKARGFLOOD, /* too many block arguments */ STIX_SYNERR_BLKFLOOD, /* too large block */ STIX_SYNERR_PRIMNO, /* wrong primitive number */ STIX_SYNERR_INCLUDE, /* #include error */ STIX_SYNERR_NAMESPACE, /* wrong namespace name */ STIX_SYNERR_POOLDIC, /* wrong pool dictionary */ STIX_SYNERR_POOLDICDUP, /* duplicate pool dictionary */ STIX_SYNERR_LITERAL /* literal expected */ }; typedef enum stix_synerrnum_t stix_synerrnum_t; typedef struct stix_iolink_t stix_iolink_t; struct stix_iolink_t { stix_iolink_t* link; }; struct stix_synerr_t { stix_synerrnum_t num; stix_ioloc_t loc; stix_oocs_t tgt; }; typedef struct stix_synerr_t stix_synerr_t; struct stix_code_t { stix_uint8_t* ptr; stix_oow_t len; }; typedef struct stix_code_t stix_code_t; struct stix_compiler_t { /* input handler */ stix_ioimpl_t impl; /* information about the last meaningful character read. * this is a copy of curinp->lxc if no ungetting is performed. * if there is something in the unget buffer, this is overwritten * by a value from the buffer when the request to read a character * is served */ stix_iolxc_t lxc; /* unget buffer */ stix_iolxc_t ungot[10]; int nungots; /* static input data buffer */ stix_ioarg_t arg; /* pointer to the current input data. initially, it points to &arg */ stix_ioarg_t* curinp; /* the last token read */ stix_iotok_t tok; stix_iolink_t* io_names; int in_array; stix_synerr_t synerr; /* temporary space to handle an illegal character */ stix_ooch_t ilchr; stix_oocs_t ilchr_ucs; /* information about a class being compiled */ struct { int flags; int indexed_type; stix_oop_class_t self_oop; stix_oop_t super_oop; /* this may be nil. so the type is stix_oop_t */ stix_oop_set_t mthdic_oop[2]; stix_oop_set_t ns_oop; stix_oocs_t fqn; stix_oocs_t name; stix_oow_t fqn_capa; stix_ioloc_t fqn_loc; stix_oop_set_t superns_oop; stix_oocs_t superfqn; stix_oocs_t supername; stix_oow_t superfqn_capa; stix_ioloc_t superfqn_loc; /* instance variable, class variable, class instance variable */ stix_oocs_t vars[3]; stix_oow_t vars_capa[3]; /* var_count, unlike vars above, includes superclass counts as well. * var_count[0] - number of named instance variables * var_count[1] - number of class variables * var_count[2] - number of class instance variables */ stix_oow_t var_count[3]; stix_oocs_t pooldic; stix_oow_t pooldic_capa; stix_oow_t pooldic_count; stix_oop_set_t* pooldic_oops; stix_oow_t pooldic_oop_capa; } cls; /* information about a function being comipled */ struct { int type; /* method source text */ stix_oocs_t text; stix_oow_t text_capa; /* buffer to store identifier names to be assigned */ stix_oocs_t assignees; stix_oow_t assignees_capa; /* buffer to store binary selectors being worked on */ stix_oocs_t binsels; stix_oow_t binsels_capa; /* buffer to store keyword selectors being worked on */ stix_oocs_t kwsels; stix_oow_t kwsels_capa; /* method name */ stix_oocs_t name; stix_oow_t name_capa; stix_ioloc_t name_loc; /* single string containing a space separated list of temporaries */ stix_oocs_t tmprs; stix_oow_t tmprs_capa; stix_oow_t tmpr_count; /* total number of temporaries including arguments */ stix_oow_t tmpr_nargs; /* literals */ stix_oop_t* literals; stix_oow_t literal_count; stix_oow_t literal_capa; /* byte array elements */ stix_oob_t* balit; stix_oow_t balit_count; stix_oow_t balit_capa; /* array elements */ stix_oop_t* arlit; stix_oow_t arlit_count; stix_oow_t arlit_capa; /* 0 for no primitive, 1 for a normal primitive, 2 for a named primitive */ int prim_type; /* primitive number */ stix_ooi_t prim_no; /* block depth */ stix_oow_t blk_depth; stix_oow_t* blk_tmprcnt; stix_oow_t blk_tmprcnt_capa; /* byte code */ stix_code_t code; stix_oow_t code_capa; } mth; }; typedef struct stix_bchbuf_t stix_bchbuf_t; struct stix_bchbuf_t { stix_bch_t sbuf[128]; stix_bch_t* ptr; stix_oow_t capa; }; typedef struct stix_oochbuf_t stix_oochbuf_t; struct stix_oochbuf_t { stix_ooch_t sbuf[128]; stix_ooch_t* ptr; stix_oow_t capa; }; struct stix_decoder_t { stix_oochbuf_t fltout; stix_bchbuf_t fltfmt; }; #endif #if defined(STIX_USE_OBJECT_TRAILER) /* let it point to the trailer of the method */ # define SET_ACTIVE_METHOD_CODE(stix) ((stix)->active_code = (stix_oob_t*)&(stix)->active_method->slot[STIX_OBJ_GET_SIZE((stix)->active_method) + 1 - STIX_METHOD_NAMED_INSTVARS]) #else /* let it point to the payload of the code byte array */ # define SET_ACTIVE_METHOD_CODE(stix) ((stix)->active_code = (stix)->active_method->code->slot) #endif #if defined(STIX_BCODE_LONG_PARAM_SIZE) && (STIX_BCODE_LONG_PARAM_SIZE == 1) # define MAX_CODE_INDEX (0xFFu) # define MAX_CODE_NTMPRS (0xFFu) # define MAX_CODE_NARGS (0xFFu) # define MAX_CODE_NBLKARGS (0xFFu) # define MAX_CODE_NBLKTMPRS (0xFFu) # define MAX_CODE_JUMP (0xFFu) # define MAX_CODE_PARAM (0xFFu) #elif defined(STIX_BCODE_LONG_PARAM_SIZE) && (STIX_BCODE_LONG_PARAM_SIZE == 2) # define MAX_CODE_INDEX (0xFFFFu) # define MAX_CODE_NTMPRS (0xFFFFu) # define MAX_CODE_NARGS (0xFFFFu) # define MAX_CODE_NBLKARGS (0xFFFFu) # define MAX_CODE_NBLKTMPRS (0xFFFFu) # define MAX_CODE_JUMP (0xFFFFu) # define MAX_CODE_PARAM (0xFFFFu) #else # error Unsupported STIX_BCODE_LONG_PARAM_SIZE #endif /* ---------------------------------------------------------------------------------------------------------------- SHORT INSTRUCTION CODE LONG INSTRUCTION CODE ---------------------------------------------------------------------------------------------------------------- v v 0-3 0000 00XX STORE_INTO_INSTVAR 128 1000 0000 XXXXXXXX STORE_INTO_INSTVAR_X (bit 4 off, bit 3 off) 4-7 0000 01XX STORE_INTO_INSTVAR 8-11 0000 10XX POP_INTO_INSTVAR 136 1000 1000 XXXXXXXX POP_INTO_INSTVAR_X (bit 4 off, bit 3 on) 12-15 0000 11XX POP_INTO_INSTVAR 16-19 0001 00XX PUSH_INSTVAR 144 1001 0000 XXXXXXXX PUSH_INSTVAR_X (bit 4 on) 20-23 0001 01XX PUSH_INSTVAR v v 24-27 0001 10XX PUSH_TEMPVAR 152 1001 1000 XXXXXXXX PUSH_TEMPVAR_X (bit 4 on) 28-31 0001 11XX PUSH_TEMPVAR 32-35 0010 00XX STORE_INTO_TEMPVAR 160 1010 0000 XXXXXXXX STORE_INTO_TEMPVAR_X (bit 4 off, bit 3 off) 36-39 0010 01XX STORE_INTO_TEMPVAR 40-43 0010 10XX POP_INTO_TEMPVAR 168 1010 1000 XXXXXXXX POP_INTO_TEMPVAR_X (bit 4 off, bit 3 on) 44-47 0010 11XX POP_INTO_TEMPVAR 48-51 0011 00XX PUSH_LITERAL 176 1011 0000 XXXXXXXX PUSH_LITERAL_X 52-55 0011 01XX PUSH_LITERAL vv 56-59 0011 10XX STORE_INTO_OBJECT 184 1011 1000 XXXXXXXX STORE_INTO_OBJECT (bit 3 on, bit 2 off) 60-63 0011 11XX POP_INTO_OBJECT 188 1011 1100 XXXXXXXX POP_INTO_OBJECT (bit 3 on, bit 2 on) 64-67 0100 00XX PUSH_OBJECT 192 1100 0000 XXXXXXXX PUSH_OBJECT (bit 3 off) 68-71 0100 01XX JUMP_FORWARD 196 1100 0100 XXXXXXXX JUMP_FORWARD_X 72-75 0100 10XX JUMP_BACKWARD 200 1100 1000 XXXXXXXX JUMP_BACKWARD_X 76-79 0100 11XX JUMP_IF_TRUE 204 1100 1100 XXXXXXXX JUMP_IF_TRUE_X 80-83 0101 00XX JUMP_IF_FALSE 208 1101 0000 XXXXXXXX JUMP_IF_FALSE_X 84-87 0101 01XX UNUSED vv 88-91 0101 10XX YYYYYYYY STORE_INTO_CTXTEMPVAR 216 1101 1000 XXXXXXXX YYYYYYYY STORE_INTO_CTXTEMPVAR_X (bit 3 on, bit 2 off) 92-95 0101 11XX YYYYYYYY POP_INTO_CTXTEMPVAR 220 1101 1100 XXXXXXXX YYYYYYYY POP_INTO_CTXTEMPVAR_X (bit 3 on, bit 2 on) 96-99 0110 00XX YYYYYYYY PUSH_CTXTEMPVAR 224 1110 0000 XXXXXXXX YYYYYYYY PUSH_CTXTEMPVAR_X (bit 3 off) # XXXth outer-frame, YYYYYYYY local variable 100-103 0110 01XX YYYYYYYY PUSH_OBJVAR 228 1110 0100 XXXXXXXX YYYYYYYY PUSH_OBJVAR_X (bit 3 off) 104-107 0110 10XX YYYYYYYY STORE_INTO_OBJVAR 232 1110 1000 XXXXXXXX YYYYYYYY STORE_INTO_OBJVAR_X (bit 3 on, bit 2 off) 108-111 0110 11XX YYYYYYYY POP_INTO_OBJVAR 236 1110 1100 XXXXXXXX YYYYYYYY POP_INTO_OBJVAR_X (bit 3 on, bit 2 on) # XXXth instance variable of YYYYYYYY object v 112-115 0111 00XX YYYYYYYY SEND_MESSAGE 240 1111 0000 XXXXXXXX YYYYYYYY SEND_MESSAGE_X (bit 2 off) 116-119 0111 01XX YYYYYYYY SEND_MESSAGE_TO_SUPER 244 1111 0100 XXXXXXXX YYYYYYYY SEND_MESSAGE_TO_SUPER_X (bit 2 on) # XXX args, YYYYYYYY message 120-123 0111 10XX UNUSED 124-127 0111 11XX UNUSED ## ## "SHORT_CODE_0 | 0x80" becomes "LONG_CODE_X". ## A special single byte instruction is assigned an unused number greater than 128. ## */ enum stix_bcode_t { BCODE_STORE_INTO_INSTVAR_0 = 0x00, BCODE_STORE_INTO_INSTVAR_1 = 0x01, BCODE_STORE_INTO_INSTVAR_2 = 0x02, BCODE_STORE_INTO_INSTVAR_3 = 0x03, BCODE_STORE_INTO_INSTVAR_4 = 0x04, BCODE_STORE_INTO_INSTVAR_5 = 0x05, BCODE_STORE_INTO_INSTVAR_6 = 0x06, BCODE_STORE_INTO_INSTVAR_7 = 0x07, BCODE_POP_INTO_INSTVAR_0 = 0x08, BCODE_POP_INTO_INSTVAR_1 = 0x09, BCODE_POP_INTO_INSTVAR_2 = 0x0A, BCODE_POP_INTO_INSTVAR_3 = 0x0B, BCODE_POP_INTO_INSTVAR_4 = 0x0C, BCODE_POP_INTO_INSTVAR_5 = 0x0D, BCODE_POP_INTO_INSTVAR_6 = 0x0E, BCODE_POP_INTO_INSTVAR_7 = 0x0F, BCODE_PUSH_INSTVAR_0 = 0x10, BCODE_PUSH_INSTVAR_1 = 0x11, BCODE_PUSH_INSTVAR_2 = 0x12, BCODE_PUSH_INSTVAR_3 = 0x13, BCODE_PUSH_INSTVAR_4 = 0x14, BCODE_PUSH_INSTVAR_5 = 0x15, BCODE_PUSH_INSTVAR_6 = 0x16, BCODE_PUSH_INSTVAR_7 = 0x17, BCODE_PUSH_TEMPVAR_0 = 0x18, BCODE_PUSH_TEMPVAR_1 = 0x19, BCODE_PUSH_TEMPVAR_2 = 0x1A, BCODE_PUSH_TEMPVAR_3 = 0x1B, BCODE_PUSH_TEMPVAR_4 = 0x1C, BCODE_PUSH_TEMPVAR_5 = 0x1D, BCODE_PUSH_TEMPVAR_6 = 0x1E, BCODE_PUSH_TEMPVAR_7 = 0x1F, BCODE_STORE_INTO_TEMPVAR_0 = 0x20, BCODE_STORE_INTO_TEMPVAR_1 = 0x21, BCODE_STORE_INTO_TEMPVAR_2 = 0x22, BCODE_STORE_INTO_TEMPVAR_3 = 0x23, BCODE_STORE_INTO_TEMPVAR_4 = 0x24, BCODE_STORE_INTO_TEMPVAR_5 = 0x25, BCODE_STORE_INTO_TEMPVAR_6 = 0x26, BCODE_STORE_INTO_TEMPVAR_7 = 0x27, BCODE_POP_INTO_TEMPVAR_0 = 0x28, BCODE_POP_INTO_TEMPVAR_1 = 0x29, BCODE_POP_INTO_TEMPVAR_2 = 0x2A, BCODE_POP_INTO_TEMPVAR_3 = 0x2B, BCODE_POP_INTO_TEMPVAR_4 = 0x2C, BCODE_POP_INTO_TEMPVAR_5 = 0x2D, BCODE_POP_INTO_TEMPVAR_6 = 0x2E, BCODE_POP_INTO_TEMPVAR_7 = 0x2F, BCODE_PUSH_LITERAL_0 = 0x30, BCODE_PUSH_LITERAL_1 = 0x31, BCODE_PUSH_LITERAL_2 = 0x32, BCODE_PUSH_LITERAL_3 = 0x33, BCODE_PUSH_LITERAL_4 = 0x34, BCODE_PUSH_LITERAL_5 = 0x35, BCODE_PUSH_LITERAL_6 = 0x36, BCODE_PUSH_LITERAL_7 = 0x37, /* -------------------------------------- */ BCODE_STORE_INTO_OBJECT_0 = 0x38, BCODE_STORE_INTO_OBJECT_1 = 0x39, BCODE_STORE_INTO_OBJECT_2 = 0x3A, BCODE_STORE_INTO_OBJECT_3 = 0x3B, BCODE_POP_INTO_OBJECT_0 = 0x3C, BCODE_POP_INTO_OBJECT_1 = 0x3D, BCODE_POP_INTO_OBJECT_2 = 0x3E, BCODE_POP_INTO_OBJECT_3 = 0x3F, BCODE_PUSH_OBJECT_0 = 0x40, BCODE_PUSH_OBJECT_1 = 0x41, BCODE_PUSH_OBJECT_2 = 0x42, BCODE_PUSH_OBJECT_3 = 0x43, BCODE_JUMP_FORWARD_0 = 0x44, /* 68 */ BCODE_JUMP_FORWARD_1 = 0x45, /* 69 */ BCODE_JUMP_FORWARD_2 = 0x46, /* 70 */ BCODE_JUMP_FORWARD_3 = 0x47, /* 71 */ BCODE_JUMP_BACKWARD_0 = 0x48, BCODE_JUMP_BACKWARD_1 = 0x49, BCODE_JUMP_BACKWARD_2 = 0x4A, BCODE_JUMP_BACKWARD_3 = 0x4B, BCODE_JUMP_IF_TRUE_0 = 0x4C, BCODE_JUMP_IF_TRUE_1 = 0x4D, BCODE_JUMP_IF_TRUE_2 = 0x4E, BCODE_JUMP_IF_TRUE_3 = 0x4F, BCODE_JUMP_IF_FALSE_0 = 0x50, /* 80 */ BCODE_JUMP_IF_FALSE_1 = 0x51, /* 81 */ BCODE_JUMP_IF_FALSE_2 = 0x52, /* 82 */ BCODE_JUMP_IF_FALSE_3 = 0x53, /* 83 */ BCODE_STORE_INTO_CTXTEMPVAR_0 = 0x58, /* 88 */ BCODE_STORE_INTO_CTXTEMPVAR_1 = 0x59, /* 89 */ BCODE_STORE_INTO_CTXTEMPVAR_2 = 0x5A, /* 90 */ BCODE_STORE_INTO_CTXTEMPVAR_3 = 0x5B, /* 91 */ BCODE_POP_INTO_CTXTEMPVAR_0 = 0x5C, /* 92 */ BCODE_POP_INTO_CTXTEMPVAR_1 = 0x5D, /* 93 */ BCODE_POP_INTO_CTXTEMPVAR_2 = 0x5E, /* 94 */ BCODE_POP_INTO_CTXTEMPVAR_3 = 0x5F, /* 95 */ BCODE_PUSH_CTXTEMPVAR_0 = 0x60, /* 96 */ BCODE_PUSH_CTXTEMPVAR_1 = 0x61, /* 97 */ BCODE_PUSH_CTXTEMPVAR_2 = 0x62, /* 98 */ BCODE_PUSH_CTXTEMPVAR_3 = 0x63, /* 99 */ BCODE_PUSH_OBJVAR_0 = 0x64, BCODE_PUSH_OBJVAR_1 = 0x65, BCODE_PUSH_OBJVAR_2 = 0x66, BCODE_PUSH_OBJVAR_3 = 0x67, BCODE_STORE_INTO_OBJVAR_0 = 0x68, BCODE_STORE_INTO_OBJVAR_1 = 0x69, BCODE_STORE_INTO_OBJVAR_2 = 0x6A, BCODE_STORE_INTO_OBJVAR_3 = 0x6B, BCODE_POP_INTO_OBJVAR_0 = 0x6C, BCODE_POP_INTO_OBJVAR_1 = 0x6D, BCODE_POP_INTO_OBJVAR_2 = 0x6E, BCODE_POP_INTO_OBJVAR_3 = 0x6F, BCODE_SEND_MESSAGE_0 = 0x70, BCODE_SEND_MESSAGE_1 = 0x71, BCODE_SEND_MESSAGE_2 = 0x72, BCODE_SEND_MESSAGE_3 = 0x73, BCODE_SEND_MESSAGE_TO_SUPER_0 = 0x74, BCODE_SEND_MESSAGE_TO_SUPER_1 = 0x75, BCODE_SEND_MESSAGE_TO_SUPER_2 = 0x76, BCODE_SEND_MESSAGE_TO_SUPER_3 = 0x77, /* UNUSED 0x78 - 0x7F */ BCODE_STORE_INTO_INSTVAR_X = 0x80, /* 128 */ BCODE_POP_INTO_INSTVAR_X = 0x88, /* 136 */ BCODE_PUSH_INSTVAR_X = 0x90, /* 144 */ BCODE_PUSH_TEMPVAR_X = 0x98, /* 152 */ BCODE_STORE_INTO_TEMPVAR_X = 0xA0, /* 160 */ BCODE_POP_INTO_TEMPVAR_X = 0xA8, /* 168 */ BCODE_PUSH_LITERAL_X = 0xB0, /* 176 */ BCODE_STORE_INTO_OBJECT_X = 0xB8, /* 184 */ BCODE_POP_INTO_OBJECT_X = 0xBC, /* 188 */ BCODE_PUSH_OBJECT_X = 0xC0, /* 192 */ BCODE_JUMP_FORWARD_X = 0xC4, /* 196 */ BCODE_JUMP_BACKWARD_X = 0xC8, /* 200 */ BCODE_JUMP_IF_TRUE_X = 0xCC, /* 204 */ BCODE_JUMP_IF_FALSE_X = 0xD0, /* 208 */ BCODE_STORE_INTO_CTXTEMPVAR_X = 0xD8, /* 216 */ BCODE_POP_INTO_CTXTEMPVAR_X = 0xDC, /* 220 */ BCODE_PUSH_CTXTEMPVAR_X = 0xE0, /* 224 */ BCODE_PUSH_OBJVAR_X = 0xE4, /* 228 */ BCODE_STORE_INTO_OBJVAR_X = 0xE8, /* 232 */ BCODE_POP_INTO_OBJVAR_X = 0xEC, /* 236 */ BCODE_SEND_MESSAGE_X = 0xF0, /* 240 */ BCODE_SEND_MESSAGE_TO_SUPER_X = 0xF4, /* 244 */ /* -------------------------------------- */ BCODE_JUMP2_FORWARD = 0xC5, /* 197 */ BCODE_JUMP2_BACKWARD = 0xC9, /* 201 */ BCODE_PUSH_RECEIVER = 0x81, /* 129 */ BCODE_PUSH_NIL = 0x82, /* 130 */ BCODE_PUSH_TRUE = 0x83, /* 131 */ BCODE_PUSH_FALSE = 0x84, /* 132 */ BCODE_PUSH_CONTEXT = 0x85, /* 133 */ BCODE_PUSH_PROCESS = 0x86, /* 134 */ BCODE_PUSH_NEGONE = 0x87, /* 135 */ BCODE_PUSH_ZERO = 0x89, /* 137 */ BCODE_PUSH_ONE = 0x8A, /* 138 */ BCODE_PUSH_TWO = 0x8B, /* 139 */ BCODE_PUSH_INTLIT = 0xB1, /* 177 */ BCODE_PUSH_NEGINTLIT = 0xB2, /* 178 */ /* UNUSED 0xE8 - 0xF7 */ BCODE_DUP_STACKTOP = 0xF8, BCODE_POP_STACKTOP = 0xF9, BCODE_RETURN_STACKTOP = 0xFA, /* ^something */ BCODE_RETURN_RECEIVER = 0xFB, /* ^self */ BCODE_RETURN_FROM_BLOCK = 0xFC, /* return the stack top from a block */ BCODE_MAKE_BLOCK = 0xFD, BCODE_SEND_BLOCK_COPY = 0xFE, BCODE_NOOP = 0xFF }; #if defined(__cplusplus) extern "C" { #endif /* ========================================================================= */ /* heap.c */ /* ========================================================================= */ /** * The stix_makeheap() function creates a new heap of the \a size bytes. * * \return heap pointer on success and #STIX_NULL on failure. */ stix_heap_t* stix_makeheap ( stix_t* stix, stix_oow_t size ); /** * The stix_killheap() function destroys the heap pointed to by \a heap. */ void stix_killheap ( stix_t* stix, stix_heap_t* heap ); /** * The stix_allocheapmem() function allocates \a size bytes in the heap pointed * to by \a heap. * * \return memory pointer on success and #STIX_NULL on failure. */ void* stix_allocheapmem ( stix_t* stix, stix_heap_t* heap, stix_oow_t size ); /* ========================================================================= */ /* gc.c */ /* ========================================================================= */ stix_oop_t stix_moveoop ( stix_t* stix, stix_oop_t oop ); /* ========================================================================= */ /* obj.c */ /* ========================================================================= */ void* stix_allocbytes ( stix_t* stix, stix_oow_t size ); /** * The stix_allocoopobj() function allocates a raw object composed of \a size * pointer fields excluding the header. */ stix_oop_t stix_allocoopobj ( stix_t* stix, stix_oow_t size ); #if defined(STIX_USE_OBJECT_TRAILER) stix_oop_t stix_allocoopobjwithtrailer ( stix_t* stix, stix_oow_t size, const stix_oob_t* tptr, stix_oow_t tlen ); #endif stix_oop_t stix_alloccharobj ( stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len ); stix_oop_t stix_allocbyteobj ( stix_t* stix, const stix_oob_t* ptr, stix_oow_t len ); stix_oop_t stix_allochalfwordobj ( stix_t* stix, const stix_oohw_t* ptr, stix_oow_t len ); stix_oop_t stix_allocwordobj ( stix_t* stix, const stix_oow_t* ptr, stix_oow_t len ); #if defined(STIX_USE_OBJECT_TRAILER) stix_oop_t stix_instantiatewithtrailer ( stix_t* stix, stix_oop_t _class, stix_oow_t vlen, const stix_oob_t* tptr, stix_oow_t tlen ); #endif /* ========================================================================= */ /* sym.c */ /* ========================================================================= */ stix_oop_t stix_makesymbol ( stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len ); stix_oop_t stix_findsymbol ( stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len ); stix_oop_t stix_makestring ( stix_t* stix, const stix_ooch_t* ptr, stix_oow_t len ); /* ========================================================================= */ /* dic.c */ /* ========================================================================= */ stix_oop_association_t stix_putatsysdic ( stix_t* stix, stix_oop_t key, stix_oop_t value ); stix_oop_association_t stix_getatsysdic ( stix_t* stix, stix_oop_t key ); stix_oop_association_t stix_lookupsysdic ( stix_t* stix, const stix_oocs_t* name ); stix_oop_association_t stix_putatdic ( stix_t* stix, stix_oop_set_t dic, stix_oop_t key, stix_oop_t value ); stix_oop_association_t stix_getatdic ( stix_t* stix, stix_oop_set_t dic, stix_oop_t key ); stix_oop_association_t stix_lookupdic ( stix_t* stix, stix_oop_set_t dic, const stix_oocs_t* name ); stix_oop_set_t stix_makedic ( stix_t* stix, stix_oop_t cls, stix_oow_t size ); /* ========================================================================= */ /* proc.c */ /* ========================================================================= */ stix_oop_process_t stix_makeproc ( stix_t* stix ); /* ========================================================================= */ /* utf8.c */ /* ========================================================================= */ stix_oow_t stix_uctoutf8 ( stix_uch_t uc, stix_bch_t* utf8, stix_oow_t size ); stix_oow_t stix_utf8touc ( const stix_bch_t* utf8, stix_oow_t size, stix_uch_t* uc ); /** * The stix_ucstoutf8() function converts a unicode character string \a ucs * to a UTF8 string and writes it into the buffer pointed to by \a bcs, but * not more than \a bcslen bytes including the terminating null. * * Upon return, \a bcslen is modified to the actual number of bytes written to * \a bcs excluding the terminating null; \a ucslen is modified to the number of * wide characters converted. * * You may pass #STIX_NULL for \a bcs to dry-run conversion or to get the * required buffer size for conversion. -2 is never returned in this case. * * \return * - 0 on full conversion, * - -1 on no or partial conversion for an illegal character encountered, * - -2 on no or partial conversion for a small buffer. * * \code * const stix_uch_t ucs[] = { 'H', 'e', 'l', 'l', 'o' }; * stix_bch_t bcs[10]; * stix_oow_t ucslen = 5; * stix_oow_t bcslen = STIX_COUNTOF(bcs); * n = stix_ucstoutf8 (ucs, &ucslen, bcs, &bcslen); * if (n <= -1) * { * // conversion error * } * \endcode */ int stix_ucstoutf8 ( const stix_uch_t* ucs, stix_oow_t* ucslen, stix_bch_t* bcs, stix_oow_t* bcslen ); /** * The stix_utf8toucs() function converts a UTF8 string to a uncide string. * * It never returns -2 if \a ucs is #STIX_NULL. * * \code * const stix_bch_t* bcs = "test string"; * stix_uch_t ucs[100]; * stix_oow_t ucslen = STIX_COUNTOF(buf), n; * stix_oow_t bcslen = 11; * int n; * n = stix_utf8toucs (bcs, &bcslen, ucs, &ucslen); * if (n <= -1) { invalid/incomplenete sequence or buffer to small } * \endcode * * For a null-terminated string, you can specify ~(stix_oow_t)0 in * \a bcslen. The destination buffer \a ucs also must be large enough to * store a terminating null. Otherwise, -2 is returned. * * The resulting \a ucslen can still be greater than 0 even if the return * value is negative. The value indiates the number of characters converted * before the error has occurred. * * \return 0 on success. * -1 if \a bcs contains an illegal character. * -2 if the wide-character string buffer is too small. * -3 if \a bcs is not a complete sequence. */ int stix_utf8toucs ( const stix_bch_t* bcs, stix_oow_t* bcslen, stix_uch_t* ucs, stix_oow_t* ucslen ); /* ========================================================================= */ /* bigint.c */ /* ========================================================================= */ int stix_isint ( stix_t* stix, stix_oop_t x ); int stix_inttooow ( stix_t* stix, stix_oop_t x, stix_oow_t* w ); stix_oop_t stix_oowtoint ( stix_t* stix, stix_oow_t w ); stix_oop_t stix_addints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_subints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_mulints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_divints ( stix_t* stix, stix_oop_t x, stix_oop_t y, int modulo, stix_oop_t* rem ); stix_oop_t stix_negateint ( stix_t* stix, stix_oop_t x ); stix_oop_t stix_bitatint ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_bitandints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_bitorints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_bitxorints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_bitinvint ( stix_t* stix, stix_oop_t x ); stix_oop_t stix_bitshiftint ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_eqints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_neints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_gtints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_geints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_ltints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_leints ( stix_t* stix, stix_oop_t x, stix_oop_t y ); stix_oop_t stix_strtoint ( stix_t* stix, const stix_ooch_t* str, stix_oow_t len, int radix ); stix_oop_t stix_inttostr ( stix_t* stix, stix_oop_t num, int radix ); /* ========================================================================= */ /* comp.c */ /* ========================================================================= */ STIX_EXPORT int stix_compile ( stix_t* stix, stix_ioimpl_t io ); STIX_EXPORT void stix_getsynerr ( stix_t* stix, stix_synerr_t* synerr ); /* ========================================================================= */ /* exec.c */ /* ========================================================================= */ int stix_getprimno ( stix_t* stix, const stix_oocs_t* name ); /* TODO: remove debugging functions */ /* ========================================================================= */ /* debug.c */ /* ========================================================================= */ void stix_dumpsymtab (stix_t* stix); void stix_dumpdic (stix_t* stix, stix_oop_set_t dic, const stix_bch_t* title); #if defined(__cplusplus) } #endif #endif