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