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