quakeforge/include/QF/progs.h

453 lines
13 KiB
C
Raw Normal View History

/*
progs.h
(description)
Copyright (C) 1996-1997 Id Software, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id$
*/
2001-08-27 21:13:00 +00:00
#ifndef __QF_progs_h
#define __QF_progs_h
#include "QF/link.h"
#include "QF/pr_comp.h"
#include "QF/pr_debug.h"
#include "QF/quakeio.h"
2003-12-06 22:49:18 +00:00
#define MAX_ENT_LEAFS 16
2003-12-05 22:33:11 +00:00
typedef struct edict_s {
qboolean free;
link_t area; // linked to a division node or leaf
int num_leafs;
short leafnums[MAX_ENT_LEAFS];
float freetime; // sv.time when the object was freed
void *data; // external per-edict data
pr_type_t v[1]; // fields from progs
} edict_t;
2003-12-06 22:49:18 +00:00
#define EDICT_FROM_AREA(l) STRUCT_FROM_LINK(l,edict_t,area)
#ifndef PROGS_T
typedef struct progs_s progs_t;
#define PROGS_T
#endif
#ifndef PR_RESOURCE_T
typedef struct pr_resource_s pr_resource_t;
#define PR_RESOURCE_T
#endif
//============================================================================
void PR_Init (void);
void PR_Init_Cvars (void);
2003-12-05 22:33:11 +00:00
void PR_PrintStatement (progs_t *pr, dstatement_t *s);
void PR_PushFrame (progs_t *pr);
void PR_PopFrame (progs_t *pr);
2003-12-05 22:33:11 +00:00
void PR_EnterFunction (progs_t *pr, dfunction_t *f);
void PR_ExecuteProgram (progs_t *pr, func_t fnum);
2003-12-05 22:33:11 +00:00
void PR_LoadProgsFile (progs_t *pr, QFile *file, int size, int edicts,
int zone);
void PR_LoadProgs (progs_t *pr, const char *progsname, int edicts, int zone);
int PR_LoadStrings (progs_t *pr);
int PR_LoadDebug (progs_t *pr);
edict_t *PR_InitEdicts (progs_t *pr, int num_edicts);
int PR_Check_Opcodes (progs_t *pr);
void PR_Profile_f (void);
2003-12-05 22:33:11 +00:00
void ED_ClearEdict (progs_t *pr, edict_t *e, int val);
edict_t *ED_Alloc (progs_t *pr);
void ED_Free (progs_t *pr, edict_t *ed);
void ED_Print (progs_t *pr, edict_t *ed);
void ED_Write (progs_t *pr, QFile *f, edict_t *ed);
2001-07-15 07:04:17 +00:00
const char *ED_ParseEdict (progs_t *pr, const char *data, edict_t *ent);
void ED_WriteGlobals (progs_t *pr, QFile *f);
2001-07-15 07:04:17 +00:00
void ED_ParseGlobals (progs_t *pr, const char *data);
2001-07-15 07:04:17 +00:00
void ED_LoadFromFile (progs_t *pr, const char *data);
ddef_t *ED_FieldAtOfs (progs_t *pr, int ofs);
ddef_t *ED_FindField (progs_t *pr, const char *name);
2001-07-15 07:04:17 +00:00
int ED_GetFieldIndex (progs_t *pr, const char *name);
dfunction_t *ED_FindFunction (progs_t *pr, const char *name);
int PR_AccessField (progs_t *pr, const char *name, etype_t type,
const char *file, int line);
//define EDICT_NUM(p,n) ((edict_t *)(*(p)->edicts+ (n)*(p)->pr_edict_size))
//define NUM_FOR_EDICT(p,e) (((byte *)(e) - *(p)->edicts)/(p)->pr_edict_size)
edict_t *EDICT_NUM(progs_t *pr, int n);
int NUM_FOR_EDICT(progs_t *pr, edict_t *e);
int NUM_FOR_BAD_EDICT(progs_t *pr, edict_t *e);
qboolean PR_EdictValid (progs_t *pr, int e);
2003-12-06 22:49:18 +00:00
#define NEXT_EDICT(p,e) ((edict_t *)( (byte *)e + (p)->pr_edict_size))
#define PR_edicts(p) ((byte *)*(p)->edicts)
2003-12-06 22:49:18 +00:00
#define EDICT_TO_PROG(p,e) ((byte *)(e) - PR_edicts (p))
#define PROG_TO_EDICT(p,e) ((edict_t *)(PR_edicts (p) + (e)))
//============================================================================
#define G_var(p,o,t) ((p)->pr_globals[o].t##_var)
2003-12-06 22:49:18 +00:00
#define G_FLOAT(p,o) G_var (p, o, float)
#define G_INT(p,o) G_var (p, o, integer)
#define G_UINT(p,o) G_var (p, o, uinteger)
#define G_VECTOR(p,o) G_var (p, o, vector)
#define G_STRING(p,o) G_var (p, o, string)
2003-12-06 22:49:18 +00:00
#define G_FUNCTION(p,o) G_var (p, o, func)
#define G_POINTER(p,o) G_var (p, o, pointer)
#define G_EDICT(p,o) ((edict_t *)(PR_edicts (p) + G_INT (p, o)))
#define G_EDICTNUM(p,o) NUM_FOR_EDICT(p, G_EDICT (p, o))
2003-12-06 22:49:18 +00:00
#define G_GSTRING(p,o) PR_GetString (p, G_STRING (p, o))
#define G_DSTRING(p,o) PR_GetDString (p, G_STRING (p, o))
2003-12-06 22:49:18 +00:00
#define G_GPOINTER(p,o) PR_GetPointer (p, o)
#define G_STRUCT(p,t,o) (*(t *)G_GPOINTER (p, o))
#define P_var(p,n,t) ((p)->pr_params[n]->t##_var)
#define P_FLOAT(p,n) P_var (p, n, float)
#define P_INT(p,n) P_var (p, n, integer)
#define P_UINT(p,n) P_var (p, n, uinteger)
#define P_VECTOR(p,n) P_var (p, n, vector)
#define P_STRING(p,n) P_var (p, n, string)
#define P_FUNCTION(p,n) P_var (p, n, func)
#define P_POINTER(p,n) P_var (p, n, pointer)
#define P_EDICT(p,n) ((edict_t *)(PR_edicts (p) + P_INT (p, n)))
#define P_EDICTNUM(p,n) NUM_FOR_EDICT (p, P_EDICT (p, n))
#define P_GSTRING(p,n) PR_GetString (p, P_STRING (p, n))
#define P_DSTRING(p,n) PR_GetDString (p, P_STRING (p, n))
#define P_GPOINTER(p,n) PR_GetPointer (p, P_POINTER (p, n))
#define P_STRUCT(p,t,n) (*(t *)P_GPOINTER (p, n))
#define R_var(p,t) ((p)->pr_return->t##_var)
#define R_FLOAT(p) R_var (p, float)
#define R_INT(p) R_var (p, integer)
#define R_UINT(p) R_var (p, uinteger)
#define R_VECTOR(p) R_var (p, vector)
#define R_STRING(p) R_var (p, string)
#define R_FUNCTION(p) R_var (p, func)
#define R_POINTER(p) R_var (p, pointer)
#define RETURN_STRING(p, s) (R_STRING (p) = PR_SetReturnString((p), s))
2003-12-06 22:49:18 +00:00
#define RETURN_EDICT(p, e) (R_STRING (p) = EDICT_TO_PROG(p, e))
#define RETURN_POINTER(pr,p) (R_POINTER (pr) = POINTER_TO_PROG (pr, p))
#define RETURN_VECTOR(p, v) (VectorCopy (v, R_VECTOR (p)))
#define E_var(e,o,t) ((e)->v[o].t##_var)
2003-12-06 22:49:18 +00:00
#define E_FLOAT(e,o) E_var (e, o, float)
#define E_INT(e,o) E_var (e, o, integer)
#define E_UINT(e,o) E_var (e, o, uinteger)
#define E_VECTOR(e,o) E_var (e, o, vector)
#define E_STRING(e,o) E_var (e, o, string)
2003-09-12 23:12:21 +00:00
#define E_FUNCTION(p,o) E_var (p, o, func)
#define E_POINTER(p,o) E_var (p, o, pointer)
2003-12-06 22:49:18 +00:00
#define E_GSTRING(p,e,o) (PR_GetString (p, E_STRING (e, o)))
#define E_DSTRING(p,e,o) (PR_GetDString (p, E_STRING (e, o)))
/*
Builtins are arranged into groups of 65536 to allow for diffent expantion
sets. eg, stock id is 0x0000xxxx, quakeforge is 0x000fxxxx. predefined
groups go up to 0x0fffxxxx allowing 4096 different groups. Builtins
0x10000000 to 0x7fffffff are reserved for auto-allocation. The range
0x8000000 to 0xffffffff is unavailable due to the builtin number being
a negative statement address.
*/
#define PR_RANGE_SHIFT 16
#define PR_RANGE_MASK 0xffff0000
#define PR_RANGE_QF 0x000f
#define PR_RANGE_AUTO 0x1000
#define PR_RANGE_NONE 0xffff
#define PR_AUTOBUILTIN (PR_RANGE_AUTO << PR_RANGE_SHIFT)
typedef void (*builtin_proc) (progs_t *pr);
typedef struct {
const char *name;
builtin_proc proc;
int binum;
} builtin_t;
typedef struct {
int first_statement;
builtin_proc func;
} bfunction_t;
ddef_t *PR_FindGlobal (progs_t *pr, const char *name);
2003-12-05 22:33:11 +00:00
ddef_t *ED_GlobalAtOfs (progs_t *pr, int ofs);
pr_type_t *PR_GetGlobalPointer (progs_t *pr, const char *name);
func_t PR_GetFunctionIndex (progs_t *pr, const char *name);
int PR_GetFieldOffset (progs_t *pr, const char *name);
void PR_Error (progs_t *pr, const char *error, ...) __attribute__((format(printf,2,3), noreturn));
void PR_RunError (progs_t *pr, const char *error, ...) __attribute__((format(printf,2,3), noreturn));
void ED_PrintEdicts (progs_t *pr, const char *fieldval);
void ED_PrintNum (progs_t *pr, int ent);
void ED_Count (progs_t *pr);
void PR_Profile (progs_t *pr);
const char *PR_GlobalString (progs_t *pr, int ofs, etype_t type);
const char *PR_GlobalStringNoContents (progs_t *pr, int ofs, etype_t type);
2001-07-15 07:04:17 +00:00
pr_type_t *GetEdictFieldValue(progs_t *pr, edict_t *ed, const char *field);
void PR_RegisterBuiltins (progs_t *pr, builtin_t *builtins);
builtin_t *PR_FindBuiltin (progs_t *pr, const char *name);
builtin_t *PR_FindBuiltinNum (progs_t *pr, int num);
int PR_RelocateBuiltins (progs_t *pr);
int PR_ResolveGlobals (progs_t *pr);
typedef int pr_load_func_t (progs_t *);
void PR_AddLoadFunc (progs_t *pr, pr_load_func_t *func);
int PR_RunLoadFuncs (progs_t *pr);
//
// PR Obj stuff
//
void PR_Obj_Progs_Init (progs_t *pr);
int PR_InitRuntime (progs_t *pr);
//
// PR Strings stuff
//
qboolean PR_StringValid (progs_t *pr, int num);
const char *PR_GetString(progs_t *pr, int num);
struct dstring_s *PR_GetDString(progs_t *pr, int num);
2001-07-15 07:04:17 +00:00
int PR_SetString(progs_t *pr, const char *s);
int PR_SetReturnString(progs_t *pr, const char *s);
int PR_SetTempString(progs_t *pr, const char *s);
void PR_MakeTempString(progs_t *pr, int str);
int PR_NewString (progs_t *pr);
void PR_ClearReturnStrings (progs_t *pr);
void PR_FreeString (progs_t *pr, int str);
void PR_FreeTempStrings (progs_t *pr);
void PR_Sprintf (progs_t *pr, struct dstring_s *result, const char *name,
const char *format, int count, pr_type_t **args);
//
// PR Resources stuff
//
2002-01-30 06:29:32 +00:00
void PR_Resources_Init (progs_t *pr);
void PR_Resources_Clear (progs_t *pr);
void PR_Resources_Register (progs_t *pr, const char *name, void *data,
void (*clear)(progs_t *, void *));
void *PR_Resources_Find (progs_t *pr, const char *name);
//
// PR Zone stuff
//
void PR_Zone_Init (progs_t *pr);
void PR_Zone_Free (progs_t *pr, void *ptr);
2002-01-30 08:09:53 +00:00
void *PR_Zone_Malloc (progs_t *pr, int size);
void *PR_Zone_Realloc (progs_t *pr, void *ptr, int size);
//
// PR Debug stuff
//
void PR_Debug_Init (void);
void PR_Debug_Init_Cvars (void);
pr_auxfunction_t *PR_Get_Lineno_Func (progs_t *pr, pr_lineno_t *lineno);
2001-11-29 19:35:25 +00:00
unsigned int PR_Get_Lineno_Addr (progs_t *pr, pr_lineno_t *lineno);
unsigned int PR_Get_Lineno_Line (progs_t *pr, pr_lineno_t *lineno);
pr_lineno_t *PR_Find_Lineno (progs_t *pr, unsigned int addr);
const char *PR_Get_Source_File (progs_t *pr, pr_lineno_t *lineno);
2001-11-29 19:35:25 +00:00
const char *PR_Get_Source_Line (progs_t *pr, unsigned int addr);
ddef_t *PR_Get_Local_Def (progs_t *pr, int offs);
void PR_DumpState (progs_t *pr);
2003-12-05 22:33:11 +00:00
void PR_StackTrace (progs_t *pr);
extern struct cvar_s *pr_debug;
extern struct cvar_s *pr_deadbeef_ents;
2001-10-28 04:23:37 +00:00
extern struct cvar_s *pr_deadbeef_locals;
extern struct cvar_s *pr_boundscheck;
extern struct cvar_s *pr_faultchecks;
extern const char *pr_gametype;
//
// PR Cmds stuff
//
char *PF_VarString (progs_t *pr, int first);
void PR_Cmds_Init (progs_t *pr);
//============================================================================
#define MAX_STACK_DEPTH 64
#define LOCALSTACK_SIZE 4096
#define PR_RS_SLOTS 16
typedef struct strref_s strref_t;
typedef struct {
int s;
dfunction_t *f;
strref_t *tstr;
} prstack_t;
struct progs_s {
2003-12-05 22:33:11 +00:00
const char *progs_name;
dprograms_t *progs;
int progs_size;
struct memzone_s *zone;
2003-12-05 22:33:11 +00:00
int zone_size;
struct hashtab_s *builtin_hash;
struct hashtab_s *builtin_num_hash;
unsigned bi_next;
unsigned (*bi_map)(progs_t *pr, unsigned binum);
struct hashtab_s *function_hash;
struct hashtab_s *global_hash;
struct hashtab_s *field_hash;
2003-12-05 22:33:11 +00:00
int num_load_funcs;
int max_load_funcs;
pr_load_func_t **load_funcs;
struct dstring_mem_s *ds_mem;
strref_t *free_string_refs;
strref_t *static_strings;
strref_t **dynamic_strings;
strref_t *return_strings[PR_RS_SLOTS];
int rs_slot;
2003-12-05 22:33:11 +00:00
unsigned dyn_str_size;
struct hashtab_s *strref_hash;
2003-12-05 22:33:11 +00:00
int num_strings;
strref_t *pr_xtstr;
2003-12-05 22:33:11 +00:00
dfunction_t *pr_functions;
char *pr_strings;
int pr_stringsize;
ddef_t *pr_globaldefs;
ddef_t *pr_fielddefs;
dstatement_t *pr_statements;
pr_type_t *pr_globals; // same as pr_global_struct
int globals_size;
2003-12-05 22:33:11 +00:00
pr_type_t *pr_return;
pr_type_t *pr_params[MAX_PARMS];
int pr_param_size; // covers both params and return
2003-12-05 22:33:11 +00:00
int pr_edict_size; // in bytes
int pr_edictareasize; // for bounds checking, starts at 0
2003-12-05 22:33:11 +00:00
int pr_argc;
2003-12-05 22:33:11 +00:00
qboolean pr_trace;
dfunction_t *pr_xfunction;
int pr_xstatement;
2003-12-05 22:33:11 +00:00
prstack_t pr_stack[MAX_STACK_DEPTH];
int pr_depth;
2003-12-05 22:33:11 +00:00
int localstack[LOCALSTACK_SIZE];
int localstack_used;
2003-12-05 22:33:11 +00:00
edict_t **edicts;
int *num_edicts;
int *reserved_edicts; //alloc will start at reserved_edicts+1
double *time;
int null_bad;
int no_exec_limit;
2003-12-05 22:33:11 +00:00
unsigned short crc;
2003-12-05 22:33:11 +00:00
void (*unlink)(edict_t *ent);
void (*flush)(void);
2003-12-05 22:33:11 +00:00
int (*parse_field)(progs_t *pr, const char *key, const char *value);
int (*prune_edict)(progs_t *pr, edict_t *ent);
void (*free_edict)(progs_t *pr, edict_t *ent);
2003-12-05 22:33:11 +00:00
void (*file_error)(progs_t *pr, const char *path);
void *(*load_file)(progs_t *pr, const char *path);
void *(*allocate_progs_mem)(progs_t *pr, int size);
void (*free_progs_mem)(progs_t *pr, void *mem);
2003-12-05 22:33:11 +00:00
pr_resource_t *resources;
struct hashtab_s *resource_hash;
// obj info
struct hashtab_s *selectors;
struct hashtab_s *classes;
struct hashtab_s *categories;
struct hashtab_s *protocols;
// debug info
2003-12-05 22:33:11 +00:00
const char *debugfile;
struct pr_debug_header_s *debug;
struct pr_auxfunction_s *auxfunctions;
struct pr_auxfunction_s **auxfunction_map;
struct pr_lineno_s *linenos;
2003-12-05 22:33:11 +00:00
ddef_t *local_defs;
// required globals
struct {
2003-12-05 22:33:11 +00:00
float *time;
int *self;
} globals;
// required fields (offsets into the edict)
struct {
2003-12-05 22:33:11 +00:00
int nextthink;
int frame;
int think;
int this;
} fields;
};
static inline pr_type_t *
PR_GetPointer (progs_t *pr, int o)
{
return o ? pr->pr_globals + o : 0;
}
static inline pointer_t
POINTER_TO_PROG (progs_t *pr, void *p)
{
return p ? (pr_type_t *) p - pr->pr_globals : 0;
}
2001-08-27 21:13:00 +00:00
#endif//__QF_progs_h