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);
  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 cvar_t  prvm_boundscheck = {0, "prvm_boundscheck", "1"};
  36 // LordHavoc: prints every opcode as it executes - warning: this is significant spew
  37 cvar_t  prvm_traceqc = {0, "prvm_traceqc", "0"};
  38
  39 //============================================================================
  40 // mempool handling
  41
  42 /*
  43 ===============
  44 PRVM_MEM_Alloc
  45 ===============
  46 */
  47 void PRVM_MEM_Alloc(void)
  48 {
  49         int i;
  50
  51         // reserve space for the null entity aka world
  52         // check bound of max_edicts
  53         prog->max_edicts = bound(1 + prog->reserved_edicts, prog->max_edicts, prog->limit_edicts);
  54         prog->num_edicts = bound(1 + prog->reserved_edicts, prog->num_edicts, prog->max_edicts);
  55
  56         // edictprivate_size has to be min as big prvm_edict_private_t
  57         prog->edictprivate_size = max(prog->edictprivate_size,(int)sizeof(prvm_edict_private_t));
  58
  59         // alloc edicts
  60         prog->edicts = Mem_Alloc(prog->progs_mempool,prog->limit_edicts * sizeof(prvm_edict_t));
  61
  62         // alloc edict private space
  63         prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
  64
  65         // alloc edict fields
  66         prog->edictsfields = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edict_size);
  67
  68         // set edict pointers
  69         for(i = 0; i < prog->max_edicts; i++)
  70         {
  71                 prog->edicts[i].priv.required = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
  72                 prog->edicts[i].fields.vp = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
  73         }
  74 }
  75
  76 /*
  77 ===============
  78 PRVM_MEM_IncreaseEdicts
  79 ===============
  80 */
  81 void PRVM_MEM_IncreaseEdicts(void)
  82 {
  83         int             i;
  84         int             oldmaxedicts = prog->max_edicts;
  85         void    *oldedictsfields = prog->edictsfields;
  86         void    *oldedictprivate = prog->edictprivate;
  87
  88         if(prog->max_edicts >= prog->limit_edicts)
  89                 return;
  90
  91         PRVM_GCALL(begin_increase_edicts)();
  92
  93         // increase edicts
  94         prog->max_edicts = min(prog->max_edicts + 256, prog->limit_edicts);
  95
  96         prog->edictsfields = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edict_size);
  97         prog->edictprivate = Mem_Alloc(prog->progs_mempool, prog->max_edicts * prog->edictprivate_size);
  98
  99         memcpy(prog->edictsfields, oldedictsfields, oldmaxedicts * prog->edict_size);
 100         memcpy(prog->edictprivate, oldedictprivate, oldmaxedicts * prog->edictprivate_size);
 101
 102         //set e and v pointers
 103         for(i = 0; i < prog->max_edicts; i++)
 104         {
 105                 prog->edicts[i].priv.required  = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
 106                 prog->edicts[i].fields.vp = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
 107         }
 108
 109         PRVM_GCALL(end_increase_edicts)();
 110
 111         Mem_Free(oldedictsfields);
 112         Mem_Free(oldedictprivate);
 113 }
 114
 115 //============================================================================
 116 // normal prvm
 117
 118 int PRVM_ED_FindFieldOffset(const char *field)
 119 {
 120         ddef_t *d;
 121         d = PRVM_ED_FindField(field);
 122         if (!d)
 123                 return 0;
 124         return d->ofs*4;
 125 }
 126
 127 qboolean PRVM_ProgLoaded(int prognr)
 128 {
 129         if(prognr < 0 || prognr >= PRVM_MAXPROGS)
 130                 return FALSE;
 131
 132         return (prog_list[prognr].loaded ? TRUE : FALSE);
 133 }
 134
 135 /*
 136 =================
 137 PRVM_SetProgFromString
 138 =================
 139 */
 140 // perhaps add a return value when the str doesnt exist
 141 qboolean PRVM_SetProgFromString(const char *str)
 142 {
 143         int i = 0;
 144         for(; i < PRVM_MAXPROGS ; i++)
 145                 if(prog_list[i].name && !strcmp(prog_list[i].name,str))
 146                 {
 147                         if(prog_list[i].loaded)
 148                         {
 149                                 prog = &prog_list[i];
 150                                 return TRUE;
 151                         }
 152                         else
 153                         {
 154                                 Con_Printf("%s not loaded !\n",PRVM_NAME);
 155                                 return FALSE;
 156                         }
 157                 }
 158
 159         Con_Printf("Invalid program name %s !\n", str);
 160         return FALSE;
 161 }
 162
 163 /*
 164 =================
 165 PRVM_SetProg
 166 =================
 167 */
 168 void PRVM_SetProg(int prognr)
 169 {
 170         if(0 <= prognr && prognr < PRVM_MAXPROGS)
 171         {
 172                 if(prog_list[prognr].loaded)
 173                         prog = &prog_list[prognr];
 174                 else
 175                         PRVM_ERROR("%i not loaded !\n", prognr);
 176                 return;
 177         }
 178         PRVM_ERROR("Invalid program number %i\n", prognr);
 179 }
 180
 181 /*
 182 =================
 183 PRVM_ED_ClearEdict
 184
 185 Sets everything to NULL
 186 =================
 187 */
 188 void PRVM_ED_ClearEdict (prvm_edict_t *e)
 189 {
 190         memset (e->fields.vp, 0, prog->progs->entityfields * 4);
 191         e->priv.required->free = false;
 192
 193         // AK: Let the init_edict function determine if something needs to be initialized
 194         PRVM_GCALL(init_edict)(e);
 195 }
 196
 197 /*
 198 =================
 199 PRVM_ED_Alloc
 200
 201 Either finds a free edict, or allocates a new one.
 202 Try to avoid reusing an entity that was recently freed, because it
 203 can cause the client to think the entity morphed into something else
 204 instead of being removed and recreated, which can cause interpolated
 205 angles and bad trails.
 206 =================
 207 */
 208 prvm_edict_t *PRVM_ED_Alloc (void)
 209 {
 210         int                     i;
 211         prvm_edict_t            *e;
 212
 213         // the client qc dont need maxclients
 214         // thus it doesnt need to use svs.maxclients
 215         // AK:  changed i=svs.maxclients+1
 216         // AK:  changed so the edict 0 wont spawn -> used as reserved/world entity
 217         //              although the menu/client has no world
 218         for (i = prog->reserved_edicts + 1;i < prog->num_edicts;i++)
 219         {
 220                 e = PRVM_EDICT_NUM(i);
 221                 // the first couple seconds of server time can involve a lot of
 222                 // freeing and allocating, so relax the replacement policy
 223                 if (e->priv.required->free && ( e->priv.required->freetime < 2 || (*prog->time - e->priv.required->freetime) > 0.5 ) )
 224                 {
 225                         PRVM_ED_ClearEdict (e);
 226                         return e;
 227                 }
 228         }
 229
 230         if (i == prog->limit_edicts)
 231                 PRVM_ERROR ("%s: PRVM_ED_Alloc: no free edicts",PRVM_NAME);
 232
 233         prog->num_edicts++;
 234         if (prog->num_edicts >= prog->max_edicts)
 235                 PRVM_MEM_IncreaseEdicts();
 236
 237         e = PRVM_EDICT_NUM(i);
 238         PRVM_ED_ClearEdict (e);
 239
 240         return e;
 241 }
 242
 243 /*
 244 =================
 245 PRVM_ED_Free
 246
 247 Marks the edict as free
 248 FIXME: walk all entities and NULL out references to this entity
 249 =================
 250 */
 251 void PRVM_ED_Free (prvm_edict_t *ed)
 252 {
 253         // dont delete the null entity (world) or reserved edicts
 254         if(PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
 255                 return;
 256
 257         PRVM_GCALL(free_edict)(ed);
 258
 259         ed->priv.required->free = true;
 260         ed->priv.required->freetime = *prog->time;
 261 }
 262
 263 //===========================================================================
 264
 265 /*
 266 ============
 267 PRVM_ED_GlobalAtOfs
 268 ============
 269 */
 270 ddef_t *PRVM_ED_GlobalAtOfs (int ofs)
 271 {
 272         ddef_t          *def;
 273         int                     i;
 274
 275         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
 276         {
 277                 def = &prog->globaldefs[i];
 278                 if (def->ofs == ofs)
 279                         return def;
 280         }
 281         return NULL;
 282 }
 283
 284 /*
 285 ============
 286 PRVM_ED_FieldAtOfs
 287 ============
 288 */
 289 ddef_t *PRVM_ED_FieldAtOfs (int ofs)
 290 {
 291         ddef_t          *def;
 292         int                     i;
 293
 294         for (i=0 ; i<prog->progs->numfielddefs ; i++)
 295         {
 296                 def = &prog->fielddefs[i];
 297                 if (def->ofs == ofs)
 298                         return def;
 299         }
 300         return NULL;
 301 }
 302
 303 /*
 304 ============
 305 PRVM_ED_FindField
 306 ============
 307 */
 308 ddef_t *PRVM_ED_FindField (const char *name)
 309 {
 310         ddef_t *def;
 311         int i;
 312
 313         for (i=0 ; i<prog->progs->numfielddefs ; i++)
 314         {
 315                 def = &prog->fielddefs[i];
 316                 if (!strcmp(PRVM_GetString(def->s_name), name))
 317                         return def;
 318         }
 319         return NULL;
 320 }
 321
 322 /*
 323 ============
 324 PRVM_ED_FindGlobal
 325 ============
 326 */
 327 ddef_t *PRVM_ED_FindGlobal (const char *name)
 328 {
 329         ddef_t *def;
 330         int i;
 331
 332         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
 333         {
 334                 def = &prog->globaldefs[i];
 335                 if (!strcmp(PRVM_GetString(def->s_name), name))
 336                         return def;
 337         }
 338         return NULL;
 339 }
 340
 341
 342 /*
 343 ============
 344 PRVM_ED_FindFunction
 345 ============
 346 */
 347 mfunction_t *PRVM_ED_FindFunction (const char *name)
 348 {
 349         mfunction_t             *func;
 350         int                             i;
 351
 352         for (i=0 ; i<prog->progs->numfunctions ; i++)
 353         {
 354                 func = &prog->functions[i];
 355                 if (!strcmp(PRVM_GetString(func->s_name), name))
 356                         return func;
 357         }
 358         return NULL;
 359 }
 360
 361
 362 /*
 363 ============
 364 PRVM_ValueString
 365
 366 Returns a string describing *data in a type specific manner
 367 =============
 368 */
 369 char *PRVM_ValueString (etype_t type, prvm_eval_t *val)
 370 {
 371         static char line[1024]; // LordHavoc: enlarged a bit (was 256)
 372         ddef_t *def;
 373         mfunction_t *f;
 374         int n;
 375
 376         type &= ~DEF_SAVEGLOBAL;
 377
 378         switch (type)
 379         {
 380         case ev_string:
 381                 strlcpy (line, PRVM_GetString (val->string), sizeof (line));
 382                 break;
 383         case ev_entity:
 384                 n = val->edict;
 385                 if (n < 0 || n >= prog->limit_edicts)
 386                         sprintf (line, "entity %i (invalid!)", n);
 387                 else
 388                         sprintf (line, "entity %i", n);
 389                 break;
 390         case ev_function:
 391                 f = prog->functions + val->function;
 392                 sprintf (line, "%s()", PRVM_GetString(f->s_name));
 393                 break;
 394         case ev_field:
 395                 def = PRVM_ED_FieldAtOfs ( val->_int );
 396                 sprintf (line, ".%s", PRVM_GetString(def->s_name));
 397                 break;
 398         case ev_void:
 399                 sprintf (line, "void");
 400                 break;
 401         case ev_float:
 402                 // LordHavoc: changed from %5.1f to %10.4f
 403                 sprintf (line, "%10.4f", val->_float);
 404                 break;
 405         case ev_vector:
 406                 // LordHavoc: changed from %5.1f to %10.4f
 407                 sprintf (line, "'%10.4f %10.4f %10.4f'", val->vector[0], val->vector[1], val->vector[2]);
 408                 break;
 409         case ev_pointer:
 410                 sprintf (line, "pointer");
 411                 break;
 412         default:
 413                 sprintf (line, "bad type %i", type);
 414                 break;
 415         }
 416
 417         return line;
 418 }
 419
 420 /*
 421 ============
 422 PRVM_UglyValueString
 423
 424 Returns a string describing *data in a type specific manner
 425 Easier to parse than PR_ValueString
 426 =============
 427 */
 428 char *PRVM_UglyValueString (etype_t type, prvm_eval_t *val)
 429 {
 430         static char line[4096];
 431         int i;
 432         const char *s;
 433         ddef_t *def;
 434         mfunction_t *f;
 435
 436         type &= ~DEF_SAVEGLOBAL;
 437
 438         switch (type)
 439         {
 440         case ev_string:
 441                 // Parse the string a bit to turn special characters
 442                 // (like newline, specifically) into escape codes,
 443                 // this fixes saving games from various mods
 444                 s = PRVM_GetString (val->string);
 445                 for (i = 0;i < (int)sizeof(line) - 2 && *s;)
 446                 {
 447                         if (*s == '\n')
 448                         {
 449                                 line[i++] = '\\';
 450                                 line[i++] = 'n';
 451                         }
 452                         else if (*s == '\r')
 453                         {
 454                                 line[i++] = '\\';
 455                                 line[i++] = 'r';
 456                         }
 457                         else
 458                                 line[i++] = *s;
 459                         s++;
 460                 }
 461                 line[i] = '\0';
 462                 break;
 463         case ev_entity:
 464                 dpsnprintf (line, sizeof (line), "%i", PRVM_NUM_FOR_EDICT(PRVM_PROG_TO_EDICT(val->edict)));
 465                 break;
 466         case ev_function:
 467                 f = prog->functions + val->function;
 468                 strlcpy (line, PRVM_GetString (f->s_name), sizeof (line));
 469                 break;
 470         case ev_field:
 471                 def = PRVM_ED_FieldAtOfs ( val->_int );
 472                 dpsnprintf (line, sizeof (line), ".%s", PRVM_GetString(def->s_name));
 473                 break;
 474         case ev_void:
 475                 dpsnprintf (line, sizeof (line), "void");
 476                 break;
 477         case ev_float:
 478                 dpsnprintf (line, sizeof (line), "%f", val->_float);
 479                 break;
 480         case ev_vector:
 481                 dpsnprintf (line, sizeof (line), "%f %f %f", val->vector[0], val->vector[1], val->vector[2]);
 482                 break;
 483         default:
 484                 dpsnprintf (line, sizeof (line), "bad type %i", type);
 485                 break;
 486         }
 487
 488         return line;
 489 }
 490
 491 /*
 492 ============
 493 PRVM_GlobalString
 494
 495 Returns a string with a description and the contents of a global,
 496 padded to 20 field width
 497 ============
 498 */
 499 char *PRVM_GlobalString (int ofs)
 500 {
 501         char    *s;
 502         int             i;
 503         ddef_t  *def;
 504         void    *val;
 505         static char     line[128];
 506
 507         val = (void *)&prog->globals.generic[ofs];
 508         def = PRVM_ED_GlobalAtOfs(ofs);
 509         if (!def)
 510                 sprintf (line,"%i(?)", ofs);
 511         else
 512         {
 513                 s = PRVM_ValueString (def->type, val);
 514                 sprintf (line,"%i(%s)%s", ofs, PRVM_GetString(def->s_name), s);
 515         }
 516
 517         i = strlen(line);
 518         for ( ; i<20 ; i++)
 519                 strcat (line," ");
 520         strcat (line," ");
 521
 522         return line;
 523 }
 524
 525 char *PRVM_GlobalStringNoContents (int ofs)
 526 {
 527         int             i;
 528         ddef_t  *def;
 529         static char     line[128];
 530
 531         def = PRVM_ED_GlobalAtOfs(ofs);
 532         if (!def)
 533                 sprintf (line,"%i(?)", ofs);
 534         else
 535                 sprintf (line,"%i(%s)", ofs, PRVM_GetString(def->s_name));
 536
 537         i = strlen(line);
 538         for ( ; i<20 ; i++)
 539                 strcat (line," ");
 540         strcat (line," ");
 541
 542         return line;
 543 }
 544
 545
 546 /*
 547 =============
 548 PRVM_ED_Print
 549
 550 For debugging
 551 =============
 552 */
 553 // LordHavoc: optimized this to print out much more quickly (tempstring)
 554 // LordHavoc: changed to print out every 4096 characters (incase there are a lot of fields to print)
 555 void PRVM_ED_Print(prvm_edict_t *ed)
 556 {
 557         int             l;
 558         ddef_t  *d;
 559         int             *v;
 560         int             i, j;
 561         const char      *name;
 562         int             type;
 563         char    tempstring[8192], tempstring2[260]; // temporary string buffers
 564
 565         if (ed->priv.required->free)
 566         {
 567                 Con_Printf("%s: FREE\n",PRVM_NAME);
 568                 return;
 569         }
 570
 571         tempstring[0] = 0;
 572         sprintf(tempstring, "\n%s EDICT %i:\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ed));
 573         for (i=1 ; i<prog->progs->numfielddefs ; i++)
 574         {
 575                 d = &prog->fielddefs[i];
 576                 name = PRVM_GetString(d->s_name);
 577                 if (name[strlen(name)-2] == '_')
 578                         continue;       // skip _x, _y, _z vars
 579
 580                 v = (int *)((char *)ed->fields.vp + d->ofs*4);
 581
 582         // if the value is still all 0, skip the field
 583                 type = d->type & ~DEF_SAVEGLOBAL;
 584
 585                 for (j=0 ; j<prvm_type_size[type] ; j++)
 586                         if (v[j])
 587                                 break;
 588                 if (j == prvm_type_size[type])
 589                         continue;
 590
 591                 if (strlen(name) > 256)
 592                 {
 593                         memcpy (tempstring2, name, 256);
 594                         tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
 595                         tempstring2[259] = 0;
 596                         name = tempstring2;
 597                 }
 598                 strcat(tempstring, name);
 599                 for (l = strlen(name);l < 14;l++)
 600                         strcat(tempstring, " ");
 601                 strcat(tempstring, " ");
 602
 603                 name = PRVM_ValueString(d->type, (prvm_eval_t *)v);
 604                 if (strlen(name) > 256)
 605                 {
 606                         memcpy (tempstring2, name, 256);
 607                         tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
 608                         tempstring2[259] = 0;
 609                         name = tempstring2;
 610                 }
 611                 strcat(tempstring, name);
 612                 strcat(tempstring, "\n");
 613                 if (strlen(tempstring) >= 4096)
 614                 {
 615                         Con_Print(tempstring);
 616                         tempstring[0] = 0;
 617                 }
 618         }
 619         if (tempstring[0])
 620                 Con_Print(tempstring);
 621 }
 622
 623 /*
 624 =============
 625 PRVM_ED_Write
 626
 627 For savegames
 628 =============
 629 */
 630 void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 631 {
 632         ddef_t  *d;
 633         int             *v;
 634         int             i, j;
 635         const char      *name;
 636         int             type;
 637
 638         FS_Print(f, "{\n");
 639
 640         if (ed->priv.required->free)
 641         {
 642                 FS_Print(f, "}\n");
 643                 return;
 644         }
 645
 646         for (i=1 ; i<prog->progs->numfielddefs ; i++)
 647         {
 648                 d = &prog->fielddefs[i];
 649                 name = PRVM_GetString(d->s_name);
 650                 if (name[strlen(name)-2] == '_')
 651                         continue;       // skip _x, _y, _z vars
 652
 653                 v = (int *)((char *)ed->fields.vp + d->ofs*4);
 654
 655         // if the value is still all 0, skip the field
 656                 type = d->type & ~DEF_SAVEGLOBAL;
 657                 for (j=0 ; j<prvm_type_size[type] ; j++)
 658                         if (v[j])
 659                                 break;
 660                 if (j == prvm_type_size[type])
 661                         continue;
 662
 663                 FS_Printf(f,"\"%s\" ",name);
 664                 FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(d->type, (prvm_eval_t *)v));
 665         }
 666
 667         FS_Print(f, "}\n");
 668 }
 669
 670 void PRVM_ED_PrintNum (int ent)
 671 {
 672         PRVM_ED_Print(PRVM_EDICT_NUM(ent));
 673 }
 674
 675 /*
 676 =============
 677 PRVM_ED_PrintEdicts_f
 678
 679 For debugging, prints all the entities in the current server
 680 =============
 681 */
 682 void PRVM_ED_PrintEdicts_f (void)
 683 {
 684         int             i;
 685
 686         if(Cmd_Argc() != 2)
 687         {
 688                 Con_Print("prvm_edicts <program name>\n");
 689                 return;
 690         }
 691
 692         PRVM_Begin;
 693         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
 694                 return;
 695
 696         Con_Printf("%s: %i entities\n", PRVM_NAME, prog->num_edicts);
 697         for (i=0 ; i<prog->num_edicts ; i++)
 698                 PRVM_ED_PrintNum (i);
 699
 700         PRVM_End;
 701 }
 702
 703 /*
 704 =============
 705 PRVM_ED_PrintEdict_f
 706
 707 For debugging, prints a single edict
 708 =============
 709 */
 710 void PRVM_ED_PrintEdict_f (void)
 711 {
 712         int             i;
 713
 714         if(Cmd_Argc() != 3)
 715         {
 716                 Con_Print("prvm_edict <program name> <edict number>\n");
 717                 return;
 718         }
 719
 720         PRVM_Begin;
 721         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
 722                 return;
 723
 724         i = atoi (Cmd_Argv(2));
 725         if (i >= prog->num_edicts)
 726         {
 727                 Con_Print("Bad edict number\n");
 728                 PRVM_End;
 729                 return;
 730         }
 731         PRVM_ED_PrintNum (i);
 732
 733         PRVM_End;
 734 }
 735
 736 /*
 737 =============
 738 PRVM_ED_Count
 739
 740 For debugging
 741 =============
 742 */
 743 // 2 possibilities : 1. just displaying the active edict count
 744 //                                       2. making a function pointer [x]
 745 void PRVM_ED_Count_f (void)
 746 {
 747         int             i;
 748         prvm_edict_t    *ent;
 749         int             active;
 750
 751         if(Cmd_Argc() != 2)
 752         {
 753                 Con_Print("prvm_count <program name>\n");
 754                 return;
 755         }
 756
 757         PRVM_Begin;
 758         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
 759                 return;
 760
 761         if(prog->count_edicts)
 762                 prog->count_edicts();
 763         else
 764         {
 765                 active = 0;
 766                 for (i=0 ; i<prog->num_edicts ; i++)
 767                 {
 768                         ent = PRVM_EDICT_NUM(i);
 769                         if (ent->priv.required->free)
 770                                 continue;
 771                         active++;
 772                 }
 773
 774                 Con_Printf("num_edicts:%3i\n", prog->num_edicts);
 775                 Con_Printf("active    :%3i\n", active);
 776         }
 777
 778         PRVM_End;
 779 }
 780
 781 /*
 782 ==============================================================================
 783
 784                                         ARCHIVING GLOBALS
 785
 786 FIXME: need to tag constants, doesn't really work
 787 ==============================================================================
 788 */
 789
 790 /*
 791 =============
 792 PRVM_ED_WriteGlobals
 793 =============
 794 */
 795 void PRVM_ED_WriteGlobals (qfile_t *f)
 796 {
 797         ddef_t          *def;
 798         int                     i;
 799         const char              *name;
 800         int                     type;
 801
 802         FS_Print(f,"{\n");
 803         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
 804         {
 805                 def = &prog->globaldefs[i];
 806                 type = def->type;
 807                 if ( !(def->type & DEF_SAVEGLOBAL) )
 808                         continue;
 809                 type &= ~DEF_SAVEGLOBAL;
 810
 811                 if (type != ev_string && type != ev_float && type != ev_entity)
 812                         continue;
 813
 814                 name = PRVM_GetString(def->s_name);
 815                 FS_Printf(f,"\"%s\" ", name);
 816                 FS_Printf(f,"\"%s\"\n", PRVM_UglyValueString(type, (prvm_eval_t *)&prog->globals.generic[def->ofs]));
 817         }
 818         FS_Print(f,"}\n");
 819 }
 820
 821 /*
 822 =============
 823 PRVM_ED_ParseGlobals
 824 =============
 825 */
 826 void PRVM_ED_ParseGlobals (const char *data)
 827 {
 828         char keyname[1024]; // LordHavoc: good idea? bad idea?  was 64
 829         ddef_t *key;
 830
 831         while (1)
 832         {
 833                 // parse key
 834                 if (!COM_ParseToken(&data, false))
 835                         PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
 836                 if (com_token[0] == '}')
 837                         break;
 838
 839                 strcpy (keyname, com_token);
 840
 841                 // parse value
 842                 if (!COM_ParseToken(&data, false))
 843                         PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
 844
 845                 if (com_token[0] == '}')
 846                         PRVM_ERROR ("PRVM_ED_ParseEntity: closing brace without data");
 847
 848                 key = PRVM_ED_FindGlobal (keyname);
 849                 if (!key)
 850                 {
 851                         Con_DPrintf("'%s' is not a global on %s\n", keyname, PRVM_NAME);
 852                         continue;
 853                 }
 854
 855                 if (!PRVM_ED_ParseEpair(NULL, key, com_token))
 856                         PRVM_ERROR ("PRVM_ED_ParseGlobals: parse error");
 857         }
 858 }
 859
 860 //============================================================================
 861
 862
 863 /*
 864 =============
 865 PRVM_ED_ParseEval
 866
 867 Can parse either fields or globals
 868 returns false if error
 869 =============
 870 */
 871 qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
 872 {
 873         int i, l;
 874         char *new_p;
 875         ddef_t *def;
 876         prvm_eval_t *val;
 877         mfunction_t *func;
 878
 879         if (ent)
 880                 val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
 881         else
 882                 val = (prvm_eval_t *)((int *)prog->globals.generic + key->ofs);
 883         switch (key->type & ~DEF_SAVEGLOBAL)
 884         {
 885         case ev_string:
 886                 l = strlen(s) + 1;
 887                 new_p = PRVM_AllocString(l);
 888                 val->string = PRVM_SetQCString(new_p);
 889                 for (i = 0;i < l;i++)
 890                 {
 891                         if (s[i] == '\\' && i < l-1)
 892                         {
 893                                 i++;
 894                                 if (s[i] == 'n')
 895                                         *new_p++ = '\n';
 896                                 else if (s[i] == 'r')
 897                                         *new_p++ = '\r';
 898                                 else
 899                                         *new_p++ = s[i];
 900                         }
 901                         else
 902                                 *new_p++ = s[i];
 903                 }
 904                 break;
 905
 906         case ev_float:
 907                 while (*s && *s <= ' ')
 908                         s++;
 909                 val->_float = atof(s);
 910                 break;
 911
 912         case ev_vector:
 913                 for (i = 0;i < 3;i++)
 914                 {
 915                         while (*s && *s <= ' ')
 916                                 s++;
 917                         if (!*s)
 918                                 break;
 919                         val->vector[i] = atof(s);
 920                         while (*s > ' ')
 921                                 s++;
 922                         if (!*s)
 923                                 break;
 924                 }
 925                 break;
 926
 927         case ev_entity:
 928                 while (*s && *s <= ' ')
 929                         s++;
 930                 i = atoi(s);
 931                 if (i < 0 || i >= prog->limit_edicts)
 932                         Con_Printf("PRVM_ED_ParseEpair: ev_entity reference too large (edict %i >= MAX_EDICTS %i) on %s\n", i, MAX_EDICTS, PRVM_NAME);
 933                 while (i >= prog->max_edicts)
 934                         PRVM_MEM_IncreaseEdicts();
 935                         //SV_IncreaseEdicts();
 936                 // if SV_IncreaseEdicts was called the base pointer needs to be updated
 937                 if (ent)
 938                         val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
 939                 val->edict = PRVM_EDICT_TO_PROG(PRVM_EDICT_NUM(i));
 940                 break;
 941
 942         case ev_field:
 943                 def = PRVM_ED_FindField(s);
 944                 if (!def)
 945                 {
 946                         Con_DPrintf("PRVM_ED_ParseEpair: Can't find field %s in %s\n", s, PRVM_NAME);
 947                         return false;
 948                 }
 949                 val->_int = def->ofs;
 950                 break;
 951
 952         case ev_function:
 953                 func = PRVM_ED_FindFunction(s);
 954                 if (!func)
 955                 {
 956                         Con_Printf("PRVM_ED_ParseEpair: Can't find function %s in %s\n", s, PRVM_NAME);
 957                         return false;
 958                 }
 959                 val->function = func - prog->functions;
 960                 break;
 961
 962         default:
 963                 Con_Printf("PRVM_ED_ParseEpair: Unknown key->type %i for key \"%s\" on %s\n", key->type, PRVM_GetString(key->s_name), PRVM_NAME);
 964                 return false;
 965         }
 966         return true;
 967 }
 968
 969 /*
 970 =============
 971 PRVM_ED_EdictSet_f
 972
 973 Console command to set a field of a specified edict
 974 =============
 975 */
 976 void PRVM_ED_EdictSet_f(void)
 977 {
 978         prvm_edict_t *ed;
 979         ddef_t *key;
 980
 981         if(Cmd_Argc() != 5)
 982         {
 983                 Con_Print("prvm_edictset <program name> <edict number> <field> <value>\n");
 984                 return;
 985         }
 986
 987         PRVM_Begin;
 988         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
 989         {
 990                 Con_Printf("Wrong program name %s !\n", Cmd_Argv(1));
 991                 return;
 992         }
 993
 994         ed = PRVM_EDICT_NUM(atoi(Cmd_Argv(2)));
 995
 996         if((key = PRVM_ED_FindField(Cmd_Argv(3))) == 0)
 997                 Con_Printf("Key %s not found !\n", Cmd_Argv(3));
 998         else
 999                 PRVM_ED_ParseEpair(ed, key, Cmd_Argv(4));
1000
1001         PRVM_End;
1002 }
1003
1004 /*
1005 ====================
1006 PRVM_ED_ParseEdict
1007
1008 Parses an edict out of the given string, returning the new position
1009 ed should be a properly initialized empty edict.
1010 Used for initial level load and for savegames.
1011 ====================
1012 */
1013 const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
1014 {
1015         ddef_t *key;
1016         qboolean anglehack;
1017         qboolean init;
1018         char keyname[256];
1019         int n;
1020
1021         init = false;
1022
1023 // go through all the dictionary pairs
1024         while (1)
1025         {
1026         // parse key
1027                 if (!COM_ParseToken(&data, false))
1028                         PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
1029                 if (com_token[0] == '}')
1030                         break;
1031
1032                 // anglehack is to allow QuakeEd to write single scalar angles
1033                 // and allow them to be turned into vectors. (FIXME...)
1034                 if (!strcmp(com_token, "angle"))
1035                 {
1036                         strcpy (com_token, "angles");
1037                         anglehack = true;
1038                 }
1039                 else
1040                         anglehack = false;
1041
1042                 // FIXME: change light to _light to get rid of this hack
1043                 if (!strcmp(com_token, "light"))
1044                         strcpy (com_token, "light_lev");        // hack for single light def
1045
1046                 strcpy (keyname, com_token);
1047
1048                 // another hack to fix keynames with trailing spaces
1049                 n = strlen(keyname);
1050                 while (n && keyname[n-1] == ' ')
1051                 {
1052                         keyname[n-1] = 0;
1053                         n--;
1054                 }
1055
1056         // parse value
1057                 if (!COM_ParseToken(&data, false))
1058                         PRVM_ERROR ("PRVM_ED_ParseEntity: EOF without closing brace");
1059
1060                 if (com_token[0] == '}')
1061                         PRVM_ERROR ("PRVM_ED_ParseEntity: closing brace without data");
1062
1063                 init = true;
1064
1065 // keynames with a leading underscore are used for utility comments,
1066 // and are immediately discarded by quake
1067                 if (keyname[0] == '_')
1068                         continue;
1069
1070                 key = PRVM_ED_FindField (keyname);
1071                 if (!key)
1072                 {
1073                         Con_DPrintf("%s: '%s' is not a field\n", PRVM_NAME, keyname);
1074                         continue;
1075                 }
1076
1077                 if (anglehack)
1078                 {
1079                         char    temp[32];
1080                         strcpy (temp, com_token);
1081                         sprintf (com_token, "0 %s 0", temp);
1082                 }
1083
1084                 if (!PRVM_ED_ParseEpair(ent, key, com_token))
1085                         PRVM_ERROR ("PRVM_ED_ParseEdict: parse error");
1086         }
1087
1088         if (!init)
1089                 ent->priv.required->free = true;
1090
1091         return data;
1092 }
1093
1094
1095 /*
1096 ================
1097 PRVM_ED_LoadFromFile
1098
1099 The entities are directly placed in the array, rather than allocated with
1100 PRVM_ED_Alloc, because otherwise an error loading the map would have entity
1101 number references out of order.
1102
1103 Creates a server's entity / program execution context by
1104 parsing textual entity definitions out of an ent file.
1105
1106 Used for both fresh maps and savegame loads.  A fresh map would also need
1107 to call PRVM_ED_CallSpawnFunctions () to let the objects initialize themselves.
1108 ================
1109 */
1110 void PRVM_ED_LoadFromFile (const char *data)
1111 {
1112         prvm_edict_t *ent;
1113         int parsed, inhibited, spawned, died;
1114         mfunction_t *func;
1115
1116         parsed = 0;
1117         inhibited = 0;
1118         spawned = 0;
1119         died = 0;
1120
1121
1122 // parse ents
1123         while (1)
1124         {
1125 // parse the opening brace
1126                 if (!COM_ParseToken(&data, false))
1127                         break;
1128                 if (com_token[0] != '{')
1129                         PRVM_ERROR ("PRVM_ED_LoadFromFile: %s: found %s when expecting {", PRVM_NAME, com_token);
1130
1131                 // CHANGED: this is not conform to PR_LoadFromFile
1132                 if(prog->loadintoworld)
1133                 {
1134                         prog->loadintoworld = false;
1135                         ent = PRVM_EDICT_NUM(0);
1136                 }
1137                 else
1138                         ent = PRVM_ED_Alloc();
1139
1140                 // clear it
1141                 if (ent != prog->edicts)        // hack
1142                         memset (ent->fields.vp, 0, prog->progs->entityfields * 4);
1143
1144                 data = PRVM_ED_ParseEdict (data, ent);
1145                 parsed++;
1146
1147                 // remove the entity ?
1148                 if(prog->load_edict && !prog->load_edict(ent))
1149                 {
1150                         PRVM_ED_Free(ent);
1151                         inhibited++;
1152                         continue;
1153                 }
1154
1155 //
1156 // immediately call spawn function, but only if there is a self global and a classname
1157 //
1158                 if(prog->self && prog->flag & PRVM_FE_CLASSNAME)
1159                 {
1160                         string_t handle =  *(string_t*)&((qbyte*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")];
1161                         if (!handle)
1162                         {
1163                                 Con_Print("No classname for:\n");
1164                                 PRVM_ED_Print(ent);
1165                                 PRVM_ED_Free (ent);
1166                                 continue;
1167                         }
1168
1169                         // look for the spawn function
1170                         func = PRVM_ED_FindFunction (PRVM_GetString(handle));
1171
1172                         if (!func)
1173                         {
1174                                 if (developer.integer) // don't confuse non-developers with errors
1175                                 {
1176                                         Con_Print("No spawn function for:\n");
1177                                         PRVM_ED_Print(ent);
1178                                 }
1179                                 PRVM_ED_Free (ent);
1180                                 continue;
1181                         }
1182
1183                         // self = ent
1184                         PRVM_G_INT(prog->self->ofs) = PRVM_EDICT_TO_PROG(ent);
1185                         PRVM_ExecuteProgram (func - prog->functions, "");
1186                 }
1187
1188                 spawned++;
1189                 if (ent->priv.required->free)
1190                         died++;
1191         }
1192
1193         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);
1194 }
1195
1196 // not used
1197 /*
1198 typedef struct dpfield_s
1199 {
1200         int type;
1201         char *string;
1202 }
1203 dpfield_t;
1204
1205 #define DPFIELDS (sizeof(dpfields) / sizeof(dpfield_t))
1206
1207 dpfield_t dpfields[] =
1208 {
1209 };
1210 */
1211
1212 /*
1213 ===============
1214 PRVM_ResetProg
1215 ===============
1216 */
1217
1218 void PRVM_ResetProg()
1219 {
1220         PRVM_GCALL(reset_cmd)();
1221         Mem_FreePool(&prog->progs_mempool);
1222         memset(prog,0,sizeof(prvm_prog_t));
1223 }
1224
1225 /*
1226 ===============
1227 PRVM_LoadProgs
1228 ===============
1229 */
1230 void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required_func, int numrequiredfields, prvm_required_field_t *required_field)
1231 {
1232         int i;
1233         dstatement_t *st;
1234         ddef_t *infielddefs;
1235         dfunction_t *dfunctions;
1236
1237         prog->progs = (dprograms_t *)FS_LoadFile (filename, prog->progs_mempool, false);
1238         if (prog->progs == NULL)
1239                 PRVM_ERROR ("PRVM_LoadProgs: couldn't load %s for %s", filename, PRVM_NAME);
1240
1241         Con_DPrintf("%s programs occupy %iK.\n", PRVM_NAME, fs_filesize/1024);
1242
1243         prog->filecrc = CRC_Block((qbyte *)prog->progs, fs_filesize);
1244
1245 // byte swap the header
1246         for (i = 0;i < (int) sizeof(*prog->progs) / 4;i++)
1247                 ((int *)prog->progs)[i] = LittleLong ( ((int *)prog->progs)[i] );
1248
1249         if (prog->progs->version != PROG_VERSION)
1250                 PRVM_ERROR ("%s: %s has wrong version number (%i should be %i)", PRVM_NAME, filename, prog->progs->version, PROG_VERSION);
1251         if (prog->progs->crc != prog->headercrc)
1252                 PRVM_ERROR ("%s: %s system vars have been modified, progdefs.h is out of date", PRVM_NAME, filename);
1253
1254         //prog->functions = (dfunction_t *)((qbyte *)progs + progs->ofs_functions);
1255         dfunctions = (dfunction_t *)((qbyte *)prog->progs + prog->progs->ofs_functions);
1256
1257         prog->strings = (char *)prog->progs + prog->progs->ofs_strings;
1258         prog->stringssize = 0;
1259         for (i = 0;i < prog->progs->numstrings;i++)
1260         {
1261                 if (prog->progs->ofs_strings + prog->stringssize >= fs_filesize)
1262                         PRVM_ERROR ("%s: %s strings go past end of file\n", PRVM_NAME, filename);
1263                 prog->stringssize += strlen (prog->strings + prog->stringssize) + 1;
1264         }
1265         prog->numknownstrings = 0;
1266         prog->maxknownstrings = 0;
1267         prog->knownstrings = NULL;
1268
1269         prog->globaldefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_globaldefs);
1270
1271         // we need to expand the fielddefs list to include all the engine fields,
1272         // so allocate a new place for it
1273         infielddefs = (ddef_t *)((qbyte *)prog->progs + prog->progs->ofs_fielddefs);
1274         //                                                                                              ( + DPFIELDS                       )
1275         prog->fielddefs = Mem_Alloc(prog->progs_mempool, (prog->progs->numfielddefs + numrequiredfields) * sizeof(ddef_t));
1276
1277         prog->statements = (dstatement_t *)((qbyte *)prog->progs + prog->progs->ofs_statements);
1278
1279         // moved edict_size calculation down below field adding code
1280
1281         //pr_global_struct = (globalvars_t *)((qbyte *)progs + progs->ofs_globals);
1282         prog->globals.generic = (float *)((qbyte *)prog->progs + prog->progs->ofs_globals);
1283
1284 // byte swap the lumps
1285         for (i=0 ; i<prog->progs->numstatements ; i++)
1286         {
1287                 prog->statements[i].op = LittleShort(prog->statements[i].op);
1288                 prog->statements[i].a = LittleShort(prog->statements[i].a);
1289                 prog->statements[i].b = LittleShort(prog->statements[i].b);
1290                 prog->statements[i].c = LittleShort(prog->statements[i].c);
1291         }
1292
1293         prog->functions = Mem_Alloc(prog->progs_mempool, sizeof(mfunction_t) * prog->progs->numfunctions);
1294         for (i = 0;i < prog->progs->numfunctions;i++)
1295         {
1296                 prog->functions[i].first_statement = LittleLong (dfunctions[i].first_statement);
1297                 prog->functions[i].parm_start = LittleLong (dfunctions[i].parm_start);
1298                 prog->functions[i].s_name = LittleLong (dfunctions[i].s_name);
1299                 prog->functions[i].s_file = LittleLong (dfunctions[i].s_file);
1300                 prog->functions[i].numparms = LittleLong (dfunctions[i].numparms);
1301                 prog->functions[i].locals = LittleLong (dfunctions[i].locals);
1302                 memcpy(prog->functions[i].parm_size, dfunctions[i].parm_size, sizeof(dfunctions[i].parm_size));
1303         }
1304
1305         for (i=0 ; i<prog->progs->numglobaldefs ; i++)
1306         {
1307                 prog->globaldefs[i].type = LittleShort (prog->globaldefs[i].type);
1308                 prog->globaldefs[i].ofs = LittleShort (prog->globaldefs[i].ofs);
1309                 prog->globaldefs[i].s_name = LittleLong (prog->globaldefs[i].s_name);
1310         }
1311
1312         // copy the progs fields to the new fields list
1313         for (i = 0;i < prog->progs->numfielddefs;i++)
1314         {
1315                 prog->fielddefs[i].type = LittleShort (infielddefs[i].type);
1316                 if (prog->fielddefs[i].type & DEF_SAVEGLOBAL)
1317                         PRVM_ERROR ("PRVM_LoadProgs: prog->fielddefs[i].type & DEF_SAVEGLOBAL in %s", PRVM_NAME);
1318                 prog->fielddefs[i].ofs = LittleShort (infielddefs[i].ofs);
1319                 prog->fielddefs[i].s_name = LittleLong (infielddefs[i].s_name);
1320         }
1321
1322         // append the required fields
1323         for (i = 0;i < (int) numrequiredfields;i++)
1324         {
1325                 prog->fielddefs[prog->progs->numfielddefs].type = required_field[i].type;
1326                 prog->fielddefs[prog->progs->numfielddefs].ofs = prog->progs->entityfields;
1327                 prog->fielddefs[prog->progs->numfielddefs].s_name = PRVM_SetEngineString(required_field[i].name);
1328                 if (prog->fielddefs[prog->progs->numfielddefs].type == ev_vector)
1329                         prog->progs->entityfields += 3;
1330                 else
1331                         prog->progs->entityfields++;
1332                 prog->progs->numfielddefs++;
1333         }
1334
1335         // check required functions
1336         for(i=0 ; i < numrequiredfunc ; i++)
1337                 if(PRVM_ED_FindFunction(required_func[i]) == 0)
1338                         PRVM_ERROR("%s: %s not found in %s\n",PRVM_NAME, required_func[i], filename);
1339
1340         for (i=0 ; i<prog->progs->numglobals ; i++)
1341                 ((int *)prog->globals.generic)[i] = LittleLong (((int *)prog->globals.generic)[i]);
1342
1343         // moved edict_size calculation down here, below field adding code
1344         // LordHavoc: this no longer includes the prvm_edict_t header
1345         prog->edict_size = prog->progs->entityfields * 4;
1346         prog->edictareasize = prog->edict_size * prog->limit_edicts;
1347
1348         // LordHavoc: bounds check anything static
1349         for (i = 0,st = prog->statements;i < prog->progs->numstatements;i++,st++)
1350         {
1351                 switch (st->op)
1352                 {
1353                 case OP_IF:
1354                 case OP_IFNOT:
1355                         if ((unsigned short) st->a >= prog->progs->numglobals || st->b + i < 0 || st->b + i >= prog->progs->numstatements)
1356                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds IF/IFNOT (statement %d) in %s\n", i, PRVM_NAME);
1357                         break;
1358                 case OP_GOTO:
1359                         if (st->a + i < 0 || st->a + i >= prog->progs->numstatements)
1360                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds GOTO (statement %d) in %s\n", i, PRVM_NAME);
1361                         break;
1362                 // global global global
1363                 case OP_ADD_F:
1364                 case OP_ADD_V:
1365                 case OP_SUB_F:
1366                 case OP_SUB_V:
1367                 case OP_MUL_F:
1368                 case OP_MUL_V:
1369                 case OP_MUL_FV:
1370                 case OP_MUL_VF:
1371                 case OP_DIV_F:
1372                 case OP_BITAND:
1373                 case OP_BITOR:
1374                 case OP_GE:
1375                 case OP_LE:
1376                 case OP_GT:
1377                 case OP_LT:
1378                 case OP_AND:
1379                 case OP_OR:
1380                 case OP_EQ_F:
1381                 case OP_EQ_V:
1382                 case OP_EQ_S:
1383                 case OP_EQ_E:
1384                 case OP_EQ_FNC:
1385                 case OP_NE_F:
1386                 case OP_NE_V:
1387                 case OP_NE_S:
1388                 case OP_NE_E:
1389                 case OP_NE_FNC:
1390                 case OP_ADDRESS:
1391                 case OP_LOAD_F:
1392                 case OP_LOAD_FLD:
1393                 case OP_LOAD_ENT:
1394                 case OP_LOAD_S:
1395                 case OP_LOAD_FNC:
1396                 case OP_LOAD_V:
1397                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
1398                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)\n", i);
1399                         break;
1400                 // global none global
1401                 case OP_NOT_F:
1402                 case OP_NOT_V:
1403                 case OP_NOT_S:
1404                 case OP_NOT_FNC:
1405                 case OP_NOT_ENT:
1406                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->c >= prog->progs->numglobals)
1407                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s\n", i, PRVM_NAME);
1408                         break;
1409                 // 2 globals
1410                 case OP_STOREP_F:
1411                 case OP_STOREP_ENT:
1412                 case OP_STOREP_FLD:
1413                 case OP_STOREP_S:
1414                 case OP_STOREP_FNC:
1415                 case OP_STORE_F:
1416                 case OP_STORE_ENT:
1417                 case OP_STORE_FLD:
1418                 case OP_STORE_S:
1419                 case OP_STORE_FNC:
1420                 case OP_STATE:
1421                 case OP_STOREP_V:
1422                 case OP_STORE_V:
1423                         if ((unsigned short) st->a >= prog->progs->numglobals || (unsigned short) st->b >= prog->progs->numglobals)
1424                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d)\n in %s", i, PRVM_NAME);
1425                         break;
1426                 // 1 global
1427                 case OP_CALL0:
1428                 case OP_CALL1:
1429                 case OP_CALL2:
1430                 case OP_CALL3:
1431                 case OP_CALL4:
1432                 case OP_CALL5:
1433                 case OP_CALL6:
1434                 case OP_CALL7:
1435                 case OP_CALL8:
1436                 case OP_DONE:
1437                 case OP_RETURN:
1438                         if ((unsigned short) st->a >= prog->progs->numglobals)
1439                                 PRVM_ERROR("PRVM_LoadProgs: out of bounds global index (statement %d) in %s\n", i, PRVM_NAME);
1440                         break;
1441                 default:
1442                         PRVM_ERROR("PRVM_LoadProgs: unknown opcode %d at statement %d in %s\n", st->op, i, PRVM_NAME);
1443                         break;
1444                 }
1445         }
1446
1447         PRVM_Init_Exec();
1448
1449         prog->loaded = TRUE;
1450
1451         // set flags & ddef_ts in prog
1452
1453         prog->flag = 0;
1454
1455         prog->self = PRVM_ED_FindGlobal("self");
1456
1457         if( PRVM_ED_FindGlobal("time") && PRVM_ED_FindGlobal("time")->type & ev_float )
1458                 prog->time = &PRVM_G_FLOAT(PRVM_ED_FindGlobal("time")->ofs);
1459
1460         if(PRVM_ED_FindField ("chain"))
1461                 prog->flag |= PRVM_FE_CHAIN;
1462
1463         if(PRVM_ED_FindField ("classname"))
1464                 prog->flag |= PRVM_FE_CLASSNAME;
1465
1466         if(PRVM_ED_FindField ("nextthink") && PRVM_ED_FindField ("frame") && PRVM_ED_FindField ("think")
1467                 && prog->flag && prog->self)
1468                 prog->flag |= PRVM_OP_STATE;
1469
1470         PRVM_GCALL(init_cmd)();
1471
1472         // init mempools
1473         PRVM_MEM_Alloc();
1474 }
1475
1476
1477 void PRVM_Fields_f (void)
1478 {
1479         int i, j, ednum, used, usedamount;
1480         int *counts;
1481         char tempstring[5000], tempstring2[260];
1482         const char *name;
1483         prvm_edict_t *ed;
1484         ddef_t *d;
1485         int *v;
1486
1487         // TODO
1488         /*
1489         if (!sv.active)
1490         {
1491                 Con_Print("no progs loaded\n");
1492                 return;
1493         }
1494         */
1495
1496         if(Cmd_Argc() != 2)
1497         {
1498                 Con_Print("prvm_fields <program name>\n");
1499                 return;
1500         }
1501
1502         PRVM_Begin;
1503         if(!PRVM_SetProgFromString(Cmd_Argv(1)))
1504                 return;
1505
1506         counts = Mem_Alloc(tempmempool, prog->progs->numfielddefs * sizeof(int));
1507         for (ednum = 0;ednum < prog->max_edicts;ednum++)
1508         {
1509                 ed = PRVM_EDICT_NUM(ednum);
1510                 if (ed->priv.required->free)
1511                         continue;
1512                 for (i = 1;i < prog->progs->numfielddefs;i++)
1513                 {
1514                         d = &prog->fielddefs[i];
1515                         name = PRVM_GetString(d->s_name);
1516                         if (name[strlen(name)-2] == '_')
1517                                 continue;       // skip _x, _y, _z vars
1518                         v = (int *)((char *)ed->fields.vp + d->ofs*4);
1519                         // if the value is still all 0, skip the field
1520                         for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
1521                         {
1522                                 if (v[j])
1523                                 {
1524                                         counts[i]++;
1525                                         break;
1526                                 }
1527                         }
1528                 }
1529         }
1530         used = 0;
1531         usedamount = 0;
1532         tempstring[0] = 0;
1533         for (i = 0;i < prog->progs->numfielddefs;i++)
1534         {
1535                 d = &prog->fielddefs[i];
1536                 name = PRVM_GetString(d->s_name);
1537                 if (name[strlen(name)-2] == '_')
1538                         continue;       // skip _x, _y, _z vars
1539                 switch(d->type & ~DEF_SAVEGLOBAL)
1540                 {
1541                 case ev_string:
1542                         strcat(tempstring, "string   ");
1543                         break;
1544                 case ev_entity:
1545                         strcat(tempstring, "entity   ");
1546                         break;
1547                 case ev_function:
1548                         strcat(tempstring, "function ");
1549                         break;
1550                 case ev_field:
1551                         strcat(tempstring, "field    ");
1552                         break;
1553                 case ev_void:
1554                         strcat(tempstring, "void     ");
1555                         break;
1556                 case ev_float:
1557                         strcat(tempstring, "float    ");
1558                         break;
1559                 case ev_vector:
1560                         strcat(tempstring, "vector   ");
1561                         break;
1562                 case ev_pointer:
1563                         strcat(tempstring, "pointer  ");
1564                         break;
1565                 default:
1566                         sprintf (tempstring2, "bad type %i ", d->type & ~DEF_SAVEGLOBAL);
1567                         strcat(tempstring, tempstring2);
1568                         break;
1569                 }
1570                 if (strlen(name) > 256)
1571                 {
1572                         memcpy (tempstring2, name, 256);
1573                         tempstring2[256] = tempstring2[257] = tempstring2[258] = '.';
1574                         tempstring2[259] = 0;
1575                         name = tempstring2;
1576                 }
1577                 strcat(tempstring, name);
1578                 for (j = strlen(name);j < 25;j++)
1579                         strcat(tempstring, " ");
1580                 sprintf(tempstring2, "%5d", counts[i]);
1581                 strcat(tempstring, tempstring2);
1582                 strcat(tempstring, "\n");
1583                 if (strlen(tempstring) >= 4096)
1584                 {
1585                         Con_Print(tempstring);
1586                         tempstring[0] = 0;
1587                 }
1588                 if (counts[i])
1589                 {
1590                         used++;
1591                         usedamount += prvm_type_size[d->type & ~DEF_SAVEGLOBAL];
1592                 }
1593         }
1594         Mem_Free(counts);
1595         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);
1596
1597         PRVM_End;
1598 }
1599
1600 void PRVM_Globals_f (void)
1601 {
1602         int i;
1603         // TODO
1604         /*if (!sv.active)
1605         {
1606                 Con_Print("no progs loaded\n");
1607                 return;
1608         }*/
1609         if(Cmd_Argc () != 2)
1610         {
1611                 Con_Print("prvm_globals <program name>\n");
1612                 return;
1613         }
1614
1615         PRVM_Begin;
1616         if(!PRVM_SetProgFromString (Cmd_Argv (1)))
1617                 return;
1618
1619         Con_Printf("%s :", PRVM_NAME);
1620
1621         for (i = 0;i < prog->progs->numglobaldefs;i++)
1622                 Con_Printf("%s\n", PRVM_GetString(prog->globaldefs[i].s_name));
1623         Con_Printf("%i global variables, totalling %i bytes\n", prog->progs->numglobals, prog->progs->numglobals * 4);
1624
1625         PRVM_End;
1626 }
1627
1628 /*
1629 ===============
1630 PRVM_Global
1631 ===============
1632 */
1633 void PRVM_Global_f(void)
1634 {
1635         ddef_t *global;
1636         if( Cmd_Argc() != 3 ) {
1637                 Con_Printf( "prvm_global <program name> <global name>\n" );
1638                 return;
1639         }
1640
1641         PRVM_Begin;
1642         if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
1643                 return;
1644
1645         global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
1646         if( !global )
1647                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
1648         else
1649                 Con_Printf( "%s: %s\n", Cmd_Argv(2), PRVM_ValueString( global->type, (prvm_eval_t *) &prog->globals.generic[ global->ofs ] ) );
1650         PRVM_End;
1651 }
1652
1653 /*
1654 ===============
1655 PRVM_GlobalSet
1656 ===============
1657 */
1658 void PRVM_GlobalSet_f(void)
1659 {
1660         ddef_t *global;
1661         if( Cmd_Argc() != 4 ) {
1662                 Con_Printf( "prvm_globalset <program name> <global name> <value>\n" );
1663                 return;
1664         }
1665
1666         PRVM_Begin;
1667         if( !PRVM_SetProgFromString( Cmd_Argv(1) ) )
1668                 return;
1669
1670         global = PRVM_ED_FindGlobal( Cmd_Argv(2) );
1671         if( !global )
1672                 Con_Printf( "No global '%s' in %s!\n", Cmd_Argv(2), Cmd_Argv(1) );
1673         else
1674                 PRVM_ED_ParseEpair( NULL, global, Cmd_Argv(3) );
1675         PRVM_End;
1676 }
1677
1678 /*
1679 ===============
1680 PRVM_Init
1681 ===============
1682 */
1683 void PRVM_Init (void)
1684 {
1685         Cmd_AddCommand ("prvm_edict", PRVM_ED_PrintEdict_f);
1686         Cmd_AddCommand ("prvm_edicts", PRVM_ED_PrintEdicts_f);
1687         Cmd_AddCommand ("prvm_edictcount", PRVM_ED_Count_f);
1688         Cmd_AddCommand ("prvm_profile", PRVM_Profile_f);
1689         Cmd_AddCommand ("prvm_fields", PRVM_Fields_f);
1690         Cmd_AddCommand ("prvm_globals", PRVM_Globals_f);
1691         Cmd_AddCommand ("prvm_global", PRVM_Global_f);
1692         Cmd_AddCommand ("prvm_globalset", PRVM_GlobalSet_f);
1693         Cmd_AddCommand ("prvm_edictset", PRVM_ED_EdictSet_f);
1694         // LordHavoc: optional runtime bounds checking (speed drain, but worth it for security, on by default - breaks most QCCX features (used by CRMod and others))
1695         Cvar_RegisterVariable (&prvm_boundscheck);
1696         Cvar_RegisterVariable (&prvm_traceqc);
1697
1698         //VM_Cmd_Init();
1699 }
1700
1701 /*
1702 ===============
1703 PRVM_InitProg
1704 ===============
1705 */
1706 void PRVM_InitProg(int prognr)
1707 {
1708         if(prognr < 0 || prognr >= PRVM_MAXPROGS)
1709                 Sys_Error("PRVM_InitProg: Invalid program number %i\n",prognr);
1710
1711         prog = &prog_list[prognr];
1712
1713         if(prog->loaded)
1714                 PRVM_ResetProg();
1715
1716         memset(prog, 0, sizeof(prvm_prog_t));
1717
1718         prog->time = &prog->_time;
1719 }
1720
1721 int PRVM_GetProgNr()
1722 {
1723         return prog - prog_list;
1724 }
1725
1726 void *_PRVM_Alloc(size_t buffersize, const char *filename, int fileline)
1727 {
1728         return _Mem_Alloc(prog->progs_mempool, buffersize, filename, fileline);
1729 }
1730
1731 void _PRVM_Free(void *buffer, const char *filename, int fileline)
1732 {
1733         _Mem_Free(buffer, filename, fileline);
1734 }
1735
1736 void _PRVM_FreeAll(const char *filename, int fileline)
1737 {
1738         prog->progs = NULL;
1739         prog->fielddefs = NULL;
1740         prog->functions = NULL;
1741         _Mem_EmptyPool(prog->progs_mempool, filename, fileline);
1742 }
1743
1744 // LordHavoc: turned PRVM_EDICT_NUM into a #define for speed reasons
1745 prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline)
1746 {
1747         PRVM_ERROR ("PRVM_EDICT_NUM: %s: bad number %i (called at %s:%i)", PRVM_NAME, n, filename, fileline);
1748         return NULL;
1749 }
1750
1751 void PRVM_ProcessError(void)
1752 {
1753         if(prog)
1754                 PRVM_GCALL(error_cmd)();
1755 }
1756
1757 /*
1758 int NUM_FOR_EDICT_ERROR(prvm_edict_t *e)
1759 {
1760         Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer %p (world is %p, entity number would be %i)", e, prog->edicts, e - prog->edicts);
1761         return 0;
1762 }
1763
1764 int PRVM_NUM_FOR_EDICT(prvm_edict_t *e)
1765 {
1766         int n;
1767         n = e - prog->edicts;
1768         if ((unsigned int)n >= prog->limit_edicts)
1769                 Host_Error ("PRVM_NUM_FOR_EDICT: bad pointer");
1770         return n;
1771 }
1772
1773 //int NoCrash_NUM_FOR_EDICT(prvm_edict_t *e)
1774 //{
1775 //      return e - prog->edicts;
1776 //}
1777
1778 //#define       PRVM_EDICT_TO_PROG(e) ((qbyte *)(((prvm_edict_t *)e)->v) - (qbyte *)(prog->edictsfields))
1779 //#define PRVM_PROG_TO_EDICT(e) (prog->edicts + ((e) / (progs->entityfields * 4)))
1780 int PRVM_EDICT_TO_PROG(prvm_edict_t *e)
1781 {
1782         int n;
1783         n = e - prog->edicts;
1784         if ((unsigned int)n >= (unsigned int)prog->max_edicts)
1785                 Host_Error("PRVM_EDICT_TO_PROG: invalid edict %8p (number %i compared to world at %8p)\n", e, n, prog->edicts);
1786         return n;// EXPERIMENTAL
1787         //return (qbyte *)e->v - (qbyte *)prog->edictsfields;
1788 }
1789 prvm_edict_t *PRVM_PROG_TO_EDICT(int n)
1790 {
1791         if ((unsigned int)n >= (unsigned int)prog->max_edicts)
1792                 Host_Error("PRVM_PROG_TO_EDICT: invalid edict number %i\n", n);
1793         return prog->edicts + n; // EXPERIMENTAL
1794         //return prog->edicts + ((n) / (progs->entityfields * 4));
1795 }
1796 */
1797
1798
1799 const char *PRVM_GetString(int num)
1800 {
1801         if (num >= 0 && num < prog->stringssize)
1802                 return prog->strings + num;
1803         else if (num < 0 && num >= -prog->numknownstrings)
1804         {
1805                 num = -1 - num;
1806                 if (!prog->knownstrings[num])
1807                         Host_Error("PRVM_GetString: attempt to get string that is already freed\n");
1808                 return prog->knownstrings[num];
1809         }
1810         else
1811         {
1812                 Host_Error("PRVM_GetString: invalid string offset %i\n", num);
1813                 return "";
1814         }
1815 }
1816
1817 int PRVM_SetQCString(const char *s)
1818 {
1819         int i;
1820         if (!s)
1821                 return 0;
1822         if (s >= prog->strings && s <= prog->strings + prog->stringssize)
1823                 return s - prog->strings;
1824         for (i = 0;i < prog->numknownstrings;i++)
1825                 if (prog->knownstrings[i] == s)
1826                         return -1 - i;
1827         Host_Error("PRVM_SetQCString: unknown string\n");
1828         return -1 - i;
1829 }
1830
1831 int PRVM_SetEngineString(const char *s)
1832 {
1833         int i;
1834         if (!s)
1835                 return 0;
1836         if (s >= prog->strings && s <= prog->strings + prog->stringssize)
1837                 Host_Error("PRVM_SetEngineString: s in prog->strings area\n");
1838         for (i = 0;i < prog->numknownstrings;i++)
1839                 if (prog->knownstrings[i] == s)
1840                         return -1 - i;
1841         // new unknown engine string
1842         if (developer.integer >= 3)
1843                 Con_Printf("new engine string %p\n", s);
1844         for (i = 0;i < prog->numknownstrings;i++)
1845                 if (!prog->knownstrings[i])
1846                         break;
1847         if (i >= prog->numknownstrings)
1848         {
1849                 if (i >= prog->maxknownstrings)
1850                 {
1851                         const char **oldstrings = prog->knownstrings;
1852                         prog->maxknownstrings += 128;
1853                         prog->knownstrings = PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
1854                         if (prog->numknownstrings)
1855                                 memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
1856                 }
1857                 prog->numknownstrings++;
1858         }
1859         prog->knownstrings[i] = s;
1860         return -1 - i;
1861 }
1862
1863 char *PRVM_AllocString(int bufferlength)
1864 {
1865         int i;
1866         if (!bufferlength)
1867                 return 0;
1868         for (i = 0;i < prog->numknownstrings;i++)
1869                 if (!prog->knownstrings[i])
1870                         break;
1871         if (i >= prog->numknownstrings)
1872         {
1873                 if (i >= prog->maxknownstrings)
1874                 {
1875                         const char **oldstrings = prog->knownstrings;
1876                         prog->maxknownstrings += 128;
1877                         prog->knownstrings = PRVM_Alloc(prog->maxknownstrings * sizeof(char *));
1878                         if (prog->numknownstrings)
1879                                 memcpy((char **)prog->knownstrings, oldstrings, prog->numknownstrings * sizeof(char *));
1880                 }
1881                 prog->numknownstrings++;
1882         }
1883         return (char *)(prog->knownstrings[i] = PRVM_Alloc(bufferlength));
1884 }
1885
1886 void PRVM_FreeString(char *s)
1887 {
1888         int i;
1889         if (!s)
1890                 Host_Error("PRVM_FreeString: attempt to free a NULL string\n");
1891         if (s >= prog->strings && s <= prog->strings + prog->stringssize)
1892                 Host_Error("PRVM_FreeString: attempt to free a constant string\n");
1893         for (i = 0;i < prog->numknownstrings;i++)
1894                 if (prog->knownstrings[i] == s)
1895                         break;
1896         if (i == prog->numknownstrings)
1897                 Host_Error("PRVM_FreeString: attempt to free a non-existent or already freed string\n");
1898         PRVM_Free((char *)prog->knownstrings[i]);
1899         prog->knownstrings[i] = NULL;
1900 }
1901