X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=prvm_edict.c;h=35d5fde04ead699236aaea61a28139feba044616;hb=868e31d920af94a1a825dbbe24aa530f9927aceb;hp=379b0992d9f63f5802519f17612b0afd833e47f4;hpb=9adcffeed2f6bf3a4f15414397efa5ff17040824;p=xonotic%2Fdarkplaces.git diff --git a/prvm_edict.c b/prvm_edict.c index 379b0992..35d5fde0 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -36,9 +36,6 @@ cvar_t prvm_boundscheck = {0, "prvm_boundscheck", "1"}; // LordHavoc: prints every opcode as it executes - warning: this is significant spew cvar_t prvm_traceqc = {0, "prvm_traceqc", "0"}; -ddef_t *PRVM_ED_FindField (const char *name); -mfunction_t *PRVM_ED_FindFunction (const char *name); - //============================================================================ // mempool handling @@ -47,14 +44,14 @@ mfunction_t *PRVM_ED_FindFunction (const char *name); PRVM_MEM_Alloc =============== */ -void PRVM_MEM_Alloc() +void PRVM_MEM_Alloc(void) { int i; // reserve space for the null entity aka world // check bound of max_edicts - prog->max_edicts = bound(1, prog->max_edicts, prog->limit_edicts); - prog->num_edicts = bound(1, prog->num_edicts, prog->max_edicts); + prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts); + prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts); // edictprivate_size has to be min as big prvm_edict_private_t prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t)); @@ -71,8 +68,8 @@ void PRVM_MEM_Alloc() // set edict pointers for(i = 0; i < prog->max_edicts; i++) { - prog->edicts[i].p.e = (prvm_edict_private_t *)((qbyte *)prog->edictprivate + i * prog->edictprivate_size); - prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size); + prog->edicts[i].priv.required = (prvm_edict_private_t *)((qbyte *)prog->edictprivate + i * prog->edictprivate_size); + prog->edicts[i].fields.vp = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size); } } @@ -81,7 +78,7 @@ void PRVM_MEM_Alloc() PRVM_MEM_IncreaseEdicts =============== */ -void PRVM_MEM_IncreaseEdicts() +void PRVM_MEM_IncreaseEdicts(void) { int i; int oldmaxedicts = prog->max_edicts; @@ -105,8 +102,8 @@ void PRVM_MEM_IncreaseEdicts() //set e and v pointers for(i = 0; i < prog->max_edicts; i++) { - prog->edicts[i].p.e = (prvm_edict_private_t *)((qbyte *)prog->edictprivate + i * prog->edictprivate_size); - prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size); + prog->edicts[i].priv.required = (prvm_edict_private_t *)((qbyte *)prog->edictprivate + i * prog->edictprivate_size); + prog->edicts[i].fields.vp = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size); } PRVM_GCALL(end_increase_edicts)(); @@ -170,12 +167,12 @@ PRVM_SetProg */ void PRVM_SetProg(int prognr) { - if(prognr && prognr < PRVM_MAXPROGS) + if(0 <= prognr && prognr < PRVM_MAXPROGS) { if(prog_list[prognr].loaded) prog = &prog_list[prognr]; else - PRVM_ERROR("%i(%s) not loaded !\n", prognr, PRVM_NAME); + PRVM_ERROR("%i not loaded !\n", prognr); return; } PRVM_ERROR("Invalid program number %i\n", prognr); @@ -190,14 +187,11 @@ Sets everything to NULL */ void PRVM_ED_ClearEdict (prvm_edict_t *e) { - int num; - memset (e->v, 0, prog->progs->entityfields * 4); - e->p.e->free = false; - // LordHavoc: for consistency set these here - num = PRVM_NUM_FOR_EDICT(e) - 1; + memset (e->fields.vp, 0, prog->progs->entityfields * 4); + e->priv.required->free = false; // AK: Let the init_edict function determine if something needs to be initialized - PRVM_GCALL(init_edict)(num); + PRVM_GCALL(init_edict)(e); } /* @@ -221,19 +215,19 @@ prvm_edict_t *PRVM_ED_Alloc (void) // AK: changed i=svs.maxclients+1 // AK: changed so the edict 0 wont spawn -> used as reserved/world entity // although the menu/client has no world - for (i = 1;i < prog->num_edicts;i++) + for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++) { e = PRVM_EDICT_NUM(i); // the first couple seconds of server time can involve a lot of // freeing and allocating, so relax the replacement policy - if (e->p.e->free && ( e->p.e->freetime < 2 || (*prog->time - e->p.e->freetime) > 0.5 ) ) + if (e->priv.required->free && ( e->priv.required->freetime < 2 || (*prog->time - e->priv.required->freetime) > 0.5 ) ) { PRVM_ED_ClearEdict (e); return e; } } - if (i == MAX_EDICTS) + if (i == prog->limit_edicts) PRVM_ERROR ("%s: PRVM_ED_Alloc: no free edicts",PRVM_NAME); prog->num_edicts++; @@ -256,14 +250,14 @@ FIXME: walk all entities and NULL out references to this entity */ void PRVM_ED_Free (prvm_edict_t *ed) { - // dont delete the null entity (world) - if(PRVM_NUM_FOR_EDICT(ed) == 0) + // dont delete the null entity (world) or reserved edicts + if(PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) return; PRVM_GCALL(free_edict)(ed); - ed->p.e->free = true; - ed->p.e->freetime = *prog->time; + ed->priv.required->free = true; + ed->priv.required->freetime = *prog->time; } //=========================================================================== @@ -388,7 +382,7 @@ char *PRVM_ValueString (etype_t type, prvm_eval_t *val) break; case ev_entity: n = val->edict; - if (n < 0 || n >= MAX_EDICTS) + if (n < 0 || n >= prog->limit_edicts) sprintf (line, "entity %i (invalid!)", n); else sprintf (line, "entity %i", n); @@ -470,7 +464,7 @@ char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val) dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict))); break; case ev_function: - f = pr_functions + val->function; + f = prog->functions + val->function; strlcpy (line, PRVM_GetString (f->s_name), sizeof (line)); break; case ev_field: @@ -505,12 +499,12 @@ padded to 20 field width char *PRVM_GlobalString (int ofs) { char *s; - int i; + size_t i; ddef_t *def; void *val; static char line[128]; - val = (void *)&prog->globals[ofs]; + val = (void *)&prog->globals.generic[ofs]; def = PRVM_ED_GlobalAtOfs(ofs); if (!def) sprintf (line,"%i(?)", ofs); @@ -530,7 +524,7 @@ char *PRVM_GlobalString (int ofs) char *PRVM_GlobalStringNoContents (int ofs) { - int i; + size_t i; ddef_t *def; static char line[128]; @@ -560,7 +554,7 @@ For debugging // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print) void PRVM_ED_Print(prvm_edict_t *ed) { - int l; + size_t l; ddef_t *d; int *v; int i, j; @@ -568,7 +562,7 @@ void PRVM_ED_Print(prvm_edict_t *ed) int type; char tempstring[8192], tempstring2[260]; // temporary string buffers - if (ed->p.e->free) + if (ed->priv.required->free) { Con_Printf("%s: FREE\n",PRVM_NAME); return; @@ -583,7 +577,7 @@ void PRVM_ED_Print(prvm_edict_t *ed) if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - v = (int *)((char *)ed->v + d->ofs*4); + v = (int *)((char *)ed->fields.vp + d->ofs*4); // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; @@ -643,7 +637,7 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) FS_Print(f, "{\n"); - if (ed->p.e->free) + if (ed->priv.required->free) { FS_Print(f, "}\n"); return; @@ -656,7 +650,7 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - v = (int *)((char *)ed->v + d->ofs*4); + v = (int *)((char *)ed->fields.vp + d->ofs*4); // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; @@ -772,7 +766,7 @@ void PRVM_ED_Count_f (void) for (i=0 ; inum_edicts ; i++) { ent = PRVM_EDICT_NUM(i); - if (ent->p.e->free) + if (ent->priv.required->free) continue; active++; } @@ -819,7 +813,7 @@ void PRVM_ED_WriteGlobals (qfile_t *f) name = PRVM_GetString(def->s_name); FS_Printf(f,"\"%s\" ", name); - FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals[def->ofs])); + FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals.generic[def->ofs])); } FS_Print(f,"}\n"); } @@ -883,15 +877,14 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) mfunction_t *func; if (ent) - val = (prvm_eval_t *)((int *)ent->v + key->ofs); + val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs); else - val = (prvm_eval_t *)((int *)prog->globals + key->ofs); + val = (prvm_eval_t *)((int *)prog->globals.generic + key->ofs); switch (key->type & ~DEF_SAVEGLOBAL) { case ev_string: - l = strlen(s) + 1; - new_p = PRVM_AllocString(l); - val->string = PRVM_SetQCString(new_p); + l = (int)strlen(s) + 1; + val->string = PRVM_AllocString(l, &new_p); for (i = 0;i < l;i++) { if (s[i] == '\\' && i < l-1) @@ -934,15 +927,15 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) while (*s && *s <= ' ') s++; i = atoi(s); - if (i < 0 || i >= MAX_EDICTS) - Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i) on %s\n", i, MAX_EDICTS, PRVM_NAME); + if (i >= prog->limit_edicts) + Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, (unsigned int)MAX_EDICTS, PRVM_NAME); while (i >= prog->max_edicts) PRVM_MEM_IncreaseEdicts(); //SV_IncreaseEdicts(); // if SV_IncreaseEdicts was called the base pointer needs to be updated if (ent) - val = (prvm_eval_t *)((int *)ent->v + key->ofs); - val->edict = PRVM_EDICT_TO_PROG(EDICT_NUM(i)); + val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs); + val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i)); break; case ev_field: @@ -966,7 +959,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) break; default: - Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PR_GetString(key->s_name), PRVM_NAME); + Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(key->s_name), PRVM_NAME); return false; } return true; @@ -1022,7 +1015,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) qboolean anglehack; qboolean init; char keyname[256]; - int n; + size_t n; init = false; @@ -1092,7 +1085,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) } if (!init) - ent->p.e->free = true; + ent->priv.required->free = true; return data; } @@ -1134,15 +1127,18 @@ void PRVM_ED_LoadFromFile (const char *data) if (com_token[0] != '{') PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token); - // CHANGED: this is not conform to ED_LoadFromFile - if(!prog->num_edicts) + // CHANGED: this is not conform to PR_LoadFromFile + if(prog->loadintoworld) + { + prog->loadintoworld = false; ent = PRVM_EDICT_NUM(0); + } else ent = PRVM_ED_Alloc(); // clear it if (ent != prog->edicts) // hack - memset (ent->v, 0, prog->progs->entityfields * 4); + memset (ent->fields.vp, 0, prog->progs->entityfields * 4); data = PRVM_ED_ParseEdict (data, ent); parsed++; @@ -1160,7 +1156,7 @@ void PRVM_ED_LoadFromFile (const char *data) // if(prog->self && prog->flag & PRVM_FE_CLASSNAME) { - string_t handle = *(string_t*)&((float*)ent->v)[PRVM_ED_FindFieldOffset("classname")]; + string_t handle = *(string_t*)&((qbyte*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")]; if (!handle) { Con_Print("No classname for:\n"); @@ -1189,7 +1185,7 @@ void PRVM_ED_LoadFromFile (const char *data) } spawned++; - if (ent->p.e->free) + if (ent->priv.required->free) died++; } @@ -1220,9 +1216,54 @@ PRVM_ResetProg void PRVM_ResetProg() { + PRVM_GCALL(reset_cmd)(); Mem_FreePool(&prog->progs_mempool); memset(prog,0,sizeof(prvm_prog_t)); - PRVM_GCALL(reset_cmd)(); +} + +/* +=============== +PRVM_LoadLNO +=============== +*/ +void PRVM_LoadLNO( const char *progname ) { + qbyte *lno; + unsigned int *header; + char filename[512]; + + FS_StripExtension( progname, filename, sizeof( filename ) ); + strlcat( filename, ".lno", sizeof( filename ) ); + + lno = FS_LoadFile( filename, tempmempool, false ); + if( !lno ) { + return; + } + +/* + SafeWrite (h, &lnotype, sizeof(int)); + SafeWrite (h, &version, sizeof(int)); + SafeWrite (h, &numglobaldefs, sizeof(int)); + SafeWrite (h, &numpr_globals, sizeof(int)); + SafeWrite (h, &numfielddefs, sizeof(int)); + SafeWrite (h, &numstatements, sizeof(int)); + SafeWrite (h, statement_linenums, numstatements*sizeof(int)); +*/ + if( (unsigned) fs_filesize < (6 + prog->progs->numstatements) * sizeof( int ) ) { + return; + } + + header = (unsigned int *) lno; + if( header[ 0 ] == *(unsigned int *) "LNOF" && + LittleLong( header[ 1 ] ) == 1 && + (unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs->numglobaldefs && + (unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs->numglobals && + (unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs->numfielddefs && + (unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs->numstatements ) + { + prog->statement_linenums = Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof( int ) ); + memcpy( prog->statement_linenums, (int *) lno + 6, prog->progs->numstatements * sizeof( int ) ); + } + Mem_Free( lno ); } /* @@ -1230,22 +1271,24 @@ void PRVM_ResetProg() PRVM_LoadProgs =============== */ -void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func) +void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field) { int i; dstatement_t *st; ddef_t *infielddefs; dfunction_t *dfunctions; - Mem_EmptyPool(prog->progs_mempool); + if( prog->loaded ) { + PRVM_ERROR ("PRVM_LoadProgs: there is already a %s program loaded!\n", PRVM_NAME ); + } prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false); - if (prog->progs == NULL) + if (prog->progs == NULL || fs_filesize < (fs_offset_t)sizeof(dprograms_t)) PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME); Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, fs_filesize/1024); - pr_crc = CRC_Block((qbyte *)prog->progs, fs_filesize); + prog->filecrc = CRC_Block((qbyte *)prog->progs, fs_filesize); // byte swap the header for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++) @@ -1253,23 +1296,24 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required if (prog->progs->version != PROG_VERSION) PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs->version, PROG_VERSION); - if (prog->progs->crc != prog->crc) + if (prog->progs->crc != prog->headercrc) PRVM_ERROR ("%s: %s system vars have been modified, progdefs.h is out of date", PRVM_NAME, filename); - //pr_functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions); + //prog->functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions); dfunctions = (dfunction_t *)((qbyte *)prog->progs + prog->progs->ofs_functions); prog->strings = (char *)prog->progs + prog->progs->ofs_strings; prog->stringssize = 0; for (i = 0;i < prog->progs->numstrings;i++) { - if (prog->progs->ofs_strings + prog->stringssize >= fs_filesize) + if (prog->progs->ofs_strings + prog->stringssize >= (int)fs_filesize) PRVM_ERROR ("%s: %s strings go past end of file\n", PRVM_NAME, filename); - prog->stringssize += strlen (prog->strings + prog->stringssize) + 1; + prog->stringssize += (int)strlen (prog->strings + prog->stringssize) + 1; } prog->numknownstrings = 0; prog->maxknownstrings = 0; prog->knownstrings = NULL; + prog->knownstrings_freeable = NULL; prog->globaldefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_globaldefs); @@ -1277,14 +1321,14 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required // so allocate a new place for it infielddefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_fielddefs); // ( + DPFIELDS ) - prog->fielddefs = Mem_Alloc(prog->progs_mempool, prog->progs->numfielddefs * sizeof(ddef_t)); + prog->fielddefs = Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t)); prog->statements = (dstatement_t *)((qbyte *)prog->progs + prog->progs->ofs_statements); // moved edict_size calculation down below field adding code //pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals); - prog->globals = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals); + prog->globals.generic = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals); // byte swap the lumps for (i=0 ; iprogs->numstatements ; i++) @@ -1324,18 +1368,18 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name); } -/* // append the darkplaces fields - for (i = 0;i < (int) DPFIELDS;i++) + // append the required fields + for (i = 0;i < (int) numrequiredfields;i++) { - pr_fielddefs[progs->numfielddefs].type = dpfields[i].type; - pr_fielddefs[progs->numfielddefs].ofs = progs->entityfields; - pr_fielddefs[progs->numfielddefs].s_name = PR_SetEngineString(dpfields[i].string); - if (pr_fielddefs[progs->numfielddefs].type == ev_vector) - progs->entityfields += 3; + prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type; + prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields; + prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name); + if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector) + prog->progs->entityfields += 3; else - progs->entityfields++; - progs->numfielddefs++; - }*/ + prog->progs->entityfields++; + prog->progs->numfielddefs++; + } // check required functions for(i=0 ; i < numrequiredfunc ; i++) @@ -1343,12 +1387,12 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required PRVM_ERROR("%s: %s not found in %s\n",PRVM_NAME, required_func[i], filename); for (i=0 ; iprogs->numglobals ; i++) - ((int *)prog->globals)[i] = LittleLong (((int *)prog->globals)[i]); + ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]); // moved edict_size calculation down here, below field adding code - // LordHavoc: this no longer includes the edict_t header + // LordHavoc: this no longer includes the prvm_edict_t header prog->edict_size = prog->progs->entityfields * 4; - prog->edictareasize = prog->edict_size * MAX_EDICTS; + prog->edictareasize = prog->edict_size * prog->limit_edicts; // LordHavoc: bounds check anything static for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++) @@ -1449,6 +1493,8 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required } } + PRVM_LoadLNO(filename); + PRVM_Init_Exec(); prog->loaded = TRUE; @@ -1472,7 +1518,6 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required && prog->flag && prog->self) prog->flag |= PRVM_OP_STATE; - PRVM_GCALL(reset_cmd)(); PRVM_GCALL(init_cmd)(); // init mempools @@ -1513,7 +1558,7 @@ void PRVM_Fields_f (void) for (ednum = 0;ednum < prog->max_edicts;ednum++) { ed = PRVM_EDICT_NUM(ednum); - if (ed->p.e->free) + if (ed->priv.required->free) continue; for (i = 1;i < prog->progs->numfielddefs;i++) { @@ -1521,7 +1566,7 @@ void PRVM_Fields_f (void) name = PRVM_GetString(d->s_name); if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars - v = (int *)((char *)ed->v + d->ofs*4); + v = (int *)((char *)ed->fields.vp + d->ofs*4); // if the value is still all 0, skip the field for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++) { @@ -1581,7 +1626,7 @@ void PRVM_Fields_f (void) name = tempstring2; } strcat(tempstring, name); - for (j = strlen(name);j < 25;j++) + for (j = (int)strlen(name);j < 25;j++) strcat(tempstring, " "); sprintf(tempstring2, "%5d", counts[i]); strcat(tempstring, tempstring2); @@ -1652,7 +1697,7 @@ void PRVM_Global_f(void) if( !global ) Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) ); else - Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( global->type, (prvm_eval_t *) &prog->globals[ global->ofs ] ) ); + Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) ); PRVM_End; } @@ -1722,6 +1767,7 @@ void PRVM_InitProg(int prognr) memset(prog, 0, sizeof(prvm_prog_t)); prog->time = &prog->_time; + prog->error_cmd = Host_Error; } int PRVM_GetProgNr() @@ -1754,50 +1800,44 @@ prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline) return NULL; } -void PRVM_ProcessError(void) -{ - if(prog) - PRVM_GCALL(error_cmd)(); -} - /* -int NUM_FOR_EDICT_ERROR(edict_t *e) +int NUM_FOR_EDICT_ERROR(prvm_edict_t *e) { - Host_Error ("NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, sv.edicts, e - sv.edicts); + PRVM_ERROR ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts); return 0; } -int NUM_FOR_EDICT(edict_t *e) +int PRVM_NUM_FOR_EDICT(prvm_edict_t *e) { int n; - n = e - sv.edicts; - if ((unsigned int)n >= MAX_EDICTS) - Host_Error ("NUM_FOR_EDICT: bad pointer"); + n = e - prog->edicts; + if ((unsigned int)n >= prog->limit_edicts) + Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer"); return n; } -//int NoCrash_NUM_FOR_EDICT(edict_t *e) +//int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e) //{ -// return e - sv.edicts; +// return e - prog->edicts; //} -//#define EDICT_TO_PROG(e) ((qbyte *)(((edict_t *)e)->v) - (qbyte *)(sv.edictsfields)) -//#define PROG_TO_EDICT(e) (sv.edicts + ((e) / (progs->entityfields * 4))) -int EDICT_TO_PROG(edict_t *e) +//#define PRVM_EDICT_TO_PROG(e) ((qbyte *)(((prvm_edict_t *)e)->v) - (qbyte *)(prog->edictsfields)) +//#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4))) +int PRVM_EDICT_TO_PROG(prvm_edict_t *e) { int n; - n = e - sv.edicts; - if ((unsigned int)n >= (unsigned int)sv.max_edicts) - Host_Error("EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, sv.edicts); + n = e - prog->edicts; + if ((unsigned int)n >= (unsigned int)prog->max_edicts) + Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, prog->edicts); return n;// EXPERIMENTAL - //return (qbyte *)e->v - (qbyte *)sv.edictsfields; + //return (qbyte *)e->v - (qbyte *)prog->edictsfields; } -edict_t *PROG_TO_EDICT(int n) +prvm_edict_t *PRVM_PROG_TO_EDICT(int n) { - if ((unsigned int)n >= (unsigned int)sv.max_edicts) - Host_Error("PROG_TO_EDICT: invalid edict number %i\n", n); - return sv.edicts + n; // EXPERIMENTAL - //return sv.edicts + ((n) / (progs->entityfields * 4)); + if ((unsigned int)n >= (unsigned int)prog->max_edicts) + Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i\n", n); + return prog->edicts + n; // EXPERIMENTAL + //return prog->edicts + ((n) / (progs->entityfields * 4)); } */ @@ -1810,44 +1850,30 @@ const char *PRVM_GetString(int num) { num = -1 - num; if (!prog->knownstrings[num]) - Host_Error("PRVM_GetString: attempt to get string that is already freed\n"); + PRVM_ERROR("PRVM_GetString: attempt to get string that is already freed\n"); return prog->knownstrings[num]; } else { - Host_Error("PRVM_GetString: invalid string offset %i\n", num); + PRVM_ERROR("PRVM_GetString: invalid string offset %i\n", num); return ""; } } -int PRVM_SetQCString(const char *s) -{ - int i; - if (!s) - return 0; - if (s >= prog->strings && s <= prog->strings + prog->stringssize) - return s - prog->strings; - for (i = 0;i < prog->numknownstrings;i++) - if (prog->knownstrings[i] == s) - return -1 - i; - Host_Error("PRVM_SetQCString: unknown string\n"); - return -1 - i; -} - int PRVM_SetEngineString(const char *s) { int i; if (!s) return 0; if (s >= prog->strings && s <= prog->strings + prog->stringssize) - Host_Error("PRVM_SetEngineString: s in prog->strings area\n"); + PRVM_ERROR("PRVM_SetEngineString: s in prog->strings area\n"); for (i = 0;i < prog->numknownstrings;i++) if (prog->knownstrings[i] == s) return -1 - i; // new unknown engine string if (developer.integer >= 3) Con_Printf("new engine string %p\n", s); - for (i = 0;i < prog->numknownstrings;i++) + for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++) if (!prog->knownstrings[i]) break; if (i >= prog->numknownstrings) @@ -1855,23 +1881,29 @@ int PRVM_SetEngineString(const char *s) if (i >= prog->maxknownstrings) { const char **oldstrings = prog->knownstrings; + const qbyte *oldstrings_freeable = prog->knownstrings_freeable; prog->maxknownstrings += 128; prog->knownstrings = PRVM_Alloc(prog->maxknownstrings * sizeof(char *)); + prog->knownstrings_freeable = PRVM_Alloc(prog->maxknownstrings * sizeof(qbyte)); if (prog->numknownstrings) + { memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *)); + memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(qbyte)); + } } prog->numknownstrings++; } + prog->firstfreeknownstring = i + 1; prog->knownstrings[i] = s; return -1 - i; } -char *PRVM_AllocString(int bufferlength) +int PRVM_AllocString(size_t bufferlength, char **pointer) { int i; if (!bufferlength) return 0; - for (i = 0;i < prog->numknownstrings;i++) + for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++) if (!prog->knownstrings[i]) break; if (i >= prog->numknownstrings) @@ -1879,29 +1911,45 @@ char *PRVM_AllocString(int bufferlength) if (i >= prog->maxknownstrings) { const char **oldstrings = prog->knownstrings; + const qbyte *oldstrings_freeable = prog->knownstrings_freeable; prog->maxknownstrings += 128; prog->knownstrings = PRVM_Alloc(prog->maxknownstrings * sizeof(char *)); + prog->knownstrings_freeable = PRVM_Alloc(prog->maxknownstrings * sizeof(qbyte)); if (prog->numknownstrings) + { memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *)); + memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(qbyte)); + } } prog->numknownstrings++; } - return (char *)(prog->knownstrings[i] = PRVM_Alloc(bufferlength)); + prog->firstfreeknownstring = i + 1; + prog->knownstrings[i] = PRVM_Alloc(bufferlength); + prog->knownstrings_freeable[i] = true; + if (pointer) + *pointer = (char *)(prog->knownstrings[i]); + return -1 - i; } -void PRVM_FreeString(char *s) +void PRVM_FreeString(int num) { - int i; - if (!s) - Host_Error("PRVM_FreeString: attempt to free a NULL string\n"); - if (s >= prog->strings && s <= prog->strings + prog->stringssize) - Host_Error("PRVM_FreeString: attempt to free a constant string\n"); - for (i = 0;i < prog->numknownstrings;i++) - if (prog->knownstrings[i] == s) - break; - if (i == prog->numknownstrings) - Host_Error("PRVM_FreeString: attempt to free a non-existent or already freed string\n"); - PRVM_Free((char *)prog->knownstrings[i]); - prog->knownstrings[i] = NULL; + if (num == 0) + PRVM_ERROR("PRVM_FreeString: attempt to free a NULL string\n"); + else if (num >= 0 && num < prog->stringssize) + PRVM_ERROR("PRVM_FreeString: attempt to free a constant string\n"); + else if (num < 0 && num >= -prog->numknownstrings) + { + num = -1 - num; + if (!prog->knownstrings[num]) + PRVM_ERROR("PRVM_FreeString: attempt to free a non-existent or already freed string\n"); + if (!prog->knownstrings[num]) + PRVM_ERROR("PRVM_FreeString: attempt to free a string owned by the engine\n"); + PRVM_Free((char *)prog->knownstrings[num]); + prog->knownstrings[num] = NULL; + prog->knownstrings_freeable[num] = false; + prog->firstfreeknownstring = min(prog->firstfreeknownstring, num); + } + else + PRVM_ERROR("PRVM_FreeString: invalid string offset %i\n", num); }