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 cvar_t *cvar_vars = NULL;
  25 char *cvar_null_string = "";
  26
  27 /*
  28 ============
  29 Cvar_FindVar
  30 ============
  31 */
  32 cvar_t *Cvar_FindVar (const char *var_name)
  33 {
  34         cvar_t *var;
  35
  36         for (var = cvar_vars;var;var = var->next)
  37                 if (!strcasecmp (var_name, var->name))
  38                         return var;
  39
  40         return NULL;
  41 }
  42
  43 cvar_t *Cvar_FindVarAfter (const char *prev_var_name, int neededflags)
  44 {
  45         cvar_t *var;
  46
  47         if (*prev_var_name)
  48         {
  49                 var = Cvar_FindVar (prev_var_name);
  50                 if (!var)
  51                         return NULL;
  52                 var = var->next;
  53         }
  54         else
  55                 var = cvar_vars;
  56
  57         // search for the next cvar matching the needed flags
  58         while (var)
  59         {
  60                 if ((var->flags & neededflags) || !neededflags)
  61                         break;
  62                 var = var->next;
  63         }
  64         return var;
  65 }
  66
  67 /*
  68 ============
  69 Cvar_VariableValue
  70 ============
  71 */
  72 float Cvar_VariableValue (const char *var_name)
  73 {
  74         cvar_t *var;
  75
  76         var = Cvar_FindVar (var_name);
  77         if (!var)
  78                 return 0;
  79         return atof (var->string);
  80 }
  81
  82
  83 /*
  84 ============
  85 Cvar_VariableString
  86 ============
  87 */
  88 const char *Cvar_VariableString (const char *var_name)
  89 {
  90         cvar_t *var;
  91
  92         var = Cvar_FindVar (var_name);
  93         if (!var)
  94                 return cvar_null_string;
  95         return var->string;
  96 }
  97
  98
  99 /*
 100 ============
 101 Cvar_CompleteVariable
 102 ============
 103 */
 104 const char *Cvar_CompleteVariable (const char *partial)
 105 {
 106         cvar_t          *cvar;
 107         int                     len;
 108
 109         len = strlen(partial);
 110
 111         if (!len)
 112                 return NULL;
 113
 114 // check functions
 115         for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
 116                 if (!strncasecmp (partial,cvar->name, len))
 117                         return cvar->name;
 118
 119         return NULL;
 120 }
 121
 122
 123 /*
 124         CVar_CompleteCountPossible
 125
 126         New function for tab-completion system
 127         Added by EvilTypeGuy
 128         Thanks to Fett erich@heintz.com
 129
 130 */
 131 int Cvar_CompleteCountPossible (const char *partial)
 132 {
 133         cvar_t  *cvar;
 134         int             len;
 135         int             h;
 136
 137         h = 0;
 138         len = strlen(partial);
 139
 140         if (!len)
 141                 return  0;
 142
 143         // Loop through the cvars and count all possible matches
 144         for (cvar = cvar_vars; cvar; cvar = cvar->next)
 145                 if (!strncasecmp(partial, cvar->name, len))
 146                         h++;
 147
 148         return h;
 149 }
 150
 151 /*
 152         CVar_CompleteBuildList
 153
 154         New function for tab-completion system
 155         Added by EvilTypeGuy
 156         Thanks to Fett erich@heintz.com
 157         Thanks to taniwha
 158
 159 */
 160 const char **Cvar_CompleteBuildList (const char *partial)
 161 {
 162         const cvar_t *cvar;
 163         int len = 0;
 164         int bpos = 0;
 165         int sizeofbuf = (Cvar_CompleteCountPossible (partial) + 1) * sizeof (const char *);
 166         const char **buf;
 167
 168         len = strlen(partial);
 169         buf = Mem_Alloc(tempmempool, sizeofbuf + sizeof (const char *));
 170         // Loop through the alias list and print all matches
 171         for (cvar = cvar_vars; cvar; cvar = cvar->next)
 172                 if (!strncasecmp(partial, cvar->name, len))
 173                         buf[bpos++] = cvar->name;
 174
 175         buf[bpos] = NULL;
 176         return buf;
 177 }
 178
 179 /*
 180 ============
 181 Cvar_Set
 182 ============
 183 */
 184 void Cvar_SetQuick_Internal (cvar_t *var, const char *value)
 185 {
 186         qboolean changed;
 187
 188         changed = strcmp(var->string, value);
 189         // LordHavoc: don't reallocate when there is no change
 190         if (!changed)
 191                 return;
 192
 193         // LordHavoc: don't reallocate when the buffer is the same size
 194         if (!var->string || strlen(var->string) != strlen(value))
 195         {
 196                 Z_Free (var->string);   // free the old value string
 197
 198                 var->string = Z_Malloc (strlen(value)+1);
 199         }
 200         strcpy (var->string, value);
 201         var->value = atof (var->string);
 202         var->integer = (int) var->value;
 203         if ((var->flags & CVAR_NOTIFY) && changed && sv.active)
 204                 SV_BroadcastPrintf("\"%s\" changed to \"%s\"\n", var->name, var->string);
 205 }
 206
 207 void Cvar_SetQuick (cvar_t *var, const char *value)
 208 {
 209         if (var == NULL)
 210         {
 211                 Con_Print("Cvar_SetQuick: var == NULL\n");
 212                 return;
 213         }
 214
 215         if (developer.integer)
 216                 Con_Printf("Cvar_SetQuick({\"%s\", \"%s\", %i}, \"%s\");\n", var->name, var->string, var->flags, value);
 217
 218         Cvar_SetQuick_Internal(var, value);
 219 }
 220
 221 void Cvar_Set (const char *var_name, const char *value)
 222 {
 223         cvar_t *var;
 224         var = Cvar_FindVar (var_name);
 225         if (var == NULL)
 226         {
 227                 Con_Printf("Cvar_Set: variable %s not found\n", var_name);
 228                 return;
 229         }
 230         Cvar_SetQuick(var, value);
 231 }
 232
 233 /*
 234 ============
 235 Cvar_SetValue
 236 ============
 237 */
 238 void Cvar_SetValueQuick(cvar_t *var, float value)
 239 {
 240         char val[256];
 241
 242         if ((float)((int)value) == value)
 243                 sprintf(val, "%i", (int)value);
 244         else
 245                 sprintf(val, "%f", value);
 246         Cvar_SetQuick(var, val);
 247 }
 248
 249 void Cvar_SetValue(const char *var_name, float value)
 250 {
 251         char val[256];
 252
 253         if ((float)((int)value) == value)
 254                 sprintf(val, "%i", (int)value);
 255         else
 256                 sprintf(val, "%f", value);
 257         Cvar_Set(var_name, val);
 258 }
 259
 260 /*
 261 ============
 262 Cvar_RegisterVariable
 263
 264 Adds a freestanding variable to the variable list.
 265 ============
 266 */
 267 void Cvar_RegisterVariable (cvar_t *variable)
 268 {
 269         cvar_t *cvar, *cvar2;
 270         char *oldstr;
 271
 272         if (developer.integer)
 273                 Con_Printf("Cvar_RegisterVariable({\"%s\", \"%s\", %i});\n", variable->name, variable->string, variable->flags);
 274
 275 // first check to see if it has already been defined
 276         cvar = Cvar_FindVar (variable->name);
 277         if (cvar)
 278         {
 279                 if (cvar->flags & CVAR_ALLOCATED)
 280                 {
 281                         if (developer.integer)
 282                                 Con_Printf("...  replacing existing allocated cvar {\"%s\", \"%s\", %i}", cvar->name, cvar->string, cvar->flags);
 283                         // fixed variables replace allocated ones
 284                         // (because the engine directly accesses fixed variables)
 285                         // NOTE: this isn't actually used currently
 286                         // (all cvars are registered before config parsing)
 287                         variable->flags |= (cvar->flags & ~CVAR_ALLOCATED);
 288                         // cvar->string is now owned by variable instead
 289                         variable->string = cvar->string;
 290                         variable->value = atof (variable->string);
 291                         variable->integer = (int) variable->value;
 292                         // replace cvar with this one...
 293                         variable->next = cvar->next;
 294                         if (cvar_vars == cvar)
 295                         {
 296                                 // head of the list is easy to change
 297                                 cvar_vars = variable;
 298                         }
 299                         else
 300                         {
 301                                 // otherwise find it somewhere in the list
 302                                 for (cvar2 = cvar_vars;cvar2->next != cvar;cvar2 = cvar2->next);
 303                                 if (cvar2->next == cvar)
 304                                         cvar2->next = variable;
 305                         }
 306
 307                         // get rid of old allocated cvar
 308                         // (but not the cvar->string, because we kept that)
 309                         Z_Free(cvar->name);
 310                         Z_Free(cvar);
 311                 }
 312                 else
 313                         Con_Printf("Can't register variable %s, already defined\n", variable->name);
 314                 return;
 315         }
 316
 317 // check for overlap with a command
 318         if (Cmd_Exists (variable->name))
 319         {
 320                 Con_Printf("Cvar_RegisterVariable: %s is a command\n", variable->name);
 321                 return;
 322         }
 323
 324 // copy the value off, because future sets will Z_Free it
 325         oldstr = variable->string;
 326         variable->string = Z_Malloc (strlen(variable->string)+1);
 327         strcpy (variable->string, oldstr);
 328         variable->value = atof (variable->string);
 329         variable->integer = (int) variable->value;
 330
 331 // link the variable in
 332         variable->next = cvar_vars;
 333         cvar_vars = variable;
 334 }
 335
 336 /*
 337 ============
 338 Cvar_Get
 339
 340 Adds a newly allocated variable to the variable list or sets its value.
 341 ============
 342 */
 343 cvar_t *Cvar_Get (const char *name, const char *value, int flags)
 344 {
 345         cvar_t *cvar;
 346
 347         if (developer.integer)
 348                 Con_Printf("Cvar_Get(\"%s\", \"%s\", %i);\n", name, value, flags);
 349
 350 // first check to see if it has already been defined
 351         cvar = Cvar_FindVar (name);
 352         if (cvar)
 353         {
 354                 cvar->flags |= flags;
 355                 Cvar_SetQuick_Internal (cvar, value);
 356                 return cvar;
 357         }
 358
 359 // check for overlap with a command
 360         if (Cmd_Exists (name))
 361         {
 362                 Con_Printf("Cvar_Get: %s is a command\n", name);
 363                 return NULL;
 364         }
 365
 366 // allocate a new cvar, cvar name, and cvar string
 367 // FIXME: these never get Z_Free'd
 368         cvar = Z_Malloc(sizeof(cvar_t));
 369         cvar->flags = flags | CVAR_ALLOCATED;
 370         cvar->name = Z_Malloc(strlen(name)+1);
 371         strcpy(cvar->name, name);
 372         cvar->string = Z_Malloc(strlen(value)+1);
 373         strcpy(cvar->string, value);
 374         cvar->value = atof (cvar->string);
 375         cvar->integer = (int) cvar->value;
 376
 377 // link the variable in
 378         cvar->next = cvar_vars;
 379         cvar_vars = cvar;
 380         return cvar;
 381 }
 382
 383
 384 /*
 385 ============
 386 Cvar_Command
 387
 388 Handles variable inspection and changing from the console
 389 ============
 390 */
 391 qboolean        Cvar_Command (void)
 392 {
 393         cvar_t                  *v;
 394
 395 // check variables
 396         v = Cvar_FindVar (Cmd_Argv(0));
 397         if (!v)
 398                 return false;
 399
 400 // perform a variable print or set
 401         if (Cmd_Argc() == 1)
 402         {
 403                 // only print if host_initialized (otherwise it could print twice if this is in a script)
 404                 if (host_initialized)
 405                         Con_Printf("\"%s\" is \"%s\"\n", v->name, v->string);
 406                 return true;
 407         }
 408
 409         if (developer.integer)
 410                 Con_Print("Cvar_Command: ");
 411
 412         if (v->flags & CVAR_READONLY)
 413         {
 414                 Con_Printf("%s is read-only\n", v->name);
 415                 return true;
 416         }
 417         Cvar_Set (v->name, Cmd_Argv(1));
 418         return true;
 419 }
 420
 421
 422 /*
 423 ============
 424 Cvar_WriteVariables
 425
 426 Writes lines containing "set variable value" for all variables
 427 with the archive flag set to true.
 428 ============
 429 */
 430 void Cvar_WriteVariables (qfile_t *f)
 431 {
 432         cvar_t  *var;
 433
 434         for (var = cvar_vars ; var ; var = var->next)
 435                 if (var->flags & CVAR_SAVE)
 436                         FS_Printf(f, "%s%s \"%s\"\n", var->flags & CVAR_ALLOCATED ? "seta " : "", var->name, var->string);
 437 }
 438
 439
 440 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
 441 // 2000-01-09 CvarList command By Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
 442 /*
 443 =========
 444 Cvar_List
 445 =========
 446 */
 447 void Cvar_List_f (void)
 448 {
 449         cvar_t *cvar;
 450         const char *partial;
 451         int len, count;
 452
 453         if (Cmd_Argc() > 1)
 454         {
 455                 partial = Cmd_Argv (1);
 456                 len = strlen(partial);
 457         }
 458         else
 459         {
 460                 partial = NULL;
 461                 len = 0;
 462         }
 463
 464         count = 0;
 465         for (cvar = cvar_vars; cvar; cvar = cvar->next)
 466         {
 467                 if (partial && strncasecmp (partial,cvar->name,len))
 468                         continue;
 469
 470                 Con_Printf("%s is \"%s\"\n", cvar->name, cvar->string);
 471                 count++;
 472         }
 473
 474         Con_Printf("%i cvar(s)", count);
 475         if (partial)
 476                 Con_Printf(" beginning with \"%s\"", partial);
 477         Con_Print("\n");
 478 }
 479 // 2000-01-09 CvarList command by Maddes
 480
 481 void Cvar_Set_f (void)
 482 {
 483         cvar_t *cvar;
 484
 485         // make sure it's the right number of parameters
 486         if (Cmd_Argc() < 3)
 487         {
 488                 Con_Printf("Set: wrong number of parameters, usage: set <variablename> <value>\n");
 489                 return;
 490         }
 491
 492         // check if it's read-only
 493         cvar = Cvar_FindVar(Cmd_Argv(1));
 494         if (cvar && cvar->flags & CVAR_READONLY)
 495         {
 496                 Con_Printf("Set: %s is read-only\n", cvar->name);
 497                 return;
 498         }
 499
 500         if (developer.integer)
 501                 Con_Print("Set: ");
 502
 503         // all looks ok, create/modify the cvar
 504         Cvar_Get(Cmd_Argv(1), Cmd_Argv(2), 0);
 505 }
 506
 507 void Cvar_SetA_f (void)
 508 {
 509         cvar_t *cvar;
 510
 511         // make sure it's the right number of parameters
 512         if (Cmd_Argc() < 3)
 513         {
 514                 Con_Printf("SetA: wrong number of parameters, usage: seta <variablename> <value>\n");
 515                 return;
 516         }
 517
 518         // check if it's read-only
 519         cvar = Cvar_FindVar(Cmd_Argv(1));
 520         if (cvar && cvar->flags & CVAR_READONLY)
 521         {
 522                 Con_Printf("SetA: %s is read-only\n", cvar->name);
 523                 return;
 524         }
 525
 526         if (developer.integer)
 527                 Con_Print("SetA: ");
 528
 529         // all looks ok, create/modify the cvar
 530         Cvar_Get(Cmd_Argv(1), Cmd_Argv(2), CVAR_SAVE);
 531 }
 532
 533