X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=prvm_edict.c;h=fd6b1d0318faa4fddbb818925f897dd6a63bc2e9;hp=68f5197aed5ad57c79c72ec0fa87f84acb6d6030;hb=3869bc4ae01a780a71af98e2f49c5b2f9297c9ae;hpb=84abed4f5fb96c3812143d967aa065e49e55d19d diff --git a/prvm_edict.c b/prvm_edict.c index 68f5197a..fd6b1d03 100644 --- a/prvm_edict.c +++ b/prvm_edict.c @@ -38,6 +38,8 @@ cvar_t prvm_traceqc = {0, "prvm_traceqc", "0", "prints every QuakeC statement as // LordHavoc: counts usage of each QuakeC statement cvar_t prvm_statementprofiling = {0, "prvm_statementprofiling", "0", "counts how many times each QuakeC statement has been executed, these counts are displayed in prvm_printfunction output (if enabled)"}; +extern sizebuf_t vm_tempstringsbuf; + //============================================================================ // mempool handling @@ -122,18 +124,26 @@ int PRVM_ED_FindFieldOffset(const char *field) ddef_t *d; d = PRVM_ED_FindField(field); if (!d) - return 0; - return d->ofs*4; + return -1; + return d->ofs; } -ddef_t* PRVM_ED_FindGlobal(const char *name); int PRVM_ED_FindGlobalOffset(const char *global) { ddef_t *d; d = PRVM_ED_FindGlobal(global); if (!d) + return -1; + return d->ofs; +} + +func_t PRVM_ED_FindFunctionOffset(const char *function) +{ + mfunction_t *f; + f = PRVM_ED_FindFunction(function); + if (!f) return 0; - return d->ofs*4; + return (func_t)(f - prog->functions); } qboolean PRVM_ProgLoaded(int prognr) @@ -232,7 +242,7 @@ prvm_edict_t *PRVM_ED_Alloc (void) 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 < 2 || (*prog->time - e->priv.required->freetime) > 0.5 ) ) + if (e->priv.required->free && ( e->priv.required->freetime < 2 || prog->globaloffsets.time < 0 || (PRVM_GLOBALFIELDVALUE(prog->globaloffsets.time)->_float - e->priv.required->freetime) > 0.5 ) ) { PRVM_ED_ClearEdict (e); return e; @@ -269,7 +279,7 @@ void PRVM_ED_Free (prvm_edict_t *ed) PRVM_GCALL(free_edict)(ed); ed->priv.required->free = true; - ed->priv.required->freetime = *prog->time; + ed->priv.required->freetime = prog->globaloffsets.time >= 0 ? PRVM_GLOBALFIELDVALUE(prog->globaloffsets.time)->_float : 0; } //=========================================================================== @@ -422,7 +432,7 @@ char *PRVM_ValueString (etype_t type, prvm_eval_t *val) sprintf (line, "pointer"); break; default: - sprintf (line, "bad type %i", type); + sprintf (line, "bad type %i", (int) type); break; } @@ -564,7 +574,7 @@ For debugging */ // LordHavoc: optimized this to print out much more quickly (tempstring) // 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) +void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname) { size_t l; ddef_t *d; @@ -589,6 +599,12 @@ void PRVM_ED_Print(prvm_edict_t *ed) if (name[strlen(name)-2] == '_') continue; // skip _x, _y, _z vars + // Check Field Name Wildcard + if(wildcard_fieldname) + if( !matchpattern(name, wildcard_fieldname, 1) ) + // Didn't match; skip + continue; + v = (int *)((char *)ed->fields.vp + d->ofs*4); // if the value is still all 0, skip the field @@ -607,10 +623,10 @@ void PRVM_ED_Print(prvm_edict_t *ed) tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strcat(tempstring, name); + strlcat(tempstring, name, sizeof(tempstring)); for (l = strlen(name);l < 14;l++) - strcat(tempstring, " "); - strcat(tempstring, " "); + strlcat(tempstring, " ", sizeof(tempstring)); + strlcat(tempstring, " ", sizeof(tempstring)); name = PRVM_ValueString((etype_t)d->type, (prvm_eval_t *)v); if (strlen(name) > sizeof(tempstring2)-4) @@ -620,8 +636,8 @@ void PRVM_ED_Print(prvm_edict_t *ed) tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strcat(tempstring, name); - strcat(tempstring, "\n"); + strlcat(tempstring, name, sizeof(tempstring)); + strlcat(tempstring, "\n", sizeof(tempstring)); if (strlen(tempstring) >= sizeof(tempstring)/2) { Con_Print(tempstring); @@ -679,9 +695,9 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed) FS_Print(f, "}\n"); } -void PRVM_ED_PrintNum (int ent) +void PRVM_ED_PrintNum (int ent, const char *wildcard_fieldname) { - PRVM_ED_Print(PRVM_EDICT_NUM(ent)); + PRVM_ED_Print(PRVM_EDICT_NUM(ent), wildcard_fieldname); } /* @@ -694,10 +710,11 @@ For debugging, prints all the entities in the current server void PRVM_ED_PrintEdicts_f (void) { int i; + const char *wildcard_fieldname; - if(Cmd_Argc() != 2) + if(Cmd_Argc() < 2 || Cmd_Argc() > 3) { - Con_Print("prvm_edicts \n"); + Con_Print("prvm_edicts \n"); return; } @@ -705,9 +722,14 @@ void PRVM_ED_PrintEdicts_f (void) if(!PRVM_SetProgFromString(Cmd_Argv(1))) return; + if( Cmd_Argc() == 3) + wildcard_fieldname = Cmd_Argv(2); + else + wildcard_fieldname = NULL; + Con_Printf("%s: %i entities\n", PRVM_NAME, prog->num_edicts); for (i=0 ; inum_edicts ; i++) - PRVM_ED_PrintNum (i); + PRVM_ED_PrintNum (i, wildcard_fieldname); PRVM_End; } @@ -722,10 +744,11 @@ For debugging, prints a single edict void PRVM_ED_PrintEdict_f (void) { int i; + const char *wildcard_fieldname; - if(Cmd_Argc() != 3) + if(Cmd_Argc() < 3 || Cmd_Argc() > 4) { - Con_Print("prvm_edict \n"); + Con_Print("prvm_edict \n"); return; } @@ -740,7 +763,13 @@ void PRVM_ED_PrintEdict_f (void) PRVM_End; return; } - PRVM_ED_PrintNum (i); + if( Cmd_Argc() == 4) + // Optional Wildcard Provided + wildcard_fieldname = Cmd_Argv(3); + else + // Use All + wildcard_fieldname = NULL; + PRVM_ED_PrintNum (i, wildcard_fieldname); PRVM_End; } @@ -843,15 +872,15 @@ void PRVM_ED_ParseGlobals (const char *data) while (1) { // parse key - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false, false)) PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace"); if (com_token[0] == '}') break; - strcpy (keyname, com_token); + strlcpy (keyname, com_token, sizeof(keyname)); // parse value - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false, true)) PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace"); if (com_token[0] == '}') @@ -943,8 +972,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) 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 IncreaseEdicts was called the base pointer needs to be updated if (ent) val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs); val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i)); @@ -977,6 +1005,71 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s) return true; } +/* +============= +PRVM_GameCommand_f + +Console command to send a string to QC function GameCommand of the +indicated progs + +Usage: + sv_cmd adminmsg 3 "do not teamkill" + cl_cmd someclientcommand + menu_cmd somemenucommand + +All progs can support this extension; sg calls it in server QC, cg in client +QC, mg in menu QC. +============= +*/ +void PRVM_GameCommand(const char *whichprogs, const char *whichcmd) +{ + if(Cmd_Argc() < 1) + { + Con_Printf("%s text...\n", whichcmd); + return; + } + + PRVM_Begin; + if(!PRVM_SetProgFromString(whichprogs)) + // note: this is not PRVM_SetProg because that one aborts "hard" using PRVM_Error + // also, it makes printing error messages easier! + { + Con_Printf("%s program not loaded.\n", whichprogs); + return; + } + + if(!prog->funcoffsets.GameCommand) + { + Con_Printf("%s program do not support GameCommand!\n", whichprogs); + } + else + { + int restorevm_tempstringsbuf_cursize; + const char *s; + + s = Cmd_Args(); + + restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize; + PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(s ? s : ""); + PRVM_ExecuteProgram (prog->funcoffsets.GameCommand, "QC function GameCommand is missing"); + vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize; + } + + PRVM_End; +} +void PRVM_GameCommand_Server_f(void) +{ + PRVM_GameCommand("server", "sv_cmd"); +} +void PRVM_GameCommand_Client_f(void) +{ + PRVM_GameCommand("client", "cl_cmd"); +} +void PRVM_GameCommand_Menu_f(void) +{ + PRVM_GameCommand("menu", "menu_cmd"); +} + /* ============= PRVM_ED_EdictSet_f @@ -1036,7 +1129,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) while (1) { // parse key - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false, false)) PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace"); if (developer_entityparsing.integer) Con_Printf("Key: \"%s\"", com_token); @@ -1047,7 +1140,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) // and allow them to be turned into vectors. (FIXME...) if (!strcmp(com_token, "angle")) { - strcpy (com_token, "angles"); + strlcpy (com_token, "angles", sizeof(com_token)); anglehack = true; } else @@ -1055,9 +1148,9 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) // FIXME: change light to _light to get rid of this hack if (!strcmp(com_token, "light")) - strcpy (com_token, "light_lev"); // hack for single light def + strlcpy (com_token, "light_lev", sizeof(com_token)); // hack for single light def - strcpy (keyname, com_token); + strlcpy (keyname, com_token, sizeof(keyname)); // another hack to fix keynames with trailing spaces n = strlen(keyname); @@ -1068,7 +1161,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) } // parse value - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false, true)) PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace"); if (developer_entityparsing.integer) Con_Printf(" \"%s\"\n", com_token); @@ -1097,7 +1190,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent) if (anglehack) { char temp[32]; - strcpy (temp, com_token); + strlcpy (temp, com_token, sizeof(temp)); sprintf (com_token, "0 %s 0", temp); } @@ -1143,7 +1236,7 @@ void PRVM_ED_LoadFromFile (const char *data) while (1) { // parse the opening brace - if (!COM_ParseToken(&data, false)) + if (!COM_ParseToken_Simple(&data, false, false)) break; if (com_token[0] != '{') PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token); @@ -1175,13 +1268,13 @@ void PRVM_ED_LoadFromFile (const char *data) // // immediately call spawn function, but only if there is a self global and a classname // - if(prog->self && prog->flag & PRVM_FE_CLASSNAME) + if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0) { - string_t handle = *(string_t*)&((unsigned char*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")]; + string_t handle = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.classname)->string; if (!handle) { Con_Print("No classname for:\n"); - PRVM_ED_Print(ent); + PRVM_ED_Print(ent, NULL); PRVM_ED_Free (ent); continue; } @@ -1191,18 +1284,30 @@ void PRVM_ED_LoadFromFile (const char *data) if (!func) { - if (developer.integer) // don't confuse non-developers with errors + // check for OnEntityNoSpawnFunction + if (prog->funcoffsets.SV_OnEntityNoSpawnFunction) { - Con_Print("No spawn function for:\n"); - PRVM_ED_Print(ent); + // self = ent + PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent); + PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityNoSpawnFunction, "QC function SV_OnEntityNoSpawnFunction is missing"); + } + else + { + if (developer.integer) // don't confuse non-developers with errors + { + Con_Print("No spawn function for:\n"); + PRVM_ED_Print(ent, NULL); + } + PRVM_ED_Free (ent); + continue; } - PRVM_ED_Free (ent); - continue; } - - // self = ent - PRVM_G_INT(prog->self->ofs) = PRVM_EDICT_TO_PROG(ent); - PRVM_ExecuteProgram (func - prog->functions, ""); + else + { + // self = ent + PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent); + PRVM_ExecuteProgram (func - prog->functions, ""); + } } spawned++; @@ -1213,6 +1318,161 @@ void PRVM_ED_LoadFromFile (const char *data) Con_DPrintf("%s: %i new entities parsed, %i new inhibited, %i (%i new) spawned (whereas %i removed self, %i stayed)\n", PRVM_NAME, parsed, inhibited, prog->num_edicts, spawned, died, spawned - died); } +void PRVM_FindOffsets(void) +{ + // field and global searches use -1 for NULL + memset(&prog->fieldoffsets, -1, sizeof(prog->fieldoffsets)); + memset(&prog->globaloffsets, -1, sizeof(prog->globaloffsets)); + // functions use 0 for NULL + memset(&prog->funcoffsets, 0, sizeof(prog->funcoffsets)); + + // server and client qc use a lot of similar fields, so this is combined + prog->fieldoffsets.SendEntity = PRVM_ED_FindFieldOffset("SendEntity"); + prog->fieldoffsets.Version = PRVM_ED_FindFieldOffset("Version"); + prog->fieldoffsets.alpha = PRVM_ED_FindFieldOffset("alpha"); + prog->fieldoffsets.ammo_cells1 = PRVM_ED_FindFieldOffset("ammo_cells1"); + prog->fieldoffsets.ammo_lava_nails = PRVM_ED_FindFieldOffset("ammo_lava_nails"); + prog->fieldoffsets.ammo_multi_rockets = PRVM_ED_FindFieldOffset("ammo_multi_rockets"); + prog->fieldoffsets.ammo_nails1 = PRVM_ED_FindFieldOffset("ammo_nails1"); + prog->fieldoffsets.ammo_plasma = PRVM_ED_FindFieldOffset("ammo_plasma"); + prog->fieldoffsets.ammo_rockets1 = PRVM_ED_FindFieldOffset("ammo_rockets1"); + prog->fieldoffsets.ammo_shells1 = PRVM_ED_FindFieldOffset("ammo_shells1"); + prog->fieldoffsets.angles = PRVM_ED_FindFieldOffset("angles"); + prog->fieldoffsets.button3 = PRVM_ED_FindFieldOffset("button3"); + prog->fieldoffsets.button4 = PRVM_ED_FindFieldOffset("button4"); + prog->fieldoffsets.button5 = PRVM_ED_FindFieldOffset("button5"); + prog->fieldoffsets.button6 = PRVM_ED_FindFieldOffset("button6"); + prog->fieldoffsets.button7 = PRVM_ED_FindFieldOffset("button7"); + prog->fieldoffsets.button8 = PRVM_ED_FindFieldOffset("button8"); + prog->fieldoffsets.button9 = PRVM_ED_FindFieldOffset("button9"); + prog->fieldoffsets.button10 = PRVM_ED_FindFieldOffset("button10"); + prog->fieldoffsets.button11 = PRVM_ED_FindFieldOffset("button11"); + prog->fieldoffsets.button12 = PRVM_ED_FindFieldOffset("button12"); + prog->fieldoffsets.button13 = PRVM_ED_FindFieldOffset("button13"); + prog->fieldoffsets.button14 = PRVM_ED_FindFieldOffset("button14"); + prog->fieldoffsets.button15 = PRVM_ED_FindFieldOffset("button15"); + prog->fieldoffsets.button16 = PRVM_ED_FindFieldOffset("button16"); + prog->fieldoffsets.buttonchat = PRVM_ED_FindFieldOffset("buttonchat"); + prog->fieldoffsets.buttonuse = PRVM_ED_FindFieldOffset("buttonuse"); + prog->fieldoffsets.chain = PRVM_ED_FindFieldOffset("chain"); + prog->fieldoffsets.classname = PRVM_ED_FindFieldOffset("classname"); + prog->fieldoffsets.clientcolors = PRVM_ED_FindFieldOffset("clientcolors"); + prog->fieldoffsets.color = PRVM_ED_FindFieldOffset("color"); + prog->fieldoffsets.colormod = PRVM_ED_FindFieldOffset("colormod"); + prog->fieldoffsets.contentstransition = PRVM_ED_FindFieldOffset("contentstransition"); + prog->fieldoffsets.cursor_active = PRVM_ED_FindFieldOffset("cursor_active"); + prog->fieldoffsets.cursor_screen = PRVM_ED_FindFieldOffset("cursor_screen"); + prog->fieldoffsets.cursor_trace_endpos = PRVM_ED_FindFieldOffset("cursor_trace_endpos"); + prog->fieldoffsets.cursor_trace_ent = PRVM_ED_FindFieldOffset("cursor_trace_ent"); + prog->fieldoffsets.cursor_trace_start = PRVM_ED_FindFieldOffset("cursor_trace_start"); + prog->fieldoffsets.customizeentityforclient = PRVM_ED_FindFieldOffset("customizeentityforclient"); + prog->fieldoffsets.dimension_hit = PRVM_ED_FindFieldOffset("dimension_hit"); + prog->fieldoffsets.dimension_solid = PRVM_ED_FindFieldOffset("dimension_solid"); + prog->fieldoffsets.disableclientprediction = PRVM_ED_FindFieldOffset("disableclientprediction"); + prog->fieldoffsets.dphitcontentsmask = PRVM_ED_FindFieldOffset("dphitcontentsmask"); + prog->fieldoffsets.drawonlytoclient = PRVM_ED_FindFieldOffset("drawonlytoclient"); + prog->fieldoffsets.exteriormodeltoclient = PRVM_ED_FindFieldOffset("exteriormodeltoclient"); + prog->fieldoffsets.fatness = PRVM_ED_FindFieldOffset("fatness"); + prog->fieldoffsets.forceshader = PRVM_ED_FindFieldOffset("forceshader"); + prog->fieldoffsets.frame = PRVM_ED_FindFieldOffset("frame"); + prog->fieldoffsets.frame1time = PRVM_ED_FindFieldOffset("frame1time"); + prog->fieldoffsets.frame2 = PRVM_ED_FindFieldOffset("frame2"); + prog->fieldoffsets.frame2time = PRVM_ED_FindFieldOffset("frame2time"); + prog->fieldoffsets.fullbright = PRVM_ED_FindFieldOffset("fullbright"); + 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.gravity = PRVM_ED_FindFieldOffset("gravity"); + prog->fieldoffsets.groundentity = PRVM_ED_FindFieldOffset("groundentity"); + prog->fieldoffsets.hull = PRVM_ED_FindFieldOffset("hull"); + prog->fieldoffsets.ideal_yaw = PRVM_ED_FindFieldOffset("ideal_yaw"); + prog->fieldoffsets.idealpitch = PRVM_ED_FindFieldOffset("idealpitch"); + prog->fieldoffsets.items2 = PRVM_ED_FindFieldOffset("items2"); + prog->fieldoffsets.lerpfrac = PRVM_ED_FindFieldOffset("lerpfrac"); + prog->fieldoffsets.light_lev = PRVM_ED_FindFieldOffset("light_lev"); + prog->fieldoffsets.message = PRVM_ED_FindFieldOffset("message"); + prog->fieldoffsets.modelflags = PRVM_ED_FindFieldOffset("modelflags"); + prog->fieldoffsets.movement = PRVM_ED_FindFieldOffset("movement"); + prog->fieldoffsets.netaddress = PRVM_ED_FindFieldOffset("netaddress"); + prog->fieldoffsets.nextthink = PRVM_ED_FindFieldOffset("nextthink"); + prog->fieldoffsets.nodrawtoclient = PRVM_ED_FindFieldOffset("nodrawtoclient"); + prog->fieldoffsets.pflags = PRVM_ED_FindFieldOffset("pflags"); + prog->fieldoffsets.ping = PRVM_ED_FindFieldOffset("ping"); + prog->fieldoffsets.pitch_speed = PRVM_ED_FindFieldOffset("pitch_speed"); + prog->fieldoffsets.playermodel = PRVM_ED_FindFieldOffset("playermodel"); + prog->fieldoffsets.playerskin = PRVM_ED_FindFieldOffset("playerskin"); + prog->fieldoffsets.pmodel = PRVM_ED_FindFieldOffset("pmodel"); + prog->fieldoffsets.punchvector = PRVM_ED_FindFieldOffset("punchvector"); + prog->fieldoffsets.renderamt = PRVM_ED_FindFieldOffset("renderamt"); // HalfLife support + prog->fieldoffsets.renderflags = PRVM_ED_FindFieldOffset("renderflags"); + prog->fieldoffsets.rendermode = PRVM_ED_FindFieldOffset("rendermode"); // HalfLife support + prog->fieldoffsets.scale = PRVM_ED_FindFieldOffset("scale"); + prog->fieldoffsets.style = PRVM_ED_FindFieldOffset("style"); + prog->fieldoffsets.tag_entity = PRVM_ED_FindFieldOffset("tag_entity"); + prog->fieldoffsets.tag_index = PRVM_ED_FindFieldOffset("tag_index"); + prog->fieldoffsets.think = PRVM_ED_FindFieldOffset("think"); + prog->fieldoffsets.viewmodelforclient = PRVM_ED_FindFieldOffset("viewmodelforclient"); + prog->fieldoffsets.viewzoom = PRVM_ED_FindFieldOffset("viewzoom"); + prog->fieldoffsets.yaw_speed = PRVM_ED_FindFieldOffset("yaw_speed"); + prog->funcoffsets.CSQC_ConsoleCommand = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand"); + prog->funcoffsets.CSQC_Ent_Remove = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove"); + prog->funcoffsets.CSQC_Ent_Update = PRVM_ED_FindFunctionOffset("CSQC_Ent_Update"); + prog->funcoffsets.CSQC_Event = PRVM_ED_FindFunctionOffset("CSQC_Event"); + prog->funcoffsets.CSQC_Event_Sound = PRVM_ED_FindFunctionOffset("CSQC_Event_Sound"); + prog->funcoffsets.CSQC_Init = PRVM_ED_FindFunctionOffset("CSQC_Init"); + prog->funcoffsets.CSQC_InputEvent = PRVM_ED_FindFunctionOffset("CSQC_InputEvent"); + prog->funcoffsets.CSQC_Parse_CenterPrint = PRVM_ED_FindFunctionOffset("CSQC_Parse_CenterPrint"); + prog->funcoffsets.CSQC_Parse_Print = PRVM_ED_FindFunctionOffset("CSQC_Parse_Print"); + prog->funcoffsets.CSQC_Parse_StuffCmd = PRVM_ED_FindFunctionOffset("CSQC_Parse_StuffCmd"); + prog->funcoffsets.CSQC_Parse_TempEntity = PRVM_ED_FindFunctionOffset("CSQC_Parse_TempEntity"); + prog->funcoffsets.CSQC_Shutdown = PRVM_ED_FindFunctionOffset("CSQC_Shutdown"); + prog->funcoffsets.CSQC_UpdateView = PRVM_ED_FindFunctionOffset("CSQC_UpdateView"); + prog->funcoffsets.EndFrame = PRVM_ED_FindFunctionOffset("EndFrame"); + prog->funcoffsets.RestoreGame = PRVM_ED_FindFunctionOffset("RestoreGame"); + prog->funcoffsets.SV_ChangeTeam = PRVM_ED_FindFunctionOffset("SV_ChangeTeam"); + prog->funcoffsets.SV_ParseClientCommand = PRVM_ED_FindFunctionOffset("SV_ParseClientCommand"); + prog->funcoffsets.SV_PlayerPhysics = PRVM_ED_FindFunctionOffset("SV_PlayerPhysics"); + prog->funcoffsets.SV_OnEntityNoSpawnFunction = PRVM_ED_FindFunctionOffset("SV_OnEntityNoSpawnFunction"); + prog->funcoffsets.GameCommand = PRVM_ED_FindFunctionOffset("GameCommand"); + prog->globaloffsets.SV_InitCmd = PRVM_ED_FindGlobalOffset("SV_InitCmd"); + prog->globaloffsets.self = PRVM_ED_FindGlobalOffset("self"); + prog->globaloffsets.time = PRVM_ED_FindGlobalOffset("time"); + prog->globaloffsets.v_forward = PRVM_ED_FindGlobalOffset("v_forward"); + prog->globaloffsets.v_right = PRVM_ED_FindGlobalOffset("v_right"); + prog->globaloffsets.v_up = PRVM_ED_FindGlobalOffset("v_up"); + prog->globaloffsets.view_angles = PRVM_ED_FindGlobalOffset("view_angles"); + prog->globaloffsets.trace_allsolid = PRVM_ED_FindGlobalOffset("trace_allsolid"); + prog->globaloffsets.trace_startsolid = PRVM_ED_FindGlobalOffset("trace_startsolid"); + prog->globaloffsets.trace_fraction = PRVM_ED_FindGlobalOffset("trace_fraction"); + prog->globaloffsets.trace_inwater = PRVM_ED_FindGlobalOffset("trace_inwater"); + prog->globaloffsets.trace_inopen = PRVM_ED_FindGlobalOffset("trace_inopen"); + prog->globaloffsets.trace_endpos = PRVM_ED_FindGlobalOffset("trace_endpos"); + prog->globaloffsets.trace_plane_normal = PRVM_ED_FindGlobalOffset("trace_plane_normal"); + prog->globaloffsets.trace_plane_dist = PRVM_ED_FindGlobalOffset("trace_plane_dist"); + prog->globaloffsets.trace_ent = PRVM_ED_FindGlobalOffset("trace_ent"); + prog->globaloffsets.trace_dphitcontents = PRVM_ED_FindGlobalOffset("trace_dphitcontents"); + prog->globaloffsets.trace_dphitq3surfaceflags = PRVM_ED_FindGlobalOffset("trace_dphitq3surfaceflags"); + prog->globaloffsets.trace_dphittexturename = PRVM_ED_FindGlobalOffset("trace_dphittexturename"); + prog->globaloffsets.trace_dpstartcontents = PRVM_ED_FindGlobalOffset("trace_dpstartcontents"); + prog->globaloffsets.intermission = PRVM_ED_FindGlobalOffset("intermission"); + prog->globaloffsets.coop = PRVM_ED_FindGlobalOffset("coop"); + prog->globaloffsets.deathmatch = PRVM_ED_FindGlobalOffset("deathmatch"); + prog->globaloffsets.dmg_take = PRVM_ED_FindGlobalOffset("dmg_take"); + prog->globaloffsets.dmg_save = PRVM_ED_FindGlobalOffset("dmg_save"); + prog->globaloffsets.dmg_origin = PRVM_ED_FindGlobalOffset("dmg_origin"); + prog->globaloffsets.sb_showscores = PRVM_ED_FindGlobalOffset("sb_showscores"); + + // menu qc only uses some functions, nothing else + prog->funcoffsets.m_display = PRVM_ED_FindFunctionOffset("m_display"); + prog->funcoffsets.m_draw = PRVM_ED_FindFunctionOffset("m_draw"); + prog->funcoffsets.m_hide = PRVM_ED_FindFunctionOffset("m_hide"); + prog->funcoffsets.m_init = PRVM_ED_FindFunctionOffset("m_init"); + prog->funcoffsets.m_keydown = PRVM_ED_FindFunctionOffset("m_keydown"); + prog->funcoffsets.m_keyup = PRVM_ED_FindFunctionOffset("m_keyup"); + prog->funcoffsets.m_shutdown = PRVM_ED_FindFunctionOffset("m_shutdown"); + prog->funcoffsets.m_toggle = PRVM_ED_FindFunctionOffset("m_toggle"); +} + // not used /* typedef struct dpfield_s @@ -1294,7 +1554,7 @@ void PRVM_LoadLNO( const char *progname ) { PRVM_LoadProgs =============== */ -void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field) +void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global) { int i; dstatement_t *st; @@ -1310,7 +1570,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required if (prog->progs == NULL || 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, filesize/1024); + Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024)); prog->filecrc = CRC_Block((unsigned char *)prog->progs, filesize); @@ -1326,14 +1586,11 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required //prog->functions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions); dfunctions = (dfunction_t *)((unsigned char *)prog->progs + prog->progs->ofs_functions); + if (prog->progs->ofs_strings + prog->progs->numstrings >= (int)filesize) + PRVM_ERROR ("%s: %s strings go past end of file", PRVM_NAME, filename); 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 >= (int)filesize) - PRVM_ERROR ("%s: %s strings go past end of file", PRVM_NAME, filename); - prog->stringssize += (int)strlen (prog->strings + prog->stringssize) + 1; - } + prog->stringssize = prog->progs->numstrings; + prog->numknownstrings = 0; prog->maxknownstrings = 0; prog->knownstrings = NULL; @@ -1412,6 +1669,11 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required if(PRVM_ED_FindFunction(required_func[i]) == 0) PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_func[i], filename); + // check required globals + for(i=0 ; i < numrequiredglobals ; i++) + if(PRVM_ED_FindGlobal(required_global[i]) == 0) + PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_global[i], filename); + for (i=0 ; iprogs->numglobals ; i++) ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]); @@ -1529,20 +1791,7 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required prog->flag = 0; - prog->self = PRVM_ED_FindGlobal("self"); - - if( PRVM_ED_FindGlobal("time") && PRVM_ED_FindGlobal("time")->type & ev_float ) - prog->time = &PRVM_G_FLOAT(PRVM_ED_FindGlobal("time")->ofs); - - if(PRVM_ED_FindField ("chain")) - prog->flag |= PRVM_FE_CHAIN; - - if(PRVM_ED_FindField ("classname")) - prog->flag |= PRVM_FE_CLASSNAME; - - if(PRVM_ED_FindField ("nextthink") && PRVM_ED_FindField ("frame") && PRVM_ED_FindField ("think") - && prog->flag && prog->self) - prog->flag |= PRVM_OP_STATE; + PRVM_FindOffsets(); PRVM_GCALL(init_cmd)(); @@ -1616,32 +1865,32 @@ void PRVM_Fields_f (void) switch(d->type & ~DEF_SAVEGLOBAL) { case ev_string: - strcat(tempstring, "string "); + strlcat(tempstring, "string ", sizeof(tempstring)); break; case ev_entity: - strcat(tempstring, "entity "); + strlcat(tempstring, "entity ", sizeof(tempstring)); break; case ev_function: - strcat(tempstring, "function "); + strlcat(tempstring, "function ", sizeof(tempstring)); break; case ev_field: - strcat(tempstring, "field "); + strlcat(tempstring, "field ", sizeof(tempstring)); break; case ev_void: - strcat(tempstring, "void "); + strlcat(tempstring, "void ", sizeof(tempstring)); break; case ev_float: - strcat(tempstring, "float "); + strlcat(tempstring, "float ", sizeof(tempstring)); break; case ev_vector: - strcat(tempstring, "vector "); + strlcat(tempstring, "vector ", sizeof(tempstring)); break; case ev_pointer: - strcat(tempstring, "pointer "); + strlcat(tempstring, "pointer ", sizeof(tempstring)); break; default: sprintf (tempstring2, "bad type %i ", d->type & ~DEF_SAVEGLOBAL); - strcat(tempstring, tempstring2); + strlcat(tempstring, tempstring2, sizeof(tempstring)); break; } if (strlen(name) > sizeof(tempstring2)-4) @@ -1651,12 +1900,12 @@ void PRVM_Fields_f (void) tempstring2[sizeof(tempstring2)-1] = 0; name = tempstring2; } - strcat(tempstring, name); + strlcat(tempstring, name, sizeof(tempstring)); for (j = (int)strlen(name);j < 25;j++) - strcat(tempstring, " "); + strlcat(tempstring, " ", sizeof(tempstring)); sprintf(tempstring2, "%5d", counts[i]); - strcat(tempstring, tempstring2); - strcat(tempstring, "\n"); + strlcat(tempstring, tempstring2, sizeof(tempstring)); + strlcat(tempstring, "\n", sizeof(tempstring)); if (strlen(tempstring) >= sizeof(tempstring)/2) { Con_Print(tempstring); @@ -1677,15 +1926,18 @@ void PRVM_Fields_f (void) void PRVM_Globals_f (void) { int i; + const char *wildcard; + int numculled; + numculled = 0; // TODO /*if (!sv.active) { Con_Print("no progs loaded\n"); return; }*/ - if(Cmd_Argc () != 2) + if(Cmd_Argc () < 2 || Cmd_Argc() > 3) { - Con_Print("prvm_globals \n"); + Con_Print("prvm_globals \n"); return; } @@ -1693,11 +1945,24 @@ void PRVM_Globals_f (void) if(!PRVM_SetProgFromString (Cmd_Argv (1))) return; + if( Cmd_Argc() == 3) + wildcard = Cmd_Argv(2); + else + wildcard = NULL; + Con_Printf("%s :", PRVM_NAME); for (i = 0;i < prog->progs->numglobaldefs;i++) + { + if(wildcard) + if( !matchpattern( PRVM_GetString(prog->globaldefs[i].s_name), wildcard, 1) ) + { + numculled++; + continue; + } Con_Printf("%s\n", PRVM_GetString(prog->globaldefs[i].s_name)); - Con_Printf("%i global variables, totalling %i bytes\n", prog->progs->numglobals, prog->progs->numglobals * 4); + } + Con_Printf("%i global variables, %i culled, totalling %i bytes\n", prog->progs->numglobals, numculled, prog->progs->numglobals * 4); PRVM_End; } @@ -1760,7 +2025,7 @@ PRVM_Init void PRVM_Init (void) { Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)"); - Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "set a property on an entity number in the selected VM (server, client, menu)"); + 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_fields", PRVM_Fields_f, "prints usage statistics on properties (how many entities have non-zero values) in the selected VM (server, client, menu)"); @@ -1769,6 +2034,9 @@ void PRVM_Init (void) 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_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"); + Cmd_AddCommand ("sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument"); // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others)) Cvar_RegisterVariable (&prvm_boundscheck); Cvar_RegisterVariable (&prvm_traceqc); @@ -1794,7 +2062,6 @@ void PRVM_InitProg(int prognr) memset(prog, 0, sizeof(prvm_prog_t)); - prog->time = &prog->_time; prog->error_cmd = Host_Error; } @@ -1870,21 +2137,63 @@ prvm_edict_t *PRVM_PROG_TO_EDICT(int n) */ +sizebuf_t vm_tempstringsbuf; + const char *PRVM_GetString(int num) { - if (num >= 0 && num < prog->stringssize) - return prog->strings + num; - else if (num < 0 && num >= -prog->numknownstrings) + if (num >= 0) { - num = -1 - num; - if (!prog->knownstrings[num]) - PRVM_ERROR("PRVM_GetString: attempt to get string that is already freed"); - return prog->knownstrings[num]; + if (num < prog->stringssize) + return prog->strings + num; + else +#if 1 + if (num <= prog->stringssize + vm_tempstringsbuf.maxsize) + { + num -= prog->stringssize; + if (num < vm_tempstringsbuf.cursize) + return (char *)vm_tempstringsbuf.data + num; + else + { + VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)", num, vm_tempstringsbuf.cursize); + return ""; + } + } + else +#endif + { + VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)", num, prog->stringssize); + return ""; + } } else { - PRVM_ERROR("PRVM_GetString: invalid string offset %i", num); - return ""; + num = -1 - num; +#if 0 + if (num >= (1<<30)) + { + // special range reserved for tempstrings + num -= (1<<30); + if (num < vm_tempstringsbuf.cursize) + return (char *)vm_tempstringsbuf.data + num; + else + { + VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)", num, vm_tempstringsbuf.cursize); + return ""; + } + } + else +#endif + if (num < prog->numknownstrings) + { + if (!prog->knownstrings[num]) + VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)", num); + return prog->knownstrings[num]; + } + else + { + VM_Warning("PRVM_GetString: Invalid zone-string offset (%i >= %i)", num, prog->numknownstrings); + return ""; + } } } @@ -1895,12 +2204,21 @@ int PRVM_SetEngineString(const char *s) return 0; if (s >= prog->strings && s <= prog->strings + prog->stringssize) PRVM_ERROR("PRVM_SetEngineString: s in prog->strings area"); + // if it's in the tempstrings area, use a reserved range + // (otherwise we'd get millions of useless string offsets cluttering the database) + if (s >= (char *)vm_tempstringsbuf.data && s < (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.maxsize) +#if 1 + return prog->stringssize + (s - (char *)vm_tempstringsbuf.data); +#else + return -1 - ((1<<30) + (s - (char *)vm_tempstringsbuf.data)); +#endif + // see if it's a known string address for (i = 0;i < prog->numknownstrings;i++) if (prog->knownstrings[i] == s) return -1 - i; // new unknown engine string - if (developer.integer >= 100) - Con_Printf("new engine string %p\n", s); + if (developer.integer >= 200) + Con_Printf("new engine string %p = \"%s\"\n", s, s); for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++) if (!prog->knownstrings[i]) break; @@ -1926,6 +2244,49 @@ int PRVM_SetEngineString(const char *s) return -1 - i; } +// temp string handling + +// all tempstrings go into this buffer consecutively, and it is reset +// whenever PRVM_ExecuteProgram returns to the engine +// (technically each PRVM_ExecuteProgram call saves the cursize value and +// restores it on return, so multiple recursive calls can share the same +// buffer) +// the buffer size is automatically grown as needed + +int PRVM_SetTempString(const char *s) +{ + int size; + char *t; + if (!s) + return 0; + size = (int)strlen(s) + 1; + if (developer.integer >= 300) + Con_Printf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size); + if (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size) + { + sizebuf_t old = vm_tempstringsbuf; + if (vm_tempstringsbuf.cursize + size >= 1<<28) + PRVM_ERROR("PRVM_SetTempString: ran out of tempstring memory! (refusing to grow tempstring buffer over 256MB, cursize %i, size %i)\n", vm_tempstringsbuf.cursize, size); + vm_tempstringsbuf.maxsize = max(vm_tempstringsbuf.maxsize, 65536); + while (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size) + vm_tempstringsbuf.maxsize *= 2; + if (vm_tempstringsbuf.maxsize != old.maxsize || vm_tempstringsbuf.data == NULL) + { + if (developer.integer >= 100) + Con_Printf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024); + vm_tempstringsbuf.data = Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize); + if (old.cursize) + memcpy(vm_tempstringsbuf.data, old.data, old.cursize); + if (old.data) + Mem_Free(old.data); + } + } + t = (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.cursize; + memcpy(t, s, size); + vm_tempstringsbuf.cursize += size; + return PRVM_SetEngineString(t); +} + int PRVM_AllocString(size_t bufferlength, char **pointer) { int i;