X-Git-Url: http://git.xonotic.org/?a=blobdiff_plain;f=prvm_edict.c;h=c2a3abddf05da99108d5a0cf8e20ec58f5762345;hb=f68ef7b22979928fb6b8d2ba6b28e14c4caeb7c2;hp=24eeb734a84ba692b86d8cf98026310103042e9b;hpb=21164088e07ee1abe38b269abf954d07fe656d63;p=xonotic%2Fdarkplaces.git diff --git a/prvm_edict.c b/prvm_edict.c index 24eeb734..c2a3abdd 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -39,6 +39,8 @@ cvar_t prvm_backtraceforwarnings = {0, "prvm_backtraceforwarnings", "0", "print cvar_t prvm_leaktest = {0, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"}; cvar_t prvm_leaktest_ignore_classnames = {0, "prvm_leaktest_ignore_classnames", "", "classnames of entities to NOT leak check because they are found by find(world, classname, ...) but are actually spawned by QC code (NOT map entities)"}; cvar_t prvm_errordump = {0, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"}; +cvar_t prvm_reuseedicts_startuptime = {0, "prvm_reuseedicts_startuptime", "2", "allows immediate re-use of freed entity slots during start of new level (value in seconds)"}; +cvar_t prvm_reuseedicts_neverinsameframe = {0, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"}; qboolean prvm_runawaycheck = true; @@ -224,7 +226,7 @@ void PRVM_ED_ClearEdict (prvm_edict_t *e) PRVM_GCALL(init_edict)(e); } -const char *PRVM_AllocationOrigin() +const char *PRVM_AllocationOrigin(void) { char *buf = NULL; if(prog->leaktest_active) @@ -236,6 +238,26 @@ const char *PRVM_AllocationOrigin() return buf; } +/* +================= +PRVM_ED_CanAlloc + +Returns if this particular edict could get allocated by PRVM_ED_Alloc +================= +*/ +qboolean PRVM_ED_CanAlloc(prvm_edict_t *e) +{ + if(!e->priv.required->free) + return false; + if(realtime <= e->priv.required->freetime && prvm_reuseedicts_neverinsameframe.integer) + return false; // never allow reuse in same frame (causes networking trouble) + if(e->priv.required->freetime < prog->starttime + prvm_reuseedicts_startuptime.value) + return true; + if(realtime > e->priv.required->freetime + 1) + return true; + return false; // entity slot still blocked because the entity was freed less than one second ago +} + /* ================= PRVM_ED_Alloc @@ -260,9 +282,7 @@ prvm_edict_t *PRVM_ED_Alloc (void) 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->priv.required->free && ( e->priv.required->freetime < prog->starttime + 2 || (realtime - e->priv.required->freetime) > 1 ) ) + if(PRVM_ED_CanAlloc(e)) { PRVM_ED_ClearEdict (e); e->priv.required->allocation_origin = PRVM_AllocationOrigin(); @@ -1132,6 +1152,105 @@ void PRVM_GameCommand_Menu_f(void) PRVM_GameCommand("menu", "menu_cmd"); } +/* +============= +PRVM_ED_EdictGet_f + +Console command to load a field of a specified edict +============= +*/ +void PRVM_ED_EdictGet_f(void) +{ + prvm_edict_t *ed; + ddef_t *key; + const char *s; + prvm_eval_t *v; + + if(Cmd_Argc() != 4 && Cmd_Argc() != 5) + { + Con_Print("prvm_edictget []\n"); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(Cmd_Argv(1))) + { + Con_Printf("Wrong program name %s !\n", Cmd_Argv(1)); + return; + } + + ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2))); + + if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0) + { + Con_Printf("Key %s not found !\n", Cmd_Argv(3)); + goto fail; + } + + v = (prvm_eval_t *)((char *)ed->fields.vp + key->ofs*4); + s = PRVM_UglyValueString(key->type, v); + if(Cmd_Argc() == 5) + { + cvar_t *cvar = Cvar_FindVar(Cmd_Argv(4)); + if (cvar && cvar->flags & CVAR_READONLY) + { + Con_Printf("prvm_edictget: %s is read-only\n", cvar->name); + goto fail; + } + Cvar_Get(Cmd_Argv(4), s, 0, NULL); + } + else + Con_Printf("%s\n", s); + +fail: + PRVM_End; +} + +void PRVM_ED_GlobalGet_f(void) +{ + ddef_t *key; + const char *s; + prvm_eval_t *v; + + if(Cmd_Argc() != 3 && Cmd_Argc() != 4) + { + Con_Print("prvm_globalget []\n"); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(Cmd_Argv(1))) + { + Con_Printf("Wrong program name %s !\n", Cmd_Argv(1)); + return; + } + + key = PRVM_ED_FindGlobal(Cmd_Argv(2)); + if(!key) + { + Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) ); + goto fail; + } + + v = (prvm_eval_t *) &prog->globals.generic[key->ofs]; + s = PRVM_UglyValueString(key->type, v); + if(Cmd_Argc() == 4) + { + cvar_t *cvar = Cvar_FindVar(Cmd_Argv(3)); + if (cvar && cvar->flags & CVAR_READONLY) + { + Con_Printf("prvm_globalget: %s is read-only\n", cvar->name); + goto fail; + } + Cvar_Get(Cmd_Argv(3), s, 0, NULL); + } + else + Con_Printf("%s\n", s); + +fail: + PRVM_End; +} + /* ============= PRVM_ED_EdictSet_f @@ -1477,6 +1596,7 @@ void PRVM_FindOffsets(void) prog->fieldoffsets.glow_color = PRVM_ED_FindFieldOffset("glow_color"); prog->fieldoffsets.glow_size = PRVM_ED_FindFieldOffset("glow_size"); prog->fieldoffsets.glow_trail = PRVM_ED_FindFieldOffset("glow_trail"); + prog->fieldoffsets.glowmod = PRVM_ED_FindFieldOffset("glowmod"); prog->fieldoffsets.gravity = PRVM_ED_FindFieldOffset("gravity"); prog->fieldoffsets.groundentity = PRVM_ED_FindFieldOffset("groundentity"); prog->fieldoffsets.hull = PRVM_ED_FindFieldOffset("hull"); @@ -1513,6 +1633,23 @@ void PRVM_FindOffsets(void) prog->fieldoffsets.viewmodelforclient = PRVM_ED_FindFieldOffset("viewmodelforclient"); prog->fieldoffsets.viewzoom = PRVM_ED_FindFieldOffset("viewzoom"); prog->fieldoffsets.yaw_speed = PRVM_ED_FindFieldOffset("yaw_speed"); + prog->fieldoffsets.bouncefactor = PRVM_ED_FindFieldOffset("bouncefactor"); + prog->fieldoffsets.bouncestop = PRVM_ED_FindFieldOffset("bouncestop"); + + prog->fieldoffsets.solid = PRVM_ED_FindFieldOffset("solid"); + prog->fieldoffsets.movetype = PRVM_ED_FindFieldOffset("movetype"); + prog->fieldoffsets.modelindex = PRVM_ED_FindFieldOffset("modelindex"); + prog->fieldoffsets.mins = PRVM_ED_FindFieldOffset("mins"); + prog->fieldoffsets.maxs = PRVM_ED_FindFieldOffset("maxs"); + prog->fieldoffsets.mass = PRVM_ED_FindFieldOffset("mass"); + prog->fieldoffsets.origin = PRVM_ED_FindFieldOffset("origin"); + prog->fieldoffsets.axis_forward = PRVM_ED_FindFieldOffset("axis_forward"); + prog->fieldoffsets.axis_left = PRVM_ED_FindFieldOffset("axis_left"); + prog->fieldoffsets.axis_up = PRVM_ED_FindFieldOffset("axis_up"); + prog->fieldoffsets.angles = PRVM_ED_FindFieldOffset("angles"); + prog->fieldoffsets.velocity = PRVM_ED_FindFieldOffset("velocity"); + prog->fieldoffsets.spinvelocity = PRVM_ED_FindFieldOffset("spinvelocity"); + prog->funcoffsets.CSQC_ConsoleCommand = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand"); prog->funcoffsets.CSQC_Ent_Remove = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove"); prog->funcoffsets.CSQC_Ent_Spawn = PRVM_ED_FindFunctionOffset("CSQC_Ent_Spawn"); @@ -1553,6 +1690,7 @@ void PRVM_FindOffsets(void) prog->globaloffsets.gettaginfo_parent = PRVM_ED_FindGlobalOffset("gettaginfo_parent"); prog->globaloffsets.gettaginfo_right = PRVM_ED_FindGlobalOffset("gettaginfo_right"); prog->globaloffsets.gettaginfo_up = PRVM_ED_FindGlobalOffset("gettaginfo_up"); + prog->globaloffsets.transparent_offset = PRVM_ED_FindGlobalOffset("transparent_offset"); prog->globaloffsets.intermission = PRVM_ED_FindGlobalOffset("intermission"); prog->globaloffsets.require_spawnfunc_prefix = PRVM_ED_FindGlobalOffset("require_spawnfunc_prefix"); prog->globaloffsets.sb_showscores = PRVM_ED_FindGlobalOffset("sb_showscores"); @@ -1612,8 +1750,8 @@ PRVM_ResetProg =============== */ -void PRVM_LeakTest(); -void PRVM_ResetProg() +void PRVM_LeakTest(void); +void PRVM_ResetProg(void) { PRVM_LeakTest(); PRVM_GCALL(reset_cmd)(); @@ -1689,6 +1827,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize); if (prog->progs == NULL || filesize < (fs_offset_t)sizeof(dprograms_t)) PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME); + // TODO bounds check header fields (e.g. numstatements), they must never go behind end of file Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024)); @@ -1754,6 +1893,9 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->functions[i].numparms = LittleLong (dfunctions[i].numparms); prog->functions[i].locals = LittleLong (dfunctions[i].locals); memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size)); + if(prog->functions[i].first_statement >= prog->progs->numstatements) + PRVM_ERROR("PRVM_LoadProgs: out of bounds function statement (function %d) in %s", i, PRVM_NAME); + // TODO bounds check parm_start, s_name, s_file, numparms, locals, parm_size } for (i=0 ; iprogs->numglobaldefs ; i++) @@ -1761,6 +1903,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->globaldefs[i].type = LittleShort (prog->globaldefs[i].type); prog->globaldefs[i].ofs = LittleShort (prog->globaldefs[i].ofs); prog->globaldefs[i].s_name = LittleLong (prog->globaldefs[i].s_name); + // TODO bounds check ofs, s_name } // copy the progs fields to the new fields list @@ -1771,6 +1914,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required PRVM_ERROR ("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", PRVM_NAME); prog->fielddefs[i].ofs = LittleShort (infielddefs[i].ofs); prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name); + // TODO bounds check ofs, s_name } // append the required fields @@ -1779,6 +1923,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required 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); + // TODO bounds check ofs, s_name if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector) prog->progs->entityfields += 3; else @@ -1902,6 +2047,20 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required break; } } + if(prog->progs->numstatements < 1) + { + PRVM_ERROR("PRVM_LoadProgs: empty program in %s", PRVM_NAME); + } + else switch(prog->statements[prog->progs->numstatements - 1].op) + { + case OP_RETURN: + case OP_GOTO: + case OP_DONE: + break; + default: + PRVM_ERROR("PRVM_LoadProgs: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", PRVM_NAME); + break; + } PRVM_LoadLNO(filename); @@ -2150,12 +2309,15 @@ void PRVM_Init (void) Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_childprofile", PRVM_ChildProfile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu), sorted by time taken in function with child calls"); Cmd_AddCommand ("prvm_callprofile", PRVM_CallProfile_f, "prints execution statistics about the most time consuming QuakeC calls from the engine in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)"); Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f, "changes value of a specified property of a specified entity in the selected VM (server, client, menu)"); + Cmd_AddCommand ("prvm_edictget", PRVM_ED_EdictGet_f, "retrieves the value of a specified property of a specified entity in the selected VM (server, client menu) into a cvar or to the console"); + Cmd_AddCommand ("prvm_globalget", PRVM_ED_GlobalGet_f, "retrieves the value of a specified global variable in the selected VM (server, client menu) into a cvar or to the console"); Cmd_AddCommand ("prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)"); Cmd_AddCommand ("cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument"); Cmd_AddCommand ("menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument"); @@ -2170,6 +2332,8 @@ void PRVM_Init (void) Cvar_RegisterVariable (&prvm_leaktest); Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames); Cvar_RegisterVariable (&prvm_errordump); + Cvar_RegisterVariable (&prvm_reuseedicts_startuptime); + Cvar_RegisterVariable (&prvm_reuseedicts_neverinsameframe); // COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!) prvm_runawaycheck = !COM_CheckParm("-norunaway"); @@ -2196,10 +2360,10 @@ void PRVM_InitProg(int prognr) prog->starttime = Sys_DoubleTime(); prog->error_cmd = Host_Error; - prog->leaktest_active = prvm_leaktest.integer; + prog->leaktest_active = prvm_leaktest.integer != 0; } -int PRVM_GetProgNr() +int PRVM_GetProgNr(void) { return prog - prog_list; } @@ -2320,7 +2484,10 @@ const char *PRVM_GetString(int num) if (num < prog->numknownstrings) { if (!prog->knownstrings[num]) + { VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num); + return ""; + } return prog->knownstrings[num]; } else @@ -2633,7 +2800,7 @@ static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark) return false; } -static void PRVM_MarkReferencedEdicts() +static void PRVM_MarkReferencedEdicts(void) { int j; qboolean found_new; @@ -2670,7 +2837,7 @@ static void PRVM_MarkReferencedEdicts() Con_DPrintf("leak check used %d stages to find all references\n", stage); } -void PRVM_LeakTest() +void PRVM_LeakTest(void) { int i, j; qboolean leaked = false;