eukara/fteqw
1
0
Fork 0
forked from fte/fteqw
Code Pull requests Activity
fteqw/engine/qclib/progsint.h
Spoike fcba94f554 Merging D3D and GL renderers a little. 
D3D should be functional now. Maybe not pretty, maybe not complete, maybe not correct, but at least playable, at least with classic particles.
Some download fixes.
Some q3vm 64bit fixes.
Removed some dead cvars.

git-svn-id: https://svn.code.sf.net/p/fteqw/code/branches/wip@3614 fc73d0e0-1445-4013-8a0c-d673dee63da5
2010-11-02 23:17:25 +00:00

481 lines
13 KiB
C
Raw Blame History

#ifdef _WIN32
#define _CRT_SECURE_NO_WARNINGS
#define _CRT_NONSTDC_NO_WARNINGS
#ifndef AVAIL_ZLIB
#ifdef _MSC_VER
//#define AVAIL_ZLIB
#endif
#endif
#include <windows.h>
enum{false, true};
#else
#include <stdarg.h>
#include <math.h>
#include <stdlib.h>
#include <setjmp.h>
#include <string.h>
#include <ctype.h>
#ifndef __declspec
#define __declspec(mode)
#endif
typedef enum{false, true} boolean;
//#define _inline inline
#endif
typedef unsigned char qbyte;
#include <stdio.h>
#if defined(_M_IX86) || defined(__i386__)
//#define QCJIT
#endif
#define DLL_PROG
#ifndef PROGSUSED
#define PROGSUSED
#endif
extern int maxedicts;
extern int maxprogs;
extern int hunksize;
#include "progtype.h"
#include "progslib.h"
#pragma warning(disable : 4244)
#pragma warning(disable : 4267)
//extern progfuncs_t *progfuncs;
#define prinst progfuncs->prinst
#define externs progfuncs->parms
#include "pr_comp.h"
#include "qcd.h"
typedef struct
{
int targetflags; //weather we need to mark the progs as a newer version
char *name;
char *opname;
int priority;
enum {ASSOC_LEFT, ASSOC_RIGHT, ASSOC_RIGHT_RESULT} associative;
struct QCC_type_s **type_a, **type_b, **type_c;
} QCC_opcode_t;
extern QCC_opcode_t pr_opcodes[]; // sized by initialization
#ifdef _MSC_VER
#define Q_vsnprintf _vsnprintf
#else
#define Q_vsnprintf vsnprintf
#endif
#define sv_num_edicts (*externs->sv_num_edicts)
#define sv_edicts (*externs->sv_edicts)
#define printf externs->printf
#define Sys_Error externs->Sys_Error
#define Abort externs->Abort
#define memalloc externs->memalloc
#define memfree externs->memfree
int PRHunkMark(progfuncs_t *progfuncs);
void PRHunkFree(progfuncs_t *progfuncs, int mark);
void *PRHunkAlloc(progfuncs_t *progfuncs, int size);
void *PRAddressableAlloc(progfuncs_t *progfuncs, int ammount);
#ifdef printf
#undef LIKEPRINTF
#define LIKEPRINTF(x)
#endif
//void *HunkAlloc (int size);
char *VARGS qcva (char *text, ...) LIKEPRINTF(1);
void QC_InitShares(progfuncs_t *progfuncs);
void QC_StartShares(progfuncs_t *progfuncs);
void QC_AddSharedVar(progfuncs_t *progfuncs, int num, int type);
void QC_AddSharedFieldVar(progfuncs_t *progfuncs, int num, char *stringtable);
int QC_RegisterFieldVar(progfuncs_t *progfuncs, unsigned int type, char *name, signed long requestedpos, signed long originalofs);
pbool Decompile(progfuncs_t *progfuncs, char *fname);
int PR_ToggleBreakpoint(progfuncs_t *progfuncs, char *filename, int linenum, int flag);
void StripExtension (char *path);
#define edvars(ed) (((edictrun_t*)ed)->fields) //pointer to the field vars, given an edict
void SetEndian(void);
extern short (*PRBigShort) (short l);
extern short (*PRLittleShort) (short l);
extern int (*PRBigLong) (int l);
extern int (*PRLittleLong) (int l);
extern float (*PRBigFloat) (float l);
extern float (*PRLittleFloat) (float l);
/*
#ifndef COMPILER
typedef union eval_s
{
string_t string;
float _float;
float vector[3];
func_t function;
int _int;
int edict;
progsnum_t prog; //so it can easily be changed
} eval_t;
#endif
*/
typedef struct edictrun_s
{
pbool isfree;
float freetime; // realtime when the object was freed
unsigned int entnum;
pbool readonly; //causes error when QC tries writing to it. (quake's world entity)
void *fields;
// other fields from progs come immediately after
} edictrun_t;
int Comp_Begin(progfuncs_t *progfuncs, int nump, char **parms);
int Comp_Continue(progfuncs_t *progfuncs);
char *EvaluateDebugString(progfuncs_t *progfuncs, char *key);
char *SaveEnts(progfuncs_t *progfuncs, char *mem, int *size, int mode);
int LoadEnts(progfuncs_t *progfuncs, char *file, float killonspawnflags);
char *SaveEnt (progfuncs_t *progfuncs, char *buf, int *size, struct edict_s *ed);
struct edict_s *RestoreEnt (progfuncs_t *progfuncs, char *buf, int *size, struct edict_s *ed);
char *PF_VarString (int first);
void PR_StackTrace (progfuncs_t *progfuncs);
extern int noextensions;
#ifndef COMPILER
typedef struct progstate_s
{
dprograms_t *progs;
dfunction_t *functions;
char *strings;
union {
ddefXX_t *globaldefs;
ddef16_t *globaldefs16;
ddef32_t *globaldefs32;
};
union {
ddefXX_t *fielddefs;
ddef16_t *fielddefs16;
ddef32_t *fielddefs32;
};
void *statements;
// void *global_struct;
float *globals; // same as pr_global_struct
typeinfo_t *types;
int edict_size; // in bytes
char filename[128];
builtin_t *builtins;
int numbuiltins;
int *linenums; //debug versions only
int intsize; //16 for standard (more limiting) versions
} progstate_t;
typedef struct extensionbuiltin_s {
char *name;
builtin_t func;
struct extensionbuiltin_s *prev;
} extensionbuiltin_t;
//============================================================================
#define pr_progs current_progstate->progs
#define pr_functions current_progstate->functions
#define pr_strings current_progstate->strings
#define pr_globaldefs16 ((ddef16_t*)current_progstate->globaldefs)
#define pr_globaldefs32 ((ddef32_t*)current_progstate->globaldefs)
#define pr_fielddefs16 ((ddef16_t*)current_progstate->fielddefs)
#define pr_fielddefs32 ((ddef32_t*)current_progstate->fielddefs)
#define pr_statements16 ((dstatement16_t*)current_progstate->statements)
#define pr_statements32 ((dstatement32_t*)current_progstate->statements)
//#define pr_global_struct current_progstate->global_struct
#define pr_globals current_progstate->globals
#define pr_linenums current_progstate->linenums
#define pr_types current_progstate->types
//============================================================================
void PR_Init (void);
void PR_ExecuteProgram (progfuncs_t *progfuncs, func_t fnum);
int PR_LoadProgs(progfuncs_t *progfncs, char *s, int headercrc, builtin_t *builtins, int numbuiltins);
int PR_ReallyLoadProgs (progfuncs_t *progfuncs, char *filename, int headercrc, progstate_t *progstate, pbool complain);
void *PRHunkAlloc(progfuncs_t *progfuncs, int ammount);
void PR_Profile_f (void);
struct edict_s *ED_Alloc (progfuncs_t *progfuncs);
void ED_Free (progfuncs_t *progfuncs, struct edict_s *ed);
char *ED_NewString (progfuncs_t *progfuncs, char *string, int minlength);
// returns a copy of the string allocated from the server's string heap
void ED_Print (progfuncs_t *progfuncs, struct edict_s *ed);
//void ED_Write (FILE *f, edictrun_t *ed);
char *ED_ParseEdict (progfuncs_t *progfuncs, char *data, edictrun_t *ent);
//void ED_WriteGlobals (FILE *f);
void ED_ParseGlobals (char *data);
//void ED_LoadFromFile (char *data);
//define EDICT_NUM(n) ((edict_t *)(sv.edicts+ (n)*pr_edict_size))
//define NUM_FOR_EDICT(e) (((byte *)(e) - sv.edicts)/pr_edict_size)
struct edict_s *EDICT_NUM(progfuncs_t *progfuncs, unsigned int n);
unsigned int NUM_FOR_EDICT(progfuncs_t *progfuncs, struct edict_s *e);
//#define NEXT_EDICT(e) ((edictrun_t *)( (byte *)e + pr_edict_size))
#define EDICT_TO_PROG(pf, e) (((edictrun_t*)e)->entnum)
#define PROG_TO_EDICT(pf, e) ((struct edictrun_s *)prinst->edicttable[e])
//============================================================================
#define G_FLOAT(o) (pr_globals[o])
#define G_FLOAT2(o) (pr_globals[OFS_PARM0 + o*3])
#define G_INT(o) (*(int *)&pr_globals[o])
#define G_EDICT(o) ((edict_t *)((qbyte *)sv_edicts+ *(int *)&pr_globals[o]))
#define G_EDICTNUM(o) NUM_FOR_EDICT(G_EDICT(o))
#define G_VECTOR(o) (&pr_globals[o])
#define G_STRING(o) (*(string_t *)&pr_globals[o])
#define G_STRING2(o) ((char*)*(string_t *)&pr_globals[o])
#define GQ_STRING(o) (*(QCC_string_t *)&pr_globals[o])
#define GQ_STRING2(o) ((char*)*(QCC_string_t *)&pr_globals[o])
#define G_FUNCTION(o) (*(func_t *)&pr_globals[o])
#define G_PROG(o) (*(progsnum_t *)&pr_globals[o]) //simply so it's nice and easy to change...
#define RETURN_EDICT(e) (((int *)pr_globals)[OFS_RETURN] = EDICT_TO_PROG(e))
#define E_FLOAT(e,o) (((float*)&e->v)[o])
#define E_INT(e,o) (*(int *)&((float*)&e->v)[o])
#define E_VECTOR(e,o) (&((float*)&e->v)[o])
#define E_STRING(e,o) (*(string_t *)&((float*)(e+1))[o])
const extern unsigned int type_size[];
extern unsigned short pr_crc;
void VARGS PR_RunError (progfuncs_t *progfuncs, char *error, ...) LIKEPRINTF(2);
void ED_PrintEdicts (progfuncs_t *progfuncs);
void ED_PrintNum (progfuncs_t *progfuncs, int ent);
pbool PR_SwitchProgs(progfuncs_t *progfuncs, progsnum_t type);
void PR_MoveParms(progfuncs_t *progfuncs, progsnum_t progs1, progsnum_t progs2);
eval_t *GetEdictFieldValue(progfuncs_t *progfuncs, struct edict_s *ed, char *name, evalc_t *cache);
#endif
#ifndef COMPILER
//this is windows - all files are written with this endian standard
//optimisation
//leave undefined if in doubt over os.
#ifdef _WIN32
#define NOENDIAN
#endif
typedef struct {
int varofs;
int size;
} sharedvar_t;
typedef struct
{
int s;
dfunction_t *f;
int progsnum;
int pushed;
} prstack_t;
//pr_multi.c
void PR_SetBuiltins(int type);
#define var(type, name) type name
#define vars(type, name, size) type name[size]
typedef struct prinst_s {
#ifdef QCJIT
pbool usejit;
#endif
char **tempstrings;
int maxtempstrings;
int numtempstrings;
int numtempstringsstack;
char **allocedstrings;
int maxallocedstrings;
int numallocedstrings;
var(progstate_t *, pr_progstate);
#define pr_progstate prinst->pr_progstate
var(progsnum_t, pr_typecurrent);
#define pr_typecurrent prinst->pr_typecurrent
var(unsigned int, maxprogs);
#define maxprogs prinst->maxprogs
var(progstate_t *,current_progstate);
#define current_progstate prinst->current_progstate
var(unsigned int, numshares);
#define numshares prinst->numshares
var(sharedvar_t *,shares); //shared globals, not including parms
#define shares prinst->shares
var(unsigned int, maxshares);
#define maxshares prinst->maxshares
var(struct prmemb_s *, memblocks);
#define memb prinst->memblocks
var(unsigned int, maxfields);
#define maxfields prinst->maxfields
var(unsigned int, numfields);
#define numfields prinst->numfields
var(fdef_t*, field); //biggest size
#define field prinst->field
int reorganisefields;
//pr_exec.c
#define MAX_STACK_DEPTH 64
vars(prstack_t, pr_stack, MAX_STACK_DEPTH);
#define pr_stack prinst->pr_stack
var(int, pr_depth);
#define pr_depth prinst->pr_depth
var(int, spushed);
#define pr_spushed prinst->spushed
#define LOCALSTACK_SIZE 4096
vars(int, localstack, LOCALSTACK_SIZE);
#define localstack prinst->localstack
var(int, localstack_used);
#define localstack_used prinst->localstack_used
var(int, continuestatement);
var(int, exitdepth);
var(int, pr_trace);
#define pr_trace prinst->pr_trace
var(dfunction_t *, pr_xfunction);
#define pr_xfunction prinst->pr_xfunction
var(int, pr_xstatement);
#define pr_xstatement prinst->pr_xstatement
var(int, pr_argc);
#define pr_argc prinst->pr_argc
//pr_edict.c
var(unsigned int, maxedicts);
#define maxedicts prinst->maxedicts
var(evalc_t, spawnflagscache);
#define spawnflagscache prinst->spawnflagscache
var(unsigned int, fields_size); // in bytes
#define fields_size prinst->fields_size
var(unsigned int, max_fields_size);
#define max_fields_size prinst->max_fields_size
//initlib.c
var(char *, addressablehunk);
#define addressablehunk prinst->addressablehunk
var(unsigned int, addressableused);
#define addressableused prinst->addressableused
var(unsigned int, addressablesize);
#define addressablesize prinst->addressablesize
//var(extensionbuiltin_t *, extensionbuiltin);
//#define extensionbuiltin prinst->extensionbuiltin
struct edict_s **edicttable;
} prinst_t;
extern vec3_t vec3_origin;
eval_t *PR_FindGlobal(progfuncs_t *prfuncs, char *globname, progsnum_t pnum);
ddef16_t *ED_FindTypeGlobalFromProgs16 (progfuncs_t *progfuncs, char *name, progsnum_t prnum, int type);
ddef32_t *ED_FindTypeGlobalFromProgs32 (progfuncs_t *progfuncs, char *name, progsnum_t prnum, int type);
ddef16_t *ED_FindGlobalFromProgs16 (progfuncs_t *progfuncs, char *name, progsnum_t prnum);
ddef32_t *ED_FindGlobalFromProgs32 (progfuncs_t *progfuncs, char *name, progsnum_t prnum);
fdef_t *ED_FindField (progfuncs_t *progfuncs, char *name);
fdef_t *ED_FieldAtOfs (progfuncs_t *progfuncs, unsigned int ofs);
dfunction_t *ED_FindFunction (progfuncs_t *progfuncs, char *name, progsnum_t *pnum, progsnum_t fromprogs);
func_t PR_FindFunc(progfuncs_t *progfncs, char *funcname, progsnum_t pnum);
void PR_Configure (progfuncs_t *progfncs, int addressable_size, int max_progs);
int PR_InitEnts(progfuncs_t *progfncs, int maxents);
char *PR_ValueString (progfuncs_t *progfuncs, etype_t type, eval_t *val);
void QC_ClearEdict (progfuncs_t *progfuncs, struct edict_s *ed);
void PRAddressableFlush(progfuncs_t *progfuncs, int totalammount);
void QC_FlushProgsOffsets(progfuncs_t *progfuncs);
ddef16_t *ED_GlobalAtOfs16 (progfuncs_t *progfuncs, int ofs);
ddef16_t *ED_FindGlobal16 (progfuncs_t *progfuncs, char *name);
ddef32_t *ED_FindGlobal32 (progfuncs_t *progfuncs, char *name);
ddef32_t *ED_GlobalAtOfs32 (progfuncs_t *progfuncs, unsigned int ofs);
string_t PR_StringToProgs (progfuncs_t *inst, char *str);
char *PR_StringToNative (progfuncs_t *inst, string_t str);
void PR_FreeTemps (progfuncs_t *progfuncs, int depth);
char *PR_GlobalString (progfuncs_t *progfuncs, int ofs);
char *PR_GlobalStringNoContents (progfuncs_t *progfuncs, int ofs);
pbool CompileFile(progfuncs_t *progfuncs, char *filename);
pbool PR_GenerateJit(progfuncs_t *progfuncs);
void PR_EnterJIT(progfuncs_t *progfuncs, int statement);
char *QCC_COM_Parse (char *data);
extern char qcc_token[1024];
#endif
View git blame Copy permalink