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