prvm_edict.c

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