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 (!strcmp (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 (!strncmp (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 (cvar_t *var, const char *value)
 185 {
 186         qboolean changed;
 187
 188         if (var == NULL)
 189         {
 190                 Con_Printf("Cvar_SetQuick: var == NULL\n");
 191                 return;
 192         }
 193
 194         changed = strcmp(var->string, value);
 195         // LordHavoc: don't reallocate when there is no change
 196         if (!changed)
 197                 return;
 198
 199         // LordHavoc: don't reallocate when the buffer is the same size
 200         if (!var->string || strlen(var->string) != strlen(value))
 201         {
 202                 Z_Free (var->string);   // free the old value string
 203
 204                 var->string = Z_Malloc (strlen(value)+1);
 205         }
 206         strcpy (var->string, value);
 207         var->value = atof (var->string);
 208         var->integer = (int) var->value;
 209         if ((var->flags & CVAR_NOTIFY) && changed)
 210         {
 211                 if (sv.active)
 212                         SV_BroadcastPrintf ("\"%s\" changed to \"%s\"\n", var->name, var->string);
 213         }
 214 }
 215
 216 void Cvar_Set (const char *var_name, const char *value)
 217 {
 218         cvar_t *var;
 219         var = Cvar_FindVar (var_name);
 220         if (var == NULL)
 221         {
 222                 // there is an error in C code if this happens
 223                 Con_Printf ("Cvar_Set: variable %s not found\n", var_name);
 224                 return;
 225         }
 226         if (var->flags & CVAR_READONLY)
 227         {
 228                 Con_Printf ("Cvar_Set: %s is read-only\n", var_name);
 229                 return;
 230         }
 231
 232         Cvar_SetQuick(var, value);
 233 }
 234
 235 /*
 236 ============
 237 Cvar_SetValue
 238 ============
 239 */
 240 void Cvar_SetValueQuick(cvar_t *var, float value)
 241 {
 242         char val[256];
 243
 244         if ((float)((int)value) == value)
 245                 sprintf(val, "%i", (int)value);
 246         else
 247                 sprintf(val, "%f", value);
 248         Cvar_SetQuick(var, val);
 249 }
 250
 251 void Cvar_SetValue(const char *var_name, float value)
 252 {
 253         char val[256];
 254
 255         if ((float)((int)value) == value)
 256                 sprintf(val, "%i", (int)value);
 257         else
 258                 sprintf(val, "%f", value);
 259         Cvar_Set(var_name, val);
 260 }
 261
 262 /*
 263 ============
 264 Cvar_RegisterVariable
 265
 266 Adds a freestanding variable to the variable list.
 267 ============
 268 */
 269 void Cvar_RegisterVariable (cvar_t *variable)
 270 {
 271         char    *oldstr;
 272
 273 // first check to see if it has already been defined
 274         if (Cvar_FindVar (variable->name))
 275         {
 276                 Con_Printf ("Can't register variable %s, already defined\n", variable->name);
 277                 return;
 278         }
 279
 280 // check for overlap with a command
 281         if (Cmd_Exists (variable->name))
 282         {
 283                 Con_Printf ("Cvar_RegisterVariable: %s is a command\n", variable->name);
 284                 return;
 285         }
 286
 287 // copy the value off, because future sets will Z_Free it
 288         oldstr = variable->string;
 289         variable->string = Z_Malloc (strlen(variable->string)+1);
 290         strcpy (variable->string, oldstr);
 291         variable->value = atof (variable->string);
 292         variable->integer = (int) variable->value;
 293
 294 // link the variable in
 295         variable->next = cvar_vars;
 296         cvar_vars = variable;
 297 }
 298
 299 /*
 300 ============
 301 Cvar_Command
 302
 303 Handles variable inspection and changing from the console
 304 ============
 305 */
 306 qboolean        Cvar_Command (void)
 307 {
 308         cvar_t                  *v;
 309
 310 // check variables
 311         v = Cvar_FindVar (Cmd_Argv(0));
 312         if (!v)
 313                 return false;
 314
 315 // perform a variable print or set
 316         if (Cmd_Argc() == 1)
 317         {
 318                 Con_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
 319                 return true;
 320         }
 321
 322         Cvar_Set (v->name, Cmd_Argv(1));
 323         return true;
 324 }
 325
 326
 327 /*
 328 ============
 329 Cvar_WriteVariables
 330
 331 Writes lines containing "set variable value" for all variables
 332 with the archive flag set to true.
 333 ============
 334 */
 335 void Cvar_WriteVariables (qfile_t *f)
 336 {
 337         cvar_t  *var;
 338
 339         for (var = cvar_vars ; var ; var = var->next)
 340                 if (var->flags & CVAR_SAVE)
 341                         FS_Printf (f, "%s \"%s\"\n", var->name, var->string);
 342 }
 343
 344
 345 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
 346 // 2000-01-09 CvarList command By Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
 347 /*
 348 =========
 349 Cvar_List
 350 =========
 351 */
 352 void Cvar_List_f (void)
 353 {
 354         cvar_t *cvar;
 355         const char *partial;
 356         int len, count;
 357
 358         if (Cmd_Argc() > 1)
 359         {
 360                 partial = Cmd_Argv (1);
 361                 len = strlen(partial);
 362         }
 363         else
 364         {
 365                 partial = NULL;
 366                 len = 0;
 367         }
 368
 369         count = 0;
 370         for (cvar = cvar_vars; cvar; cvar = cvar->next)
 371         {
 372                 if (partial && strncmp (partial,cvar->name,len))
 373                         continue;
 374
 375                 Con_Printf ("%s is \"%s\"\n", cvar->name, cvar->string);
 376                 count++;
 377         }
 378
 379         Con_Printf ("%i cvar(s)", count);
 380         if (partial)
 381                 Con_Printf (" beginning with \"%s\"", partial);
 382         Con_Printf ("\n");
 383 }
 384 // 2000-01-09 CvarList command by Maddes
 385