fteqw/engine/qclib/pr_comp.h

// this file is shared by the execution and compiler

/*i'm part way through making this work
I've given up now that I can't work out a way to load pointers.
Setting them should be fine.
*/
#ifndef __PR_COMP_H__
#define __PR_COMP_H__
#include "progtype.h"

/*
#ifdef USE_MSVCRT_DEBUG
void *BZ_MallocNamed(int size, char *file, int line);
void *BZ_ReallocNamed(void *data, int newsize, char *file, int line);
void BZ_Free(void *data);
#define BZ_Malloc(size) BZ_MallocNamed(size, __FILE__, __LINE__)
#define BZ_Realloc(ptr, size) BZ_ReallocNamed(ptr, size, __FILE__, __LINE__)
#define malloc BZ_Malloc
#define realloc BZ_Realloc
#define free BZ_Free
#endif
*/

typedef int dstring_t;
#define QCC_string_t dstring_t

#if defined(_MSC_VER) && _MSC_VER < 1300
#define prclocks_t unsigned __int64
#define ull2dbl(x)	((double)(__int64)x)
#else
#define prclocks_t unsigned long long
#define ull2dbl(x) ((double)x)
#endif

//typedef enum {ev_void, ev_string, ev_float, ev_vector, ev_entity, ev_field, ev_function, ev_pointer, ev_integer, ev_struct, ev_union} etype_t;
//				0			1		2			3			4		5			6				7			8		9			10

#define	OFS_NULL		0
#define	OFS_RETURN		1
#define	OFS_PARM0		4		// leave 3 ofs for each parm to hold vectors
#define	OFS_PARM1		7
#define	OFS_PARM2		10
#define	OFS_PARM3		13
#define	OFS_PARM4		16
#define	OFS_PARM5		19
#define	OFS_PARM6		22
#define	OFS_PARM7		25
#define	RESERVED_OFS	28


enum qcop_e {
	OP_DONE,	//0
	OP_MUL_F,
	OP_MUL_V,
	OP_MUL_FV,
	OP_MUL_VF,
	OP_DIV_F,
	OP_ADD_F,
	OP_ADD_V,
	OP_SUB_F,
	OP_SUB_V,
	
	OP_EQ_F,	//10
	OP_EQ_V,
	OP_EQ_S,
	OP_EQ_E,
	OP_EQ_FNC,
	
	OP_NE_F,
	OP_NE_V,
	OP_NE_S,
	OP_NE_E,
	OP_NE_FNC,
	
	OP_LE_F,	//20
	OP_GE_F,
	OP_LT_F,
	OP_GT_F,

	OP_LOAD_F,
	OP_LOAD_V,
	OP_LOAD_S,
	OP_LOAD_ENT,
	OP_LOAD_FLD,
	OP_LOAD_FNC,

	OP_ADDRESS,	//30

	OP_STORE_F,
	OP_STORE_V,
	OP_STORE_S,
	OP_STORE_ENT,
	OP_STORE_FLD,
	OP_STORE_FNC,

	OP_STOREP_F,
	OP_STOREP_V,
	OP_STOREP_S,
	OP_STOREP_ENT,	//40
	OP_STOREP_FLD,
	OP_STOREP_FNC,

	OP_RETURN,
	OP_NOT_F,
	OP_NOT_V,
	OP_NOT_S,
	OP_NOT_ENT,
	OP_NOT_FNC,
	OP_IF_I,
	OP_IFNOT_I,		//50
	OP_CALL0,		//careful... hexen2 and q1 have different calling conventions
	OP_CALL1,		//remap hexen2 calls to OP_CALL2H
	OP_CALL2,
	OP_CALL3,
	OP_CALL4,
	OP_CALL5,
	OP_CALL6,
	OP_CALL7,
	OP_CALL8,
	OP_STATE,		//60
	OP_GOTO,
	OP_AND_F,
	OP_OR_F,
	
	OP_BITAND_F,
	OP_BITOR_F,

	
	//these following ones are Hexen 2 constants.
	
	OP_MULSTORE_F,	//66 redundant, for h2 compat
	OP_MULSTORE_VF,	//67 redundant, for h2 compat
	OP_MULSTOREP_F,	//68
	OP_MULSTOREP_VF,//69

	OP_DIVSTORE_F,	//70 redundant, for h2 compat
	OP_DIVSTOREP_F,	//71

	OP_ADDSTORE_F,	//72 redundant, for h2 compat
	OP_ADDSTORE_V,	//73 redundant, for h2 compat
	OP_ADDSTOREP_F,	//74
	OP_ADDSTOREP_V,	//75

	OP_SUBSTORE_F,	//76 redundant, for h2 compat
	OP_SUBSTORE_V,	//77 redundant, for h2 compat
	OP_SUBSTOREP_F,	//78
	OP_SUBSTOREP_V,	//79

	OP_FETCH_GBL_F,	//80 has built-in bounds check
	OP_FETCH_GBL_V,	//81 has built-in bounds check
	OP_FETCH_GBL_S,	//82 has built-in bounds check
	OP_FETCH_GBL_E,	//83 has built-in bounds check
	OP_FETCH_GBL_FNC,//84 has built-in bounds check

	OP_CSTATE,		//85
	OP_CWSTATE,		//86

	OP_THINKTIME,	//87 shortcut for OPA.nextthink=time+OPB

	OP_BITSETSTORE_F,	//88 redundant, for h2 compat
	OP_BITSETSTOREP_F,	//89
	OP_BITCLRSTORE_F,	//90
	OP_BITCLRSTOREP_F,	//91

	OP_RAND0,		//92	OPC = random()
	OP_RAND1,		//93	OPC = random()*OPA
	OP_RAND2,		//94	OPC = random()*(OPB-OPA)+OPA
	OP_RANDV0,		//95	//3d/box versions of the above.
	OP_RANDV1,		//96
	OP_RANDV2,		//97

	OP_SWITCH_F,	//98	switchref=OPA; PC += OPB   --- the jump allows the jump table (such as it is) to be inserted after the block.
	OP_SWITCH_V,	//99
	OP_SWITCH_S,	//100
	OP_SWITCH_E,	//101
	OP_SWITCH_FNC,	//102

	OP_CASE,		//103	if (OPA===switchref) PC += OPB
	OP_CASERANGE,	//104   if (OPA<=switchref&&switchref<=OPB) PC += OPC





	//the rest are added
	//mostly they are various different ways of adding two vars with conversions.

	//hexen2 calling convention (-TH2 requires us to remap OP_CALLX to these on load, -TFTE just uses these directly.)
	OP_CALL1H,	//OFS_PARM0=OPB
	OP_CALL2H,	//OFS_PARM0,1=OPB,OPC
	OP_CALL3H,	//no extra args
	OP_CALL4H,
	OP_CALL5H,
	OP_CALL6H,		//110
	OP_CALL7H,
	OP_CALL8H,


	OP_STORE_I,
	OP_STORE_IF,			//OPB.f = (float)OPA.i (makes more sense when written as a->b)
	OP_STORE_FI,			//OPB.i = (int)OPA.f
	
	OP_ADD_I,
	OP_ADD_FI,				//OPC.f = OPA.f + OPB.i
	OP_ADD_IF,				//OPC.f = OPA.i + OPB.f	-- redundant...
  
	OP_SUB_I,				//OPC.i = OPA.i - OPB.i
	OP_SUB_FI,		//120	//OPC.f = OPA.f - OPB.i
	OP_SUB_IF,				//OPC.f = OPA.i - OPB.f

	OP_CONV_ITOF,			//OPC.f=(float)OPA.i -- useful mostly so decompilers don't do weird stuff.
	OP_CONV_FTOI,			//OPC.i=(int)OPA.f
	OP_LOADP_ITOF,				//OPC.f=(float)(*OPA).i	-- fixme: rename to LOADP_ITOF
	OP_LOADP_FTOI,				//OPC.i=(int)(*OPA).f
	OP_LOAD_I,
	OP_STOREP_I,
	OP_STOREP_IF,
	OP_STOREP_FI,

	OP_BITAND_I,	//130
	OP_BITOR_I,

	OP_MUL_I,
	OP_DIV_I,
	OP_EQ_I,
	OP_NE_I,

	OP_IFNOT_S,	//compares string empty, rather than just null.
	OP_IF_S,

	OP_NOT_I,

	OP_DIV_VF,

	OP_BITXOR_I,		//140
	OP_RSHIFT_I,
	OP_LSHIFT_I,

	OP_GLOBALADDRESS,	//C.p = &A + B.i*4
	OP_ADD_PIW,			//C.p = A.p + B.i*4

	OP_LOADA_F,
	OP_LOADA_V,	
	OP_LOADA_S,
	OP_LOADA_ENT,
	OP_LOADA_FLD,
	OP_LOADA_FNC,	//150
	OP_LOADA_I,

	OP_STORE_P,	//152... erm.. wait...
	OP_LOAD_P,

	OP_LOADP_F,
	OP_LOADP_V,	
	OP_LOADP_S,
	OP_LOADP_ENT,
	OP_LOADP_FLD,
	OP_LOADP_FNC,
	OP_LOADP_I,		//160

	OP_LE_I,
	OP_GE_I,
	OP_LT_I,
	OP_GT_I,

	OP_LE_IF,
	OP_GE_IF,
	OP_LT_IF,
	OP_GT_IF,

	OP_LE_FI,
	OP_GE_FI,		//170
	OP_LT_FI,
	OP_GT_FI,

	OP_EQ_IF,
	OP_EQ_FI,

	//-------------------------------------
	//string manipulation.
	OP_ADD_SF,	//(char*)c = (char*)a + (float)b    add_fi->i
	OP_SUB_S,	//(float)c = (char*)a - (char*)b    sub_ii->f
	OP_STOREP_C,//(float)c = *(char*)b = (float)a
	OP_LOADP_C,	//(float)c = *(char*)
	//-------------------------------------


	OP_MUL_IF,
	OP_MUL_FI,		//180
	OP_MUL_VI,
	OP_MUL_IV,
	OP_DIV_IF,
	OP_DIV_FI,
	OP_BITAND_IF,
	OP_BITOR_IF,
	OP_BITAND_FI,
	OP_BITOR_FI,
	OP_AND_I,
	OP_OR_I,		//190
	OP_AND_IF,
	OP_OR_IF,
	OP_AND_FI,
	OP_OR_FI,
	OP_NE_IF,
	OP_NE_FI,

//fte doesn't really model two separate pointer types. these are thus special-case things for array access only.
	OP_GSTOREP_I,
	OP_GSTOREP_F,
	OP_GSTOREP_ENT,
	OP_GSTOREP_FLD,		//200
	OP_GSTOREP_S,
	OP_GSTOREP_FNC,		
	OP_GSTOREP_V,
	OP_GADDRESS,	//poorly defined opcode, which makes it too unreliable to actually use.
	OP_GLOAD_I,
	OP_GLOAD_F,
	OP_GLOAD_FLD,
	OP_GLOAD_ENT,
	OP_GLOAD_S,
	OP_GLOAD_FNC,		//210

//back to ones that we do use.
	OP_BOUNDCHECK,
	OP_UNUSED,	//used to be OP_STOREP_P, which is now emulated with OP_STOREP_I, fteqcc nor fte generated it
	OP_PUSH,	//push 4octets onto the local-stack (which is ALWAYS poped on function return). Returns a pointer.
	OP_POP,		//pop those ones that were pushed (don't over do it). Needs assembler.

	OP_SWITCH_I,//hmm.
	OP_GLOAD_V,
//r3349+
	OP_IF_F,		//compares as an actual float, instead of treating -0 as positive.
	OP_IFNOT_F,

//r5697+
	OP_STOREF_V,	//3 elements...
	OP_STOREF_F,	//1 fpu element...
	OP_STOREF_S,	//1 string reference
	OP_STOREF_I,	//1 non-string reference/int

//r5744+
	OP_STOREP_B,//((char*)b)[(int)c] = (int)a
	OP_LOADP_B,	//(int)c = *(char*)

//r5768+
//opcodes for 32bit uints
	OP_LE_U,		//aka GT
	OP_LT_U,		//aka GE
	OP_DIV_U,		//don't need mul+add+sub
	OP_RSHIFT_U,	//lshift is the same for signed+unsigned

//opcodes for 64bit ints
	OP_ADD_I64,
	OP_SUB_I64,
	OP_MUL_I64,
	OP_DIV_I64,
	OP_BITAND_I64,
	OP_BITOR_I64,
	OP_BITXOR_I64,
	OP_LSHIFT_I64I,
	OP_RSHIFT_I64I,
	OP_LE_I64,		//aka GT
	OP_LT_I64,		//aka GE
	OP_EQ_I64,
	OP_NE_I64,
//extra opcodes for 64bit uints
	OP_LE_U64,		//aka GT
	OP_LT_U64,		//aka GE
	OP_DIV_U64,
	OP_RSHIFT_U64I,

//general 64bitness
	OP_STORE_I64,
	OP_STOREP_I64,
	OP_STOREF_I64,
	OP_LOAD_I64,
	OP_LOADA_I64,
	OP_LOADP_I64,
//various conversions for our 64bit types (yay type promotion)
	OP_CONV_UI64, //zero extend
	OP_CONV_II64, //sign extend
	OP_CONV_I64I,	//truncate
	OP_CONV_FD,	//extension
	OP_CONV_DF,	//truncation
	OP_CONV_I64F,	//logically a promotion (always signed)
	OP_CONV_FI64,	//demotion (always signed)
	OP_CONV_I64D,	//'promotion' (always signed)
	OP_CONV_DI64,	//demotion (always signed)

//opcodes for doubles.
	OP_ADD_D,
	OP_SUB_D,
	OP_MUL_D,
	OP_DIV_D,
	OP_LE_D,
	OP_LT_D,
	OP_EQ_D,
	OP_NE_D,


	OP_NUMREALOPS,

	/*
	These ops are emulated out, always, and are only present in the compiler.
	*/

	OP_BITSETSTORE_I,	//220
	OP_BITSETSTOREP_I,
	OP_BITCLRSTORE_I,

	OP_MULSTORE_I,
	OP_DIVSTORE_I,
	OP_ADDSTORE_I,
	OP_SUBSTORE_I,
	OP_MULSTOREP_I,
	OP_DIVSTOREP_I,
	OP_ADDSTOREP_I,
	OP_SUBSTOREP_I,	//230

	OP_MULSTORE_IF,
	OP_MULSTOREP_IF,
	OP_DIVSTORE_IF,
	OP_DIVSTOREP_IF,
	OP_ADDSTORE_IF,
	OP_ADDSTOREP_IF,
	OP_SUBSTORE_IF,
	OP_SUBSTOREP_IF,

	OP_MULSTORE_FI,
	OP_MULSTOREP_FI,	//240
	OP_DIVSTORE_FI,
	OP_DIVSTOREP_FI,
	OP_ADDSTORE_FI,
	OP_ADDSTOREP_FI,
	OP_SUBSTORE_FI,
	OP_SUBSTOREP_FI,

	OP_MULSTORE_VI,
	OP_MULSTOREP_VI,

	OP_LOADA_STRUCT,
	OP_LOADP_P,
	OP_STOREP_P,

	OP_BITNOT_F,
	OP_BITNOT_I,

	OP_EQ_P,
	OP_NE_P,
	OP_LE_P,
	OP_GE_P,
	OP_LT_P,
	OP_GT_P,

	OP_ANDSTORE_F,
	OP_BITCLR_F,
	OP_BITCLR_I,
	OP_BITCLR_V,

	OP_ADD_SI,
	OP_ADD_IS,
	OP_ADD_PF,
	OP_ADD_FP,
	OP_ADD_PI,
	OP_ADD_IP,

	OP_SUB_SI,
	OP_SUB_PF,
	OP_SUB_PI,

	OP_SUB_PP,

	OP_MOD_F,
	OP_MOD_I,
	OP_MOD_FI,
	OP_MOD_IF,
	OP_MOD_V,

	OP_BITXOR_F,
	OP_RSHIFT_F,
	OP_LSHIFT_F,
	OP_RSHIFT_IF,
	OP_LSHIFT_IF,
	OP_RSHIFT_FI,
	OP_LSHIFT_FI,

	OP_AND_ANY,
	OP_OR_ANY,

	OP_ADD_EI,
	OP_ADD_EF,
	OP_SUB_EI,
	OP_SUB_EF,

	OP_BITAND_V,
	OP_BITOR_V,
	OP_BITNOT_V,
	OP_BITXOR_V,

	OP_POW_F,
	OP_POW_I,
	OP_POW_FI,
	OP_POW_IF,
	OP_CROSS_V,

	OP_EQ_FLD,
	OP_NE_FLD,

	OP_SPACESHIP_F,	//lame
	OP_SPACESHIP_S,	//basically strcmp.


	//uint32 opcodes. they match the int32 ones so emulation is basically swapping them over.
	OP_ADD_U,
	OP_SUB_U,
	OP_MUL_U,
	OP_MOD_U,	//complex
	OP_BITAND_U,
	OP_BITOR_U,
	OP_BITXOR_U,
	OP_BITNOT_U,	//BITXOR ~0
	OP_BITCLR_U,
	OP_LSHIFT_U,	//same as signed (unlike rshift)
	OP_GE_U,	//LT_U
	OP_GT_U,	//LE_U
//	OP_AND_U,
//	OP_OR_U,
	OP_EQ_U,
	OP_NE_U,

	//uint64 opcodes. they match the int32 ones so emulation is basically swapping them over.
	OP_BITNOT_I64,	//BITXOR ~0
	OP_BITCLR_I64,
	OP_GE_I64,	//LT_I64
	OP_GT_I64,	//LE_I64

	OP_ADD_U64,
	OP_SUB_U64,
	OP_MUL_U64,
	OP_MOD_U64,	//complex
	OP_BITAND_U64,
	OP_BITOR_U64,
	OP_BITXOR_U64,
	OP_BITNOT_U64,	//BITXOR ~0
	OP_BITCLR_U64,
	OP_LSHIFT_U64I,
	OP_GE_U64,	//LT_U64
	OP_GT_U64,	//LE_U64
	OP_EQ_U64,
	OP_NE_U64,

	//generally implemented by forcing to int64.
	OP_BITAND_D,
	OP_BITOR_D,
	OP_BITXOR_D,
	OP_BITNOT_D,
	OP_BITCLR_D,
	OP_LSHIFT_DI,
	OP_RSHIFT_DI,

	OP_WSTATE,	//for the 'w' part of CWSTATE. will probably never be used, but hey, hexen2...

	//special/fake opcodes used by the decompiler.
	OPD_GOTO_FORSTART,
	OPD_GOTO_WHILE1,

	OP_NUMOPS,
#define OP_BIT_BREAKPOINT 0x8000
};

#define	MAX_PARMS	8

// qtest structs (used for reordering and not execution)
typedef struct qtest_statement_s
{
	unsigned int	line; // line number in source code file
	unsigned short	op;
	unsigned short	a,b,c;
} qtest_statement_t;

typedef struct qtest_def_s
{
	unsigned int	type; // no DEFGLOBAL found in qtest progs
	unsigned int	s_name; // different order!
	unsigned int	ofs;
} qtest_def_t;

typedef struct qtest_function_s
{
	int		first_statement;
	int		unused1;
	int		locals;	// assumed! (always 0 in real qtest progs)
	int		profile; // assumed! (always 0 in real qtest progs)

	int		s_name;
	int		s_file;

	int		numparms;
	int		parm_start; // different order
	int		parm_size[MAX_PARMS]; // ints instead of bytes...
} qtest_function_t;

typedef struct statement16_s
{
	unsigned short	op;
	unsigned short	a,b,c;
} dstatement16_t;
typedef struct statement32_s
{
	unsigned int	op;
	unsigned int	a,b,c;
} dstatement32_t;
#define QCC_dstatement16_t dstatement16_t
#define QCC_dstatement32_t dstatement32_t

typedef struct
{
	struct QCC_def_s *sym;
	unsigned int ofs;
	struct QCC_type_s *cast;	//the entire sref is considered null if there is no cast, although it *MAY* have an ofs specified if its part of a jump instruction
} QCC_sref_t;
typedef struct qcc_statement_s
{
	unsigned short		op;
	#define STF_LOGICOP (1u<<0)	//do not bother following when looking for uninitialised variables.
	unsigned short		flags;
	QCC_sref_t			a, b, c;
	unsigned int		linenum;
} QCC_statement_t;

//these should be the same except the string type
typedef struct ddef16_s
{
	unsigned short	type;		// if DEF_SAVEGLOBAL bit is set
								// the variable needs to be saved in savegames
	unsigned short	ofs;
	string_t		s_name;
} ddef16_t;

typedef struct ddef32_s
{
	unsigned int	type;		// if DEF_SAVEGLOBAL bit is set
								// the variable needs to be saved in savegames
	unsigned int	ofs;
	string_t		s_name;
} ddef32_t;

typedef void *ddefXX_t;

typedef struct QCC_ddef16_s
{
	unsigned short	type;		// if DEF_SAVEGLOBAL bit is set
								// the variable needs to be saved in savegames
	unsigned short	ofs;
	QCC_string_t		s_name;
} QCC_ddef16_t;

typedef struct QCC_ddef32_s
{
	unsigned int	type;		// if DEF_SAVEGLOBAL bit is set
								// the variable needs to be saved in savegames
	unsigned int	ofs;
	QCC_string_t		s_name;
} QCC_ddef32_t;
#define QCC_ddef_t QCC_ddef32_t

#define	DEF_SAVEGLOBAL 		(1<<15)
#define	DEF_SHARED 		(1<<14)

typedef struct
{
	int		first_statement;	// negative numbers are builtins
	int		parm_start;
	int		locals;				// total ints of parms + locals

	int		profile;		// runtime

	string_t	s_name;
	string_t	s_file;			// source file defined in

	int		numparms;
	pbyte	parm_size[MAX_PARMS];
} dfunction_t;

typedef struct
{
	int		first_statement;	// negative numbers are builtins
	int		parm_start;
	int		locals;				// total ints of parms + locals

	int		profile;						//number of qc instructions executed.
	prclocks_t profiletime;			//total time inside (cpu cycles)
	prclocks_t profilechildtime;	//time inside children (excluding builtins, cpu cycles)

	string_t	s_name;
	string_t	s_file;			// source file defined in

	int		numparms;
	pbyte	parm_size[MAX_PARMS];
} mfunction_t;

#define PROG_QTESTVERSION	3
#define	PROG_VERSION	6
#define PROG_KKQWSVVERSION 7
#define	PROG_EXTENDEDVERSION	7
#define PROG_SECONDARYVERSION16 ((('1'<<0)|('F'<<8)|('T'<<16)|('E'<<24))^(('P'<<0)|('R'<<8)|('O'<<16)|('G'<<24)))	//something unlikly and still meaningful (to me)
#define PROG_SECONDARYVERSION32 ((('1'<<0)|('F'<<8)|('T'<<16)|('E'<<24))^(('3'<<0)|('2'<<8)|('B'<<16)|(' '<<24)))	//something unlikly and still meaningful (to me)
#define PROG_SECONDARYUHEXEN2	((('U'<<0)|('H'<<8)|('2'<<16)|('7'<<24)))	//something unlikly and still meaningful (to me)
#define PROG_SECONDARYKKQWSV	((('K'<<0)|('K'<<8)|('Q'<<16)|('W'<<24)))	//something unlikly and still meaningful (to me)
typedef struct
{
	int		version;
	int		crc;			// check of header file

	unsigned int		ofs_statements;	//comp 1
	unsigned int		numstatements;	// statement 0 is an error

	unsigned int		ofs_globaldefs;	//comp 2
	unsigned int		numglobaldefs;

	unsigned int		ofs_fielddefs;	//comp 4
	unsigned int		numfielddefs;

	unsigned int		ofs_functions;	//comp 8
	unsigned int		numfunctions;	// function 0 is an empty

	unsigned int		ofs_strings;	//comp 16
	unsigned int		numstrings;		// first string is a null string

	unsigned int		ofs_globals;	//comp 32
	unsigned int		numglobals;

	unsigned int		entityfields;

	//debug / version 7 extensions
	unsigned int		ofsfiles;	//non list format. no comp
	unsigned int		ofslinenums;	//numstatements big	//comp 64
	unsigned int		ofsbodylessfuncs;	//no comp
	unsigned int		numbodylessfuncs;

	unsigned int	ofs_types;	//comp 128
	unsigned int	numtypes;
	unsigned int	blockscompressed;

	int	secondaryversion;	//Constant - to say that any version 7 progs are actually ours, not someone else's alterations.
} dprograms_t;
#define standard_dprograms_t_size ((size_t)&((dprograms_t*)NULL)->ofsfiles)





typedef struct {
	char filename[128];
	int size;
	int compsize;
	int compmethod;
	int ofs;
} includeddatafile_t;




typedef struct typeinfo_s
{
	etype_t	type;

	int		next;
	int		aux_type;
	int		num_parms;

	int		ofs;	//inside a structure.
	int		size;
	string_t	name;
} typeinfo_t;

#endif