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                 if (prog->funcoffsets.SV_OnEntityPreSpawnFunction)
1327                 {
1328                         // self = ent
1329                         PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1330                         PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPreSpawnFunction, "QC function SV_OnEntityPreSpawnFunction is missing");
1331                 }
1332
1333 //
1334 // immediately call spawn function, but only if there is a self global and a classname
1335 //
1336                 if(!ent->priv.required->free)
1337                 if(prog->globaloffsets.self >= 0 && prog->fieldoffsets.classname >= 0)
1338                 {
1339                         string_t handle =  PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.classname)->string;
1340                         if (!handle)
1341                         {
1342                                 Con_Print("No classname for:\n");
1343                                 PRVM_ED_Print(ent, NULL);
1344                                 PRVM_ED_Free (ent);
1345                                 continue;
1346                         }
1347
1348                         // look for the spawn function
1349                         funcname = PRVM_GetString(handle);
1350                         func = PRVM_ED_FindFunction (va("spawnfunc_%s", funcname));
1351                         if(!func)
1352                                 if(prog->globaloffsets.require_spawnfunc_prefix < 0)
1353                                         func = PRVM_ED_FindFunction (funcname);
1354
1355                         if (!func)
1356                         {
1357                                 // check for OnEntityNoSpawnFunction
1358                                 if (prog->funcoffsets.SV_OnEntityNoSpawnFunction)
1359                                 {
1360                                         // self = ent
1361                                         PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1362                                         PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityNoSpawnFunction, "QC function SV_OnEntityNoSpawnFunction is missing");
1363                                 }
1364                                 else
1365                                 {
1366                                         if (developer.integer) // don't confuse non-developers with errors
1367                                         {
1368                                                 Con_Print("No spawn function for:\n");
1369                                                 PRVM_ED_Print(ent, NULL);
1370                                         }
1371                                         PRVM_ED_Free (ent);
1372                                         continue; // not included in "inhibited" count
1373                                 }
1374                         }
1375                         else
1376                         {
1377                                 // self = ent
1378                                 PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1379                                 PRVM_ExecuteProgram (func - prog->functions, "");
1380                         }
1381                 }
1382
1383                 if(!ent->priv.required->free)
1384                 if (prog->funcoffsets.SV_OnEntityPostSpawnFunction)
1385                 {
1386                         // self = ent
1387                         PRVM_GLOBALFIELDVALUE(prog->globaloffsets.self)->edict = PRVM_EDICT_TO_PROG(ent);
1388                         PRVM_ExecuteProgram (prog->funcoffsets.SV_OnEntityPostSpawnFunction, "QC function SV_OnEntityPostSpawnFunction is missing");
1389                 }
1390
1391                 spawned++;
1392                 if (ent->priv.required->free)
1393                         died++;
1394         }
1395
1396         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);
1397 }
1398
1399 void PRVM_FindOffsets(void)
1400 {
1401         // field and global searches use -1 for NULL
1402         memset(&prog->fieldoffsets, -1, sizeof(prog->fieldoffsets));
1403         memset(&prog->globaloffsets, -1, sizeof(prog->globaloffsets));
1404         // functions use 0 for NULL
1405         memset(&prog->funcoffsets, 0, sizeof(prog->funcoffsets));
1406
1407         // server and client qc use a lot of similar fields, so this is combined
1408         prog->fieldoffsets.SendEntity                     = PRVM_ED_FindFieldOffset("SendEntity");
1409         prog->fieldoffsets.SendFlags                      = PRVM_ED_FindFieldOffset("SendFlags");
1410         prog->fieldoffsets.Version                        = PRVM_ED_FindFieldOffset("Version");
1411         prog->fieldoffsets.alpha                          = PRVM_ED_FindFieldOffset("alpha");
1412         prog->fieldoffsets.ammo_cells1                    = PRVM_ED_FindFieldOffset("ammo_cells1");
1413         prog->fieldoffsets.ammo_lava_nails                = PRVM_ED_FindFieldOffset("ammo_lava_nails");
1414         prog->fieldoffsets.ammo_multi_rockets             = PRVM_ED_FindFieldOffset("ammo_multi_rockets");
1415         prog->fieldoffsets.ammo_nails1                    = PRVM_ED_FindFieldOffset("ammo_nails1");
1416         prog->fieldoffsets.ammo_plasma                    = PRVM_ED_FindFieldOffset("ammo_plasma");
1417         prog->fieldoffsets.ammo_rockets1                  = PRVM_ED_FindFieldOffset("ammo_rockets1");
1418         prog->fieldoffsets.ammo_shells1                   = PRVM_ED_FindFieldOffset("ammo_shells1");
1419         prog->fieldoffsets.angles                         = PRVM_ED_FindFieldOffset("angles");
1420         prog->fieldoffsets.button3                        = PRVM_ED_FindFieldOffset("button3");
1421         prog->fieldoffsets.button4                        = PRVM_ED_FindFieldOffset("button4");
1422         prog->fieldoffsets.button5                        = PRVM_ED_FindFieldOffset("button5");
1423         prog->fieldoffsets.button6                        = PRVM_ED_FindFieldOffset("button6");
1424         prog->fieldoffsets.button7                        = PRVM_ED_FindFieldOffset("button7");
1425         prog->fieldoffsets.button8                        = PRVM_ED_FindFieldOffset("button8");
1426         prog->fieldoffsets.button9                        = PRVM_ED_FindFieldOffset("button9");
1427         prog->fieldoffsets.button10                       = PRVM_ED_FindFieldOffset("button10");
1428         prog->fieldoffsets.button11                       = PRVM_ED_FindFieldOffset("button11");
1429         prog->fieldoffsets.button12                       = PRVM_ED_FindFieldOffset("button12");
1430         prog->fieldoffsets.button13                       = PRVM_ED_FindFieldOffset("button13");
1431         prog->fieldoffsets.button14                       = PRVM_ED_FindFieldOffset("button14");
1432         prog->fieldoffsets.button15                       = PRVM_ED_FindFieldOffset("button15");
1433         prog->fieldoffsets.button16                       = PRVM_ED_FindFieldOffset("button16");
1434         prog->fieldoffsets.buttonchat                     = PRVM_ED_FindFieldOffset("buttonchat");
1435         prog->fieldoffsets.buttonuse                      = PRVM_ED_FindFieldOffset("buttonuse");
1436         prog->fieldoffsets.chain                          = PRVM_ED_FindFieldOffset("chain");
1437         prog->fieldoffsets.classname                      = PRVM_ED_FindFieldOffset("classname");
1438         prog->fieldoffsets.clientcolors                   = PRVM_ED_FindFieldOffset("clientcolors");
1439         prog->fieldoffsets.color                          = PRVM_ED_FindFieldOffset("color");
1440         prog->fieldoffsets.colormod                       = PRVM_ED_FindFieldOffset("colormod");
1441         prog->fieldoffsets.contentstransition             = PRVM_ED_FindFieldOffset("contentstransition");
1442         prog->fieldoffsets.cursor_active                  = PRVM_ED_FindFieldOffset("cursor_active");
1443         prog->fieldoffsets.cursor_screen                  = PRVM_ED_FindFieldOffset("cursor_screen");
1444         prog->fieldoffsets.cursor_trace_endpos            = PRVM_ED_FindFieldOffset("cursor_trace_endpos");
1445         prog->fieldoffsets.cursor_trace_ent               = PRVM_ED_FindFieldOffset("cursor_trace_ent");
1446         prog->fieldoffsets.cursor_trace_start             = PRVM_ED_FindFieldOffset("cursor_trace_start");
1447         prog->fieldoffsets.customizeentityforclient       = PRVM_ED_FindFieldOffset("customizeentityforclient");
1448         prog->fieldoffsets.dimension_hit                  = PRVM_ED_FindFieldOffset("dimension_hit");
1449         prog->fieldoffsets.dimension_solid                = PRVM_ED_FindFieldOffset("dimension_solid");
1450         prog->fieldoffsets.disableclientprediction        = PRVM_ED_FindFieldOffset("disableclientprediction");
1451         prog->fieldoffsets.dphitcontentsmask              = PRVM_ED_FindFieldOffset("dphitcontentsmask");
1452         prog->fieldoffsets.drawonlytoclient               = PRVM_ED_FindFieldOffset("drawonlytoclient");
1453         prog->fieldoffsets.exteriormodeltoclient          = PRVM_ED_FindFieldOffset("exteriormodeltoclient");
1454         prog->fieldoffsets.fatness                        = PRVM_ED_FindFieldOffset("fatness");
1455         prog->fieldoffsets.forceshader                    = PRVM_ED_FindFieldOffset("forceshader");
1456         prog->fieldoffsets.frame                          = PRVM_ED_FindFieldOffset("frame");
1457         prog->fieldoffsets.frame1time                     = PRVM_ED_FindFieldOffset("frame1time");
1458         prog->fieldoffsets.frame2                         = PRVM_ED_FindFieldOffset("frame2");
1459         prog->fieldoffsets.frame2time                     = PRVM_ED_FindFieldOffset("frame2time");
1460         prog->fieldoffsets.fullbright                     = PRVM_ED_FindFieldOffset("fullbright");
1461         prog->fieldoffsets.glow_color                     = PRVM_ED_FindFieldOffset("glow_color");
1462         prog->fieldoffsets.glow_size                      = PRVM_ED_FindFieldOffset("glow_size");
1463         prog->fieldoffsets.glow_trail                     = PRVM_ED_FindFieldOffset("glow_trail");
1464         prog->fieldoffsets.gravity                        = PRVM_ED_FindFieldOffset("gravity");
1465         prog->fieldoffsets.groundentity                   = PRVM_ED_FindFieldOffset("groundentity");
1466         prog->fieldoffsets.hull                           = PRVM_ED_FindFieldOffset("hull");
1467         prog->fieldoffsets.ideal_yaw                      = PRVM_ED_FindFieldOffset("ideal_yaw");
1468         prog->fieldoffsets.idealpitch                     = PRVM_ED_FindFieldOffset("idealpitch");
1469         prog->fieldoffsets.items2                         = PRVM_ED_FindFieldOffset("items2");
1470         prog->fieldoffsets.lerpfrac                       = PRVM_ED_FindFieldOffset("lerpfrac");
1471         prog->fieldoffsets.light_lev                      = PRVM_ED_FindFieldOffset("light_lev");
1472         prog->fieldoffsets.message                        = PRVM_ED_FindFieldOffset("message");
1473         prog->fieldoffsets.modelflags                     = PRVM_ED_FindFieldOffset("modelflags");
1474         prog->fieldoffsets.movement                       = PRVM_ED_FindFieldOffset("movement");
1475         prog->fieldoffsets.movetypesteplandevent          = PRVM_ED_FindFieldOffset("movetypesteplandevent");
1476         prog->fieldoffsets.netaddress                     = PRVM_ED_FindFieldOffset("netaddress");
1477         prog->fieldoffsets.nextthink                      = PRVM_ED_FindFieldOffset("nextthink");
1478         prog->fieldoffsets.nodrawtoclient                 = PRVM_ED_FindFieldOffset("nodrawtoclient");
1479         prog->fieldoffsets.pflags                         = PRVM_ED_FindFieldOffset("pflags");
1480         prog->fieldoffsets.ping                           = PRVM_ED_FindFieldOffset("ping");
1481         prog->fieldoffsets.pitch_speed                    = PRVM_ED_FindFieldOffset("pitch_speed");
1482         prog->fieldoffsets.playermodel                    = PRVM_ED_FindFieldOffset("playermodel");
1483         prog->fieldoffsets.playerskin                     = PRVM_ED_FindFieldOffset("playerskin");
1484         prog->fieldoffsets.pmodel                         = PRVM_ED_FindFieldOffset("pmodel");
1485         prog->fieldoffsets.punchvector                    = PRVM_ED_FindFieldOffset("punchvector");
1486         prog->fieldoffsets.renderamt                      = PRVM_ED_FindFieldOffset("renderamt"); // HalfLife support
1487         prog->fieldoffsets.renderflags                    = PRVM_ED_FindFieldOffset("renderflags");
1488         prog->fieldoffsets.rendermode                     = PRVM_ED_FindFieldOffset("rendermode"); // HalfLife support
1489         prog->fieldoffsets.scale                          = PRVM_ED_FindFieldOffset("scale");
1490         prog->fieldoffsets.style                          = PRVM_ED_FindFieldOffset("style");
1491         prog->fieldoffsets.tag_entity                     = PRVM_ED_FindFieldOffset("tag_entity");
1492         prog->fieldoffsets.tag_index                      = PRVM_ED_FindFieldOffset("tag_index");
1493         prog->fieldoffsets.think                          = PRVM_ED_FindFieldOffset("think");
1494         prog->fieldoffsets.viewmodelforclient             = PRVM_ED_FindFieldOffset("viewmodelforclient");
1495         prog->fieldoffsets.viewzoom                       = PRVM_ED_FindFieldOffset("viewzoom");
1496         prog->fieldoffsets.yaw_speed                      = PRVM_ED_FindFieldOffset("yaw_speed");
1497         prog->fieldoffsets.clientcamera                   = PRVM_ED_FindFieldOffset("clientcamera");
1498         prog->fieldoffsets.clientstatus                   = PRVM_ED_FindFieldOffset("clientstatus");
1499         prog->funcoffsets.CSQC_ConsoleCommand             = PRVM_ED_FindFunctionOffset("CSQC_ConsoleCommand");
1500         prog->funcoffsets.CSQC_Ent_Remove                 = PRVM_ED_FindFunctionOffset("CSQC_Ent_Remove");
1501         prog->funcoffsets.CSQC_Ent_Update                 = PRVM_ED_FindFunctionOffset("CSQC_Ent_Update");
1502         prog->funcoffsets.CSQC_Ent_Spawn                  = PRVM_ED_FindFunctionOffset("CSQC_Ent_Spawn");
1503         prog->funcoffsets.CSQC_Event                      = PRVM_ED_FindFunctionOffset("CSQC_Event");
1504         prog->funcoffsets.CSQC_Event_Sound                = PRVM_ED_FindFunctionOffset("CSQC_Event_Sound");
1505         prog->funcoffsets.CSQC_Init                       = PRVM_ED_FindFunctionOffset("CSQC_Init");
1506         prog->funcoffsets.CSQC_InputEvent                 = PRVM_ED_FindFunctionOffset("CSQC_InputEvent");
1507         prog->funcoffsets.CSQC_Parse_CenterPrint          = PRVM_ED_FindFunctionOffset("CSQC_Parse_CenterPrint");
1508         prog->funcoffsets.CSQC_Parse_Print                = PRVM_ED_FindFunctionOffset("CSQC_Parse_Print");
1509         prog->funcoffsets.CSQC_Parse_StuffCmd             = PRVM_ED_FindFunctionOffset("CSQC_Parse_StuffCmd");
1510         prog->funcoffsets.CSQC_Parse_TempEntity           = PRVM_ED_FindFunctionOffset("CSQC_Parse_TempEntity");
1511         prog->funcoffsets.CSQC_Shutdown                   = PRVM_ED_FindFunctionOffset("CSQC_Shutdown");
1512         prog->funcoffsets.CSQC_UpdateView                 = PRVM_ED_FindFunctionOffset("CSQC_UpdateView");
1513         prog->funcoffsets.Gecko_Query                     = PRVM_ED_FindFunctionOffset("Gecko_Query");
1514         prog->funcoffsets.EndFrame                        = PRVM_ED_FindFunctionOffset("EndFrame");
1515         prog->funcoffsets.RestoreGame                     = PRVM_ED_FindFunctionOffset("RestoreGame");
1516         prog->funcoffsets.SV_ChangeTeam                   = PRVM_ED_FindFunctionOffset("SV_ChangeTeam");
1517         prog->funcoffsets.SV_ParseClientCommand           = PRVM_ED_FindFunctionOffset("SV_ParseClientCommand");
1518         prog->funcoffsets.SV_PlayerPhysics                = PRVM_ED_FindFunctionOffset("SV_PlayerPhysics");
1519         prog->funcoffsets.SV_OnEntityNoSpawnFunction      = PRVM_ED_FindFunctionOffset("SV_OnEntityNoSpawnFunction");
1520         prog->funcoffsets.SV_OnEntityPreSpawnFunction     = PRVM_ED_FindFunctionOffset("SV_OnEntityPreSpawnFunction");
1521         prog->funcoffsets.SV_OnEntityPostSpawnFunction    = PRVM_ED_FindFunctionOffset("SV_OnEntityPostSpawnFunction");
1522         prog->funcoffsets.GameCommand                     = PRVM_ED_FindFunctionOffset("GameCommand");
1523         prog->funcoffsets.SV_Shutdown                     = PRVM_ED_FindFunctionOffset("SV_Shutdown");
1524         prog->funcoffsets.URI_Get_Callback                = PRVM_ED_FindFunctionOffset("URI_Get_Callback");
1525         prog->globaloffsets.SV_InitCmd                    = PRVM_ED_FindGlobalOffset("SV_InitCmd");
1526         prog->globaloffsets.self                          = PRVM_ED_FindGlobalOffset("self");
1527         prog->globaloffsets.time                          = PRVM_ED_FindGlobalOffset("time");
1528         prog->globaloffsets.v_forward                     = PRVM_ED_FindGlobalOffset("v_forward");
1529         prog->globaloffsets.v_right                       = PRVM_ED_FindGlobalOffset("v_right");
1530         prog->globaloffsets.v_up                          = PRVM_ED_FindGlobalOffset("v_up");
1531         prog->globaloffsets.view_angles                   = PRVM_ED_FindGlobalOffset("view_angles");
1532         prog->globaloffsets.trace_allsolid                = PRVM_ED_FindGlobalOffset("trace_allsolid");
1533         prog->globaloffsets.trace_startsolid              = PRVM_ED_FindGlobalOffset("trace_startsolid");
1534         prog->globaloffsets.trace_fraction                = PRVM_ED_FindGlobalOffset("trace_fraction");
1535         prog->globaloffsets.trace_inwater                 = PRVM_ED_FindGlobalOffset("trace_inwater");
1536         prog->globaloffsets.trace_inopen                  = PRVM_ED_FindGlobalOffset("trace_inopen");
1537         prog->globaloffsets.trace_endpos                  = PRVM_ED_FindGlobalOffset("trace_endpos");
1538         prog->globaloffsets.trace_plane_normal            = PRVM_ED_FindGlobalOffset("trace_plane_normal");
1539         prog->globaloffsets.trace_plane_dist              = PRVM_ED_FindGlobalOffset("trace_plane_dist");
1540         prog->globaloffsets.trace_ent                     = PRVM_ED_FindGlobalOffset("trace_ent");
1541         prog->globaloffsets.trace_networkentity           = PRVM_ED_FindGlobalOffset("trace_networkentity");
1542         prog->globaloffsets.trace_dphitcontents           = PRVM_ED_FindGlobalOffset("trace_dphitcontents");
1543         prog->globaloffsets.trace_dphitq3surfaceflags     = PRVM_ED_FindGlobalOffset("trace_dphitq3surfaceflags");
1544         prog->globaloffsets.trace_dphittexturename        = PRVM_ED_FindGlobalOffset("trace_dphittexturename");
1545         prog->globaloffsets.trace_dpstartcontents         = PRVM_ED_FindGlobalOffset("trace_dpstartcontents");
1546         prog->globaloffsets.intermission                  = PRVM_ED_FindGlobalOffset("intermission");
1547         prog->globaloffsets.coop                          = PRVM_ED_FindGlobalOffset("coop");
1548         prog->globaloffsets.deathmatch                    = PRVM_ED_FindGlobalOffset("deathmatch");
1549         prog->globaloffsets.dmg_take                      = PRVM_ED_FindGlobalOffset("dmg_take");
1550         prog->globaloffsets.dmg_save                      = PRVM_ED_FindGlobalOffset("dmg_save");
1551         prog->globaloffsets.dmg_origin                    = PRVM_ED_FindGlobalOffset("dmg_origin");
1552         prog->globaloffsets.sb_showscores                 = PRVM_ED_FindGlobalOffset("sb_showscores");
1553         prog->globaloffsets.drawfont                      = PRVM_ED_FindGlobalOffset("drawfont");
1554         prog->globaloffsets.require_spawnfunc_prefix      = PRVM_ED_FindGlobalOffset("require_spawnfunc_prefix");
1555         prog->globaloffsets.worldstatus                   = PRVM_ED_FindGlobalOffset("worldstatus");
1556
1557         // menu qc only uses some functions, nothing else
1558         prog->funcoffsets.m_draw                          = PRVM_ED_FindFunctionOffset("m_draw");
1559         prog->funcoffsets.m_init                          = PRVM_ED_FindFunctionOffset("m_init");
1560         prog->funcoffsets.m_keydown                       = PRVM_ED_FindFunctionOffset("m_keydown");
1561         prog->funcoffsets.m_keyup                         = PRVM_ED_FindFunctionOffset("m_keyup");
1562         prog->funcoffsets.m_shutdown                      = PRVM_ED_FindFunctionOffset("m_shutdown");
1563         prog->funcoffsets.m_toggle                        = PRVM_ED_FindFunctionOffset("m_toggle");
1564 }
1565
1566 // not used
1567 /*
1568 typedef struct dpfield_s
1569 {
1570         int type;
1571         char *string;
1572 }
1573 dpfield_t;
1574
1575 #define DPFIELDS (sizeof(dpfields) / sizeof(dpfield_t))
1576
1577 dpfield_t dpfields[] =
1578 {
1579 };
1580 */
1581
1582 /*
1583 ===============
1584 PRVM_ResetProg
1585 ===============
1586 */
1587
1588 void PRVM_LeakTest();
1589 void PRVM_ResetProg()
1590 {
1591         PRVM_LeakTest();
1592         PRVM_GCALL(reset_cmd)();
1593         Mem_FreePool(&prog->progs_mempool);
1594         memset(prog,0,sizeof(prvm_prog_t));
1595         prog->starttime = Sys_DoubleTime();
1596 }
1597
1598 /*
1599 ===============
1600 PRVM_LoadLNO
1601 ===============
1602 */
1603 void PRVM_LoadLNO( const char *progname ) {
1604         fs_offset_t filesize;
1605         unsigned char *lno;
1606         unsigned int *header;
1607         char filename[512];
1608
1609         FS_StripExtension( progname, filename, sizeof( filename ) );
1610         strlcat( filename, ".lno", sizeof( filename ) );
1611
1612         lno = FS_LoadFile( filename, tempmempool, false, &filesize );
1613         if( !lno ) {
1614                 return;
1615         }
1616
1617 /*
1618 <Spike>    SafeWrite (h, &lnotype, sizeof(int));
1619 <Spike>    SafeWrite (h, &version, sizeof(int));
1620 <Spike>    SafeWrite (h, &numglobaldefs, sizeof(int));
1621 <Spike>    SafeWrite (h, &numpr_globals, sizeof(int));
1622 <Spike>    SafeWrite (h, &numfielddefs, sizeof(int));
1623 <Spike>    SafeWrite (h, &numstatements, sizeof(int));
1624 <Spike>    SafeWrite (h, statement_linenums, numstatements*sizeof(int));
1625 */
1626         if( (unsigned) filesize < (6 + prog->progs->numstatements) * sizeof( int ) ) {
1627                 Mem_Free(lno);
1628                 return;
1629         }
1630
1631         header = (unsigned int *) lno;
1632         if( header[ 0 ] == *(unsigned int *) "LNOF" &&
1633                 LittleLong( header[ 1 ] ) == 1 &&
1634                 (unsigned int)LittleLong( header[ 2 ] ) == (unsigned int)prog->progs->numglobaldefs &&
1635                 (unsigned int)LittleLong( header[ 3 ] ) == (unsigned int)prog->progs->numglobals &&
1636                 (unsigned int)LittleLong( header[ 4 ] ) == (unsigned int)prog->progs->numfielddefs &&
1637                 (unsigned int)LittleLong( header[ 5 ] ) == (unsigned int)prog->progs->numstatements )
1638         {
1639                 prog->statement_linenums = (int *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof( int ) );
1640                 memcpy( prog->statement_linenums, (int *) lno + 6, prog->progs->numstatements * sizeof( int ) );
1641         }
1642         Mem_Free( lno );
1643 }
1644
1645 /*
1646 ===============
1647 PRVM_LoadProgs
1648 ===============
1649 */
1650 void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field, int numrequiredglobals, char **required_global)
1651 {
1652         int i;
1653         dstatement_t *st;
1654         ddef_t *infielddefs;
1655         dfunction_t *dfunctions;
1656         fs_offset_t filesize;
1657
1658         if( prog->loaded ) {
1659                 PRVM_ERROR ("PRVM_LoadProgs: there is already a %s program loaded!", PRVM_NAME );
1660         }
1661
1662         prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false, &filesize);
1663         if (prog->progs == NULL || filesize < (fs_offset_t)sizeof(dprograms_t))
1664                 PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME);
1665
1666         Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, (int)(filesize/1024));
1667
1668         prog->filecrc = CRC_Block((unsigned char *)prog->progs, filesize);
1669
1670 // byte swap the header
1671         for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++)
1672                 ((int *)prog->progs)[i] = LittleLong ( ((int *)prog->progs)[i] );
1673
1674         if (prog->progs->version != PROG_VERSION)
1675                 PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs->version, PROG_VERSION);
1676         if (prog->progs->crc != prog->headercrc && prog->progs->crc != prog->headercrc2)
1677                 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);
1678
1679         //prog->functions = (dfunction_t *)((unsigned char *)progs + progs->ofs_functions);
1680         dfunctions = (dfunction_t *)((unsigned char *)prog->progs + prog->progs->ofs_functions);
1681
1682         if (prog->progs->ofs_strings + prog->progs->numstrings >= (int)filesize)
1683                 PRVM_ERROR ("%s: %s strings go past end of file", PRVM_NAME, filename);
1684         prog->strings = (char *)prog->progs + prog->progs->ofs_strings;
1685         prog->stringssize = prog->progs->numstrings;
1686
1687         prog->numknownstrings = 0;
1688         prog->maxknownstrings = 0;
1689         prog->knownstrings = NULL;
1690         prog->knownstrings_freeable = NULL;
1691
1692         Mem_ExpandableArray_NewArray(&prog->stringbuffersarray, prog->progs_mempool, sizeof(prvm_stringbuffer_t), 64);
1693
1694         prog->globaldefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_globaldefs);
1695
1696         // we need to expand the fielddefs list to include all the engine fields,
1697         // so allocate a new place for it
1698         infielddefs = (ddef_t *)((unsigned char *)prog->progs + prog->progs->ofs_fielddefs);
1699         //                                                                                              ( + DPFIELDS                       )
1700         prog->fielddefs = (ddef_t *)Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t));
1701
1702         prog->statements = (dstatement_t *)((unsigned char *)prog->progs + prog->progs->ofs_statements);
1703
1704         prog->statement_profile = (double *)Mem_Alloc(prog->progs_mempool, prog->progs->numstatements * sizeof(*prog->statement_profile));
1705
1706         // moved edict_size calculation down below field adding code
1707
1708         //pr_global_struct = (globalvars_t *)((unsigned char *)progs + progs->ofs_globals);
1709         prog->globals.generic = (float *)((unsigned char *)prog->progs + prog->progs->ofs_globals);
1710
1711 // byte swap the lumps
1712         for (i=0 ; i<prog->progs->numstatements ; i++)
1713         {
1714                 prog->statements[i].op = LittleShort(prog->statements[i].op);
1715                 prog->statements[i].a = LittleShort(prog->statements[i].a);
1716                 prog->statements[i].b = LittleShort(prog->statements[i].b);
1717                 prog->statements[i].c = LittleShort(prog->statements[i].c);
1718         }
1719
1720         prog->functions = (mfunction_t *)Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions);
1721         for (i = 0;i < prog->progs->numfunctions;i++)
1722         {
1723                 prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
1724                 prog->functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
1725                 prog->functions[i].s_name = LittleLong (dfunctions[i].s_name);
1726                 prog->functions[i].s_file = LittleLong (dfunctions[i].s_file);
1727                 prog->functions[i].numparms = LittleLong (dfunctions[i].numparms);
1728                 prog->functions[i].locals = LittleLong (dfunctions[i].locals);
1729                 memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
1730         }
1731
1732         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
1733         {
1734                 prog->globaldefs[i].type = LittleShort (prog->globaldefs[i].type);
1735                 prog->globaldefs[i].ofs = LittleShort (prog->globaldefs[i].ofs);
1736                 prog->globaldefs[i].s_name = LittleLong (prog->globaldefs[i].s_name);
1737         }
1738
1739         // copy the progs fields to the new fields list
1740         for (i = 0;i < prog->progs->numfielddefs;i++)
1741         {
1742                 prog->fielddefs[i].type = LittleShort (infielddefs[i].type);
1743                 if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
1744                         PRVM_ERROR ("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", PRVM_NAME);
1745                 prog->fielddefs[i].ofs = LittleShort (infielddefs[i].ofs);
1746                 prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
1747         }
1748
1749         // append the required fields
1750         for (i = 0;i < (int) numrequiredfields;i++)
1751         {
1752                 prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type;
1753                 prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields;
1754                 prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name);
1755                 if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector)
1756                         prog->progs->entityfields += 3;
1757                 else
1758                         prog->progs->entityfields++;
1759                 prog->progs->numfielddefs++;
1760         }
1761
1762         // check required functions
1763         for(i=0 ; i < numrequiredfunc ; i++)
1764                 if(PRVM_ED_FindFunction(required_func[i]) == 0)
1765                         PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_func[i], filename);
1766
1767         // check required globals
1768         for(i=0 ; i < numrequiredglobals ; i++)
1769                 if(PRVM_ED_FindGlobal(required_global[i]) == 0)
1770                         PRVM_ERROR("%s: %s not found in %s",PRVM_NAME, required_global[i], filename);
1771
1772         for (i=0 ; i<prog->progs->numglobals ; i++)
1773                 ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]);
1774
1775         // moved edict_size calculation down here, below field adding code
1776         // LordHavoc: this no longer includes the prvm_edict_t header
1777         prog->edict_size = prog->progs->entityfields * 4;
1778         prog->edictareasize = prog->edict_size * prog->limit_edicts;
1779
1780         // LordHavoc: bounds check anything static
1781         for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++)
1782         {
1783                 switch (st->op)
1784                 {
1785                 case OP_IF:
1786                 case OP_IFNOT:
1787                         if ((unsigned short) st->a >= prog->progs->numglobals || st->b + i < 0 || st->b + i >= prog->progs->numstatements)
1788                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s", i, PRVM_NAME);
1789                         break;
1790                 case OP_GOTO:
1791                         if (st->a + i < 0 || st->a + i >= prog->progs->numstatements)
1792                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s", i, PRVM_NAME);
1793                         break;
1794                 // global global global
1795                 case OP_ADD_F:
1796                 case OP_ADD_V:
1797                 case OP_SUB_F:
1798                 case OP_SUB_V:
1799                 case OP_MUL_F:
1800                 case OP_MUL_V:
1801                 case OP_MUL_FV:
1802                 case OP_MUL_VF:
1803                 case OP_DIV_F:
1804                 case OP_BITAND:
1805                 case OP_BITOR:
1806                 case OP_GE:
1807                 case OP_LE:
1808                 case OP_GT:
1809                 case OP_LT:
1810                 case OP_AND:
1811                 case OP_OR:
1812                 case OP_EQ_F:
1813                 case OP_EQ_V:
1814                 case OP_EQ_S:
1815                 case OP_EQ_E:
1816                 case OP_EQ_FNC:
1817                 case OP_NE_F:
1818                 case OP_NE_V:
1819                 case OP_NE_S:
1820                 case OP_NE_E:
1821                 case OP_NE_FNC:
1822                 case OP_ADDRESS:
1823                 case OP_LOAD_F:
1824                 case OP_LOAD_FLD:
1825                 case OP_LOAD_ENT:
1826                 case OP_LOAD_S:
1827                 case OP_LOAD_FNC:
1828                 case OP_LOAD_V:
1829                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
1830                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)", i);
1831                         break;
1832                 // global none global
1833                 case OP_NOT_F:
1834                 case OP_NOT_V:
1835                 case OP_NOT_S:
1836                 case OP_NOT_FNC:
1837                 case OP_NOT_ENT:
1838                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
1839                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
1840                         break;
1841                 // 2 globals
1842                 case OP_STOREP_F:
1843                 case OP_STOREP_ENT:
1844                 case OP_STOREP_FLD:
1845                 case OP_STOREP_S:
1846                 case OP_STOREP_FNC:
1847                 case OP_STORE_F:
1848                 case OP_STORE_ENT:
1849                 case OP_STORE_FLD:
1850                 case OP_STORE_S:
1851                 case OP_STORE_FNC:
1852                 case OP_STATE:
1853                 case OP_STOREP_V:
1854                 case OP_STORE_V:
1855                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals)
1856                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
1857                         break;
1858                 // 1 global
1859                 case OP_CALL0:
1860                 case OP_CALL1:
1861                 case OP_CALL2:
1862                 case OP_CALL3:
1863                 case OP_CALL4:
1864                 case OP_CALL5:
1865                 case OP_CALL6:
1866                 case OP_CALL7:
1867                 case OP_CALL8:
1868                 case OP_DONE:
1869                 case OP_RETURN:
1870                         if ((unsigned short) st->a >= prog->progs->numglobals)
1871                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s", i, PRVM_NAME);
1872                         break;
1873                 default:
1874                         Con_DPrintf("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", st->op, i, PRVM_NAME);
1875                         break;
1876                 }
1877         }
1878
1879         PRVM_LoadLNO(filename);
1880
1881         PRVM_Init_Exec();
1882
1883         prog->loaded = TRUE;
1884
1885         // set flags & ddef_ts in prog
1886
1887         prog->flag = 0;
1888
1889         PRVM_FindOffsets();
1890
1891         PRVM_GCALL(init_cmd)();
1892
1893         // init mempools
1894         PRVM_MEM_Alloc();
1895 }
1896
1897
1898 void PRVM_Fields_f (void)
1899 {
1900         int i, j, ednum, used, usedamount;
1901         int *counts;
1902         char tempstring[MAX_INPUTLINE], tempstring2[260];
1903         const char *name;
1904         prvm_edict_t *ed;
1905         ddef_t *d;
1906         int *v;
1907
1908         // TODO
1909         /*
1910         if (!sv.active)
1911         {
1912                 Con_Print("no progs loaded\n");
1913                 return;
1914         }
1915         */
1916
1917         if(Cmd_Argc() != 2)
1918         {
1919                 Con_Print("prvm_fields <program name>\n");
1920                 return;
1921         }
1922
1923         PRVM_Begin;
1924         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
1925                 return;
1926
1927         counts = (int *)Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int));
1928         for (ednum = 0;ednum < prog->max_edicts;ednum++)
1929         {
1930                 ed = PRVM_EDICT_NUM(ednum);
1931                 if (ed->priv.required->free)
1932                         continue;
1933                 for (i = 1;i < prog->progs->numfielddefs;i++)
1934                 {
1935                         d = &prog->fielddefs[i];
1936                         name = PRVM_GetString(d->s_name);
1937                         if (name[strlen(name)-2] == '_')
1938                                 continue;       // skip _x, _y, _z vars
1939                         v = (int *)((char *)ed->fields.vp + d->ofs*4);
1940                         // if the value is still all 0, skip the field
1941                         for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
1942                         {
1943                                 if (v[j])
1944                                 {
1945                                         counts[i]++;
1946                                         break;
1947                                 }
1948                         }
1949                 }
1950         }
1951         used = 0;
1952         usedamount = 0;
1953         tempstring[0] = 0;
1954         for (i = 0;i < prog->progs->numfielddefs;i++)
1955         {
1956                 d = &prog->fielddefs[i];
1957                 name = PRVM_GetString(d->s_name);
1958                 if (name[strlen(name)-2] == '_')
1959                         continue;       // skip _x, _y, _z vars
1960                 switch(d->type & ~DEF_SAVEGLOBAL)
1961                 {
1962                 case ev_string:
1963                         strlcat(tempstring, "string   ", sizeof(tempstring));
1964                         break;
1965                 case ev_entity:
1966                         strlcat(tempstring, "entity   ", sizeof(tempstring));
1967                         break;
1968                 case ev_function:
1969                         strlcat(tempstring, "function ", sizeof(tempstring));
1970                         break;
1971                 case ev_field:
1972                         strlcat(tempstring, "field    ", sizeof(tempstring));
1973                         break;
1974                 case ev_void:
1975                         strlcat(tempstring, "void     ", sizeof(tempstring));
1976                         break;
1977                 case ev_float:
1978                         strlcat(tempstring, "float    ", sizeof(tempstring));
1979                         break;
1980                 case ev_vector:
1981                         strlcat(tempstring, "vector   ", sizeof(tempstring));
1982                         break;
1983                 case ev_pointer:
1984                         strlcat(tempstring, "pointer  ", sizeof(tempstring));
1985                         break;
1986                 default:
1987                         dpsnprintf (tempstring2, sizeof(tempstring2), "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
1988                         strlcat(tempstring, tempstring2, sizeof(tempstring));
1989                         break;
1990                 }
1991                 if (strlen(name) > sizeof(tempstring2)-4)
1992                 {
1993                         memcpy (tempstring2, name, sizeof(tempstring2)-4);
1994                         tempstring2[sizeof(tempstring2)-4] = tempstring2[sizeof(tempstring2)-3] = tempstring2[sizeof(tempstring2)-2] = '.';
1995                         tempstring2[sizeof(tempstring2)-1] = 0;
1996                         name = tempstring2;
1997                 }
1998                 strlcat(tempstring, name, sizeof(tempstring));
1999                 for (j = (int)strlen(name);j < 25;j++)
2000                         strlcat(tempstring, " ", sizeof(tempstring));
2001                 dpsnprintf(tempstring2, sizeof(tempstring2), "%5d", counts[i]);
2002                 strlcat(tempstring, tempstring2, sizeof(tempstring));
2003                 strlcat(tempstring, "\n", sizeof(tempstring));
2004                 if (strlen(tempstring) >= sizeof(tempstring)/2)
2005                 {
2006                         Con_Print(tempstring);
2007                         tempstring[0] = 0;
2008                 }
2009                 if (counts[i])
2010                 {
2011                         used++;
2012                         usedamount += prvm_type_size[d->type & ~DEF_SAVEGLOBAL];
2013                 }
2014         }
2015         Mem_Free(counts);
2016         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);
2017
2018         PRVM_End;
2019 }
2020
2021 void PRVM_Globals_f (void)
2022 {
2023         int i;
2024         const char *wildcard;
2025         int numculled;
2026                 numculled = 0;
2027         // TODO
2028         /*if (!sv.active)
2029         {
2030                 Con_Print("no progs loaded\n");
2031                 return;
2032         }*/
2033         if(Cmd_Argc () < 2 || Cmd_Argc() > 3)
2034         {
2035                 Con_Print("prvm_globals <program name> <optional name wildcard>\n");
2036                 return;
2037         }
2038
2039         PRVM_Begin;
2040         if(!PRVM_SetProgFromString (Cmd_Argv (1)))
2041                 return;
2042
2043         if( Cmd_Argc() == 3)
2044                 wildcard = Cmd_Argv(2);
2045         else
2046                 wildcard = NULL;
2047
2048         Con_Printf("%s :", PRVM_NAME);
2049
2050         for (i = 0;i < prog->progs->numglobaldefs;i++)
2051         {
2052                 if(wildcard)
2053                         if( !matchpattern( PRVM_GetString(prog->globaldefs[i].s_name), wildcard, 1) )
2054                         {
2055                                 numculled++;
2056                                 continue;
2057                         }
2058                 Con_Printf("%s\n", PRVM_GetString(prog->globaldefs[i].s_name));
2059         }
2060         Con_Printf("%i global variables, %i culled, totalling %i bytes\n", prog->progs->numglobals, numculled, prog->progs->numglobals * 4);
2061
2062         PRVM_End;
2063 }
2064
2065 /*
2066 ===============
2067 PRVM_Global
2068 ===============
2069 */
2070 void PRVM_Global_f(void)
2071 {
2072         ddef_t *global;
2073         if( Cmd_Argc() != 3 ) {
2074                 Con_Printf( "prvm_global <program name> <global name>\n" );
2075                 return;
2076         }
2077
2078         PRVM_Begin;
2079         if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
2080                 return;
2081
2082         global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
2083         if( !global )
2084                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
2085         else
2086                 Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( (etype_t)global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) );
2087         PRVM_End;
2088 }
2089
2090 /*
2091 ===============
2092 PRVM_GlobalSet
2093 ===============
2094 */
2095 void PRVM_GlobalSet_f(void)
2096 {
2097         ddef_t *global;
2098         if( Cmd_Argc() != 4 ) {
2099                 Con_Printf( "prvm_globalset <program name> <global name> <value>\n" );
2100                 return;
2101         }
2102
2103         PRVM_Begin;
2104         if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
2105                 return;
2106
2107         global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
2108         if( !global )
2109                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
2110         else
2111                 PRVM_ED_ParseEpair( NULL, global, Cmd_Argv(3), true );
2112         PRVM_End;
2113 }
2114
2115 /*
2116 ===============
2117 PRVM_Init
2118 ===============
2119 */
2120 void PRVM_Init (void)
2121 {
2122         Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f, "print all data about an entity number in the selected VM (server, client, menu)");
2123         Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f, "prints all data about all entities in the selected VM (server, client, menu)");
2124         Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f, "prints number of active entities in the selected VM (server, client, menu)");
2125         Cmd_AddCommand ("prvm_profile", PRVM_Profile_f, "prints execution statistics about the most used QuakeC functions in the selected VM (server, client, menu)");
2126         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)");
2127         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)");
2128         Cmd_AddCommand ("prvm_globals", PRVM_Globals_f, "prints all global variables in the selected VM (server, client, menu)");
2129         Cmd_AddCommand ("prvm_global", PRVM_Global_f, "prints value of a specified global variable in the selected VM (server, client, menu)");
2130         Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f, "sets value of a specified global variable in the selected VM (server, client, menu)");
2131         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)");
2132         Cmd_AddCommand ("prvm_printfunction", PRVM_PrintFunction_f, "prints a disassembly (QuakeC instructions) of the specified function in the selected VM (server, client, menu)");
2133         Cmd_AddCommand ("cl_cmd", PRVM_GameCommand_Client_f, "calls the client QC function GameCommand with the supplied string as argument");
2134         Cmd_AddCommand ("menu_cmd", PRVM_GameCommand_Menu_f, "calls the menu QC function GameCommand with the supplied string as argument");
2135         Cmd_AddCommand ("sv_cmd", PRVM_GameCommand_Server_f, "calls the server QC function GameCommand with the supplied string as argument");
2136
2137         // COMMANDLINEOPTION: PRVM: -noboundscheck disables the bounds checks (security hole if CSQC is in use!)
2138         prvm_boundscheck = !COM_CheckParm("-noboundscheck");
2139
2140         Cvar_RegisterVariable (&prvm_traceqc);
2141         Cvar_RegisterVariable (&prvm_statementprofiling);
2142         Cvar_RegisterVariable (&prvm_backtraceforwarnings);
2143         Cvar_RegisterVariable (&prvm_leaktest);
2144         Cvar_RegisterVariable (&prvm_leaktest_ignore_classnames);
2145         Cvar_RegisterVariable (&prvm_errordump);
2146
2147         // COMMANDLINEOPTION: PRVM: -norunaway disables the runaway loop check (it might be impossible to exit DarkPlaces if used!)
2148         prvm_runawaycheck = !COM_CheckParm("-norunaway");
2149
2150         //VM_Cmd_Init();
2151 }
2152
2153 /*
2154 ===============
2155 PRVM_InitProg
2156 ===============
2157 */
2158 void PRVM_InitProg(int prognr)
2159 {
2160         if(prognr < 0 || prognr >= PRVM_MAXPROGS)
2161                 Sys_Error("PRVM_InitProg: Invalid program number %i",prognr);
2162
2163         prog = &prog_list[prognr];
2164
2165         if(prog->loaded)
2166                 PRVM_ResetProg();
2167
2168         memset(prog, 0, sizeof(prvm_prog_t));
2169         prog->starttime = Sys_DoubleTime();
2170
2171         prog->error_cmd = Host_Error;
2172         prog->leaktest_active = prvm_leaktest.integer;
2173 }
2174
2175 int PRVM_GetProgNr()
2176 {
2177         return prog - prog_list;
2178 }
2179
2180 void *_PRVM_Alloc(size_t buffersize, const char *filename, int fileline)
2181 {
2182         return _Mem_Alloc(prog->progs_mempool, buffersize, filename, fileline);
2183 }
2184
2185 void _PRVM_Free(void *buffer, const char *filename, int fileline)
2186 {
2187         _Mem_Free(buffer, filename, fileline);
2188 }
2189
2190 void _PRVM_FreeAll(const char *filename, int fileline)
2191 {
2192         prog->progs = NULL;
2193         prog->fielddefs = NULL;
2194         prog->functions = NULL;
2195         _Mem_EmptyPool(prog->progs_mempool, filename, fileline);
2196 }
2197
2198 // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
2199 unsigned int PRVM_EDICT_NUM_ERROR(unsigned int n, char *filename, int fileline)
2200 {
2201         PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline);
2202         return 0;
2203 }
2204
2205 /*
2206 int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
2207 {
2208         PRVM_ERROR ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
2209         return 0;
2210 }
2211
2212 int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
2213 {
2214         int n;
2215         n = e - prog->edicts;
2216         if ((unsigned int)n >= prog->limit_edicts)
2217                 Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
2218         return n;
2219 }
2220
2221 //int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
2222 //{
2223 //      return e - prog->edicts;
2224 //}
2225
2226 //#define       PRVM_EDICT_TO_PROG(e) ((unsigned char *)(((prvm_edict_t *)e)->v) - (unsigned char *)(prog->edictsfields))
2227 //#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
2228 int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
2229 {
2230         int n;
2231         n = e - prog->edicts;
2232         if ((unsigned int)n >= (unsigned int)prog->max_edicts)
2233                 Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)", e, n, prog->edicts);
2234         return n;// EXPERIMENTAL
2235         //return (unsigned char *)e->v - (unsigned char *)prog->edictsfields;
2236 }
2237 prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
2238 {
2239         if ((unsigned int)n >= (unsigned int)prog->max_edicts)
2240                 Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i", n);
2241         return prog->edicts + n; // EXPERIMENTAL
2242         //return prog->edicts + ((n) / (progs->entityfields * 4));
2243 }
2244 */
2245
2246
2247 sizebuf_t vm_tempstringsbuf;
2248
2249 const char *PRVM_GetString(int num)
2250 {
2251         if (num >= 0)
2252         {
2253                 if (num < prog->stringssize)
2254                         return prog->strings + num;
2255                 else
2256 #if 1
2257                 if (num <= prog->stringssize + vm_tempstringsbuf.maxsize)
2258                 {
2259                         num -= prog->stringssize;
2260                         if (num < vm_tempstringsbuf.cursize)
2261                                 return (char *)vm_tempstringsbuf.data + num;
2262                         else
2263                         {
2264                                 VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
2265                                 return "";
2266                         }
2267                 }
2268                 else
2269 #endif
2270                 {
2271                         VM_Warning("PRVM_GetString: Invalid constant-string offset (%i >= %i prog->stringssize)\n", num, prog->stringssize);
2272                         return "";
2273                 }
2274         }
2275         else
2276         {
2277                 num = -1 - num;
2278 #if 0
2279                 if (num >= (1<<30))
2280                 {
2281                         // special range reserved for tempstrings
2282                         num -= (1<<30);
2283                         if (num < vm_tempstringsbuf.cursize)
2284                                 return (char *)vm_tempstringsbuf.data + num;
2285                         else
2286                         {
2287                                 VM_Warning("PRVM_GetString: Invalid temp-string offset (%i >= %i vm_tempstringsbuf.cursize)\n", num, vm_tempstringsbuf.cursize);
2288                                 return "";
2289                         }
2290                 }
2291                 else
2292 #endif
2293                 if (num < prog->numknownstrings)
2294                 {
2295                         if (!prog->knownstrings[num])
2296                                 VM_Warning("PRVM_GetString: Invalid zone-string offset (%i has been freed)\n", num);
2297                         return prog->knownstrings[num];
2298                 }
2299                 else
2300                 {
2301                         VM_Warning("PRVM_GetString: Invalid zone-string offset (%i >= %i)\n", num, prog->numknownstrings);
2302                         return "";
2303                 }
2304         }
2305 }
2306
2307 int PRVM_SetEngineString(const char *s)
2308 {
2309         int i;
2310         if (!s)
2311                 return 0;
2312         if (s >= prog->strings && s <= prog->strings + prog->stringssize)
2313                 PRVM_ERROR("PRVM_SetEngineString: s in prog->strings area");
2314         // if it's in the tempstrings area, use a reserved range
2315         // (otherwise we'd get millions of useless string offsets cluttering the database)
2316         if (s >= (char *)vm_tempstringsbuf.data && s < (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.maxsize)
2317 #if 1
2318                 return prog->stringssize + (s - (char *)vm_tempstringsbuf.data);
2319 #else
2320                 return -1 - ((1<<30) + (s - (char *)vm_tempstringsbuf.data));
2321 #endif
2322         // see if it's a known string address
2323         for (i = 0;i < prog->numknownstrings;i++)
2324                 if (prog->knownstrings[i] == s)
2325                         return -1 - i;
2326         // new unknown engine string
2327         if (developer.integer >= 200)
2328                 Con_Printf("new engine string %p = \"%s\"\n", s, s);
2329         for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
2330                 if (!prog->knownstrings[i])
2331                         break;
2332         if (i >= prog->numknownstrings)
2333         {
2334                 if (i >= prog->maxknownstrings)
2335                 {
2336                         const char **oldstrings = prog->knownstrings;
2337                         const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
2338                         const char **oldstrings_origin = prog->knownstrings_origin;
2339                         prog->maxknownstrings += 128;
2340                         prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2341                         prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
2342                         if(prog->leaktest_active)
2343                                 prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2344                         if (prog->numknownstrings)
2345                         {
2346                                 memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
2347                                 memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
2348                                 if(prog->leaktest_active)
2349                                         memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
2350                         }
2351                 }
2352                 prog->numknownstrings++;
2353         }
2354         prog->firstfreeknownstring = i + 1;
2355         prog->knownstrings[i] = s;
2356         prog->knownstrings_freeable[i] = false;
2357         if(prog->leaktest_active)
2358                 prog->knownstrings_origin[i] = NULL;
2359         return -1 - i;
2360 }
2361
2362 // temp string handling
2363
2364 // all tempstrings go into this buffer consecutively, and it is reset
2365 // whenever PRVM_ExecuteProgram returns to the engine
2366 // (technically each PRVM_ExecuteProgram call saves the cursize value and
2367 //  restores it on return, so multiple recursive calls can share the same
2368 //  buffer)
2369 // the buffer size is automatically grown as needed
2370
2371 int PRVM_SetTempString(const char *s)
2372 {
2373         int size;
2374         char *t;
2375         if (!s)
2376                 return 0;
2377         size = (int)strlen(s) + 1;
2378         if (developer.integer >= 300)
2379                 Con_Printf("PRVM_SetTempString: cursize %i, size %i\n", vm_tempstringsbuf.cursize, size);
2380         if (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size)
2381         {
2382                 sizebuf_t old = vm_tempstringsbuf;
2383                 if (vm_tempstringsbuf.cursize + size >= 1<<28)
2384                         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);
2385                 vm_tempstringsbuf.maxsize = max(vm_tempstringsbuf.maxsize, 65536);
2386                 while (vm_tempstringsbuf.maxsize < vm_tempstringsbuf.cursize + size)
2387                         vm_tempstringsbuf.maxsize *= 2;
2388                 if (vm_tempstringsbuf.maxsize != old.maxsize || vm_tempstringsbuf.data == NULL)
2389                 {
2390                         if (developer.integer >= 100)
2391                                 Con_Printf("PRVM_SetTempString: enlarging tempstrings buffer (%iKB -> %iKB)\n", old.maxsize/1024, vm_tempstringsbuf.maxsize/1024);
2392                         vm_tempstringsbuf.data = (unsigned char *) Mem_Alloc(sv_mempool, vm_tempstringsbuf.maxsize);
2393                         if (old.cursize)
2394                                 memcpy(vm_tempstringsbuf.data, old.data, old.cursize);
2395                         if (old.data)
2396                                 Mem_Free(old.data);
2397                 }
2398         }
2399         t = (char *)vm_tempstringsbuf.data + vm_tempstringsbuf.cursize;
2400         memcpy(t, s, size);
2401         vm_tempstringsbuf.cursize += size;
2402         return PRVM_SetEngineString(t);
2403 }
2404
2405 int PRVM_AllocString(size_t bufferlength, char **pointer)
2406 {
2407         int i;
2408         if (!bufferlength)
2409                 return 0;
2410         for (i = prog->firstfreeknownstring;i < prog->numknownstrings;i++)
2411                 if (!prog->knownstrings[i])
2412                         break;
2413         if (i >= prog->numknownstrings)
2414         {
2415                 if (i >= prog->maxknownstrings)
2416                 {
2417                         const char **oldstrings = prog->knownstrings;
2418                         const unsigned char *oldstrings_freeable = prog->knownstrings_freeable;
2419                         const char **oldstrings_origin = prog->knownstrings_origin;
2420                         prog->maxknownstrings += 128;
2421                         prog->knownstrings = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2422                         prog->knownstrings_freeable = (unsigned char *)PRVM_Alloc(prog->maxknownstrings * sizeof(unsigned char));
2423                         if(prog->leaktest_active)
2424                                 prog->knownstrings_origin = (const char **)PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
2425                         if (prog->numknownstrings)
2426                         {
2427                                 memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
2428                                 memcpy((char **)prog->knownstrings_freeable, oldstrings_freeable, prog->numknownstrings * sizeof(unsigned char));
2429                                 if(prog->leaktest_active)
2430                                         memcpy((char **)prog->knownstrings_origin, oldstrings_origin, prog->numknownstrings * sizeof(char *));
2431                         }
2432                         // TODO why not Mem_Free the old ones?
2433                 }
2434                 prog->numknownstrings++;
2435         }
2436         prog->firstfreeknownstring = i + 1;
2437         prog->knownstrings[i] = (char *)PRVM_Alloc(bufferlength);
2438         prog->knownstrings_freeable[i] = true;
2439         if(prog->leaktest_active)
2440                 prog->knownstrings_origin[i] = PRVM_AllocationOrigin();
2441         if (pointer)
2442                 *pointer = (char *)(prog->knownstrings[i]);
2443         return -1 - i;
2444 }
2445
2446 void PRVM_FreeString(int num)
2447 {
2448         if (num == 0)
2449                 PRVM_ERROR("PRVM_FreeString: attempt to free a NULL string");
2450         else if (num >= 0 && num < prog->stringssize)
2451                 PRVM_ERROR("PRVM_FreeString: attempt to free a constant string");
2452         else if (num < 0 && num >= -prog->numknownstrings)
2453         {
2454                 num = -1 - num;
2455                 if (!prog->knownstrings[num])
2456                         PRVM_ERROR("PRVM_FreeString: attempt to free a non-existent or already freed string");
2457                 if (!prog->knownstrings_freeable[num])
2458                         PRVM_ERROR("PRVM_FreeString: attempt to free a string owned by the engine");
2459                 PRVM_Free((char *)prog->knownstrings[num]);
2460                 if(prog->leaktest_active)
2461                         if(prog->knownstrings_origin[num])
2462                                 PRVM_Free((char *)prog->knownstrings_origin[num]);
2463                 prog->knownstrings[num] = NULL;
2464                 prog->knownstrings_freeable[num] = false;
2465                 prog->firstfreeknownstring = min(prog->firstfreeknownstring, num);
2466         }
2467         else
2468                 PRVM_ERROR("PRVM_FreeString: invalid string offset %i", num);
2469 }
2470
2471 static qboolean PRVM_IsStringReferenced(string_t string)
2472 {
2473         int i, j;
2474
2475         for (i = 0;i < prog->progs->numglobaldefs;i++)
2476         {
2477                 ddef_t *d = &prog->globaldefs[i];
2478                 if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
2479                         continue;
2480                 if(string == ((prvm_eval_t *) &prog->globals.generic[d->ofs])->string)
2481                         return true;
2482         }
2483
2484         for(j = 0; j < prog->num_edicts; ++j)
2485         {
2486                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
2487                 if (ed->priv.required->free)
2488                         continue;
2489                 for (i=0; i<prog->progs->numfielddefs; ++i)
2490                 {
2491                         ddef_t *d = &prog->fielddefs[i];
2492                         if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_string)
2493                                 continue;
2494                         if(string == ((prvm_eval_t *) &((float*)ed->fields.vp)[d->ofs])->string)
2495                                 return true;
2496                 }
2497         }
2498
2499         return false;
2500 }
2501
2502 static qboolean PRVM_IsEdictRelevant(prvm_edict_t *edict)
2503 {
2504         if(PRVM_NUM_FOR_EDICT(edict) <= prog->reserved_edicts)
2505                 return true; // world or clients
2506         switch(prog - prog_list)
2507         {
2508                 case PRVM_SERVERPROG:
2509                         {
2510                                 entvars_t *ev = edict->fields.server;
2511                                 if(ev->solid) // can block other stuff, or is a trigger?
2512                                         return true;
2513                                 if(ev->modelindex) // visible ent?
2514                                         return true;
2515                                 if(ev->effects) // particle effect?
2516                                         return true;
2517                                 if(ev->think) // has a think function?
2518                                         if(ev->nextthink > 0) // that actually will eventually run?
2519                                                 return true;
2520                                 if(ev->takedamage)
2521                                         return true;
2522                                 if(*prvm_leaktest_ignore_classnames.string)
2523                                 {
2524                                         if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname))))
2525                                                 return true;
2526                                 }
2527                         }
2528                         break;
2529                 case PRVM_CLIENTPROG:
2530                         {
2531                                 // TODO someone add more stuff here
2532                                 cl_entvars_t *ev = edict->fields.client;
2533                                 if(ev->entnum) // csqc networked
2534                                         return true;
2535                                 if(ev->modelindex) // visible ent?
2536                                         return true;
2537                                 if(ev->effects) // particle effect?
2538                                         return true;
2539                                 if(ev->think) // has a think function?
2540                                         if(ev->nextthink > 0) // that actually will eventually run?
2541                                                 return true;
2542                                 if(*prvm_leaktest_ignore_classnames.string)
2543                                 {
2544                                         if(strstr(va(" %s ", prvm_leaktest_ignore_classnames.string), va(" %s ", PRVM_GetString(ev->classname))))
2545                                                 return true;
2546                                 }
2547                         }
2548                         break;
2549                 case PRVM_MENUPROG:
2550                         // menu prog does not have classnames
2551                         break;
2552         }
2553         return false;
2554 }
2555
2556 static qboolean PRVM_IsEdictReferenced(prvm_edict_t *edict, int mark)
2557 {
2558         int i, j;
2559         int edictnum = PRVM_NUM_FOR_EDICT(edict);
2560         const char *targetname = NULL;
2561
2562         switch(prog - prog_list)
2563         {
2564                 case PRVM_SERVERPROG:
2565                         targetname = PRVM_GetString(edict->fields.server->targetname);
2566                         break;
2567         }
2568
2569         if(targetname)
2570                 if(!*targetname) // ""
2571                         targetname = NULL;
2572
2573         for (i = 0;i < prog->progs->numglobaldefs;i++)
2574         {
2575                 ddef_t *d = &prog->globaldefs[i];
2576                 if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
2577                         continue;
2578                 if(edictnum == ((prvm_eval_t *) &prog->globals.generic[d->ofs])->edict)
2579                         return true;
2580         }
2581
2582         for(j = 0; j < prog->num_edicts; ++j)
2583         {
2584                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
2585                 if (ed->priv.required->mark < mark)
2586                         continue;
2587                 if(ed == edict)
2588                         continue;
2589                 if(targetname)
2590                 {
2591                         const char *target = PRVM_GetString(ed->fields.server->target);
2592                         if(target)
2593                                 if(!strcmp(target, targetname))
2594                                         return true;
2595                 }
2596                 for (i=0; i<prog->progs->numfielddefs; ++i)
2597                 {
2598                         ddef_t *d = &prog->fielddefs[i];
2599                         if((etype_t)((int) d->type & ~DEF_SAVEGLOBAL) != ev_entity)
2600                                 continue;
2601                         if(edictnum == ((prvm_eval_t *) &((float*)ed->fields.vp)[d->ofs])->edict)
2602                                 return true;
2603                 }
2604         }
2605
2606         return false;
2607 }
2608
2609 static void PRVM_MarkReferencedEdicts()
2610 {
2611         int j;
2612         qboolean found_new;
2613         int stage;
2614
2615         for(j = 0; j < prog->num_edicts; ++j)
2616         {
2617                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
2618                 if(ed->priv.required->free)
2619                         continue;
2620                 ed->priv.required->mark = PRVM_IsEdictRelevant(ed) ? 1 : 0;
2621         }
2622
2623         stage = 1;
2624         do
2625         {
2626                 found_new = false;
2627                 for(j = 0; j < prog->num_edicts; ++j)
2628                 {
2629                         prvm_edict_t *ed = PRVM_EDICT_NUM(j);
2630                         if(ed->priv.required->free)
2631                                 continue;
2632                         if(ed->priv.required->mark)
2633                                 continue;
2634                         if(PRVM_IsEdictReferenced(ed, stage))
2635                         {
2636                                 ed->priv.required->mark = stage + 1;
2637                                 found_new = true;
2638                         }
2639                 }
2640                 ++stage;
2641         }
2642         while(found_new);
2643         Con_DPrintf("leak check used %d stages to find all references\n", stage);
2644 }
2645
2646 void PRVM_LeakTest()
2647 {
2648         int i, j;
2649         qboolean leaked = false;
2650
2651         if(!prog->leaktest_active)
2652                 return;
2653
2654         // 1. Strings
2655         for (i = 0; i < prog->numknownstrings; ++i)
2656         {
2657                 if(prog->knownstrings[i])
2658                 if(prog->knownstrings_freeable[i])
2659                 if(prog->knownstrings_origin[i])
2660                 if(!PRVM_IsStringReferenced(-1 - i))
2661                 {
2662                         Con_Printf("Unreferenced string found!\n  Value: %s\n  Origin: %s\n", prog->knownstrings[i], prog->knownstrings_origin[i]);
2663                         leaked = true;
2664                 }
2665         }
2666
2667         // 2. Edicts
2668         PRVM_MarkReferencedEdicts();
2669         for(j = 0; j < prog->num_edicts; ++j)
2670         {
2671                 prvm_edict_t *ed = PRVM_EDICT_NUM(j);
2672                 if(ed->priv.required->free)
2673                         continue;
2674                 if(!ed->priv.required->mark)
2675                 if(ed->priv.required->allocation_origin)
2676                 {
2677                         Con_Printf("Unreferenced edict found!\n  Allocated at: %s\n", ed->priv.required->allocation_origin);
2678                         PRVM_ED_Print(ed, NULL);
2679                         Con_Print("\n");
2680                         leaked = true;
2681                 }
2682         }
2683
2684         for (i = 0; i < (int)Mem_ExpandableArray_IndexRange(&prog->stringbuffersarray); ++i)
2685         {
2686                 prvm_stringbuffer_t *stringbuffer = (prvm_stringbuffer_t*) Mem_ExpandableArray_RecordAtIndex(&prog->stringbuffersarray, i);
2687                 if(stringbuffer)
2688                 if(stringbuffer->origin)
2689                 {
2690                         Con_Printf("Open string buffer handle found!\n  Allocated at: %s\n", stringbuffer->origin);
2691                         leaked = true;
2692                 }
2693         }
2694
2695         for(i = 0; i < PRVM_MAX_OPENFILES; ++i)
2696         {
2697                 if(prog->openfiles[i])
2698                 if(prog->openfiles_origin[i])
2699                 {
2700                         Con_Printf("Open file handle found!\n  Allocated at: %s\n", prog->openfiles_origin[i]);
2701                         leaked = true;
2702                 }
2703         }
2704
2705         for(i = 0; i < PRVM_MAX_OPENSEARCHES; ++i)
2706         {
2707                 if(prog->opensearches[i])
2708                 if(prog->opensearches_origin[i])
2709                 {
2710                         Con_Printf("Open search handle found!\n  Allocated at: %s\n", prog->opensearches_origin[i]);
2711                         leaked = true;
2712                 }
2713         }
2714
2715         if(!leaked)
2716                 Con_Printf("Congratulations. No leaks found.\n");
2717 }