cvar.c

   1 /*
   2 Copyright (C) 1996-1997 Id Software, Inc.
   3 Copyright (C) 2000-2021 DarkPlaces contributors
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13
  14 See the GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 */
  21 // cvar.c -- dynamic variable tracking
  22
  23 #include "quakedef.h"
  24
  25 const char *cvar_dummy_description = "custom cvar";
  26 static const char *cvar_null_string = "";
  27
  28 cvar_state_t cvars_all;
  29 cvar_state_t cvars_null;
  30
  31 /*
  32 ============
  33 Cvar_FindVar
  34 ============
  35 */
  36 cvar_t *Cvar_FindVar(cvar_state_t *cvars, const char *var_name, int neededflags)
  37 {
  38         int hashindex;
  39         cvar_hash_t *hash;
  40
  41         // use hash lookup to minimize search time
  42         hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
  43         for (hash = cvars->hashtable[hashindex];hash;hash = hash->next)
  44                 if (!strcmp (var_name, hash->cvar->name) && (hash->cvar->flags & neededflags))
  45                         return hash->cvar;
  46                 else
  47                         for (char **alias = hash->cvar->aliases; alias && *alias; alias++)
  48                                 if (!strcmp (var_name, *alias) && (hash->cvar->flags & neededflags))
  49                                         return hash->cvar;
  50         return NULL;
  51 }
  52
  53 cvar_t *Cvar_FindVarAfter(cvar_state_t *cvars, const char *prev_var_name, int neededflags)
  54 {
  55         cvar_t *var;
  56
  57         if (*prev_var_name)
  58         {
  59                 var = Cvar_FindVar(cvars, prev_var_name, neededflags);
  60                 if (!var)
  61                         return NULL;
  62                 var = var->next;
  63         }
  64         else
  65                 var = cvars->vars;
  66
  67         // search for the next cvar matching the needed flags
  68         while (var)
  69         {
  70                 if (var->flags & neededflags)
  71                         break;
  72                 var = var->next;
  73         }
  74         return var;
  75 }
  76
  77 static cvar_t *Cvar_FindVarLink(cvar_state_t *cvars, const char *var_name, cvar_t **parent, cvar_t ***link, cvar_t **prev_alpha, int neededflags)
  78 {
  79         int hashindex;
  80         cvar_hash_t *hash;
  81
  82         // use hash lookup to minimize search time
  83         hashindex = CRC_Block((const unsigned char *)var_name, strlen(var_name)) % CVAR_HASHSIZE;
  84         if(parent) *parent = NULL;
  85         if(prev_alpha) *prev_alpha = NULL;
  86         if(link) *link = &cvars->hashtable[hashindex]->cvar;
  87         for (hash = cvars->hashtable[hashindex];hash;hash = hash->next)
  88         {
  89                 if (!strcmp (var_name, hash->cvar->name) && (hash->cvar->flags & neededflags))
  90                         goto match;
  91                 else
  92                         for (char **alias = hash->cvar->aliases; alias && *alias; alias++)
  93                                 if (!strcmp (var_name, *alias) && (hash->cvar->flags & neededflags))
  94                                         goto match;
  95                 if(parent) *parent = hash->cvar;
  96         }
  97         return NULL;
  98 match:
  99         if(!prev_alpha || hash->cvar == cvars->vars)
 100                 return hash->cvar;
 101
 102         *prev_alpha = cvars->vars;
 103         // if prev_alpha happens to become NULL then there has been some inconsistency elsewhere
 104         // already - should I still insert '*prev_alpha &&' in the loop?
 105         while((*prev_alpha)->next != hash->cvar)
 106                 *prev_alpha = (*prev_alpha)->next;
 107         return hash->cvar;
 108 }
 109
 110 /*
 111 ============
 112 Cvar_VariableValue
 113 ============
 114 */
 115 float Cvar_VariableValueOr(cvar_state_t *cvars, const char *var_name, float def, int neededflags)
 116 {
 117         cvar_t *var;
 118
 119         var = Cvar_FindVar(cvars, var_name, neededflags);
 120         if (!var)
 121                 return def;
 122         return atof (var->string);
 123 }
 124
 125 float Cvar_VariableValue(cvar_state_t *cvars, const char *var_name, int neededflags)
 126 {
 127         return Cvar_VariableValueOr(cvars, var_name, 0, neededflags);
 128 }
 129
 130 /*
 131 ============
 132 Cvar_VariableString
 133 ============
 134 */
 135 const char *Cvar_VariableStringOr(cvar_state_t *cvars, const char *var_name, const char *def, int neededflags)
 136 {
 137         cvar_t *var;
 138
 139         var = Cvar_FindVar(cvars, var_name, neededflags);
 140         if (!var)
 141                 return def;
 142         return var->string;
 143 }
 144
 145 const char *Cvar_VariableString(cvar_state_t *cvars, const char *var_name, int neededflags)
 146 {
 147         return Cvar_VariableStringOr(cvars, var_name, cvar_null_string, neededflags);
 148 }
 149
 150 /*
 151 ============
 152 Cvar_VariableDefString
 153 ============
 154 */
 155 const char *Cvar_VariableDefString(cvar_state_t *cvars, const char *var_name, int neededflags)
 156 {
 157         cvar_t *var;
 158
 159         var = Cvar_FindVar(cvars, var_name, neededflags);
 160         if (!var)
 161                 return cvar_null_string;
 162         return var->defstring;
 163 }
 164
 165 /*
 166 ============
 167 Cvar_VariableDescription
 168 ============
 169 */
 170 const char *Cvar_VariableDescription(cvar_state_t *cvars, const char *var_name, int neededflags)
 171 {
 172         cvar_t *var;
 173
 174         var = Cvar_FindVar(cvars, var_name, neededflags);
 175         if (!var)
 176                 return cvar_null_string;
 177         return var->description;
 178 }
 179
 180
 181 /*
 182 ============
 183 Cvar_CompleteVariable
 184 ============
 185 */
 186 const char *Cvar_CompleteVariable(cvar_state_t *cvars, const char *partial, int neededflags)
 187 {
 188         cvar_t          *cvar;
 189         size_t          len;
 190
 191         len = strlen(partial);
 192
 193         if (!len)
 194                 return NULL;
 195
 196 // check functions
 197         for (cvar=cvars->vars ; cvar ; cvar=cvar->next)
 198                 if (!strncasecmp (partial,cvar->name, len) && (cvar->flags & neededflags))
 199                         return cvar->name;
 200
 201         return NULL;
 202 }
 203
 204
 205 /*
 206         CVar_CompleteCountPossible
 207
 208         New function for tab-completion system
 209         Added by EvilTypeGuy
 210         Thanks to Fett erich@heintz.com
 211
 212 */
 213 int Cvar_CompleteCountPossible(cvar_state_t *cvars, const char *partial, int neededflags)
 214 {
 215         cvar_t  *cvar;
 216         size_t  len;
 217         int             h;
 218
 219         h = 0;
 220         len = strlen(partial);
 221
 222         if (!len)
 223                 return  0;
 224
 225         // Loop through the cvars and count all possible matches
 226         for (cvar = cvars->vars; cvar; cvar = cvar->next)
 227                 if (!strncasecmp(partial, cvar->name, len) && (cvar->flags & neededflags))
 228                         h++;
 229                 else
 230                         for (char **alias = cvar->aliases; alias && *alias; alias++)
 231                                 if (!strncasecmp(partial, *alias, len) && (cvar->flags & neededflags))
 232                                         h++;
 233
 234         return h;
 235 }
 236
 237 /*
 238         CVar_CompleteBuildList
 239
 240         New function for tab-completion system
 241         Added by EvilTypeGuy
 242         Thanks to Fett erich@heintz.com
 243         Thanks to taniwha
 244
 245 */
 246 const char **Cvar_CompleteBuildList(cvar_state_t *cvars, const char *partial, int neededflags)
 247 {
 248         const cvar_t *cvar;
 249         size_t len = 0;
 250         size_t bpos = 0;
 251         size_t sizeofbuf = (Cvar_CompleteCountPossible(cvars, partial, neededflags) + 1) * sizeof(const char *);
 252         const char **buf;
 253
 254         len = strlen(partial);
 255         buf = (const char **)Mem_Alloc(tempmempool, sizeofbuf + sizeof(const char *));
 256         // Loop through the alias list and print all matches
 257         for (cvar = cvars->vars; cvar; cvar = cvar->next)
 258                 if (!strncasecmp(partial, cvar->name, len) && (cvar->flags & neededflags))
 259                         buf[bpos++] = cvar->name;
 260                 else
 261                         for (char **alias = cvar->aliases; alias && *alias; alias++)
 262                                 if (!strncasecmp(partial, *alias, len) && (cvar->flags & neededflags))
 263                                         buf[bpos++] = *alias;
 264
 265
 266         buf[bpos] = NULL;
 267         return buf;
 268 }
 269
 270 void Cvar_PrintHelp(cvar_t *cvar, const char *name, qbool full)
 271 {
 272         // Aliases are purple, cvars are yellow
 273         if (strcmp(cvar->name, name))
 274                 Con_Printf("^6%s^7 (alias of ^3%s^7)", name, cvar->name);
 275         else
 276                 Con_Printf("^3%s^7", name);
 277         Con_Printf(" is \"%s^7\" [\"%s^7\"]", ((cvar->flags & CF_PRIVATE) ? "********"/*hunter2*/ : cvar->string), cvar->defstring);
 278         if (full)
 279                 Con_Printf(" %s", cvar->description);
 280         Con_Print("\n");
 281 }
 282
 283 // written by LadyHavoc
 284 void Cvar_CompleteCvarPrint(cvar_state_t *cvars, const char *partial, int neededflags)
 285 {
 286         cvar_t *cvar;
 287         size_t len = strlen(partial);
 288         // Loop through the command list and print all matches
 289         for (cvar = cvars->vars; cvar; cvar = cvar->next)
 290                 if (!strncasecmp(partial, cvar->name, len) && (cvar->flags & neededflags))
 291                         Cvar_PrintHelp(cvar, cvar->name, true);
 292                 else
 293                         for (char **alias = cvar->aliases; alias && *alias; alias++)
 294                                 if (!strncasecmp (partial, *alias, len) && (cvar->flags & neededflags))
 295                                         Cvar_PrintHelp(cvar, *alias, true);
 296
 297
 298 }
 299
 300 // check if a cvar is held by some progs
 301 static qbool Cvar_IsAutoCvar(cvar_t *var)
 302 {
 303         int i;
 304         prvm_prog_t *prog;
 305         for (i = 0;i < PRVM_PROG_MAX;i++)
 306         {
 307                 prog = &prvm_prog_list[i];
 308                 if (prog->loaded && var->globaldefindex[i] >= 0)
 309                         return true;
 310         }
 311         return false;
 312 }
 313
 314 // we assume that prog is already set to the target progs
 315 static void Cvar_UpdateAutoCvar(cvar_t *var)
 316 {
 317         int i;
 318         int j;
 319         const char *s;
 320         vec3_t v;
 321         prvm_prog_t *prog;
 322         for (i = 0;i < PRVM_PROG_MAX;i++)
 323         {
 324                 prog = &prvm_prog_list[i];
 325                 if (prog->loaded && var->globaldefindex[i] >= 0)
 326                 {
 327                         // MUST BE SYNCED WITH prvm_edict.c PRVM_LoadProgs
 328                         switch(prog->globaldefs[var->globaldefindex[i]].type & ~DEF_SAVEGLOBAL)
 329                         {
 330                         case ev_float:
 331                                 PRVM_GLOBALFIELDFLOAT(prog->globaldefs[var->globaldefindex[i]].ofs) = var->value;
 332                                 break;
 333                         case ev_vector:
 334                                 s = var->string;
 335                                 VectorClear(v);
 336                                 for (j = 0;j < 3;j++)
 337                                 {
 338                                         while (*s && ISWHITESPACE(*s))
 339                                                 s++;
 340                                         if (!*s)
 341                                                 break;
 342                                         v[j] = atof(s);
 343                                         while (!ISWHITESPACE(*s))
 344                                                 s++;
 345                                         if (!*s)
 346                                                 break;
 347                                 }
 348                                 VectorCopy(v, PRVM_GLOBALFIELDVECTOR(prog->globaldefs[var->globaldefindex[i]].ofs));
 349                                 break;
 350                         case ev_string:
 351                                 PRVM_ChangeEngineString(prog, var->globaldefindex_stringno[i], var->string);
 352                                 PRVM_GLOBALFIELDSTRING(prog->globaldefs[var->globaldefindex[i]].ofs) = var->globaldefindex_stringno[i];
 353                                 break;
 354                         }
 355                 }
 356         }
 357 }
 358
 359 // called after loading a savegame
 360 void Cvar_UpdateAllAutoCvars(cvar_state_t *cvars)
 361 {
 362         cvar_t *var;
 363         for (var = cvars->vars ; var ; var = var->next)
 364                 Cvar_UpdateAutoCvar(var);
 365 }
 366
 367 void Cvar_Callback(cvar_t *var)
 368 {
 369         if (var == NULL)
 370         {
 371                 Con_Print(CON_WARN "Cvar_Callback: var == NULL\n");
 372                 return;
 373         }
 374
 375         if(var->callback)
 376                 var->callback(var);
 377 }
 378
 379 /*
 380 ============
 381 Cvar_Set
 382 ============
 383 */
 384 extern cvar_t sv_disablenotify;
 385 static void Cvar_SetQuick_Internal (cvar_t *var, const char *value)
 386 {
 387         qbool changed;
 388         size_t valuelen;
 389
 390         changed = strcmp(var->string, value) != 0;
 391         // LadyHavoc: don't reallocate when there is no change
 392         if (!changed)
 393                 goto cvar_callback;
 394
 395         // LadyHavoc: don't reallocate when the buffer is the same size
 396         valuelen = strlen(value);
 397         if (!var->string || strlen(var->string) != valuelen)
 398         {
 399                 Z_Free ((char *)var->string);   // free the old value string
 400
 401                 var->string = (char *)Z_Malloc (valuelen + 1);
 402         }
 403         memcpy ((char *)var->string, value, valuelen + 1);
 404         var->value = atof (var->string);
 405         var->integer = (int) var->value;
 406         if ((var->flags & CF_NOTIFY) && sv.active && !sv_disablenotify.integer)
 407                 SV_BroadcastPrintf("\003^3Server cvar \"%s\" changed to \"%s\"\n", var->name, var->string);
 408 #if 0
 409         // TODO: add infostring support to the server?
 410         if ((var->flags & CF_SERVERINFO) && changed && sv.active)
 411         {
 412                 InfoString_SetValue(svs.serverinfo, sizeof(svs.serverinfo), var->name, var->string);
 413                 if (sv.active)
 414                 {
 415                         MSG_WriteByte (&sv.reliable_datagram, svc_serverinfostring);
 416                         MSG_WriteString (&sv.reliable_datagram, var->name);
 417                         MSG_WriteString (&sv.reliable_datagram, var->string);
 418                 }
 419         }
 420 #endif
 421         if (var->flags & CF_USERINFO)
 422                 CL_SetInfo(var->name, var->string, true, false, false, false);
 423
 424         Cvar_UpdateAutoCvar(var);
 425
 426 cvar_callback:
 427         // Call the function stored in the cvar for bounds checking, cleanup, etc
 428         Cvar_Callback(var);
 429 }
 430
 431 void Cvar_SetQuick (cvar_t *var, const char *value)
 432 {
 433         if (var == NULL)
 434         {
 435                 Con_Print(CON_WARN "Cvar_SetQuick: var == NULL\n");
 436                 return;
 437         }
 438
 439         if (!(var->flags & CF_REGISTERED) && !(var->flags & CF_ALLOCATED))
 440         {
 441                 Con_Printf(CON_WARN "Warning: Cvar_SetQuick() cannot set unregistered cvar \"%s\"\n", var->name);
 442                 return; // setting an unregistered engine cvar crashes
 443         }
 444
 445         if (developer_extra.integer)
 446                 Con_DPrintf("Cvar_SetQuick({\"%s\", \"%s\", %i, \"%s\"}, \"%s\");\n", var->name, var->string, var->flags, var->defstring, value);
 447
 448         Cvar_SetQuick_Internal(var, value);
 449 }
 450
 451 void Cvar_Set(cvar_state_t *cvars, const char *var_name, const char *value)
 452 {
 453         cvar_t *var;
 454         var = Cvar_FindVar(cvars, var_name, ~0);
 455         if (var == NULL)
 456         {
 457                 Con_Printf(CON_WARN "Cvar_Set: variable %s not found\n", var_name);
 458                 return;
 459         }
 460         Cvar_SetQuick(var, value);
 461 }
 462
 463 /*
 464 ============
 465 Cvar_SetValue
 466 ============
 467 */
 468 void Cvar_SetValueQuick(cvar_t *var, float value)
 469 {
 470         char val[MAX_INPUTLINE];
 471
 472         if ((float)((int)value) == value)
 473                 dpsnprintf(val, sizeof(val), "%i", (int)value);
 474         else
 475                 dpsnprintf(val, sizeof(val), "%f", value);
 476         Cvar_SetQuick(var, val);
 477 }
 478
 479 void Cvar_SetValue(cvar_state_t *cvars, const char *var_name, float value)
 480 {
 481         char val[MAX_INPUTLINE];
 482
 483         if ((float)((int)value) == value)
 484                 dpsnprintf(val, sizeof(val), "%i", (int)value);
 485         else
 486                 dpsnprintf(val, sizeof(val), "%f", value);
 487         Cvar_Set(cvars, var_name, val);
 488 }
 489
 490 void Cvar_RegisterCallback(cvar_t *variable, void (*callback)(cvar_t *))
 491 {
 492         if (variable == NULL)
 493         {
 494                 Con_Print(CON_WARN "Cvar_RegisterCallback: var == NULL\n");
 495                 return;
 496         }
 497
 498         if (!(variable->flags & cmd_local->cvars_flagsmask))
 499         {
 500                 if (developer_extra.integer)
 501                         Con_DPrintf("^6Cvar_RegisterCallback: rejecting cvar \"%s\"\n", variable->name);
 502                 return;
 503         }
 504
 505         variable->callback = callback;
 506 }
 507
 508 void Cvar_RegisterVirtual(cvar_t *variable, const char *name )
 509 {
 510         cvar_state_t *cvars = &cvars_all;
 511         cvar_hash_t *hash;
 512         int hashindex;
 513
 514         if (!(variable->flags & cmd_local->cvars_flagsmask))
 515         {
 516                 if (developer_extra.integer)
 517                         Con_DPrintf("^6Cvar_RegisterVirtual: rejecting cvar \"%s\" alias \"%s\"\n", variable->name, name);
 518                 return;
 519         }
 520
 521         if(!*name)
 522         {
 523                 Con_Printf(CON_WARN "Cvar_RegisterVirtual: invalid virtual cvar name\n");
 524                 return;
 525         }
 526
 527         // check for overlap with a command
 528         if (Cmd_Exists(cmd_local, name))
 529         {
 530                 Con_Printf(CON_WARN "Cvar_RegisterVirtual: %s is a command\n", name);
 531                 return;
 532         }
 533
 534         if(Cvar_FindVar(&cvars_all, name, 0))
 535         {
 536                 Con_Printf(CON_WARN "Cvar_RegisterVirtual: %s is a cvar\n", name);
 537                 return;
 538         }
 539
 540         // Resize the variable->aliases list to have room for another entry and a null terminator.
 541         // This zero-pads when resizing, so we don't need to write the NULL terminator manually here.
 542         // Also if aliases is NULL this allocates fresh for the correct size, so it's fine to just do this.
 543         variable->aliases = (char **)Z_Realloc(variable->aliases, sizeof(char *) * (variable->aliases_size + 2));
 544         // Add the new alias, and increment the number of aliases in the list
 545         variable->aliases[variable->aliases_size++] = (char *)Z_strdup(name);
 546
 547         // link to head of list in this hash table index
 548         hash = (cvar_hash_t *)Z_Malloc(sizeof(cvar_hash_t));
 549         hashindex = CRC_Block((const unsigned char *)name, strlen(name)) % CVAR_HASHSIZE;
 550         hash->next = cvars->hashtable[hashindex];
 551         cvars->hashtable[hashindex] = hash;
 552         hash->cvar = variable;
 553 }
 554
 555 /*
 556 ============
 557 Cvar_Link
 558
 559 Links a variable to the variable list and hashtable
 560 ============
 561 */
 562 static void Cvar_Link(cvar_t *variable, cvar_state_t *cvars)
 563 {
 564         cvar_t *current, *next;
 565         cvar_hash_t *hash;
 566         int hashindex;
 567         /*
 568          * Link the variable in
 569          * alphanumerical order
 570          */
 571         for( current = NULL, next = cvars->vars ; next && strcmp( next->name, variable->name ) < 0 ; current = next, next = next->next )
 572                 ;
 573         if(current)
 574                 current->next = variable;
 575         else
 576                 cvars->vars = variable;
 577         variable->next = next;
 578
 579         // link to head of list in this hash table index
 580         hash = (cvar_hash_t *)Z_Malloc(sizeof(cvar_hash_t));
 581         hashindex = CRC_Block((const unsigned char *)variable->name, strlen(variable->name)) % CVAR_HASHSIZE;
 582         hash->next = cvars->hashtable[hashindex];
 583         hash->cvar = variable;
 584         cvars->hashtable[hashindex] = hash;
 585 }
 586
 587 /*
 588 ============
 589 Cvar_RegisterVariable
 590
 591 Adds a freestanding variable to the variable list.
 592 ============
 593 */
 594 void Cvar_RegisterVariable (cvar_t *variable)
 595 {
 596         cvar_state_t *cvars = &cvars_all;
 597         cvar_t *current, *cvar;
 598         int i;
 599
 600         if (!(variable->flags & cmd_local->cvars_flagsmask))
 601         {
 602                 if (developer_extra.integer)
 603                         Con_DPrintf("^2Cvar_RegisterVariable: rejecting cvar \"%s\"\n", variable->name);
 604                 return;
 605         }
 606
 607         if (developer_extra.integer)
 608                 Con_DPrintf("Cvar_RegisterVariable({\"%s\", \"%s\", %i});\n", variable->name, variable->string, variable->flags);
 609
 610         // first check to see if it has already been defined
 611         cvar = Cvar_FindVar(cvars, variable->name, ~0);
 612         if (cvar)
 613         {
 614                 if (cvar->flags & CF_ALLOCATED)
 615                 {
 616                         if (developer_extra.integer)
 617                                 Con_DPrintf("...  replacing existing allocated cvar {\"%s\", \"%s\", %i}\n", cvar->name, cvar->string, cvar->flags);
 618                         // fixed variables replace allocated ones
 619                         // (because the engine directly accesses fixed variables)
 620                         // NOTE: this isn't actually used currently
 621                         // (all cvars are registered before config parsing)
 622                         variable->flags &= ~CF_ALLOCATED;
 623                         // cvar->string is now owned by variable instead
 624                         variable->string = cvar->string;
 625                         variable->defstring = cvar->defstring;
 626                         variable->value = atof (variable->string);
 627                         variable->integer = (int) variable->value;
 628                         // Preserve autocvar status.
 629                         memcpy(variable->globaldefindex, cvar->globaldefindex, sizeof(variable->globaldefindex));
 630                         memcpy(variable->globaldefindex_stringno, cvar->globaldefindex_stringno, sizeof(variable->globaldefindex_stringno));
 631                         // replace cvar with this one...
 632                         variable->next = cvar->next;
 633                         if (cvars->vars == cvar)
 634                         {
 635                                 // head of the list is easy to change
 636                                 cvars->vars = variable;
 637                         }
 638                         else
 639                         {
 640                                 // otherwise find it somewhere in the list
 641                                 for (current = cvars->vars;current->next != cvar;current = current->next)
 642                                         ;
 643                                 current->next = variable;
 644                         }
 645
 646                         // get rid of old allocated cvar
 647                         // (but not cvar->string and cvar->defstring, because we kept those)
 648                         Z_Free((char *)cvar->name);
 649                         Z_Free(cvar);
 650                 }
 651                 else
 652                         Con_DPrintf("Can't register variable %s, already defined\n", variable->name);
 653                 return;
 654         }
 655
 656         // check for overlap with a command
 657         if (Cmd_Exists(cmd_local, variable->name))
 658         {
 659                 Con_Printf(CON_WARN "Cvar_RegisterVariable: %s is a command\n", variable->name);
 660                 return;
 661         }
 662
 663         // copy the value off, because future sets will Z_Free it
 664         variable->name = (char *)Mem_strdup(zonemempool, variable->name);
 665         variable->string = (char *)Mem_strdup(zonemempool, variable->string);
 666         variable->defstring = (char *)Mem_strdup(zonemempool, variable->string);
 667         variable->value = atof (variable->string);
 668         variable->integer = (int) variable->value;
 669         variable->aliases = NULL;
 670         variable->aliases_size = 0;
 671         variable->initstate = NULL;
 672
 673         // Mark it as not an autocvar.
 674         for (i = 0;i < PRVM_PROG_MAX;i++)
 675                 variable->globaldefindex[i] = -1;
 676
 677         // Safe for Cvar_SetQuick()
 678         variable->flags |= CF_REGISTERED;
 679
 680         Cvar_Link(variable, cvars);
 681 }
 682
 683 /*
 684 ============
 685 Cvar_Get
 686
 687 Adds a newly allocated variable to the variable list or sets its value.
 688 ============
 689 */
 690 cvar_t *Cvar_Get(cvar_state_t *cvars, const char *name, const char *value, int flags, const char *newdescription)
 691 {
 692         cvar_t *cvar;
 693         int i;
 694
 695         if (developer_extra.integer)
 696                 Con_DPrintf("Cvar_Get(\"%s\", \"%s\", %i);\n", name, value, flags);
 697
 698         // first check to see if it has already been defined
 699         cvar = Cvar_FindVar(cvars, name, ~0);
 700         if (cvar)
 701         {
 702                 cvar->flags |= flags;
 703                 Cvar_SetQuick_Internal (cvar, value);
 704                 if(newdescription && (cvar->flags & CF_ALLOCATED))
 705                 {
 706                         if(cvar->description != cvar_dummy_description)
 707                                 Z_Free((char *)cvar->description);
 708
 709                         if(*newdescription)
 710                                 cvar->description = (char *)Mem_strdup(zonemempool, newdescription);
 711                         else
 712                                 cvar->description = cvar_dummy_description;
 713                 }
 714                 return cvar;
 715         }
 716
 717         // check for pure evil
 718         if (!*name)
 719         {
 720                 Con_Printf(CON_WARN "Cvar_Get: invalid variable name\n");
 721                 return NULL;
 722         }
 723
 724         // check for overlap with a command
 725         if (Cmd_Exists(cmd_local, name))
 726         {
 727                 Con_Printf(CON_WARN "Cvar_Get: %s is a command\n", name);
 728                 return NULL;
 729         }
 730
 731         // allocate a new cvar, cvar name, and cvar string
 732         // TODO: factorize the following code with the one at the end of Cvar_RegisterVariable()
 733         // FIXME: these never get Z_Free'd
 734         cvar = (cvar_t *)Z_Malloc(sizeof(cvar_t));
 735         cvar->flags = flags | CF_ALLOCATED;
 736         cvar->name = (char *)Mem_strdup(zonemempool, name);
 737         cvar->string = (char *)Mem_strdup(zonemempool, value);
 738         cvar->defstring = (char *)Mem_strdup(zonemempool, value);
 739         cvar->value = atof (cvar->string);
 740         cvar->integer = (int) cvar->value;
 741         cvar->aliases = NULL;
 742         cvar->aliases_size = 0;
 743         cvar->initstate = NULL;
 744
 745         if(newdescription && *newdescription)
 746                 cvar->description = (char *)Mem_strdup(zonemempool, newdescription);
 747         else
 748                 cvar->description = cvar_dummy_description; // actually checked by VM_cvar_type
 749
 750         // Mark it as not an autocvar.
 751         for (i = 0;i < PRVM_PROG_MAX;i++)
 752                 cvar->globaldefindex[i] = -1;
 753
 754         Cvar_Link(cvar, cvars);
 755
 756         return cvar;
 757 }
 758
 759 qbool Cvar_Readonly (cvar_t *var, const char *cmd_name)
 760 {
 761         if (var->flags & CF_READONLY)
 762         {
 763                 Con_Print(CON_WARN);
 764                 if(cmd_name)
 765                         Con_Printf("%s: ",cmd_name);
 766                 Con_Printf("%s is read-only\n", var->name);
 767                 return true;
 768         }
 769         return false;
 770 }
 771
 772 /*
 773 ============
 774 Cvar_Command
 775
 776 Handles variable inspection and changing from the console
 777 ============
 778 */
 779 qbool   Cvar_Command (cmd_state_t *cmd)
 780 {
 781         cvar_state_t    *cvars = cmd->cvars;
 782         cvar_t                  *v;
 783
 784         // check variables
 785         v = Cvar_FindVar(cvars, Cmd_Argv(cmd, 0), (cmd->cvars_flagsmask));
 786         if (!v)
 787                 return false;
 788
 789         // perform a variable print or set
 790         if (Cmd_Argc(cmd) == 1)
 791         {
 792                 Cvar_PrintHelp(v, Cmd_Argv(cmd, 0), true);
 793                 return true;
 794         }
 795
 796         if (developer_extra.integer)
 797                 Con_DPrint("Cvar_Command: ");
 798
 799         if(Cvar_Readonly(v, NULL))
 800                 return true;
 801
 802         Cvar_SetQuick(v, Cmd_Argv(cmd, 1));
 803         if (developer_extra.integer)
 804                 Con_DPrint("\n");
 805         return true;
 806 }
 807
 808 void Cvar_UnlockDefaults(cmd_state_t *cmd)
 809 {
 810         cvar_state_t *cvars = cmd->cvars;
 811         cvar_t *var;
 812         // unlock the default values of all cvars
 813         for (var = cvars->vars ; var ; var = var->next)
 814                 var->flags &= ~CF_DEFAULTSET;
 815 }
 816
 817 void Cvar_LockDefaults_f(cmd_state_t *cmd)
 818 {
 819         cvar_state_t *cvars = cmd->cvars;
 820         cvar_t *var;
 821         // lock in the default values of all cvars
 822         for (var = cvars->vars ; var ; var = var->next)
 823         {
 824                 if (!(var->flags & CF_DEFAULTSET))
 825                 {
 826                         size_t alloclen;
 827
 828                         //Con_Printf("locking cvar %s (%s -> %s)\n", var->name, var->string, var->defstring);
 829                         var->flags |= CF_DEFAULTSET;
 830                         Z_Free((char *)var->defstring);
 831                         alloclen = strlen(var->string) + 1;
 832                         var->defstring = (char *)Z_Malloc(alloclen);
 833                         memcpy((char *)var->defstring, var->string, alloclen);
 834                 }
 835         }
 836 }
 837
 838 void Cvar_SaveInitState(cvar_state_t *cvars)
 839 {
 840         cvar_t *c;
 841         for (c = cvars->vars;c;c = c->next)
 842         {
 843                 c->initstate = (cvar_t *)Z_Malloc(sizeof(cvar_t));
 844                 memcpy(c->initstate, c, sizeof(cvar_t));
 845         }
 846 }
 847
 848 void Cvar_RestoreInitState(cvar_state_t *cvars)
 849 {
 850         int hashindex;
 851         cvar_t *c, **cp;
 852         cvar_t *c2, **cp2;
 853         for (cp = &cvars->vars;(c = *cp);)
 854         {
 855                 if (c->initstate)
 856                 {
 857                         // restore this cvar, it existed at init
 858                         if (((c->flags ^ c->initstate->flags) & CF_MAXFLAGSVAL)
 859                          || strcmp(c->defstring ? c->defstring : "", c->initstate->defstring ? c->initstate->defstring : "")
 860                          || strcmp(c->string ? c->string : "", c->initstate->string ? c->initstate->string : ""))
 861                         {
 862                                 Con_DPrintf("Cvar_RestoreInitState: Restoring cvar \"%s\"\n", c->name);
 863                                 if (c->defstring)
 864                                         Z_Free((char *)c->defstring);
 865                                 c->defstring = Mem_strdup(zonemempool, c->initstate->defstring);
 866                                 if (c->string)
 867                                         Z_Free((char *)c->string);
 868                                 c->string = Mem_strdup(zonemempool, c->initstate->string);
 869                         }
 870                         c->flags = c->initstate->flags;
 871                         c->value = c->initstate->value;
 872                         c->integer = c->initstate->integer;
 873                         VectorCopy(c->initstate->vector, c->vector);
 874                         cp = &c->next;
 875                 }
 876                 else
 877                 {
 878                         if (!(c->flags & CF_ALLOCATED))
 879                         {
 880                                 Con_DPrintf("Cvar_RestoreInitState: Unable to destroy cvar \"%s\", it was registered after init!\n", c->name);
 881                                 // In this case, at least reset it to the default.
 882                                 if((c->flags & CF_PERSISTENT) == 0)
 883                                         Cvar_SetQuick(c, c->defstring);
 884                                 cp = &c->next;
 885                                 continue;
 886                         }
 887                         if (Cvar_IsAutoCvar(c))
 888                         {
 889                                 Con_DPrintf("Cvar_RestoreInitState: Unable to destroy cvar \"%s\", it is an autocvar used by running progs!\n", c->name);
 890                                 // In this case, at least reset it to the default.
 891                                 if((c->flags & CF_PERSISTENT) == 0)
 892                                         Cvar_SetQuick(c, c->defstring);
 893                                 cp = &c->next;
 894                                 continue;
 895                         }
 896                         // remove this cvar, it did not exist at init
 897                         Con_DPrintf("Cvar_RestoreInitState: Destroying cvar \"%s\"\n", c->name);
 898                         // unlink struct from hash
 899                         hashindex = CRC_Block((const unsigned char *)c->name, strlen(c->name)) % CVAR_HASHSIZE;
 900                         for (cp2 = &cvars->hashtable[hashindex]->cvar;(c2 = *cp2);)
 901                         {
 902                                 if (c2 == c)
 903                                 {
 904                                         *cp2 = cvars->hashtable[hashindex]->next->cvar;
 905                                         break;
 906                                 }
 907                                 else
 908                                         cp2 = &cvars->hashtable[hashindex]->next->cvar;
 909                         }
 910                         // unlink struct from main list
 911                         *cp = c->next;
 912                         // free strings
 913                         if (c->defstring)
 914                                 Z_Free((char *)c->defstring);
 915                         if (c->string)
 916                                 Z_Free((char *)c->string);
 917                         if (c->description && c->description != cvar_dummy_description)
 918                                 Z_Free((char *)c->description);
 919                         // free struct
 920                         Z_Free(c);
 921                 }
 922         }
 923 }
 924
 925 void Cvar_ResetToDefaults_All_f(cmd_state_t *cmd)
 926 {
 927         cvar_state_t *cvars = cmd->cvars;
 928         cvar_t *var;
 929         // restore the default values of all cvars
 930         for (var = cvars->vars ; var ; var = var->next)
 931         {
 932                 if((var->flags & CF_PERSISTENT) == 0)
 933                         Cvar_SetQuick(var, var->defstring);
 934         }
 935 }
 936
 937 void Cvar_ResetToDefaults_NoSaveOnly_f(cmd_state_t *cmd)
 938 {
 939         cvar_state_t *cvars = cmd->cvars;
 940         cvar_t *var;
 941         // restore the default values of all cvars
 942         for (var = cvars->vars ; var ; var = var->next)
 943         {
 944                 if ((var->flags & (CF_PERSISTENT | CF_ARCHIVE)) == 0)
 945                         Cvar_SetQuick(var, var->defstring);
 946         }
 947 }
 948
 949
 950 void Cvar_ResetToDefaults_SaveOnly_f(cmd_state_t *cmd)
 951 {
 952         cvar_state_t *cvars = cmd->cvars;
 953         cvar_t *var;
 954         // restore the default values of all cvars
 955         for (var = cvars->vars ; var ; var = var->next)
 956         {
 957                 if ((var->flags & (CF_PERSISTENT | CF_ARCHIVE)) == CF_ARCHIVE)
 958                         Cvar_SetQuick(var, var->defstring);
 959         }
 960 }
 961
 962 /*
 963 ============
 964 Cvar_WriteVariables
 965
 966 Writes lines containing "set variable value" for all variables
 967 with the archive flag set to true.
 968 ============
 969 */
 970 void Cvar_WriteVariables (cvar_state_t *cvars, qfile_t *f)
 971 {
 972         cvar_t  *var;
 973         char buf1[MAX_INPUTLINE], buf2[MAX_INPUTLINE];
 974
 975         // don't save cvars that match their default value
 976         for (var = cvars->vars ; var ; var = var->next) {
 977                 if ((var->flags & CF_ARCHIVE) && (strcmp(var->string, var->defstring) || ((var->flags & CF_ALLOCATED) && !(var->flags & CF_DEFAULTSET))))
 978                 {
 979                         Cmd_QuoteString(buf1, sizeof(buf1), var->name, "\"\\$", false);
 980                         Cmd_QuoteString(buf2, sizeof(buf2), var->string, "\"\\$", false);
 981                         FS_Printf(f, "%s\"%s\" \"%s\"\n", var->flags & CF_ALLOCATED ? "seta " : "", buf1, buf2);
 982                 }
 983         }
 984 }
 985
 986 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
 987 // 2000-01-09 CvarList command By Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
 988 /*
 989 =========
 990 Cvar_List
 991 =========
 992 */
 993 void Cvar_List_f(cmd_state_t *cmd)
 994 {
 995         cvar_state_t *cvars = cmd->cvars;
 996         cvar_t *cvar;
 997         const char *partial;
 998         int count;
 999         qbool ispattern;
1000         char vabuf[1024];
1001
1002         if (Cmd_Argc(cmd) > 1)
1003         {
1004                 partial = Cmd_Argv(cmd, 1);
1005                 ispattern = (strchr(partial, '*') || strchr(partial, '?'));
1006                 if(!ispattern)
1007                         partial = va(vabuf, sizeof(vabuf), "%s*", partial);
1008         }
1009         else
1010         {
1011                 partial = va(vabuf, sizeof(vabuf), "*");
1012                 ispattern = false;
1013         }
1014
1015         count = 0;
1016         for (cvar = cvars->vars; cvar; cvar = cvar->next)
1017         {
1018                 if (matchpattern_with_separator(cvar->name, partial, false, "", false))
1019                 {
1020                         Cvar_PrintHelp(cvar, cvar->name, true);
1021                         count++;
1022                 }
1023                 for (char **alias = cvar->aliases; alias && *alias; alias++)
1024                 {
1025                         if (matchpattern_with_separator(*alias, partial, false, "", false))
1026                         {
1027                                 Cvar_PrintHelp(cvar, *alias, true);
1028                                 count++;
1029                         }
1030                 }
1031         }
1032
1033         if (Cmd_Argc(cmd) > 1)
1034         {
1035                 if(ispattern)
1036                         Con_Printf("%i cvar%s matching \"%s\"\n", count, (count > 1) ? "s" : "", partial);
1037                 else
1038                         Con_Printf("%i cvar%s beginning with \"%s\"\n", count, (count > 1) ? "s" : "", Cmd_Argv(cmd,1));
1039         }
1040         else
1041                 Con_Printf("%i cvar(s)\n", count);
1042 }
1043 // 2000-01-09 CvarList command by Maddes
1044
1045 void Cvar_Set_f(cmd_state_t *cmd)
1046 {
1047         cvar_state_t *cvars = cmd->cvars;
1048         cvar_t *cvar;
1049
1050         // make sure it's the right number of parameters
1051         if (Cmd_Argc(cmd) < 3)
1052         {
1053                 Con_Printf("Set: wrong number of parameters, usage: set <variablename> <value> [<description>]\n");
1054                 return;
1055         }
1056
1057         // check if it's read-only
1058         cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0);
1059         if (cvar)
1060                 if(Cvar_Readonly(cvar,"Set"))
1061                         return;
1062
1063         if (developer_extra.integer)
1064                 Con_DPrint("Set: ");
1065
1066         // all looks ok, create/modify the cvar
1067         Cvar_Get(cvars, Cmd_Argv(cmd, 1), Cmd_Argv(cmd, 2), cmd->cvars_flagsmask, Cmd_Argc(cmd) > 3 ? Cmd_Argv(cmd, 3) : NULL);
1068 }
1069
1070 void Cvar_SetA_f(cmd_state_t *cmd)
1071 {
1072         cvar_state_t *cvars = cmd->cvars;
1073         cvar_t *cvar;
1074
1075         // make sure it's the right number of parameters
1076         if (Cmd_Argc(cmd) < 3)
1077         {
1078                 Con_Printf("SetA: wrong number of parameters, usage: seta <variablename> <value> [<description>]\n");
1079                 return;
1080         }
1081
1082         // check if it's read-only
1083         cvar = Cvar_FindVar(cvars, Cmd_Argv(cmd, 1), ~0);
1084         if (cvar)
1085                 if(Cvar_Readonly(cvar,"SetA"))
1086                         return;
1087
1088         if (developer_extra.integer)
1089                 Con_DPrint("SetA: ");
1090
1091         // all looks ok, create/modify the cvar
1092         Cvar_Get(cvars, Cmd_Argv(cmd, 1), Cmd_Argv(cmd, 2), cmd->cvars_flagsmask | CF_ARCHIVE, Cmd_Argc(cmd) > 3 ? Cmd_Argv(cmd, 3) : NULL);
1093 }
1094
1095 void Cvar_Del_f(cmd_state_t *cmd)
1096 {
1097         cvar_state_t *cvars = cmd->cvars;
1098         int neededflags = ~0;
1099         int i;
1100         cvar_t *parent, **link;
1101         cvar_t *cvar, *prev;
1102
1103         if(Cmd_Argc(cmd) < 2)
1104         {
1105                 Con_Printf("%s: wrong number of parameters, usage: unset <variablename1> [<variablename2> ...]\n", Cmd_Argv(cmd, 0));
1106                 return;
1107         }
1108         for(i = 1; i < Cmd_Argc(cmd); ++i)
1109         {
1110                 cvar = Cvar_FindVarLink(cvars, Cmd_Argv(cmd, i), &parent, &link, &prev, neededflags);
1111
1112                 if(!cvar)
1113                 {
1114                         Con_Printf("%s: %s is not defined\n", Cmd_Argv(cmd, 0), Cmd_Argv(cmd, i));
1115                         continue;
1116                 }
1117                 if(Cvar_Readonly(cvar, Cmd_Argv(cmd, 0)))
1118                         continue;
1119                 if(!(cvar->flags & CF_ALLOCATED))
1120                 {
1121                         Con_Printf("%s: %s is static and cannot be deleted\n", Cmd_Argv(cmd, 0), cvar->name);
1122                         continue;
1123                 }
1124                 if(cvar == cvars->vars)
1125                 {
1126                         cvars->vars = cvar->next;
1127                 }
1128                 else
1129                 {
1130                         // in this case, prev must be set, otherwise there has been some inconsistensy
1131                         // elsewhere already... should I still check for prev != NULL?
1132                         prev->next = cvar->next;
1133                 }
1134
1135                 if(parent)
1136                         parent->next = cvar->next;
1137                 else if(link)
1138                         *link = cvar->next;
1139                 if(cvar->description != cvar_dummy_description)
1140                         Z_Free((char *)cvar->description);
1141
1142                 Z_Free((char *)cvar->name);
1143                 Z_Free((char *)cvar->string);
1144                 Z_Free((char *)cvar->defstring);
1145                 Z_Free(cvar);
1146         }
1147 }
1148
1149 #ifdef FILLALLCVARSWITHRUBBISH
1150 void Cvar_FillAll_f(cmd_state_t *cmd)
1151 {
1152         char *buf, *p, *q;
1153         int n, i;
1154         cvar_t *var;
1155         qbool verify;
1156         if(Cmd_Argc(cmd) != 2)
1157         {
1158                 Con_Printf("Usage: %s length to plant rubbish\n", Cmd_Argv(cmd, 0));
1159                 Con_Printf("Usage: %s -length to verify that the rubbish is still there\n", Cmd_Argv(cmd, 0));
1160                 return;
1161         }
1162         n = atoi(Cmd_Argv(cmd, 1));
1163         verify = (n < 0);
1164         if(verify)
1165                 n = -n;
1166         buf = Z_Malloc(n + 1);
1167         buf[n] = 0;
1168         for(var = cvars->vars; var; var = var->next)
1169         {
1170                 for(i = 0, p = buf, q = var->name; i < n; ++i)
1171                 {
1172                         *p++ = *q++;
1173                         if(!*q)
1174                                 q = var->name;
1175                 }
1176                 if(verify && strcmp(var->string, buf))
1177                 {
1178                         Con_Printf("\n%s does not contain the right rubbish, either this is the first run or a possible overrun was detected, or something changed it intentionally; it DOES contain: %s\n", var->name, var->string);
1179                 }
1180                 Cvar_SetQuick(var, buf);
1181         }
1182         Z_Free(buf);
1183 }
1184 #endif /* FILLALLCVARSWITHRUBBISH */