pr_comp.h

Go to the documentation of this file.

// 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