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