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