change representation of string offsets for allocated strings and engine
[xonotic/darkplaces.git] / prvm_edict.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // AK new vm
21
22 #include "quakedef.h"
23 #include "progsvm.h"
24
25 prvm_prog_t *prog;
26
27 static prvm_prog_t prog_list[PRVM_MAXPROGS];
28
29 int             prvm_type_size[8] = {1,sizeof(string_t)/4,1,3,1,1,sizeof(func_t)/4,sizeof(void *)/4};
30
31 ddef_t *PRVM_ED_FieldAtOfs(int ofs);
32 qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash);
33
34 cvar_t prvm_language = {0, "prvm_language", "", "when set, loads progs.dat.LANGUAGENAME.po for string translations; when set to dump, progs.dat.dump.po is written from the strings in the progs"};
35 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
36 cvar_t prvm_traceqc = {0, "prvm_traceqc", "0", "prints every QuakeC statement as it is executed (only for really thorough debugging!)"};
37 // LordHavoc: counts usage of each QuakeC statement
38 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)"};
39 cvar_t prvm_backtraceforwarnings = {0, "prvm_backtraceforwarnings", "0", "print a backtrace for warnings too"};
40 cvar_t prvm_leaktest = {0, "prvm_leaktest", "0", "try to detect memory leaks in strings or entities"};
41 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)"};
42 cvar_t prvm_errordump = {0, "prvm_errordump", "0", "write a savegame on crash to crash-server.dmp"};
43 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)"};
44 cvar_t prvm_reuseedicts_neverinsameframe = {0, "prvm_reuseedicts_neverinsameframe", "1", "never allows re-use of freed entity slots during same frame"};
45
46 static double prvm_reuseedicts_always_allow = 0;
47 qboolean prvm_runawaycheck = true;
48
49 extern sizebuf_t vm_tempstringsbuf;
50
51 //============================================================================
52 // mempool handling
53
54 /*
55 ===============
56 PRVM_MEM_Alloc
57 ===============
58 */
59 void PRVM_MEM_Alloc(void)
60 {
61         int i;
62
63         // reserve space for the null entity aka world
64         // check bound of max_edicts
65         prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts);
66         prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts);
67
68         // edictprivate_size has to be min as big prvm_edict_private_t
69         prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t));
70
71         // alloc edicts
72         prog->edicts = (prvm_edict_t *)Mem_Alloc(prog->progs_mempool,prog->limit_edicts * sizeof(prvm_edict_t));
73
74         // alloc edict private space
75         prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
76
77         // alloc edict fields
78         prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
79         prog->edictsfields = (vec_t *)Mem_Alloc(prog->progs_mempool, prog->entityfieldsarea * sizeof(vec_t));
80
81         // set edict pointers
82         for(i = 0; i < prog->max_edicts; i++)
83         {
84                 prog->edicts[i].priv.required = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
85                 prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
86         }
87 }
88
89 /*
90 ===============
91 PRVM_MEM_IncreaseEdicts
92 ===============
93 */
94 void PRVM_MEM_IncreaseEdicts(void)
95 {
96         int             i;
97
98         if(prog->max_edicts >= prog->limit_edicts)
99                 return;
100
101         PRVM_GCALL(begin_increase_edicts)();
102
103         // increase edicts
104         prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
105
106         prog->entityfieldsarea = prog->entityfields * prog->max_edicts;
107         prog->edictsfields = (vec_t*)Mem_Realloc(prog->progs_mempool, (void *)prog->edictsfields, prog->entityfieldsarea * sizeof(vec_t));
108         prog->edictprivate = (void *)Mem_Realloc(prog->progs_mempool, (void *)prog->edictprivate, prog->max_edicts * prog->edictprivate_size);
109
110         //set e and v pointers
111         for(i = 0; i < prog->max_edicts; i++)
112         {
113                 prog->edicts[i].priv.required  = (prvm_edict_private_t *)((unsigned char  *)prog->edictprivate + i * prog->edictprivate_size);
114                 prog->edicts[i].fields.vp = prog->edictsfields + i * prog->entityfields;
115         }
116
117         PRVM_GCALL(end_increase_edicts)();
118 }
119
120 //============================================================================
121 // normal prvm
122
123 int PRVM_ED_FindFieldOffset(const char *field)
124 {
125         ddef_t *d;
126         d = PRVM_ED_FindField(field);
127         if (!d)
128                 return -1;
129         return d->ofs;
130 }
131
132 int PRVM_ED_FindGlobalOffset(const char *global)
133 {
134         ddef_t *d;
135         d = PRVM_ED_FindGlobal(global);
136         if (!d)
137                 return -1;
138         return d->ofs;
139 }
140
141 func_t PRVM_ED_FindFunctionOffset(const char *function)
142 {
143         mfunction_t *f;
144         f = PRVM_ED_FindFunction(function);
145         if (!f)
146                 return 0;
147         return (func_t)(f - prog->functions);
148 }
149
150 qboolean PRVM_ProgLoaded(int prognr)
151 {
152         if(prognr < 0 || prognr >= PRVM_MAXPROGS)
153                 return FALSE;
154
155         return (prog_list[prognr].loaded ? TRUE : FALSE);
156 }
157
158 /*
159 =================
160 PRVM_SetProgFromString
161 =================
162 */
163 // perhaps add a return value when the str doesnt exist
164 qboolean PRVM_SetProgFromString(const char *str)
165 {
166         int i = 0;
167         for(; i < PRVM_MAXPROGS ; i++)
168                 if(prog_list[i].name && !strcmp(prog_list[i].name,str))
169                 {
170                         if(prog_list[i].loaded)
171                         {
172                                 prog = &prog_list[i];
173                                 return TRUE;
174                         }
175                         else
176                         {
177                                 Con_Printf("%s not loaded !\n",PRVM_NAME);
178                                 return FALSE;
179                         }
180                 }
181
182         Con_Printf("Invalid program name %s !\n", str);
183         return FALSE;
184 }
185
186 /*
187 =================
188 PRVM_SetProg
189 =================
190 */
191 void PRVM_SetProg(int prognr)
192 {
193         if(0 <= prognr && prognr < PRVM_MAXPROGS)
194         {
195                 if(prog_list[prognr].loaded)
196                         prog = &prog_list[prognr];
197                 else
198                         PRVM_ERROR("%i not loaded !", prognr);
199                 return;
200         }
201         PRVM_ERROR("Invalid program number %i", prognr);
202 }
203
204 /*
205 =================
206 PRVM_ED_ClearEdict
207
208 Sets everything to NULL
209 =================
210 */
211 void PRVM_ED_ClearEdict (prvm_edict_t *e)
212 {
213         memset (e->fields.vp, 0, prog->progs->entityfields * 4);
214         e->priv.required->free = false;
215
216         // AK: Let the init_edict function determine if something needs to be initialized
217         PRVM_GCALL(init_edict)(e);
218 }
219
220 const char *PRVM_AllocationOrigin(void)
221 {
222         char *buf = NULL;
223         if(prog->leaktest_active)
224         if(prog->depth > 0) // actually in QC code and not just parsing the entities block of a map/savegame
225         {
226                 buf = (char *)PRVM_Alloc(128);
227                 PRVM_ShortStackTrace(buf, 128);
228         }
229         return buf;
230 }
231
232 /*
233 =================
234 PRVM_ED_CanAlloc
235
236 Returns if this particular edict could get allocated by PRVM_ED_Alloc
237 =================
238 */
239 qboolean PRVM_ED_CanAlloc(prvm_edict_t *e)
240 {
241         if(!e->priv.required->free)
242                 return false;
243         if(prvm_reuseedicts_always_allow == realtime)
244                 return true;
245         if(realtime <= e->priv.required->freetime && prvm_reuseedicts_neverinsameframe.integer)
246                 return false; // never allow reuse in same frame (causes networking trouble)
247         if(e->priv.required->freetime < prog->starttime + prvm_reuseedicts_startuptime.value)
248                 return true;
249         if(realtime > e->priv.required->freetime + 1)
250                 return true;
251         return false; // entity slot still blocked because the entity was freed less than one second ago
252 }
253
254 /*
255 =================
256 PRVM_ED_Alloc
257
258 Either finds a free edict, or allocates a new one.
259 Try to avoid reusing an entity that was recently freed, because it
260 can cause the client to think the entity morphed into something else
261 instead of being removed and recreated, which can cause interpolated
262 angles and bad trails.
263 =================
264 */
265 prvm_edict_t *PRVM_ED_Alloc (void)
266 {
267         int                     i;
268         prvm_edict_t            *e;
269
270         // the client qc dont need maxclients
271         // thus it doesnt need to use svs.maxclients
272         // AK:  changed i=svs.maxclients+1
273         // AK:  changed so the edict 0 wont spawn -> used as reserved/world entity
274         //              although the menu/client has no world
275         for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++)
276         {
277                 e = PRVM_EDICT_NUM(i);
278                 if(PRVM_ED_CanAlloc(e))
279                 {
280                         PRVM_ED_ClearEdict (e);
281                         e->priv.required->allocation_origin = PRVM_AllocationOrigin();
282                         return e;
283                 }
284         }
285
286         if (i == prog->limit_edicts)
287                 PRVM_ERROR ("%s: PRVM_ED_Alloc: no free edicts",PRVM_NAME);
288
289         prog->num_edicts++;
290         if (prog->num_edicts >= prog->max_edicts)
291                 PRVM_MEM_IncreaseEdicts();
292
293         e = PRVM_EDICT_NUM(i);
294         PRVM_ED_ClearEdict (e);
295
296         e->priv.required->allocation_origin = PRVM_AllocationOrigin();
297
298         return e;
299 }
300
301 /*
302 =================
303 PRVM_ED_Free
304
305 Marks the edict as free
306 FIXME: walk all entities and NULL out references to this entity
307 =================
308 */
309 void PRVM_ED_Free (prvm_edict_t *ed)
310 {
311         // dont delete the null entity (world) or reserved edicts
312         if(PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
313                 return;
314
315         PRVM_GCALL(free_edict)(ed);
316
317         ed->priv.required->free = true;
318         ed->priv.required->freetime = realtime;
319         if(ed->priv.required->allocation_origin)
320         {
321                 PRVM_Free((char *)ed->priv.required->allocation_origin);
322                 ed->priv.required->allocation_origin = NULL;
323         }
324 }
325
326 //===========================================================================
327
328 /*
329 ============
330 PRVM_ED_GlobalAtOfs
331 ============
332 */
333 ddef_t *PRVM_ED_GlobalAtOfs (int ofs)
334 {
335         ddef_t          *def;
336         int                     i;
337
338         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
339         {
340                 def = &prog->globaldefs[i];
341                 if (def->ofs == ofs)
342                         return def;
343         }
344         return NULL;
345 }
346
347 /*
348 ============
349 PRVM_ED_FieldAtOfs
350 ============
351 */
352 ddef_t *PRVM_ED_FieldAtOfs (int ofs)
353 {
354         ddef_t          *def;
355         int                     i;
356
357         for (i=0 ; i<prog->progs->numfielddefs ; i++)
358         {
359                 def = &prog->fielddefs[i];
360                 if (def->ofs == ofs)
361                         return def;
362         }
363         return NULL;
364 }
365
366 /*
367 ============
368 PRVM_ED_FindField
369 ============
370 */
371 ddef_t *PRVM_ED_FindField (const char *name)
372 {
373         ddef_t *def;
374         int i;
375
376         for (i=0 ; i<prog->progs->numfielddefs ; i++)
377         {
378                 def = &prog->fielddefs[i];
379                 if (!strcmp(PRVM_GetString(def->s_name), name))
380                         return def;
381         }
382         return NULL;
383 }
384
385 /*
386 ============
387 PRVM_ED_FindGlobal
388 ============
389 */
390 ddef_t *PRVM_ED_FindGlobal (const char *name)
391 {
392         ddef_t *def;
393         int i;
394
395         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
396         {
397                 def = &prog->globaldefs[i];
398                 if (!strcmp(PRVM_GetString(def->s_name), name))
399                         return def;
400         }
401         return NULL;
402 }
403
404
405 /*
406 ============
407 PRVM_ED_FindFunction
408 ============
409 */
410 mfunction_t *PRVM_ED_FindFunction (const char *name)
411 {
412         mfunction_t             *func;
413         int                             i;
414
415         for (i=0 ; i<prog->progs->numfunctions ; i++)
416         {
417                 func = &prog->functions[i];
418                 if (!strcmp(PRVM_GetString(func->s_name), name))
419                         return func;
420         }
421         return NULL;
422 }
423
424
425 /*
426 ============
427 PRVM_ValueString
428
429 Returns a string describing *data in a type specific manner
430 =============
431 */
432 char *PRVM_ValueString (etype_t type, prvm_eval_t *val)
433 {
434         static char line[MAX_INPUTLINE];
435         ddef_t *def;
436         mfunction_t *f;
437         int n;
438
439         type = (etype_t)((int) type & ~DEF_SAVEGLOBAL);
440
441         switch (type)
442         {
443         case ev_string:
444                 strlcpy (line, PRVM_GetString (val->string), sizeof (line));
445                 break;
446         case ev_entity:
447                 n = val->edict;
448                 if (n < 0 || n >= prog->max_edicts)
449                         dpsnprintf (line, sizeof(line), "entity %i (invalid!)", n);
450                 else
451                         dpsnprintf (line, sizeof(line), "entity %i", n);
452                 break;
453         case ev_function:
454                 f = prog->functions + val->function;
455                 dpsnprintf (line, sizeof(line), "%s()", PRVM_GetString(f->s_name));
456                 break;
457         case ev_field:
458                 def = PRVM_ED_FieldAtOfs ( val->_int );
459                 dpsnprintf (line, sizeof(line), ".%s", PRVM_GetString(def->s_name));
460                 break;
461         case ev_void:
462                 dpsnprintf (line, sizeof(line), "void");
463                 break;
464         case ev_float:
465                 // LordHavoc: changed from %5.1f to %10.4f
466                 dpsnprintf (line, sizeof(line), "%10.4f", val->_float);
467                 break;
468         case ev_vector:
469                 // LordHavoc: changed from %5.1f to %10.4f
470                 dpsnprintf (line, sizeof(line), "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
471                 break;
472         case ev_pointer:
473                 dpsnprintf (line, sizeof(line), "pointer");
474                 break;
475         default:
476                 dpsnprintf (line, sizeof(line), "bad type %i", (int) type);
477                 break;
478         }
479
480         return line;
481 }
482
483 /*
484 ============
485 PRVM_UglyValueString
486
487 Returns a string describing *data in a type specific manner
488 Easier to parse than PR_ValueString
489 =============
490 */
491 char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val)
492 {
493         static char line[MAX_INPUTLINE];
494         int i;
495         const char *s;
496         ddef_t *def;
497         mfunction_t *f;
498
499         type = (etype_t)((int)type & ~DEF_SAVEGLOBAL);
500
501         switch (type)
502         {
503         case ev_string:
504                 // Parse the string a bit to turn special characters
505                 // (like newline, specifically) into escape codes,
506                 // this fixes saving games from various mods
507                 s = PRVM_GetString (val->string);
508                 for (i = 0;i < (int)sizeof(line) - 2 && *s;)
509                 {
510                         if (*s == '\n')
511                         {
512                                 line[i++] = '\\';
513                                 line[i++] = 'n';
514                         }
515                         else if (*s == '\r')
516                         {
517                                 line[i++] = '\\';
518                                 line[i++] = 'r';
519                         }
520                         else if (*s == '\\')
521                         {
522                                 line[i++] = '\\';
523                                 line[i++] = '\\';
524                         }
525                         else if (*s == '"')
526                         {
527                                 line[i++] = '\\';
528                                 line[i++] = '"';
529                         }
530                         else
531                                 line[i++] = *s;
532                         s++;
533                 }
534                 line[i] = '\0';
535                 break;
536         case ev_entity:
537                 dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
538                 break;
539         case ev_function:
540                 f = prog->functions + val->function;
541                 strlcpy (line, PRVM_GetString (f->s_name), sizeof (line));
542                 break;
543         case ev_field:
544                 def = PRVM_ED_FieldAtOfs ( val->_int );
545                 dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
546                 break;
547         case ev_void:
548                 dpsnprintf (line, sizeof (line), "void");
549                 break;
550         case ev_float:
551                 dpsnprintf (line, sizeof (line), "%.9g", val->_float);
552                 break;
553         case ev_vector:
554                 dpsnprintf (line, sizeof (line), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]);
555                 break;
556         default:
557                 dpsnprintf (line, sizeof (line), "bad type %i", type);
558                 break;
559         }
560
561         return line;
562 }
563
564 /*
565 ============
566 PRVM_GlobalString
567
568 Returns a string with a description and the contents of a global,
569 padded to 20 field width
570 ============
571 */
572 char *PRVM_GlobalString (int ofs)
573 {
574         char    *s;
575         //size_t        i;
576         ddef_t  *def;
577         void    *val;
578         static char     line[128];
579
580         val = (void *)&prog->globals.generic[ofs];
581         def = PRVM_ED_GlobalAtOfs(ofs);
582         if (!def)
583                 dpsnprintf (line, sizeof(line), "GLOBAL%i", ofs);
584         else
585         {
586                 s = PRVM_ValueString ((etype_t)def->type, (prvm_eval_t *)val);
587                 dpsnprintf (line, sizeof(line), "%s (=%s)", PRVM_GetString(def->s_name), s);
588         }
589
590         //i = strlen(line);
591         //for ( ; i<20 ; i++)
592         //      strcat (line," ");
593         //strcat (line," ");
594
595         return line;
596 }
597
598 char *PRVM_GlobalStringNoContents (int ofs)
599 {
600         //size_t        i;
601         ddef_t  *def;
602         static char     line[128];
603
604         def = PRVM_ED_GlobalAtOfs(ofs);
605         if (!def)
606                 dpsnprintf (line, sizeof(line), "GLOBAL%i", ofs);
607         else
608                 dpsnprintf (line, sizeof(line), "%s", PRVM_GetString(def->s_name));
609
610         //i = strlen(line);
611         //for ( ; i<20 ; i++)
612         //      strcat (line," ");
613         //strcat (line," ");
614
615         return line;
616 }
617
618
619 /*
620 =============
621 PRVM_ED_Print
622
623 For debugging
624 =============
625 */
626 // LordHavoc: optimized this to print out much more quickly (tempstring)
627 // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
628 void PRVM_ED_Print(prvm_edict_t *ed, const char *wildcard_fieldname)
629 {
630         size_t  l;
631         ddef_t  *d;
632         int             *v;
633         int             i, j;
634         const char      *name;
635         int             type;
636         char    tempstring[MAX_INPUTLINE], tempstring2[260]; // temporary string buffers
637
638         if (ed->priv.required->free)
639         {
640                 Con_Printf("%s: FREE\n",PRVM_NAME);
641                 return;
642         }
643
644         tempstring[0] = 0;
645         dpsnprintf(tempstring, sizeof(tempstring), "\n%s EDICT %i:\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ed));
646         for (i=1 ; i<prog->progs->numfielddefs ; i++)
647         {
648                 d = &prog->fielddefs[i];
649                 name = PRVM_GetString(d->s_name);
650                 if (name[strlen(name)-2] == '_')
651                         continue;       // skip _x, _y, _z vars
652
653                 // Check Field Name Wildcard
654                 if(wildcard_fieldname)
655                         if( !matchpattern(name, wildcard_fieldname, 1) )
656                                 // Didn't match; skip
657                                 continue;
658
659                 v = (int *)(ed->fields.vp + d->ofs);
660
661         // if the value is still all 0, skip the field
662                 type = d->type & ~DEF_SAVEGLOBAL;
663
664                 for (j=0 ; j<prvm_type_size[type] ; j++)
665                         if (v[j])
666                                 break;
667                 if (j == prvm_type_size[type])
668                         continue;
669
670                 if (strlen(name) > sizeof(tempstring2)-4)
671                 {
672                         memcpy (tempstring2, name, sizeof(tempstring2)-4);
673                         tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
674                         tempstring2[sizeof(tempstring2)-1] = 0;
675                         name = tempstring2;
676                 }
677                 strlcat(tempstring, name, sizeof(tempstring));
678                 for (l = strlen(name);l < 14;l++)
679                         strlcat(tempstring, " ", sizeof(tempstring));
680                 strlcat(tempstring, " ", sizeof(tempstring));
681
682                 name = PRVM_ValueString((etype_t)d->type, (prvm_eval_t *)v);
683                 if (strlen(name) > sizeof(tempstring2)-4)
684                 {
685                         memcpy (tempstring2, name, sizeof(tempstring2)-4);
686                         tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
687                         tempstring2[sizeof(tempstring2)-1] = 0;
688                         name = tempstring2;
689                 }
690                 strlcat(tempstring, name, sizeof(tempstring));
691                 strlcat(tempstring, "\n", sizeof(tempstring));
692                 if (strlen(tempstring) >= sizeof(tempstring)/2)
693                 {
694                         Con_Print(tempstring);
695                         tempstring[0] = 0;
696                 }
697         }
698         if (tempstring[0])
699                 Con_Print(tempstring);
700 }
701
702 /*
703 =============
704 PRVM_ED_Write
705
706 For savegames
707 =============
708 */
709 extern cvar_t developer_entityparsing;
710 void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
711 {
712         ddef_t  *d;
713         int             *v;
714         int             i, j;
715         const char      *name;
716         int             type;
717
718         FS_Print(f, "{\n");
719
720         if (ed->priv.required->free)
721         {
722                 FS_Print(f, "}\n");
723                 return;
724         }
725
726         for (i=1 ; i<prog->progs->numfielddefs ; i++)
727         {
728                 d = &prog->fielddefs[i];
729                 name = PRVM_GetString(d->s_name);
730
731                 if(developer_entityparsing.integer)
732                         Con_Printf("PRVM_ED_Write: at entity %d field %s\n", PRVM_NUM_FOR_EDICT(ed), name);
733
734                 if (name[strlen(name)-2] == '_')
735                         continue;       // skip _x, _y, _z vars
736
737                 v = (int *)(ed->fields.vp + d->ofs);
738
739         // if the value is still all 0, skip the field
740                 type = d->type & ~DEF_SAVEGLOBAL;
741                 for (j=0 ; j<prvm_type_size[type] ; j++)
742                         if (v[j])
743                                 break;
744                 if (j == prvm_type_size[type])
745                         continue;
746
747                 FS_Printf(f,"\"%s\" ",name);
748                 prog->statestring = va("PRVM_ED_Write, ent=%d, name=%s", i, name);
749                 FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)d->type, (prvm_eval_t *)v));
750                 prog->statestring = NULL;
751         }
752
753         FS_Print(f, "}\n");
754 }
755
756 void PRVM_ED_PrintNum (int ent, const char *wildcard_fieldname)
757 {
758         PRVM_ED_Print(PRVM_EDICT_NUM(ent), wildcard_fieldname);
759 }
760
761 /*
762 =============
763 PRVM_ED_PrintEdicts_f
764
765 For debugging, prints all the entities in the current server
766 =============
767 */
768 void PRVM_ED_PrintEdicts_f (void)
769 {
770         int             i;
771         const char *wildcard_fieldname;
772
773         if(Cmd_Argc() < 2 || Cmd_Argc() > 3)
774         {
775                 Con_Print("prvm_edicts <program name> <optional field name wildcard>\n");
776                 return;
777         }
778
779         PRVM_Begin;
780         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
781                 return;
782
783         if( Cmd_Argc() == 3)
784                 wildcard_fieldname = Cmd_Argv(2);
785         else
786                 wildcard_fieldname = NULL;
787
788         Con_Printf("%s: %i entities\n", PRVM_NAME, prog->num_edicts);
789         for (i=0 ; i<prog->num_edicts ; i++)
790                 PRVM_ED_PrintNum (i, wildcard_fieldname);
791
792         PRVM_End;
793 }
794
795 /*
796 =============
797 PRVM_ED_PrintEdict_f
798
799 For debugging, prints a single edict
800 =============
801 */
802 void PRVM_ED_PrintEdict_f (void)
803 {
804         int             i;
805         const char      *wildcard_fieldname;
806
807         if(Cmd_Argc() < 3 || Cmd_Argc() > 4)
808         {
809                 Con_Print("prvm_edict <program name> <edict number> <optional field name wildcard>\n");
810                 return;
811         }
812
813         PRVM_Begin;
814         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
815                 return;
816
817         i = atoi (Cmd_Argv(2));
818         if (i >= prog->num_edicts)
819         {
820                 Con_Print("Bad edict number\n");
821                 PRVM_End;
822                 return;
823         }
824         if( Cmd_Argc() == 4)
825                 // Optional Wildcard Provided
826                 wildcard_fieldname = Cmd_Argv(3);
827         else
828                 // Use All
829                 wildcard_fieldname = NULL;
830         PRVM_ED_PrintNum (i, wildcard_fieldname);
831
832         PRVM_End;
833 }
834
835 /*
836 =============
837 PRVM_ED_Count
838
839 For debugging
840 =============
841 */
842 // 2 possibilities : 1. just displaying the active edict count
843 //                                       2. making a function pointer [x]
844 void PRVM_ED_Count_f (void)
845 {
846         int             i;
847         prvm_edict_t    *ent;
848         int             active;
849
850         if(Cmd_Argc() != 2)
851         {
852                 Con_Print("prvm_count <program name>\n");
853                 return;
854         }
855
856         PRVM_Begin;
857         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
858                 return;
859
860         if(prog->count_edicts)
861                 prog->count_edicts();
862         else
863         {
864                 active = 0;
865                 for (i=0 ; i<prog->num_edicts ; i++)
866                 {
867                         ent = PRVM_EDICT_NUM(i);
868                         if (ent->priv.required->free)
869                                 continue;
870                         active++;
871                 }
872
873                 Con_Printf("num_edicts:%3i\n", prog->num_edicts);
874                 Con_Printf("active    :%3i\n", active);
875         }
876
877         PRVM_End;
878 }
879
880 /*
881 ==============================================================================
882
883                                         ARCHIVING GLOBALS
884
885 FIXME: need to tag constants, doesn't really work
886 ==============================================================================
887 */
888
889 /*
890 =============
891 PRVM_ED_WriteGlobals
892 =============
893 */
894 void PRVM_ED_WriteGlobals (qfile_t *f)
895 {
896         ddef_t          *def;
897         int                     i;
898         const char              *name;
899         int                     type;
900
901         FS_Print(f,"{\n");
902         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
903         {
904                 def = &prog->globaldefs[i];
905                 type = def->type;
906                 if ( !(def->type & DEF_SAVEGLOBAL) )
907                         continue;
908                 type &= ~DEF_SAVEGLOBAL;
909
910                 if (type != ev_string && type != ev_float && type != ev_entity)
911                         continue;
912
913                 name = PRVM_GetString(def->s_name);
914
915                 if(developer_entityparsing.integer)
916                         Con_Printf("PRVM_ED_WriteGlobals: at global %s\n", name);
917
918                 prog->statestring = va("PRVM_ED_WriteGlobals, name=%s", name);
919                 FS_Printf(f,"\"%s\" ", name);
920                 FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString((etype_t)type, (prvm_eval_t *)&prog->globals.generic[def->ofs]));
921                 prog->statestring = NULL;
922         }
923         FS_Print(f,"}\n");
924 }
925
926 /*
927 =============
928 PRVM_ED_ParseGlobals
929 =============
930 */
931 void PRVM_ED_ParseGlobals (const char *data)
932 {
933         char keyname[MAX_INPUTLINE];
934         ddef_t *key;
935
936         while (1)
937         {
938                 // parse key
939                 if (!COM_ParseToken_Simple(&data, false, false))
940                         PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace");
941                 if (com_token[0] == '}')
942                         break;
943
944                 if (developer_entityparsing.integer)
945                         Con_Printf("Key: \"%s\"", com_token);
946
947                 strlcpy (keyname, com_token, sizeof(keyname));
948
949                 // parse value
950                 if (!COM_ParseToken_Simple(&data, false, true))
951                         PRVM_ERROR ("PRVM_ED_ParseGlobals: EOF without closing brace");
952
953                 if (developer_entityparsing.integer)
954                         Con_Printf(" \"%s\"\n", com_token);
955
956                 if (com_token[0] == '}')
957                         PRVM_ERROR ("PRVM_ED_ParseGlobals: closing brace without data");
958
959                 key = PRVM_ED_FindGlobal (keyname);
960                 if (!key)
961                 {
962                         Con_DPrintf("'%s' is not a global on %s\n", keyname, PRVM_NAME);
963                         continue;
964                 }
965
966                 if (!PRVM_ED_ParseEpair(NULL, key, com_token, true))
967                         PRVM_ERROR ("PRVM_ED_ParseGlobals: parse error");
968         }
969 }
970
971 //============================================================================
972
973
974 /*
975 =============
976 PRVM_ED_ParseEval
977
978 Can parse either fields or globals
979 returns false if error
980 =============
981 */
982 qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s, qboolean parsebackslash)
983 {
984         int i, l;
985         char *new_p;
986         ddef_t *def;
987         prvm_eval_t *val;
988         mfunction_t *func;
989
990         if (ent)
991                 val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
992         else
993                 val = (prvm_eval_t *)(prog->globals.generic + key->ofs);
994         switch (key->type & ~DEF_SAVEGLOBAL)
995         {
996         case ev_string:
997                 l = (int)strlen(s) + 1;
998                 val->string = PRVM_AllocString(l, &new_p);
999                 for (i = 0;i < l;i++)
1000                 {
1001                         if (s[i] == '\\' && s[i+1] && parsebackslash)
1002                         {
1003                                 i++;
1004                                 if (s[i] == 'n')
1005                                         *new_p++ = '\n';
1006                                 else if (s[i] == 'r')
1007                                         *new_p++ = '\r';
1008                                 else
1009                                         *new_p++ = s[i];
1010                         }
1011                         else
1012                                 *new_p++ = s[i];
1013                 }
1014                 break;
1015
1016         case ev_float:
1017                 while (*s && ISWHITESPACE(*s))
1018                         s++;
1019                 val->_float = atof(s);
1020                 break;
1021
1022         case ev_vector:
1023                 for (i = 0;i < 3;i++)
1024                 {
1025                         while (*s && ISWHITESPACE(*s))
1026                                 s++;
1027                         if (!*s)
1028                                 break;
1029                         val->vector[i] = atof(s);
1030                         while (!ISWHITESPACE(*s))
1031                                 s++;
1032                         if (!*s)
1033                                 break;
1034                 }
1035                 break;
1036
1037         case ev_entity:
1038                 while (*s && ISWHITESPACE(*s))
1039                         s++;
1040                 i = atoi(s);
1041                 if (i >= prog->limit_edicts)
1042                         Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %u >= MAX_EDICTS %u) on %s\n", (unsigned int)i, prog->limit_edicts, PRVM_NAME);
1043                 while (i >= prog->max_edicts)
1044                         PRVM_MEM_IncreaseEdicts();
1045                 // if IncreaseEdicts was called the base pointer needs to be updated
1046                 if (ent)
1047                         val = (prvm_eval_t *)(ent->fields.vp + key->ofs);
1048                 val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM((int)i));
1049                 break;
1050
1051         case ev_field:
1052                 if (*s != '.')
1053                 {
1054                         Con_DPrintf("PRVM_ED_ParseEpair: Bogus field name %s in %s\n", s, PRVM_NAME);
1055                         return false;
1056                 }
1057                 def = PRVM_ED_FindField(s + 1);
1058                 if (!def)
1059                 {
1060                         Con_DPrintf("PRVM_ED_ParseEpair: Can't find field %s in %s\n", s, PRVM_NAME);
1061                         return false;
1062                 }
1063                 val->_int = def->ofs;
1064                 break;
1065
1066         case ev_function:
1067                 func = PRVM_ED_FindFunction(s);
1068                 if (!func)
1069                 {
1070                         Con_Printf("PRVM_ED_ParseEpair: Can't find function %s in %s\n", s, PRVM_NAME);
1071                         return false;
1072                 }
1073                 val->function = func - prog->functions;
1074                 break;
1075
1076         default:
1077                 Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(key->s_name), PRVM_NAME);
1078                 return false;
1079         }
1080         return true;
1081 }
1082
1083 /*
1084 =============
1085 PRVM_GameCommand_f
1086
1087 Console command to send a string to QC function GameCommand of the
1088 indicated progs
1089
1090 Usage:
1091   sv_cmd adminmsg 3 "do not teamkill"
1092   cl_cmd someclientcommand
1093   menu_cmd somemenucommand
1094
1095 All progs can support this extension; sg calls it in server QC, cg in client
1096 QC, mg in menu QC.
1097 =============
1098 */
1099 void PRVM_GameCommand(const char *whichprogs, const char *whichcmd)
1100 {
1101         if(Cmd_Argc() < 1)
1102         {
1103                 Con_Printf("%s text...\n", whichcmd);
1104                 return;
1105         }
1106
1107         PRVM_Begin;
1108         if(!PRVM_SetProgFromString(whichprogs))
1109         // note: this is not PRVM_SetProg because that one aborts "hard" using PRVM_Error
1110         // also, it makes printing error messages easier!
1111         {
1112                 Con_Printf("%s program not loaded.\n", whichprogs);
1113                 return;
1114         }
1115
1116         if(!prog->funcoffsets.GameCommand)
1117         {
1118                 Con_Printf("%s program do not support GameCommand!\n", whichprogs);
1119         }
1120         else
1121         {
1122                 int restorevm_tempstringsbuf_cursize;
1123                 const char *s;
1124
1125                 s = Cmd_Args();
1126
1127                 restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
1128                 PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(s ? s : "");
1129                 PRVM_ExecuteProgram (prog->funcoffsets.GameCommand, "QC function GameCommand is missing");
1130                 vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
1131         }
1132
1133         PRVM_End;
1134 }
1135 void PRVM_GameCommand_Server_f(void)
1136 {
1137         PRVM_GameCommand("server", "sv_cmd");
1138 }
1139 void PRVM_GameCommand_Client_f(void)
1140 {
1141         PRVM_GameCommand("client", "cl_cmd");
1142 }
1143 void PRVM_GameCommand_Menu_f(void)
1144 {
1145         PRVM_GameCommand("menu", "menu_cmd");
1146 }
1147
1148 /*
1149 =============
1150 PRVM_ED_EdictGet_f
1151
1152 Console command to load a field of a specified edict
1153 =============
1154 */
1155 void PRVM_ED_EdictGet_f(void)
1156 {
1157         prvm_edict_t *ed;
1158         ddef_t *key;
1159         const char *s;
1160         prvm_eval_t *v;
1161
1162         if(Cmd_Argc() != 4 && Cmd_Argc() != 5)
1163         {
1164                 Con_Print("prvm_edictget <program name> <edict number> <field> [<cvar>]\n");
1165                 return;
1166         }
1167
1168         PRVM_Begin;
1169         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
1170         {
1171                 Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
1172                 return;
1173         }
1174
1175         ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
1176
1177         if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0)
1178         {
1179                 Con_Printf("Key %s not found !\n", Cmd_Argv(3));
1180                 goto fail;
1181         }
1182
1183         v = (prvm_eval_t *)(ed->fields.vp + key->ofs);
1184         s = PRVM_UglyValueString(key->type, v);
1185         if(Cmd_Argc() == 5)
1186         {
1187                 cvar_t *cvar = Cvar_FindVar(Cmd_Argv(4));
1188                 if (cvar && cvar->flags & CVAR_READONLY)
1189                 {
1190                         Con_Printf("prvm_edictget: %s is read-only\n", cvar->name);
1191                         goto fail;
1192                 }
1193                 Cvar_Get(Cmd_Argv(4), s, 0, NULL);
1194         }
1195         else
1196                 Con_Printf("%s\n", s);
1197
1198 fail:
1199         PRVM_End;
1200 }
1201
1202 void PRVM_ED_GlobalGet_f(void)
1203 {
1204         ddef_t *key;
1205         const char *s;
1206         prvm_eval_t *v;
1207
1208         if(Cmd_Argc() != 3 && Cmd_Argc() != 4)
1209         {
1210                 Con_Print("prvm_globalget <program name> <global> [<cvar>]\n");
1211                 return;
1212         }
1213
1214         PRVM_Begin;
1215         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
1216         {
1217                 Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
1218                 return;
1219         }
1220
1221         key = PRVM_ED_FindGlobal(Cmd_Argv(2));
1222         if(!key)
1223         {
1224                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
1225                 goto fail;
1226         }
1227
1228         v = (prvm_eval_t *) &prog->globals.generic[key->ofs];
1229         s = PRVM_UglyValueString(key->type, v);
1230         if(Cmd_Argc() == 4)
1231         {
1232                 cvar_t *cvar = Cvar_FindVar(Cmd_Argv(3));
1233                 if (cvar && cvar->flags & CVAR_READONLY)
1234                 {
1235                         Con_Printf("prvm_globalget: %s is read-only\n", cvar->name);
1236                         goto fail;
1237                 }
1238                 Cvar_Get(Cmd_Argv(3), s, 0, NULL);
1239         }
1240         else
1241                 Con_Printf("%s\n", s);
1242
1243 fail:
1244         PRVM_End;
1245 }
1246
1247 /*
1248 =============
1249 PRVM_ED_EdictSet_f
1250
1251 Console command to set a field of a specified edict
1252 =============
1253 */
1254 void PRVM_ED_EdictSet_f(void)
1255 {
1256         prvm_edict_t *ed;
1257         ddef_t *key;
1258
1259         if(Cmd_Argc() != 5)
1260         {
1261                 Con_Print("prvm_edictset <program name> <edict number> <field> <value>\n");
1262                 return;
1263         }
1264
1265         PRVM_Begin;
1266         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
1267         {
1268                 Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
1269                 return;
1270         }
1271
1272         ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
1273
1274         if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0)
1275                 Con_Printf("Key %s not found !\n", Cmd_Argv(3));
1276         else
1277                 PRVM_ED_ParseEpair(ed, key, Cmd_Argv(4), true);
1278
1279         PRVM_End;
1280 }
1281
1282 /*
1283 ====================
1284 PRVM_ED_ParseEdict
1285
1286 Parses an edict out of the given string, returning the new position
1287 ed should be a properly initialized empty edict.
1288 Used for initial level load and for savegames.
1289 ====================
1290 */
1291 const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
1292 {
1293         ddef_t *key;
1294         qboolean anglehack;
1295         qboolean init;
1296         char keyname[256];
1297         size_t n;
1298
1299         init = false;
1300
1301 // go through all the dictionary pairs
1302         while (1)
1303         {
1304         // parse key
1305                 if (!COM_ParseToken_Simple(&data, false, false))
1306                         PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace");
1307                 if (developer_entityparsing.integer)
1308                         Con_Printf("Key: \"%s\"", com_token);
1309                 if (com_token[0] == '}')
1310                         break;
1311
1312                 // anglehack is to allow QuakeEd to write single scalar angles
1313                 // and allow them to be turned into vectors. (FIXME...)
1314                 if (!strcmp(com_token, "angle"))
1315                 {
1316                         strlcpy (com_token, "angles", sizeof(com_token));
1317                         anglehack = true;
1318                 }
1319                 else
1320                         anglehack = false;
1321
1322                 // FIXME: change light to _light to get rid of this hack
1323                 if (!strcmp(com_token, "light"))
1324                         strlcpy (com_token, "light_lev", sizeof(com_token));    // hack for single light def
1325
1326                 strlcpy (keyname, com_token, sizeof(keyname));
1327
1328                 // another hack to fix keynames with trailing spaces
1329                 n = strlen(keyname);
1330                 while (n && keyname[n-1] == ' ')
1331                 {
1332                         keyname[n-1] = 0;
1333                         n--;
1334                 }
1335
1336         // parse value
1337                 if (!COM_ParseToken_Simple(&data, false, false))
1338                         PRVM_ERROR ("PRVM_ED_ParseEdict: EOF without closing brace");
1339                 if (developer_entityparsing.integer)
1340                         Con_Printf(" \"%s\"\n", com_token);
1341
1342                 if (com_token[0] == '}')
1343                         PRVM_ERROR ("PRVM_ED_ParseEdict: closing brace without data");
1344
1345                 init = true;
1346
1347                 // ignore attempts to set key "" (this problem occurs in nehahra neh1m8.bsp)
1348                 if (!keyname[0])
1349                         continue;
1350
1351 // keynames with a leading underscore are used for utility comments,
1352 // and are immediately discarded by quake
1353                 if (keyname[0] == '_')
1354                         continue;
1355
1356                 key = PRVM_ED_FindField (keyname);
1357                 if (!key)
1358                 {
1359                         Con_DPrintf("%s: '%s' is not a field\n", PRVM_NAME, keyname);
1360                         continue;
1361                 }
1362
1363                 if (anglehack)
1364                 {
1365                         char    temp[32];
1366                         strlcpy (temp, com_token, sizeof(temp));
1367                         dpsnprintf (com_token, sizeof(com_token), "0 %s 0", temp);
1368                 }
1369
1370                 if (!PRVM_ED_ParseEpair(ent, key, com_token, strcmp(keyname, "wad") != 0))
1371                         PRVM_ERROR ("PRVM_ED_ParseEdict: parse error");
1372         }
1373
1374         if (!init)
1375                 ent->priv.required->free = true;
1376
1377         return data;
1378 }
1379
1380
1381 /*
1382 ================
1383 PRVM_ED_LoadFromFile
1384
1385 The entities are directly placed in the array, rather than allocated with
1386 PRVM_ED_Alloc, because otherwise an error loading the map would have entity
1387 number references out of order.
1388
1389 Creates a server's entity / program execution context by
1390 parsing textual entity definitions out of an ent file.
1391
1392 Used for both fresh maps and savegame loads.  A fresh map would also need
1393 to call PRVM_ED_CallSpawnFunctions () to let the objects initialize themselves.
1394 ================
1395 */
1396 void PRVM_ED_LoadFromFile (const char *data)
1397 {
1398         prvm_edict_t *ent;
1399         int parsed, inhibited, spawned, died;
1400         const char *funcname;
1401         mfunction_t *func;
1402
1403         parsed = 0;
1404         inhibited = 0;
1405         spawned = 0;
1406         died = 0;
1407
1408         prvm_reuseedicts_always_allow = realtime;
1409
1410 // parse ents
1411         while (1)
1412         {
1413 // parse the opening brace
1414                 if (!COM_ParseToken_Simple(&data, false, false))
1415                         break;
1416                 if (com_token[0] != '{')
1417                         PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token);
1418
1419                 // CHANGED: this is not conform to PR_LoadFromFile
1420                 if(prog->loadintoworld)
1421                 {
1422                         prog->loadintoworld = false;
1423                         ent = PRVM_EDICT_NUM(0);
1424                 }
1425                 else
1426                         ent = PRVM_ED_Alloc();
1427
1428                 // clear it
1429                 if (ent != prog->edicts)        // hack
1430                         memset (ent->fields.vp, 0, prog->progs->entityfields * 4);
1431
1432                 data = PRVM_ED_ParseEdict (data, ent);
1433                 parsed++;
1434
1435                 // remove the entity ?
1436                 if(prog->load_edict && !prog->load_edict(ent))
1437                 {
1438                         PRVM_ED_Free(ent);
1439                         inhibited++;
1440                         continue;
1441                 }
1442
1443                 if (prog->funcoffsets.SV_OnEntityPreSpawnFunction)
1444                 {
1445                         // self = ent
1446                         PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1447                         PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPreSpawnFunction, "QC function SV_OnEntityPreSpawnFunction is missing");
1448                 }
1449
1450                 if(ent->priv.required->free)
1451                 {
1452                         inhibited++;
1453                         continue;
1454                 }
1455
1456 //
1457 // immediately call spawn function, but only if there is a self global and a classname
1458 //
1459                 if(!ent->priv.required->free)
1460                 if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0)
1461                 {
1462                         string_t handle =  PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.classname)->string;
1463                         if (!handle)
1464                         {
1465                                 Con_Print("No classname for:\n");
1466                                 PRVM_ED_Print(ent, NULL);
1467                                 PRVM_ED_Free (ent);
1468                                 continue;
1469                         }
1470
1471                         // look for the spawn function
1472                         funcname = PRVM_GetString(handle);
1473                         func = PRVM_ED_FindFunction (va("spawnfunc_%s", funcname));
1474                         if(!func)
1475                                 if(prog->globaloffsets.require_spawnfunc_prefix < 0)
1476                                         func = PRVM_ED_FindFunction (funcname);
1477
1478                         if (!func)
1479                         {
1480                                 // check for OnEntityNoSpawnFunction
1481                                 if (prog->funcoffsets.SV_OnEntityNoSpawnFunction)
1482                                 {
1483                                         // self = ent
1484                                         PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1485                                         PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityNoSpawnFunction, "QC function SV_OnEntityNoSpawnFunction is missing");
1486                                 }
1487                                 else
1488                                 {
1489                                         if (developer.integer) // don't confuse non-developers with errors
1490                                         {
1491                                                 Con_Print("No spawn function for:\n");
1492                                                 PRVM_ED_Print(ent, NULL);
1493                                         }
1494                                         PRVM_ED_Free (ent);
1495                                         continue; // not included in "inhibited" count
1496                                 }
1497                         }
1498                         else
1499                         {
1500                                 // self = ent
1501                                 PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1502                                 PRVM_ExecuteProgram (func - prog->functions, "");
1503                         }
1504                 }
1505
1506                 if(!ent->priv.required->free)
1507                 if (prog->funcoffsets.SV_OnEntityPostSpawnFunction)
1508                 {
1509                         // self = ent
1510                         PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1511                         PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPostSpawnFunction, "QC function SV_OnEntityPostSpawnFunction is missing");
1512                 }
1513
1514                 spawned++;
1515                 if (ent->priv.required->free)
1516                         died++;
1517         }
1518
1519         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);
1520
1521         prvm_reuseedicts_always_allow = 0;
1522 }
1523
1524 void PRVM_FindOffsets(void)
1525 {
1526         // field and global searches use -1 for NULL
1527         memset(&prog->fieldoffsets, -1, sizeof(prog->fieldoffsets));
1528         memset(&prog->globaloffsets, -1, sizeof(prog->globaloffsets));
1529         // functions use 0 for NULL
1530         memset(&prog->funcoffsets, 0, sizeof(prog->funcoffsets));
1531
1532         // server and client qc use a lot of similar fields, so this is combined
1533         prog->fieldoffsets.SendEntity                     = PRVM_ED_FindFieldOffset("SendEntity");
1534         prog->fieldoffsets.SendFlags                      = PRVM_ED_FindFieldOffset("SendFlags");
1535         prog->fieldoffsets.Version                        = PRVM_ED_FindFieldOffset("Version");
1536         prog->fieldoffsets.alpha                          = PRVM_ED_FindFieldOffset("alpha");
1537         prog->fieldoffsets.ammo_cells1                    = PRVM_ED_FindFieldOffset("ammo_cells1");
1538         prog->fieldoffsets.ammo_lava_nails                = PRVM_ED_FindFieldOffset("ammo_lava_nails");
1539         prog->fieldoffsets.ammo_multi_rockets             = PRVM_ED_FindFieldOffset("ammo_multi_rockets");
1540         prog->fieldoffsets.ammo_nails1                    = PRVM_ED_FindFieldOffset("ammo_nails1");
1541         prog->fieldoffsets.ammo_plasma                    = PRVM_ED_FindFieldOffset("ammo_plasma");
1542         prog->fieldoffsets.ammo_rockets1                  = PRVM_ED_FindFieldOffset("ammo_rockets1");
1543         prog->fieldoffsets.ammo_shells1                   = PRVM_ED_FindFieldOffset("ammo_shells1");
1544         prog->fieldoffsets.angles                         = PRVM_ED_FindFieldOffset("angles");
1545         prog->fieldoffsets.button3                        = PRVM_ED_FindFieldOffset("button3");
1546         prog->fieldoffsets.button4                        = PRVM_ED_FindFieldOffset("button4");
1547         prog->fieldoffsets.button5                        = PRVM_ED_FindFieldOffset("button5");
1548         prog->fieldoffsets.button6                        = PRVM_ED_FindFieldOffset("button6");
1549         prog->fieldoffsets.button7                        = PRVM_ED_FindFieldOffset("button7");
1550         prog->fieldoffsets.button8                        = PRVM_ED_FindFieldOffset("button8");
1551         prog->fieldoffsets.button9                        = PRVM_ED_FindFieldOffset("button9");
1552         prog->fieldoffsets.button10                       = PRVM_ED_FindFieldOffset("button10");
1553         prog->fieldoffsets.button11                       = PRVM_ED_FindFieldOffset("button11");
1554         prog->fieldoffsets.button12                       = PRVM_ED_FindFieldOffset("button12");
1555         prog->fieldoffsets.button13                       = PRVM_ED_FindFieldOffset("button13");
1556         prog->fieldoffsets.button14                       = PRVM_ED_FindFieldOffset("button14");
1557         prog->fieldoffsets.button15                       = PRVM_ED_FindFieldOffset("button15");
1558         prog->fieldoffsets.button16                       = PRVM_ED_FindFieldOffset("button16");
1559         prog->fieldoffsets.buttonchat                     = PRVM_ED_FindFieldOffset("buttonchat");
1560         prog->fieldoffsets.buttonuse                      = PRVM_ED_FindFieldOffset("buttonuse");
1561         prog->fieldoffsets.chain                          = PRVM_ED_FindFieldOffset("chain");
1562         prog->fieldoffsets.classname                      = PRVM_ED_FindFieldOffset("classname");
1563         prog->fieldoffsets.clientcamera                   = PRVM_ED_FindFieldOffset("clientcamera");
1564         prog->fieldoffsets.clientcolors                   = PRVM_ED_FindFieldOffset("clientcolors");
1565         prog->fieldoffsets.clientstatus                   = PRVM_ED_FindFieldOffset("clientstatus");
1566         prog->fieldoffsets.color                          = PRVM_ED_FindFieldOffset("color");
1567         prog->fieldoffsets.colormod                       = PRVM_ED_FindFieldOffset("colormod");
1568         prog->fieldoffsets.contentstransition             = PRVM_ED_FindFieldOffset("contentstransition");
1569         prog->fieldoffsets.cursor_active                  = PRVM_ED_FindFieldOffset("cursor_active");
1570         prog->fieldoffsets.cursor_screen                  = PRVM_ED_FindFieldOffset("cursor_screen");
1571         prog->fieldoffsets.cursor_trace_endpos            = PRVM_ED_FindFieldOffset("cursor_trace_endpos");
1572         prog->fieldoffsets.cursor_trace_ent               = PRVM_ED_FindFieldOffset("cursor_trace_ent");
1573         prog->fieldoffsets.cursor_trace_start             = PRVM_ED_FindFieldOffset("cursor_trace_start");
1574         prog->fieldoffsets.customizeentityforclient       = PRVM_ED_FindFieldOffset("customizeentityforclient");
1575         prog->fieldoffsets.dimension_hit                  = PRVM_ED_FindFieldOffset("dimension_hit");
1576         prog->fieldoffsets.dimension_solid                = PRVM_ED_FindFieldOffset("dimension_solid");
1577         prog->fieldoffsets.disableclientprediction        = PRVM_ED_FindFieldOffset("disableclientprediction");
1578         prog->fieldoffsets.dphitcontentsmask              = PRVM_ED_FindFieldOffset("dphitcontentsmask");
1579         prog->fieldoffsets.drawonlytoclient               = PRVM_ED_FindFieldOffset("drawonlytoclient");
1580         prog->fieldoffsets.exteriormodeltoclient          = PRVM_ED_FindFieldOffset("exteriormodeltoclient");
1581         prog->fieldoffsets.fatness                        = PRVM_ED_FindFieldOffset("fatness");
1582         prog->fieldoffsets.forceshader                    = PRVM_ED_FindFieldOffset("forceshader");
1583         prog->fieldoffsets.frame                          = PRVM_ED_FindFieldOffset("frame");
1584         prog->fieldoffsets.frame1time                     = PRVM_ED_FindFieldOffset("frame1time");
1585         prog->fieldoffsets.frame2                         = PRVM_ED_FindFieldOffset("frame2");
1586         prog->fieldoffsets.frame2time                     = PRVM_ED_FindFieldOffset("frame2time");
1587         prog->fieldoffsets.frame3                         = PRVM_ED_FindFieldOffset("frame3");
1588         prog->fieldoffsets.frame3time                     = PRVM_ED_FindFieldOffset("frame3time");
1589         prog->fieldoffsets.frame4                         = PRVM_ED_FindFieldOffset("frame4");
1590         prog->fieldoffsets.frame4time                     = PRVM_ED_FindFieldOffset("frame4time");
1591         prog->fieldoffsets.fullbright                     = PRVM_ED_FindFieldOffset("fullbright");
1592         prog->fieldoffsets.glow_color                     = PRVM_ED_FindFieldOffset("glow_color");
1593         prog->fieldoffsets.glow_size                      = PRVM_ED_FindFieldOffset("glow_size");
1594         prog->fieldoffsets.glow_trail                     = PRVM_ED_FindFieldOffset("glow_trail");
1595         prog->fieldoffsets.glowmod                        = PRVM_ED_FindFieldOffset("glowmod");
1596         prog->fieldoffsets.gravity                        = PRVM_ED_FindFieldOffset("gravity");
1597         prog->fieldoffsets.groundentity                   = PRVM_ED_FindFieldOffset("groundentity");
1598         prog->fieldoffsets.hull                           = PRVM_ED_FindFieldOffset("hull");
1599         prog->fieldoffsets.ideal_yaw                      = PRVM_ED_FindFieldOffset("ideal_yaw");
1600         prog->fieldoffsets.idealpitch                     = PRVM_ED_FindFieldOffset("idealpitch");
1601         prog->fieldoffsets.items2                         = PRVM_ED_FindFieldOffset("items2");
1602         prog->fieldoffsets.lerpfrac                       = PRVM_ED_FindFieldOffset("lerpfrac");
1603         prog->fieldoffsets.lerpfrac3                      = PRVM_ED_FindFieldOffset("lerpfrac3");
1604         prog->fieldoffsets.lerpfrac4                      = PRVM_ED_FindFieldOffset("lerpfrac4");
1605         prog->fieldoffsets.light_lev                      = PRVM_ED_FindFieldOffset("light_lev");
1606         prog->fieldoffsets.message                        = PRVM_ED_FindFieldOffset("message");
1607         prog->fieldoffsets.modelflags                     = PRVM_ED_FindFieldOffset("modelflags");
1608         prog->fieldoffsets.movement                       = PRVM_ED_FindFieldOffset("movement");
1609         prog->fieldoffsets.movetypesteplandevent          = PRVM_ED_FindFieldOffset("movetypesteplandevent");
1610         prog->fieldoffsets.netaddress                     = PRVM_ED_FindFieldOffset("netaddress");
1611         prog->fieldoffsets.nextthink                      = PRVM_ED_FindFieldOffset("nextthink");
1612         prog->fieldoffsets.nodrawtoclient                 = PRVM_ED_FindFieldOffset("nodrawtoclient");
1613         prog->fieldoffsets.pflags                         = PRVM_ED_FindFieldOffset("pflags");
1614         prog->fieldoffsets.ping                           = PRVM_ED_FindFieldOffset("ping");
1615         prog->fieldoffsets.packetloss                     = PRVM_ED_FindFieldOffset("ping_packetloss");
1616         prog->fieldoffsets.movementloss                   = PRVM_ED_FindFieldOffset("ping_movementloss");
1617         prog->fieldoffsets.pitch_speed                    = PRVM_ED_FindFieldOffset("pitch_speed");
1618         prog->fieldoffsets.playermodel                    = PRVM_ED_FindFieldOffset("playermodel");
1619         prog->fieldoffsets.playerskin                     = PRVM_ED_FindFieldOffset("playerskin");
1620         prog->fieldoffsets.pmodel                         = PRVM_ED_FindFieldOffset("pmodel");
1621         prog->fieldoffsets.punchvector                    = PRVM_ED_FindFieldOffset("punchvector");
1622         prog->fieldoffsets.renderamt                      = PRVM_ED_FindFieldOffset("renderamt"); // HalfLife support
1623         prog->fieldoffsets.renderflags                    = PRVM_ED_FindFieldOffset("renderflags");
1624         prog->fieldoffsets.rendermode                     = PRVM_ED_FindFieldOffset("rendermode"); // HalfLife support
1625         prog->fieldoffsets.scale                          = PRVM_ED_FindFieldOffset("scale");
1626         prog->fieldoffsets.shadertime                     = PRVM_ED_FindFieldOffset("shadertime");
1627         prog->fieldoffsets.skeletonindex                  = PRVM_ED_FindFieldOffset("skeletonindex");
1628         prog->fieldoffsets.style                          = PRVM_ED_FindFieldOffset("style");
1629         prog->fieldoffsets.tag_entity                     = PRVM_ED_FindFieldOffset("tag_entity");
1630         prog->fieldoffsets.tag_index                      = PRVM_ED_FindFieldOffset("tag_index");
1631         prog->fieldoffsets.think                          = PRVM_ED_FindFieldOffset("think");
1632         prog->fieldoffsets.viewmodelforclient             = PRVM_ED_FindFieldOffset("viewmodelforclient");
1633         prog->fieldoffsets.viewzoom                       = PRVM_ED_FindFieldOffset("viewzoom");
1634         prog->fieldoffsets.yaw_speed                      = PRVM_ED_FindFieldOffset("yaw_speed");
1635         prog->fieldoffsets.bouncefactor                   = PRVM_ED_FindFieldOffset("bouncefactor");
1636         prog->fieldoffsets.bouncestop                     = PRVM_ED_FindFieldOffset("bouncestop");
1637
1638         prog->fieldoffsets.solid                          = PRVM_ED_FindFieldOffset("solid");
1639         prog->fieldoffsets.movetype                       = PRVM_ED_FindFieldOffset("movetype");
1640         prog->fieldoffsets.modelindex                     = PRVM_ED_FindFieldOffset("modelindex");
1641         prog->fieldoffsets.mins                           = PRVM_ED_FindFieldOffset("mins");
1642         prog->fieldoffsets.maxs                           = PRVM_ED_FindFieldOffset("maxs");
1643         prog->fieldoffsets.mass                           = PRVM_ED_FindFieldOffset("mass");
1644         prog->fieldoffsets.origin                         = PRVM_ED_FindFieldOffset("origin");
1645         prog->fieldoffsets.velocity                       = PRVM_ED_FindFieldOffset("velocity");
1646         //prog->fieldoffsets.axis_forward                   = PRVM_ED_FindFieldOffset("axis_forward");
1647         //prog->fieldoffsets.axis_left                      = PRVM_ED_FindFieldOffset("axis_left");
1648         //prog->fieldoffsets.axis_up                        = PRVM_ED_FindFieldOffset("axis_up");
1649         //prog->fieldoffsets.spinvelocity                   = PRVM_ED_FindFieldOffset("spinvelocity");
1650         prog->fieldoffsets.angles                         = PRVM_ED_FindFieldOffset("angles");
1651         prog->fieldoffsets.avelocity                      = PRVM_ED_FindFieldOffset("avelocity");
1652         prog->fieldoffsets.aiment                         = PRVM_ED_FindFieldOffset("aiment");
1653         prog->fieldoffsets.enemy                          = PRVM_ED_FindFieldOffset("enemy");
1654         prog->fieldoffsets.jointtype                      = PRVM_ED_FindFieldOffset("jointtype");
1655         prog->fieldoffsets.movedir                        = PRVM_ED_FindFieldOffset("movedir");
1656
1657         prog->fieldoffsets.camera_transform               = PRVM_ED_FindFieldOffset("camera_transform");
1658
1659         prog->funcoffsets.CSQC_ConsoleCommand             = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand");
1660         prog->funcoffsets.CSQC_Ent_Remove                 = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove");
1661         prog->funcoffsets.CSQC_Ent_Spawn                  = PRVM_ED_FindFunctionOffset("CSQC_Ent_Spawn");
1662         prog->funcoffsets.CSQC_Ent_Update                 = PRVM_ED_FindFunctionOffset("CSQC_Ent_Update");
1663         prog->funcoffsets.CSQC_Event                      = PRVM_ED_FindFunctionOffset("CSQC_Event");
1664         prog->funcoffsets.CSQC_Event_Sound                = PRVM_ED_FindFunctionOffset("CSQC_Event_Sound");
1665         prog->funcoffsets.CSQC_Init                       = PRVM_ED_FindFunctionOffset("CSQC_Init");
1666         prog->funcoffsets.CSQC_InputEvent                 = PRVM_ED_FindFunctionOffset("CSQC_InputEvent");
1667         prog->funcoffsets.CSQC_Parse_CenterPrint          = PRVM_ED_FindFunctionOffset("CSQC_Parse_CenterPrint");
1668         prog->funcoffsets.CSQC_Parse_Print                = PRVM_ED_FindFunctionOffset("CSQC_Parse_Print");
1669         prog->funcoffsets.CSQC_Parse_StuffCmd             = PRVM_ED_FindFunctionOffset("CSQC_Parse_StuffCmd");
1670         prog->funcoffsets.CSQC_Parse_TempEntity           = PRVM_ED_FindFunctionOffset("CSQC_Parse_TempEntity");
1671         prog->funcoffsets.CSQC_Shutdown                   = PRVM_ED_FindFunctionOffset("CSQC_Shutdown");
1672         prog->funcoffsets.CSQC_UpdateView                 = PRVM_ED_FindFunctionOffset("CSQC_UpdateView");
1673         prog->funcoffsets.EndFrame                        = PRVM_ED_FindFunctionOffset("EndFrame");
1674         prog->funcoffsets.GameCommand                     = PRVM_ED_FindFunctionOffset("GameCommand");
1675         prog->funcoffsets.Gecko_Query                     = PRVM_ED_FindFunctionOffset("Gecko_Query");
1676         prog->funcoffsets.RestoreGame                     = PRVM_ED_FindFunctionOffset("RestoreGame");
1677         prog->funcoffsets.SV_ChangeTeam                   = PRVM_ED_FindFunctionOffset("SV_ChangeTeam");
1678         prog->funcoffsets.SV_OnEntityNoSpawnFunction      = PRVM_ED_FindFunctionOffset("SV_OnEntityNoSpawnFunction");
1679         prog->funcoffsets.SV_OnEntityPostSpawnFunction    = PRVM_ED_FindFunctionOffset("SV_OnEntityPostSpawnFunction");
1680         prog->funcoffsets.SV_OnEntityPreSpawnFunction     = PRVM_ED_FindFunctionOffset("SV_OnEntityPreSpawnFunction");
1681         prog->funcoffsets.SV_ParseClientCommand           = PRVM_ED_FindFunctionOffset("SV_ParseClientCommand");
1682         prog->funcoffsets.SV_PausedTic                    = PRVM_ED_FindFunctionOffset("SV_PausedTic");
1683         prog->funcoffsets.SV_PlayerPhysics                = PRVM_ED_FindFunctionOffset("SV_PlayerPhysics");
1684         prog->funcoffsets.SV_Shutdown                     = PRVM_ED_FindFunctionOffset("SV_Shutdown");
1685         prog->funcoffsets.URI_Get_Callback                = PRVM_ED_FindFunctionOffset("URI_Get_Callback");
1686         prog->globaloffsets.SV_InitCmd                    = PRVM_ED_FindGlobalOffset("SV_InitCmd");
1687         prog->globaloffsets.coop                          = PRVM_ED_FindGlobalOffset("coop");
1688         prog->globaloffsets.deathmatch                    = PRVM_ED_FindGlobalOffset("deathmatch");
1689         prog->globaloffsets.dmg_origin                    = PRVM_ED_FindGlobalOffset("dmg_origin");
1690         prog->globaloffsets.dmg_save                      = PRVM_ED_FindGlobalOffset("dmg_save");
1691         prog->globaloffsets.dmg_take                      = PRVM_ED_FindGlobalOffset("dmg_take");
1692         prog->globaloffsets.drawfont                      = PRVM_ED_FindGlobalOffset("drawfont");
1693         prog->globaloffsets.drawfontscale                 = PRVM_ED_FindGlobalOffset("drawfontscale");
1694         prog->globaloffsets.gettaginfo_forward            = PRVM_ED_FindGlobalOffset("gettaginfo_forward");
1695         prog->globaloffsets.gettaginfo_name               = PRVM_ED_FindGlobalOffset("gettaginfo_name");
1696         prog->globaloffsets.gettaginfo_offset             = PRVM_ED_FindGlobalOffset("gettaginfo_offset");
1697         prog->globaloffsets.gettaginfo_parent             = PRVM_ED_FindGlobalOffset("gettaginfo_parent");
1698         prog->globaloffsets.gettaginfo_right              = PRVM_ED_FindGlobalOffset("gettaginfo_right");
1699         prog->globaloffsets.gettaginfo_up                 = PRVM_ED_FindGlobalOffset("gettaginfo_up");
1700         prog->globaloffsets.transparent_offset            = PRVM_ED_FindGlobalOffset("transparent_offset");
1701         prog->globaloffsets.intermission                  = PRVM_ED_FindGlobalOffset("intermission");
1702         prog->globaloffsets.require_spawnfunc_prefix      = PRVM_ED_FindGlobalOffset("require_spawnfunc_prefix");
1703         prog->globaloffsets.sb_showscores                 = PRVM_ED_FindGlobalOffset("sb_showscores");
1704         prog->globaloffsets.self                          = PRVM_ED_FindGlobalOffset("self");
1705         prog->globaloffsets.serverdeltatime               = PRVM_ED_FindGlobalOffset("serverdeltatime");
1706         prog->globaloffsets.serverprevtime                = PRVM_ED_FindGlobalOffset("serverprevtime");
1707         prog->globaloffsets.servertime                    = PRVM_ED_FindGlobalOffset("servertime");
1708         prog->globaloffsets.time                          = PRVM_ED_FindGlobalOffset("time");
1709         prog->globaloffsets.trace_allsolid                = PRVM_ED_FindGlobalOffset("trace_allsolid");
1710         prog->globaloffsets.trace_dphitcontents           = PRVM_ED_FindGlobalOffset("trace_dphitcontents");
1711         prog->globaloffsets.trace_dphitq3surfaceflags     = PRVM_ED_FindGlobalOffset("trace_dphitq3surfaceflags");
1712         prog->globaloffsets.trace_dphittexturename        = PRVM_ED_FindGlobalOffset("trace_dphittexturename");
1713         prog->globaloffsets.trace_dpstartcontents         = PRVM_ED_FindGlobalOffset("trace_dpstartcontents");
1714         prog->globaloffsets.trace_endpos                  = PRVM_ED_FindGlobalOffset("trace_endpos");
1715         prog->globaloffsets.trace_ent                     = PRVM_ED_FindGlobalOffset("trace_ent");
1716         prog->globaloffsets.trace_fraction                = PRVM_ED_FindGlobalOffset("trace_fraction");
1717         prog->globaloffsets.trace_inopen                  = PRVM_ED_FindGlobalOffset("trace_inopen");
1718         prog->globaloffsets.trace_inwater                 = PRVM_ED_FindGlobalOffset("trace_inwater");
1719         prog->globaloffsets.trace_networkentity           = PRVM_ED_FindGlobalOffset("trace_networkentity");
1720         prog->globaloffsets.trace_plane_dist              = PRVM_ED_FindGlobalOffset("trace_plane_dist");
1721         prog->globaloffsets.trace_plane_normal            = PRVM_ED_FindGlobalOffset("trace_plane_normal");
1722         prog->globaloffsets.trace_startsolid              = PRVM_ED_FindGlobalOffset("trace_startsolid");
1723         prog->globaloffsets.v_forward                     = PRVM_ED_FindGlobalOffset("v_forward");
1724         prog->globaloffsets.v_right                       = PRVM_ED_FindGlobalOffset("v_right");
1725         prog->globaloffsets.v_up                          = PRVM_ED_FindGlobalOffset("v_up");
1726         prog->globaloffsets.view_angles                   = PRVM_ED_FindGlobalOffset("view_angles");
1727         prog->globaloffsets.worldstatus                   = PRVM_ED_FindGlobalOffset("worldstatus");
1728
1729         // menu qc only uses some functions, nothing else
1730         prog->funcoffsets.m_draw                          = PRVM_ED_FindFunctionOffset("m_draw");
1731         prog->funcoffsets.m_init                          = PRVM_ED_FindFunctionOffset("m_init");
1732         prog->funcoffsets.m_keydown                       = PRVM_ED_FindFunctionOffset("m_keydown");
1733         prog->funcoffsets.m_keyup                         = PRVM_ED_FindFunctionOffset("m_keyup");
1734         prog->funcoffsets.m_shutdown                      = PRVM_ED_FindFunctionOffset("m_shutdown");
1735         prog->funcoffsets.m_toggle                        = PRVM_ED_FindFunctionOffset("m_toggle");
1736 }
1737
1738 // not used
1739 /*
1740 typedef struct dpfield_s
1741 {
1742         int type;
1743         char *string;
1744 }
1745 dpfield_t;
1746
1747 #define DPFIELDS (sizeof(dpfields) / sizeof(dpfield_t))
1748
1749 dpfield_t dpfields[] =
1750 {
1751 };
1752 */
1753
1754 /*
1755 ===============
1756 PRVM_ResetProg
1757 ===============
1758 */
1759
1760 #define PO_HASHSIZE 16384
1761 typedef struct po_string_s
1762 {
1763         char *key, *value;
1764         struct po_string_s *nextonhashchain;
1765 }
1766 po_string_t;
1767 typedef struct po_s
1768 {
1769         po_string_t *hashtable[PO_HASHSIZE];
1770 }
1771 po_t;
1772 void PRVM_PO_UnparseString(char *out, const char *in, size_t outsize)
1773 {
1774         for(;;)
1775         {
1776                 switch(*in)
1777                 {
1778                         case 0:
1779                                 *out++ = 0;
1780                                 return;
1781                         case '\a': if(outsize >= 2) { *out++ = '\\'; *out++ = 'a'; outsize -= 2; } break;
1782                         case '\b': if(outsize >= 2) { *out++ = '\\'; *out++ = 'b'; outsize -= 2; } break;
1783                         case '\t': if(outsize >= 2) { *out++ = '\\'; *out++ = 't'; outsize -= 2; } break;
1784                         case '\r': if(outsize >= 2) { *out++ = '\\'; *out++ = 'r'; outsize -= 2; } break;
1785                         case '\n': if(outsize >= 2) { *out++ = '\\'; *out++ = 'n'; outsize -= 2; } break;
1786                         case '\\': if(outsize >= 2) { *out++ = '\\'; *out++ = '\\'; outsize -= 2; } break;
1787                         case '"': if(outsize >= 2) { *out++ = '\\'; *out++ = '"'; outsize -= 2; } break;
1788                         default:
1789                                 if(*in >= 0 && *in <= 0x1F)
1790                                 {
1791                                         if(outsize >= 4)
1792                                         {
1793                                                 *out++ = '\\';
1794                                                 *out++ = '0' + ((*in & 0700) >> 6);
1795                                                 *out++ = '0' + ((*in & 0070) >> 3);
1796                                                 *out++ = '0' + ((*in & 0007));
1797                                                 outsize -= 4;
1798                                         }
1799                                 }
1800                                 else
1801                                 {
1802                                         if(outsize >= 1)
1803                                         {
1804                                                 *out++ = *in;
1805                                                 outsize -= 1;
1806                                         }
1807                                 }
1808                                 break;
1809                 }
1810                 ++in;
1811         }
1812 }
1813 void PRVM_PO_ParseString(char *out, const char *in, size_t outsize)
1814 {
1815         for(;;)
1816         {
1817                 switch(*in)
1818                 {
1819                         case 0:
1820                                 *out++ = 0;
1821                                 return;
1822                         case '\\':
1823                                 ++in;
1824                                 switch(*in)
1825                                 {
1826                                         case 'a': if(outsize > 0) { *out++ = '\a'; --outsize; } break;
1827                                         case 'b': if(outsize > 0) { *out++ = '\b'; --outsize; } break;
1828                                         case 't': if(outsize > 0) { *out++ = '\t'; --outsize; } break;
1829                                         case 'r': if(outsize > 0) { *out++ = '\r'; --outsize; } break;
1830                                         case 'n': if(outsize > 0) { *out++ = '\n'; --outsize; } break;
1831                                         case '\\': if(outsize > 0) { *out++ = '\\'; --outsize; } break;
1832                                         case '"': if(outsize > 0) { *out++ = '"'; --outsize; } break;
1833                                         case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
1834                                                 if(outsize > 0) 
1835                                                         *out = *in - '0';
1836                                                 ++in;
1837                                                 if(*in >= '0' && *in <= '7')
1838                                                 {
1839                                                         if(outsize > 0)
1840                                                                 *out = (*out << 3) | (*in - '0');
1841                                                         ++in;
1842                                                 }
1843                                                 if(*in >= '0' && *in <= '7')
1844                                                 {
1845                                                         if(outsize > 0)
1846                                                                 *out = (*out << 3) | (*in - '0');
1847                                                         ++in;
1848                                                 }
1849                                                 --in;
1850                                                 if(outsize > 0)
1851                                                 {
1852                                                         ++out;
1853                                                         --outsize;
1854                                                 }
1855                                                 break;
1856                                         default:
1857                                                 if(outsize > 0) { *out++ = *in; --outsize; }
1858                                                 break;
1859                                 }
1860                                 break;
1861                         default:
1862                                 if(outsize > 0)
1863                                 {
1864                                         *out++ = *in;
1865                                         --outsize;
1866                                 }
1867                                 break;
1868                 }
1869                 ++in;
1870         }
1871 }
1872 po_t *PRVM_PO_Load(const char *filename, mempool_t *pool)
1873 {
1874         po_t *po;
1875         const char *p, *q;
1876         int mode;
1877         char inbuf[MAX_INPUTLINE];
1878         char decodedbuf[MAX_INPUTLINE];
1879         size_t decodedpos;
1880         int hashindex;
1881         po_string_t thisstr;
1882         const char *buf = (const char *) FS_LoadFile(filename, pool, true, NULL);
1883
1884         if(!buf)
1885                 return NULL;
1886
1887         po = Mem_Alloc(pool, sizeof(*po));
1888         memset(po, 0, sizeof(*po));
1889
1890         p = buf;
1891         while(*p)
1892         {
1893                 if(*p == '#')
1894                 {
1895                         // skip to newline
1896                         p = strchr(p, '\n');
1897                         if(!p)
1898                                 break;
1899                         ++p;
1900                         continue;
1901                 }
1902                 if(*p == '\r' || *p == '\n')
1903                 {
1904                         ++p;
1905                         continue;
1906                 }
1907                 if(!strncmp(p, "msgid \"", 7))
1908                 {
1909                         mode = 0;
1910                         p += 6;
1911                 }
1912                 else if(!strncmp(p, "msgstr \"", 8))
1913                 {
1914                         mode = 1;
1915                         p += 7;
1916                 }
1917                 else
1918                 {
1919                         p = strchr(p, '\n');
1920                         if(!p)
1921                                 break;
1922                         ++p;
1923                         continue;
1924                 }
1925                 decodedpos = 0;
1926                 while(*p == '"')
1927                 {
1928                         ++p;
1929                         q = strchr(p, '\n');
1930                         if(!q)
1931                                 break;
1932                         if(*(q-1) == '\r')
1933                                 --q;
1934                         if(*(q-1) != '"')
1935                                 break;
1936                         if((size_t)(q - p) >= (size_t) sizeof(inbuf))
1937                                 break;
1938                         strlcpy(inbuf, p, q - p); // not - 1, because this adds a NUL
1939                         PRVM_PO_ParseString(decodedbuf + decodedpos, inbuf, sizeof(decodedbuf) - decodedpos);
1940                         decodedpos += strlen(decodedbuf + decodedpos);
1941                         if(*q == '\r')
1942                                 ++q;
1943                         if(*q == '\n')
1944                                 ++q;
1945                         p = q;
1946                 }
1947                 if(mode == 0)
1948                 {
1949                         if(thisstr.key)
1950                                 Mem_Free(thisstr.key);
1951                         thisstr.key = Mem_Alloc(pool, decodedpos + 1);
1952                         memcpy(thisstr.key, decodedbuf, decodedpos + 1);
1953                 }
1954                 else if(decodedpos > 0 && thisstr.key) // skip empty translation results
1955                 {
1956                         thisstr.value = Mem_Alloc(pool, decodedpos + 1);
1957                         memcpy(thisstr.value, decodedbuf, decodedpos + 1);
1958                         hashindex = CRC_Block((const unsigned char *) thisstr.key, strlen(thisstr.key)) % PO_HASHSIZE;
1959                         thisstr.nextonhashchain = po->hashtable[hashindex];
1960                         po->hashtable[hashindex] = Mem_Alloc(pool, sizeof(thisstr));
1961                         memcpy(po->hashtable[hashindex], &thisstr, sizeof(thisstr));
1962                         memset(&thisstr, 0, sizeof(thisstr));
1963                 }
1964         }
1965         
1966         Mem_Free((char *) buf);
1967         return po;
1968 }
1969 const char *PRVM_PO_Lookup(po_t *po, const char *str)
1970 {
1971         int hashindex = CRC_Block((const unsigned char *) str, strlen(str)) % PO_HASHSIZE;
1972         po_string_t *p = po->hashtable[hashindex];
1973         while(p)
1974         {
1975                 if(!strcmp(str, p->key))
1976                         return p->value;
1977                 p = p->nextonhashchain;
1978         }
1979         return NULL;
1980 }
1981 void PRVM_PO_Destroy(po_t *po)
1982 {
1983         int i;
1984         for(i = 0; i < PO_HASHSIZE; ++i)
1985         {
1986                 po_string_t *p = po->hashtable[i];
1987                 while(p)
1988                 {
1989                         po_string_t *q = p;
1990                         p = p->nextonhashchain;
1991                         Mem_Free(q->key);
1992                         Mem_Free(q->value);
1993                         Mem_Free(q);
1994                 }
1995         }
1996         Mem_Free(po);
1997 }
1998
1999 void PRVM_LeakTest(void);
2000 void PRVM_ResetProg(void)
2001 {
2002         PRVM_LeakTest();
2003         PRVM_GCALL(reset_cmd)();
2004         Mem_FreePool(&prog->progs_mempool);
2005         if(prog->po)
2006                 PRVM_PO_Destroy((po_t *) prog->po);
2007         memset(prog,0,sizeof(prvm_prog_t));
2008         prog->starttime = Sys_DoubleTime();
2009 }
2010
2011 /*
2012 ===============
2013 PRVM_LoadLNO
2014 ===============
2015 */
2016 void PRVM_LoadLNO( const char *progname ) {
2017         fs_offset_t filesize;
2018         unsigned char *lno;
2019         unsigned int *header;
2020         char filename[512];
2021
2022         FS_StripExtension( progname, filename, sizeof( filename ) );
2023         strlcat( filename, ".lno", sizeof( filename ) );
2024
2025         lno = FS_LoadFile( filename, tempmempool, false, &filesize );
2026         if( !lno ) {
2027                 return;
2028         }
2029
2030 /*
2031 <Spike>    SafeWrite (h, &lnotype, sizeof(int));
2032 <Spike>    SafeWrite (h, &version, sizeof(int));
2033 <Spike>    SafeWrite (h, &numglobaldefs, sizeof(int));
2034 <Spike>    SafeWrite (h, &numpr_globals, sizeof(int));
2035 <Spike>    SafeWrite (h, &numfielddefs, sizeof(int));
2036 <Spike>    SafeWrite (h, &numstatements, sizeof(int));
2037 <Spike>    SafeWrite (h, statement_linenums, numstatements*sizeof(int));
2038 */
2039         if( (unsigned) filesize < (6 + prog->progs->numstatements) * sizeof( int ) ) {
2040                 Mem_Free(lno);
2041                 return;
2042         }
2043
2044         header = (unsigned int *) lno;
2045         if( header[ 0 ] == *(unsigned int *) "LNOF" &&
2046                 LittleLong( header[ 1 ] ) == 1 &&
2047                 (unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs->numglobaldefs &&
2048                 (unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs->numglobals &&
2049                 (unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs->numfielddefs &&
2050                 (unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs->numstatements )
2051         {
2052                 prog->statement_linenums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof( int ) );
2053                 memcpy( prog->statement_linenums, (int *) lno + 6, prog->progs->numstatements * sizeof( int ) );
2054         }
2055         Mem_Free( lno );
2056 }
2057
2058 /*
2059 ===============
2060 PRVM_LoadProgs
2061 ===============
2062 */
2063 void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global)
2064 {
2065         int i;
2066         dstatement_t *st;
2067         ddef_t *infielddefs;
2068         dfunction_t *dfunctions;
2069         fs_offset_t filesize;
2070
2071         if( prog->loaded ) {
2072                 PRVM_ERROR ("PRVM_LoadProgs: there is already a %s program loaded!", PRVM_NAME );
2073         }
2074
2075         prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
2076         if (prog->progs == NULL || filesize < (fs_offset_t)sizeof(dprograms_t))
2077                 PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME);
2078         // TODO bounds check header fields (e.g. numstatements), they must never go behind end of file
2079
2080         Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024));
2081
2082         prog->filecrc = CRC_Block((unsigned char *)prog->progs, filesize);
2083
2084 // byte swap the header
2085         for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++)
2086                 ((int *)prog->progs)[i] = LittleLong ( ((int *)prog->progs)[i] );
2087
2088         if (prog->progs->version != PROG_VERSION)
2089                 PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs->version, PROG_VERSION);
2090         if (prog->progs->crc != prog->headercrc && prog->progs->crc != prog->headercrc2)
2091                 PRVM_ERROR ("%s: %s system vars have been modified (CRC of progs.dat systemvars %i != engine %i), progdefs.h is out of date", PRVM_NAME, filename, prog->progs->crc, prog->headercrc);
2092
2093         //prog->functions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions);
2094         dfunctions = (dfunction_t *)((unsigned char *)prog->progs + prog->progs->ofs_functions);
2095
2096         if (prog->progs->ofs_strings + prog->progs->numstrings >= (int)filesize)
2097                 PRVM_ERROR ("%s: %s strings go past end of file", PRVM_NAME, filename);
2098         prog->strings = (char *)prog->progs + prog->progs->ofs_strings;
2099         prog->stringssize = prog->progs->numstrings;
2100
2101         prog->numknownstrings = 0;
2102         prog->maxknownstrings = 0;
2103         prog->knownstrings = NULL;
2104         prog->knownstrings_freeable = NULL;
2105
2106         Mem_ExpandableArray_NewArray(&prog->stringbuffersarray, prog->progs_mempool, sizeof(prvm_stringbuffer_t), 64);
2107
2108         prog->globaldefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_globaldefs);
2109
2110         // we need to expand the fielddefs list to include all the engine fields,
2111         // so allocate a new place for it
2112         infielddefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_fielddefs);
2113         //                                                                                              ( + DPFIELDS                       )
2114         prog->fielddefs = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t));
2115
2116         prog->statements = (dstatement_t *)((unsigned char *)prog->progs + prog->progs->ofs_statements);
2117
2118         prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof(*prog->statement_profile));
2119
2120         //pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals);
2121         prog->globals.generic = (float *)((unsigned char *)prog->progs + prog->progs->ofs_globals);
2122
2123 // byte swap the lumps
2124         for (i=0 ; i<prog->progs->numstatements ; i++)
2125         {
2126                 prog->statements[i].op = LittleShort(prog->statements[i].op);
2127                 prog->statements[i].a = LittleShort(prog->statements[i].a);
2128                 prog->statements[i].b = LittleShort(prog->statements[i].b);
2129                 prog->statements[i].c = LittleShort(prog->statements[i].c);
2130         }
2131
2132         prog->functions = (mfunction_t *)Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions);
2133         for (i = 0;i < prog->progs->numfunctions;i++)
2134         {
2135                 prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
2136                 prog->functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
2137                 prog->functions[i].s_name = LittleLong (dfunctions[i].s_name);
2138                 prog->functions[i].s_file = LittleLong (dfunctions[i].s_file);
2139                 prog->functions[i].numparms = LittleLong (dfunctions[i].numparms);
2140                 prog->functions[i].locals = LittleLong (dfunctions[i].locals);
2141                 memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
2142                 if(prog->functions[i].first_statement >= prog->progs->numstatements)
2143                         PRVM_ERROR("PRVM_LoadProgs: out of bounds function statement (function %d) in %s", i, PRVM_NAME);
2144                 // TODO bounds check parm_start, s_name, s_file, numparms, locals, parm_size
2145         }
2146
2147         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
2148         {
2149                 prog->globaldefs[i].type = LittleShort (prog->globaldefs[i].type);
2150                 prog->globaldefs[i].ofs = LittleShort (prog->globaldefs[i].ofs);
2151                 prog->globaldefs[i].s_name = LittleLong (prog->globaldefs[i].s_name);
2152                 // TODO bounds check ofs, s_name
2153         }
2154
2155         // copy the progs fields to the new fields list
2156         for (i = 0;i < prog->progs->numfielddefs;i++)
2157         {
2158                 prog->fielddefs[i].type = LittleShort (infielddefs[i].type);
2159                 if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
2160                         PRVM_ERROR ("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", PRVM_NAME);
2161                 prog->fielddefs[i].ofs = LittleShort (infielddefs[i].ofs);
2162                 prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
2163                 // TODO bounds check ofs, s_name
2164         }
2165
2166         // append the required fields
2167         for (i = 0;i < (int) numrequiredfields;i++)
2168         {
2169                 prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type;
2170                 prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields;
2171                 prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name);
2172                 // TODO bounds check ofs, s_name
2173                 if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector)
2174                         prog->progs->entityfields += 3;
2175                 else
2176                         prog->progs->entityfields++;
2177                 prog->progs->numfielddefs++;
2178         }
2179         prog->entityfields = prog->progs->entityfields;
2180
2181         // check required functions
2182         for(i=0 ; i < numrequiredfunc ; i++)
2183                 if(PRVM_ED_FindFunction(required_func[i]) == 0)
2184                         PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_func[i], filename);
2185
2186         // check required globals
2187         for(i=0 ; i < numrequiredglobals ; i++)
2188                 if(PRVM_ED_FindGlobal(required_global[i]) == 0)
2189                         PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_global[i], filename);
2190
2191         for (i=0 ; i<prog->progs->numglobals ; i++)
2192                 ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]);
2193
2194         // LordHavoc: bounds check anything static
2195         for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++)
2196         {
2197                 switch (st->op)
2198                 {
2199                 case OP_IF:
2200                 case OP_IFNOT:
2201                         if ((unsigned short) st->a >= prog->progs->numglobals || st->b + i < 0 || st->b + i >= prog->progs->numstatements)
2202                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s", i, PRVM_NAME);
2203                         break;
2204                 case OP_GOTO:
2205                         if (st->a + i < 0 || st->a + i >= prog->progs->numstatements)
2206                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s", i, PRVM_NAME);
2207                         break;
2208                 // global global global
2209                 case OP_ADD_F:
2210                 case OP_ADD_V:
2211                 case OP_SUB_F:
2212                 case OP_SUB_V:
2213                 case OP_MUL_F:
2214                 case OP_MUL_V:
2215                 case OP_MUL_FV:
2216                 case OP_MUL_VF:
2217                 case OP_DIV_F:
2218                 case OP_BITAND:
2219                 case OP_BITOR:
2220                 case OP_GE:
2221                 case OP_LE:
2222                 case OP_GT:
2223                 case OP_LT:
2224                 case OP_AND:
2225                 case OP_OR:
2226                 case OP_EQ_F:
2227                 case OP_EQ_V:
2228                 case OP_EQ_S:
2229                 case OP_EQ_E:
2230                 case OP_EQ_FNC:
2231                 case OP_NE_F:
2232                 case OP_NE_V:
2233                 case OP_NE_S:
2234                 case OP_NE_E:
2235                 case OP_NE_FNC:
2236                 case OP_ADDRESS:
2237                 case OP_LOAD_F:
2238                 case OP_LOAD_FLD:
2239                 case OP_LOAD_ENT:
2240                 case OP_LOAD_S:
2241                 case OP_LOAD_FNC:
2242                 case OP_LOAD_V:
2243                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
2244                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)", i);
2245                         break;
2246                 // global none global
2247                 case OP_NOT_F:
2248                 case OP_NOT_V:
2249                 case OP_NOT_S:
2250                 case OP_NOT_FNC:
2251                 case OP_NOT_ENT:
2252                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
2253                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
2254                         break;
2255                 // 2 globals
2256                 case OP_STOREP_F:
2257                 case OP_STOREP_ENT:
2258                 case OP_STOREP_FLD:
2259                 case OP_STOREP_S:
2260                 case OP_STOREP_FNC:
2261                 case OP_STORE_F:
2262                 case OP_STORE_ENT:
2263                 case OP_STORE_FLD:
2264                 case OP_STORE_S:
2265                 case OP_STORE_FNC:
2266                 case OP_STATE:
2267                 case OP_STOREP_V:
2268                 case OP_STORE_V:
2269                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals)
2270                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
2271                         break;
2272                 // 1 global
2273                 case OP_CALL0:
2274                 case OP_CALL1:
2275                 case OP_CALL2:
2276                 case OP_CALL3:
2277                 case OP_CALL4:
2278                 case OP_CALL5:
2279                 case OP_CALL6:
2280                 case OP_CALL7:
2281                 case OP_CALL8:
2282                 case OP_DONE:
2283                 case OP_RETURN:
2284                         if ((unsigned short) st->a >= prog->progs->numglobals)
2285                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
2286                         break;
2287                 default:
2288                         Con_DPrintf("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", st->op, i, PRVM_NAME);
2289                         break;
2290                 }
2291         }
2292         if(prog->progs->numstatements < 1)
2293         {
2294                 PRVM_ERROR("PRVM_LoadProgs: empty program in %s", PRVM_NAME);
2295         }
2296         else switch(prog->statements[prog->progs->numstatements - 1].op)
2297         {
2298                 case OP_RETURN:
2299                 case OP_GOTO:
2300                 case OP_DONE:
2301                         break;
2302                 default:
2303                         PRVM_ERROR("PRVM_LoadProgs: program may fall off the edge (does not end with RETURN, GOTO or DONE) in %s", PRVM_NAME);
2304                         break;
2305         }
2306
2307         PRVM_LoadLNO(filename);
2308
2309         PRVM_Init_Exec();
2310
2311         if(*prvm_language.string)
2312         // in CSQC we really shouldn't be able to change how stuff works... sorry for now
2313         // later idea: include a list of authorized .po file checksums with the csprogs
2314         {
2315                 qboolean deftrans = !!strcmp(PRVM_NAME, "client");
2316                 if(!strcmp(prvm_language.string, "dump"))
2317                 {
2318                         qfile_t *f = FS_OpenRealFile(va("%s.%s.po", filename, prvm_language.string), "w", false);
2319                         Con_Printf("Dumping to %s.%s.po\n", filename, prvm_language.string);
2320                         if(f)
2321                         {
2322                                 for (i=0 ; i<prog->progs->numglobaldefs ; i++)
2323                                 {
2324                                         const char *name;
2325                                         name = PRVM_GetString(prog->globaldefs[i].s_name);
2326                                         if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12)))
2327                                         if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
2328                                         {
2329                                                 prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs);
2330                                                 const char *value = PRVM_GetString(val->string);
2331                                                 if(*value)
2332                                                 {
2333                                                         char buf[MAX_INPUTLINE];
2334                                                         PRVM_PO_UnparseString(buf, value, sizeof(buf));
2335                                                         FS_Printf(f, "msgid \"%s\"\nmsgstr \"\"\n\n", buf);
2336                                                 }
2337                                         }
2338                                 }
2339                                 FS_Close(f);
2340                         }
2341                 }
2342                 else
2343                 {
2344                         po_t *po = PRVM_PO_Load(va("%s.%s.po", filename, prvm_language.string), prog->progs_mempool);
2345                         if(po)
2346                         {
2347                                 for (i=0 ; i<prog->progs->numglobaldefs ; i++)
2348                                 {
2349                                         const char *name;
2350                                         name = PRVM_GetString(prog->globaldefs[i].s_name);
2351                                         if(deftrans ? (!name || strncmp(name, "notranslate_", 12)) : (name && !strncmp(name, "dotranslate_", 12)))
2352                                         if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
2353                                         {
2354                                                 prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs);
2355                                                 const char *value = PRVM_GetString(val->string);
2356                                                 if(*value)
2357                                                 {
2358                                                         value = PRVM_PO_Lookup(po, value);
2359                                                         if(value)
2360                                                                 val->string = PRVM_SetEngineString(value);
2361                                                 }
2362                                         }
2363                                 }
2364                         }
2365                 }
2366         }
2367
2368         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
2369         {
2370                 const char *name;
2371                 name = PRVM_GetString(prog->globaldefs[i].s_name);
2372                 //Con_Printf("found var %s\n", name);
2373                 if(name
2374                         && !strncmp(name, "autocvar_", 9)
2375                         && !(strlen(name) > 1 && name[strlen(name)-2] == '_' && (name[strlen(name)-1] == 'x' || name[strlen(name)-1] == 'y' || name[strlen(name)-1] == 'z'))
2376                 )
2377                 {
2378                         prvm_eval_t *val = (prvm_eval_t *)(prog->globals.generic + prog->globaldefs[i].ofs);
2379                         cvar_t *cvar = Cvar_FindVar(name + 9);
2380                         //Con_Printf("PRVM_LoadProgs: autocvar global %s in %s, processing...\n", name, PRVM_NAME);
2381                         if(!cvar)
2382                         {
2383                                 const char *value;
2384                                 char buf[64];
2385                                 Con_Printf("PRVM_LoadProgs: no cvar for autocvar global %s in %s, creating...\n", name, PRVM_NAME);
2386                                 switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
2387                                 {
2388                                         case ev_float:
2389                                                 if((float)((int)(val->_float)) == val->_float)
2390                                                         dpsnprintf(buf, sizeof(buf), "%i", (int)(val->_float));
2391                                                 else
2392                                                         dpsnprintf(buf, sizeof(buf), "%.9g", val->_float);
2393                                                 value = buf;
2394                                                 break;
2395                                         case ev_vector:
2396                                                 dpsnprintf(buf, sizeof(buf), "%.9g %.9g %.9g", val->vector[0], val->vector[1], val->vector[2]); value = buf;
2397                                                 break;
2398                                         case ev_string:
2399                                                 value = PRVM_GetString(val->string);
2400                                                 break;
2401                                         default:
2402                                                 Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, PRVM_NAME);
2403                                                 goto fail;
2404                                 }
2405                                 cvar = Cvar_Get(name + 9, value, 0, NULL);
2406                                 if((prog->globaldefs[i].type & ~DEF_SAVEGLOBAL) == ev_string)
2407                                 {
2408                                         val->string = PRVM_SetEngineString(cvar->string);
2409                                         cvar->globaldefindex_stringno[prog - prog_list] = val->string;
2410                                 }
2411                                 if(!cvar)
2412                                         PRVM_ERROR("PRVM_LoadProgs: could not create cvar for autocvar global %s in %s", name, PRVM_NAME);
2413                                 cvar->globaldefindex_progid[prog - prog_list] = prog->id;
2414                                 cvar->globaldefindex[prog - prog_list] = i;
2415                         }
2416                         else if((cvar->flags & CVAR_PRIVATE) == 0)
2417                         {
2418                                 // MUST BE SYNCED WITH cvar.c Cvar_Set
2419                                 int j;
2420                                 const char *s;
2421                                 switch(prog->globaldefs[i].type & ~DEF_SAVEGLOBAL)
2422                                 {
2423                                         case ev_float:
2424                                                 val->_float = cvar->value;
2425                                                 break;
2426                                         case ev_vector:
2427                                                 s = cvar->string;
2428                                                 VectorClear(val->vector);
2429                                                 for (j = 0;j < 3;j++)
2430                                                 {
2431                                                         while (*s && ISWHITESPACE(*s))
2432                                                                 s++;
2433                                                         if (!*s)
2434                                                                 break;
2435                                                         val->vector[j] = atof(s);
2436                                                         while (!ISWHITESPACE(*s))
2437                                                                 s++;
2438                                                         if (!*s)
2439                                                                 break;
2440                                                 }
2441                                                 break;
2442                                         case ev_string:
2443                                                 val->string = PRVM_SetEngineString(cvar->string);
2444                                                 cvar->globaldefindex_stringno[prog - prog_list] = val->string;
2445                                                 break;
2446                                         default:
2447                                                 Con_Printf("PRVM_LoadProgs: invalid type of autocvar global %s in %s\n", name, PRVM_NAME);
2448                                                 goto fail;
2449                                 }
2450                                 cvar->globaldefindex_progid[prog - prog_list] = prog->id;
2451                                 cvar->globaldefindex[prog - prog_list] = i;
2452                         }
2453                         else
2454                                 Con_Printf("PRVM_LoadProgs: private cvar for autocvar global %s in %s\n", name, PRVM_NAME);
2455                 }
2456 fail:
2457                 ;
2458         }
2459
2460         prog->loaded = TRUE;
2461
2462         // set flags & ddef_ts in prog
2463
2464         prog->flag = 0;
2465
2466         PRVM_FindOffsets();
2467
2468         PRVM_GCALL(init_cmd)();
2469
2470         // init mempools
2471         PRVM_MEM_Alloc();
2472 }
2473
2474
2475 void PRVM_Fields_f (void)
2476 {
2477         int i, j, ednum, used, usedamount;
2478         int *counts;
2479         char tempstring[MAX_INPUTLINE], tempstring2[260];
2480         const char *name;
2481         prvm_edict_t *ed;
2482         ddef_t *d;
2483         int *v;
2484
2485         // TODO
2486         /*
2487         if (!sv.active)
2488         {
2489                 Con_Print("no progs loaded\n");
2490                 return;
2491         }
2492         */
2493
2494         if(Cmd_Argc() != 2)
2495         {
2496                 Con_Print("prvm_fields <program name>\n");
2497                 return;
2498         }
2499
2500         PRVM_Begin;
2501         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
2502                 return;
2503
2504         counts = (int *)Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int));
2505         for (ednum = 0;ednum < prog->max_edicts;ednum++)
2506         {
2507                 ed = PRVM_EDICT_NUM(ednum);
2508                 if (ed->priv.required->free)
2509                         continue;
2510                 for (i = 1;i < prog->progs->numfielddefs;i++)
2511                 {
2512                         d = &prog->fielddefs[i];
2513                         name = PRVM_GetString(d->s_name);
2514                         if (name[strlen(name)-2] == '_')
2515                                 continue;       // skip _x, _y, _z vars
2516                         v = (int *)(ed->fields.vp + d->ofs);
2517                         // if the value is still all 0, skip the field
2518                         for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
2519                         {
2520                                 if (v[j])
2521                                 {
2522                                         counts[i]++;
2523                                         break;
2524                                 }
2525                         }
2526                 }
2527         }
2528         used = 0;
2529         usedamount = 0;
2530         tempstring[0] = 0;
2531         for (i = 0;i < prog->progs->numfielddefs;i++)
2532         {
2533                 d = &prog->fielddefs[i];
2534                 name = PRVM_GetString(d->s_name);
2535                 if (name[strlen(name)-2] == '_')
2536                         continue;       // skip _x, _y, _z vars
2537                 switch(d->type & ~DEF_SAVEGLOBAL)
2538                 {
2539                 case ev_string:
2540                         strlcat(tempstring, "string   ", sizeof(tempstring));
2541                         break;
2542                 case ev_entity:
2543                         strlcat(tempstring, "entity   ", sizeof(tempstring));
2544                         break;
2545                 case ev_function:
2546                         strlcat(tempstring, "function ", sizeof(tempstring));
2547                         break;
2548                 case ev_field:
2549                         strlcat(tempstring, "field    ", sizeof(tempstring));
2550                         break;
2551                 case ev_void:
2552                         strlcat(tempstring, "void     ", sizeof(tempstring));
2553                         break;
2554                 case ev_float:
2555                         strlcat(tempstring, "float    ", sizeof(tempstring));
2556                         break;
2557                 case ev_vector:
2558                         strlcat(tempstring, "vector   ", sizeof(tempstring));
2559                         break;
2560                 case ev_pointer:
2561                         strlcat(tempstring, "pointer  ", sizeof(tempstring));
2562                         break;
2563                 default:
2564                         dpsnprintf (tempstring2, sizeof(tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
2565                         strlcat(tempstring, tempstring2, sizeof(tempstring));
2566                         break;
2567                 }
2568                 if (strlen(name) > sizeof(tempstring2)-4)
2569                 {
2570                         memcpy (tempstring2, name, sizeof(tempstring2)-4);
2571                         tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
2572                         tempstring2[sizeof(tempstring2)-1] = 0;
2573                         name = tempstring2;
2574                 }
2575                 strlcat(tempstring, name, sizeof(tempstring));
2576                 for (j = (int)strlen(name);j < 25;j++)
2577                         strlcat(tempstring, " ", sizeof(tempstring));
2578                 dpsnprintf(tempstring2, sizeof(tempstring2), "%5d", counts[i]);
2579                 strlcat(tempstring, tempstring2, sizeof(tempstring));
2580                 strlcat(tempstring, "\n", sizeof(tempstring));
2581                 if (strlen(tempstring) >= sizeof(tempstring)/2)
2582                 {
2583                         Con_Print(tempstring);
2584                         tempstring[0] = 0;
2585                 }
2586                 if (counts[i])
2587                 {
2588                         used++;
2589                         usedamount += prvm_type_size[d->type & ~DEF_SAVEGLOBAL];
2590                 }
2591         }
2592         Mem_Free(counts);
2593         Con_Printf("%s: %i entity fields (%i in use), totalling %i bytes per edict (%i in use), %i edicts allocated, %i bytes total spent on edict fields (%i needed)\n", PRVM_NAME, prog->progs->entityfields, used, prog->progs->entityfields * 4, usedamount * 4, prog->max_edicts, prog->progs->entityfields * 4 * prog->max_edicts, usedamount * 4 * prog->max_edicts);
2594
2595         PRVM_End;
2596 }
2597
2598 void PRVM_Globals_f (void)
2599 {
2600         int i;
2601         const char *wildcard;
2602         int numculled;
2603                 numculled = 0;
2604         // TODO
2605         /*if (!sv.active)
2606         {
2607                 Con_Print("no progs loaded\n");
2608                 return;
2609         }*/
2610         if(Cmd_Argc () < 2 || Cmd_Argc() > 3)
2611         {
2612                 Con_Print("prvm_globals <program name> <optional name wildcard>\n");
2613                 return;
2614         }
2615
2616         PRVM_Begin;
2617         if(!PRVM_SetProgFromString (Cmd_Argv (1)))
2618                 return;
2619
2620         if( Cmd_Argc() == 3)
2621                 wildcard = Cmd_Argv(2);
2622         else
2623                 wildcard = NULL;
2624
2625         Con_Printf("%s :", PRVM_NAME);
2626
2627         for (i = 0;i < prog->progs->numglobaldefs;i++)
2628         {
2629                 if(wildcard)
2630                         if( !matchpattern( PRVM_GetString(prog->globaldefs[i].s_name), wildcard, 1) )
2631                         {
2632                                 numculled++;
2633                                 continue;
2634                         }
2635                 Con_Printf("%s\n", PRVM_GetString(prog->globaldefs[i].s_name));
2636         }
2637         Con_Printf("%i global variables, %i culled, totalling %i bytes\n", prog->progs->numglobals, numculled, prog->progs->numglobals * 4);
2638
2639         PRVM_End;
2640 }
2641
2642 /*
2643 ===============
2644 PRVM_Global
2645 ===============
2646 */
2647 void PRVM_Global_f(void)
2648 {
2649         ddef_t *global;
2650         if( Cmd_Argc() != 3 ) {
2651                 Con_Printf( "prvm_global <program name> <global name>\n" );
2652                 return;
2653         }
2654
2655         PRVM_Begin;
2656         if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
2657                 return;
2658
2659         global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
2660         if( !global )
2661                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
2662         else
2663                 Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( (etype_t)global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) );
2664         PRVM_End;
2665 }
2666
2667 /*
2668 ===============
2669 PRVM_GlobalSet
2670 ===============
2671 */
2672 void PRVM_GlobalSet_f(void)
2673 {
2674         ddef_t *global;
2675         if( Cmd_Argc() != 4 ) {
2676                 Con_Printf( "prvm_globalset <program name> <global name> <value>\n" );
2677                 return;
2678         }
2679
2680         PRVM_Begin;
2681         if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
2682                 return;
2683
2684         global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
2685         if( !global )
2686                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
2687         else
2688                 PRVM_ED_ParseEpair( NULL, global, Cmd_Argv(3), true );
2689         PRVM_End;
2690 }
2691
2692 /*
2693 ===============
2694 PRVM_Init
2695 ===============
2696 */
2697 void PRVM_Init (void)
2698 {
2699         Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)");
2700         Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)");
2701         Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
2702         Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
2703         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");
2704         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)");
2705         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)");
2706         Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
2707         Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
2708         Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
2709         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)");
2710         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");
2711         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");
2712         Cmd_AddCommand ("prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)");
2713         Cmd_AddCommand ("cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument");
2714         Cmd_AddCommand ("menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument");
2715         Cmd_AddCommand ("sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument");
2716
2717         Cvar_RegisterVariable (&prvm_language);
2718         Cvar_RegisterVariable (&prvm_traceqc);
2719         Cvar_RegisterVariable (&prvm_statementprofiling);
2720         Cvar_RegisterVariable (&prvm_backtraceforwarnings);
2721         Cvar_RegisterVariable (&prvm_leaktest);
2722         Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames);
2723         Cvar_RegisterVariable (&prvm_errordump);
2724         Cvar_RegisterVariable (&prvm_reuseedicts_startuptime);
2725         Cvar_RegisterVariable (&prvm_reuseedicts_neverinsameframe);
2726
2727         // COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!)
2728         prvm_runawaycheck = !COM_CheckParm("-norunaway");
2729
2730         //VM_Cmd_Init();
2731 }
2732
2733 /*
2734 ===============
2735 PRVM_InitProg
2736 ===============
2737 */
2738 void PRVM_InitProg(int prognr)
2739 {
2740         static unsigned int progid = 0;
2741
2742         if(prognr < 0 || prognr >= PRVM_MAXPROGS)
2743                 Sys_Error("PRVM_InitProg: Invalid program number %i",prognr);
2744
2745         prog = &prog_list[prognr];
2746
2747         if(prog->loaded)
2748                 PRVM_ResetProg();
2749
2750         memset(prog, 0, sizeof(prvm_prog_t));
2751         prog->starttime = Sys_DoubleTime();
2752         prog->id = ++progid;
2753
2754         prog->error_cmd = Host_Error;
2755         prog->leaktest_active = prvm_leaktest.integer != 0;
2756 }
2757
2758 int PRVM_GetProgNr(void)
2759 {
2760         return prog - prog_list;
2761 }
2762
2763 void *_PRVM_Alloc(size_t buffersize, const char *filename, int fileline)
2764 {
2765         return _Mem_Alloc(prog->progs_mempool, NULL, buffersize, 16, filename, fileline);
2766 }
2767
2768 void _PRVM_Free(void *buffer, const char *filename, int fileline)
2769 {
2770         _Mem_Free(buffer, filename, fileline);
2771 }
2772
2773 void _PRVM_FreeAll(const char *filename, int fileline)
2774 {
2775         prog->progs = NULL;
2776         prog->fielddefs = NULL;
2777         prog->functions = NULL;
2778         _Mem_EmptyPool(prog->progs_mempool, filename, fileline);
2779 }
2780
2781 // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
2782 unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, char *filename, int fileline)
2783 {
2784         PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline);
2785         return 0;
2786 }
2787
2788 sizebuf_t vm_tempstringsbuf;
2789 #define PRVM_KNOWNSTRINGBASE 0x40000000
2790
2791 const char *PRVM_GetString(int num)
2792 {
2793         if (num < 0)
2794         {
2795                 // invalid
2796                 VM_Warning("PRVM_GetString: Invalid string offset (%i < 0)\n", num);
2797                 return "";
2798         }
2799         else if (num < prog->stringssize)
2800         {
2801                 // constant string from progs.dat
2802                 return prog->strings + num;
2803         }
2804         else if (num <= prog->stringssize + vm_tempstringsbuf.maxsize)
2805         {
2806                 // tempstring returned by engine to QC (becomes invalid after returning to engine)
2807                 num -= prog->stringssize;
2808                 if (num < vm_tempstringsbuf.cursize)
2809                         return (char *)vm_tempstringsbuf.data + num;
2810                 else
2811                 {
2812                         VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
2813                         return "";
2814                 }
2815         }
2816         else if (num & PRVM_KNOWNSTRINGBASE)
2817         {
2818                 // allocated string
2819                 num = num - PRVM_KNOWNSTRINGBASE;
2820                 if (num >= 0 && num < prog->numknownstrings)
2821                 {
2822                         if (!prog->knownstrings[num])
2823                         {
2824                                 VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
2825                                 return "";
2826                         }
2827                         return prog->knownstrings[num];
2828                 }
2829                 else
2830                 {
2831                         VM_Warning("PRVM_GetString: Invalid zone-string offset (%i >= %i)\n", num, prog->numknownstrings);
2832                         return "";
2833                 }
2834         }
2835         else
2836         {
2837                 // invalid string offset
2838                 VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
2839                 return "";
2840         }
2841 }
2842
2843 const char *PRVM_ChangeEngineString(int i, const char *s)
2844 {
2845         const char *old;
2846         i = i - PRVM_KNOWNSTRINGBASE;
2847         if(i < 0 || i >= prog->numknownstrings)
2848                 PRVM_ERROR("PRVM_ChangeEngineString: s is not an engine string");
2849         old = prog->knownstrings[i];
2850         prog->knownstrings[i] = s;
2851         return old;
2852 }
2853
2854 int PRVM_SetEngineString(const char *s)
2855 {
2856         int i;
2857         if (!s)
2858                 return 0;
2859         if (s >= prog->strings && s <= prog->strings + prog->stringssize)
2860                 PRVM_ERROR("PRVM_SetEngineString: s in prog->strings area");
2861         // if it's in the tempstrings area, use a reserved range
2862         // (otherwise we'd get millions of useless string offsets cluttering the database)
2863         if (s >= (char *)vm_tempstringsbuf.data && s < (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.maxsize)
2864 #if 1
2865                 return prog->stringssize + (s - (char *)vm_tempstringsbuf.data);
2866 #endif
2867         // see if it's a known string address
2868         for (i = 0;i < prog->numknownstrings;i++)
2869                 if (prog->knownstrings[i] == s)
2870                         return PRVM_KNOWNSTRINGBASE + i;
2871         // new unknown engine string
2872         if (developer_insane.integer)
2873                 Con_DPrintf("new engine string %p = \"%s\"\n", s, s);
2874         for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
2875                 if (!prog->knownstrings[i])
2876                         break;
2877         if (i >= prog->numknownstrings)
2878         {
2879                 if (i >= prog->maxknownstrings)
2880                 {
2881                         const char **oldstrings = prog->knownstrings;
2882                         const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
2883                         const char **oldstrings_origin = prog->knownstrings_origin;
2884                         prog->maxknownstrings += 128;
2885                         prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2886                         prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
2887                         if(prog->leaktest_active)
2888                                 prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2889                         if (prog->numknownstrings)
2890                         {
2891                                 memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
2892                                 memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
2893                                 if(prog->leaktest_active)
2894                                         memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
2895                         }
2896                 }
2897                 prog->numknownstrings++;
2898         }
2899         prog->firstfreeknownstring = i + 1;
2900         prog->knownstrings[i] = s;
2901         prog->knownstrings_freeable[i] = false;
2902         if(prog->leaktest_active)
2903                 prog->knownstrings_origin[i] = NULL;
2904         return PRVM_KNOWNSTRINGBASE + i;
2905 }
2906
2907 // temp string handling
2908
2909 // all tempstrings go into this buffer consecutively, and it is reset
2910 // whenever PRVM_ExecuteProgram returns to the engine
2911 // (technically each PRVM_ExecuteProgram call saves the cursize value and
2912 //  restores it on return, so multiple recursive calls can share the same
2913 //  buffer)
2914 // the buffer size is automatically grown as needed
2915
2916 int PRVM_SetTempString(const char *s)
2917 {
2918         int size;
2919         char *t;
2920         if (!s)
2921                 return 0;
2922         size = (int)strlen(s) + 1;
2923         if (developer_insane.integer)
2924                 Con_DPrintf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size);
2925         if (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size)
2926         {
2927                 sizebuf_t old = vm_tempstringsbuf;
2928                 if (vm_tempstringsbuf.cursize + size >= 1<<28)
2929                         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);
2930                 vm_tempstringsbuf.maxsize = max(vm_tempstringsbuf.maxsize, 65536);
2931                 while (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size)
2932                         vm_tempstringsbuf.maxsize *= 2;
2933                 if (vm_tempstringsbuf.maxsize != old.maxsize || vm_tempstringsbuf.data == NULL)
2934                 {
2935                         Con_DPrintf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024);
2936                         vm_tempstringsbuf.data = (unsigned char *) Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize);
2937                         if (old.cursize)
2938                                 memcpy(vm_tempstringsbuf.data, old.data, old.cursize);
2939                         if (old.data)
2940                                 Mem_Free(old.data);
2941                 }
2942         }
2943         t = (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.cursize;
2944         memcpy(t, s, size);
2945         vm_tempstringsbuf.cursize += size;
2946         return PRVM_SetEngineString(t);
2947 }
2948
2949 int PRVM_AllocString(size_t bufferlength, char **pointer)
2950 {
2951         int i;
2952         if (!bufferlength)
2953                 return 0;
2954         for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
2955                 if (!prog->knownstrings[i])
2956                         break;
2957         if (i >= prog->numknownstrings)
2958         {
2959                 if (i >= prog->maxknownstrings)
2960                 {
2961                         const char **oldstrings = prog->knownstrings;
2962                         const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
2963                         const char **oldstrings_origin = prog->knownstrings_origin;
2964                         prog->maxknownstrings += 128;
2965                         prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2966                         prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
2967                         if(prog->leaktest_active)
2968                                 prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2969                         if (prog->numknownstrings)
2970                         {
2971                                 memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
2972                                 memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
2973                                 if(prog->leaktest_active)
2974                                         memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
2975                         }
2976                         if (oldstrings)
2977                                 Mem_Free(oldstrings);
2978                         if (oldstrings_freeable)
2979                                 Mem_Free((unsigned char *)oldstrings_freeable);
2980                         if (oldstrings_origin)
2981                                 Mem_Free(oldstrings_origin);
2982                 }
2983                 prog->numknownstrings++;
2984         }
2985         prog->firstfreeknownstring = i + 1;
2986         prog->knownstrings[i] = (char *)PRVM_Alloc(bufferlength);
2987         prog->knownstrings_freeable[i] = true;
2988         if(prog->leaktest_active)
2989                 prog->knownstrings_origin[i] = PRVM_AllocationOrigin();
2990         if (pointer)
2991                 *pointer = (char *)(prog->knownstrings[i]);
2992         return PRVM_KNOWNSTRINGBASE + i;
2993 }
2994
2995 void PRVM_FreeString(int num)
2996 {
2997         if (num == 0)
2998                 PRVM_ERROR("PRVM_FreeString: attempt to free a NULL string");
2999         else if (num >= 0 && num < prog->stringssize)
3000                 PRVM_ERROR("PRVM_FreeString: attempt to free a constant string");
3001         else if (num >= PRVM_KNOWNSTRINGBASE && num < PRVM_KNOWNSTRINGBASE + prog->numknownstrings)
3002         {
3003                 num = num - PRVM_KNOWNSTRINGBASE;
3004                 if (!prog->knownstrings[num])
3005                         PRVM_ERROR("PRVM_FreeString: attempt to free a non-existent or already freed string");
3006                 if (!prog->knownstrings_freeable[num])
3007                         PRVM_ERROR("PRVM_FreeString: attempt to free a string owned by the engine");
3008                 PRVM_Free((char *)prog->knownstrings[num]);
3009                 if(prog->leaktest_active)
3010                         if(prog->knownstrings_origin[num])
3011                                 PRVM_Free((char *)prog->knownstrings_origin[num]);
3012                 prog->knownstrings[num] = NULL;
3013                 prog->knownstrings_freeable[num] = false;
3014                 prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
3015         }
3016         else
3017                 PRVM_ERROR("PRVM_FreeString: invalid string offset %i", num);
3018 }
3019
3020 static qboolean PRVM_IsStringReferenced(string_t string)
3021 {
3022         int i, j;
3023
3024         for (i = 0;i < prog->progs->numglobaldefs;i++)
3025         {
3026                 ddef_t *d = &prog->globaldefs[i];
3027                 if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
3028                         continue;
3029                 if(string == ((prvm_eval_t *) &prog->globals.generic[d->ofs])->string)
3030                         return true;
3031         }
3032
3033         for(j = 0; j < prog->num_edicts; ++j)
3034         {
3035                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
3036                 if (ed->priv.required->free)
3037                         continue;
3038                 for (i=0; i<prog->progs->numfielddefs; ++i)
3039                 {
3040                         ddef_t *d = &prog->fielddefs[i];
3041                         if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
3042                                 continue;
3043                         if(string == ((prvm_eval_t *) &ed->fields.vp[d->ofs])->string)
3044                                 return true;
3045                 }
3046         }
3047
3048         return false;
3049 }
3050
3051 static qboolean PRVM_IsEdictRelevant(prvm_edict_t *edict)
3052 {
3053         if(PRVM_NUM_FOR_EDICT(edict) <= prog->reserved_edicts)
3054                 return true; // world or clients
3055         switch(prog - prog_list)
3056         {
3057                 case PRVM_SERVERPROG:
3058                         {
3059                                 entvars_t *ev = edict->fields.server;
3060                                 if(ev->solid) // can block other stuff, or is a trigger?
3061                                         return true;
3062                                 if(ev->modelindex) // visible ent?
3063                                         return true;
3064                                 if(ev->effects) // particle effect?
3065                                         return true;
3066                                 if(ev->think) // has a think function?
3067                                         if(ev->nextthink > 0) // that actually will eventually run?
3068                                                 return true;
3069                                 if(ev->takedamage)
3070                                         return true;
3071                                 if(*prvm_leaktest_ignore_classnames.string)
3072                                 {
3073                                         if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname))))
3074                                                 return true;
3075                                 }
3076                         }
3077                         break;
3078                 case PRVM_CLIENTPROG:
3079                         {
3080                                 // TODO someone add more stuff here
3081                                 cl_entvars_t *ev = edict->fields.client;
3082                                 if(ev->entnum) // csqc networked
3083                                         return true;
3084                                 if(ev->modelindex) // visible ent?
3085                                         return true;
3086                                 if(ev->effects) // particle effect?
3087                                         return true;
3088                                 if(ev->think) // has a think function?
3089                                         if(ev->nextthink > 0) // that actually will eventually run?
3090                                                 return true;
3091                                 if(*prvm_leaktest_ignore_classnames.string)
3092                                 {
3093                                         if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname))))
3094                                                 return true;
3095                                 }
3096                         }
3097                         break;
3098                 case PRVM_MENUPROG:
3099                         // menu prog does not have classnames
3100                         break;
3101         }
3102         return false;
3103 }
3104
3105 static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark)
3106 {
3107         int i, j;
3108         int edictnum = PRVM_NUM_FOR_EDICT(edict);
3109         const char *targetname = NULL;
3110
3111         switch(prog - prog_list)
3112         {
3113                 case PRVM_SERVERPROG:
3114                         targetname = PRVM_GetString(edict->fields.server->targetname);
3115                         break;
3116         }
3117
3118         if(targetname)
3119                 if(!*targetname) // ""
3120                         targetname = NULL;
3121
3122         for (i = 0;i < prog->progs->numglobaldefs;i++)
3123         {
3124                 ddef_t *d = &prog->globaldefs[i];
3125                 if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
3126                         continue;
3127                 if(edictnum == ((prvm_eval_t *) &prog->globals.generic[d->ofs])->edict)
3128                         return true;
3129         }
3130
3131         for(j = 0; j < prog->num_edicts; ++j)
3132         {
3133                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
3134                 if (ed->priv.required->mark < mark)
3135                         continue;
3136                 if(ed == edict)
3137                         continue;
3138                 if(targetname)
3139                 {
3140                         const char *target = PRVM_GetString(ed->fields.server->target);
3141                         if(target)
3142                                 if(!strcmp(target, targetname))
3143                                         return true;
3144                 }
3145                 for (i=0; i<prog->progs->numfielddefs; ++i)
3146                 {
3147                         ddef_t *d = &prog->fielddefs[i];
3148                         if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
3149                                 continue;
3150                         if(edictnum == ((prvm_eval_t *) &ed->fields.vp[d->ofs])->edict)
3151                                 return true;
3152                 }
3153         }
3154
3155         return false;
3156 }
3157
3158 static void PRVM_MarkReferencedEdicts(void)
3159 {
3160         int j;
3161         qboolean found_new;
3162         int stage;
3163
3164         for(j = 0; j < prog->num_edicts; ++j)
3165         {
3166                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
3167                 if(ed->priv.required->free)
3168                         continue;
3169                 ed->priv.required->mark = PRVM_IsEdictRelevant(ed) ? 1 : 0;
3170         }
3171
3172         stage = 1;
3173         do
3174         {
3175                 found_new = false;
3176                 for(j = 0; j < prog->num_edicts; ++j)
3177                 {
3178                         prvm_edict_t *ed = PRVM_EDICT_NUM(j);
3179                         if(ed->priv.required->free)
3180                                 continue;
3181                         if(ed->priv.required->mark)
3182                                 continue;
3183                         if(PRVM_IsEdictReferenced(ed, stage))
3184                         {
3185                                 ed->priv.required->mark = stage + 1;
3186                                 found_new = true;
3187                         }
3188                 }
3189                 ++stage;
3190         }
3191         while(found_new);
3192         Con_DPrintf("leak check used %d stages to find all references\n", stage);
3193 }
3194
3195 void PRVM_LeakTest(void)
3196 {
3197         int i, j;
3198         qboolean leaked = false;
3199
3200         if(!prog->leaktest_active)
3201                 return;
3202
3203         // 1. Strings
3204         for (i = 0; i < prog->numknownstrings; ++i)
3205         {
3206                 if(prog->knownstrings[i])
3207                 if(prog->knownstrings_freeable[i])
3208                 if(prog->knownstrings_origin[i])
3209                 if(!PRVM_IsStringReferenced(-1 - i))
3210                 {
3211                         Con_Printf("Unreferenced string found!\n  Value: %s\n  Origin: %s\n", prog->knownstrings[i], prog->knownstrings_origin[i]);
3212                         leaked = true;
3213                 }
3214         }
3215
3216         // 2. Edicts
3217         PRVM_MarkReferencedEdicts();
3218         for(j = 0; j < prog->num_edicts; ++j)
3219         {
3220                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
3221                 if(ed->priv.required->free)
3222                         continue;
3223                 if(!ed->priv.required->mark)
3224                 if(ed->priv.required->allocation_origin)
3225                 {
3226                         Con_Printf("Unreferenced edict found!\n  Allocated at: %s\n", ed->priv.required->allocation_origin);
3227                         PRVM_ED_Print(ed, NULL);
3228                         Con_Print("\n");
3229                         leaked = true;
3230                 }
3231         }
3232
3233         for (i = 0; i < (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray); ++i)
3234         {
3235                 prvm_stringbuffer_t *stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);
3236                 if(stringbuffer)
3237                 if(stringbuffer->origin)
3238                 {
3239                         Con_Printf("Open string buffer handle found!\n  Allocated at: %s\n", stringbuffer->origin);
3240                         leaked = true;
3241                 }
3242         }
3243
3244         for(i = 0; i < PRVM_MAX_OPENFILES; ++i)
3245         {
3246                 if(prog->openfiles[i])
3247                 if(prog->openfiles_origin[i])
3248                 {
3249                         Con_Printf("Open file handle found!\n  Allocated at: %s\n", prog->openfiles_origin[i]);
3250                         leaked = true;
3251                 }
3252         }
3253
3254         for(i = 0; i < PRVM_MAX_OPENSEARCHES; ++i)
3255         {
3256                 if(prog->opensearches[i])
3257                 if(prog->opensearches_origin[i])
3258                 {
3259                         Con_Printf("Open search handle found!\n  Allocated at: %s\n", prog->opensearches_origin[i]);
3260                         leaked = true;
3261                 }
3262         }
3263
3264         if(!leaked)
3265                 Con_Printf("Congratulations. No leaks found.\n");
3266 }