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;
  25 char    *cvar_null_string = "";
  26
  27 /*
  28 ============
  29 Cvar_FindVar
  30 ============
  31 */
  32 cvar_t *Cvar_FindVar (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 /*
  44 ============
  45 Cvar_VariableValue
  46 ============
  47 */
  48 float   Cvar_VariableValue (char *var_name)
  49 {
  50         cvar_t  *var;
  51
  52         var = Cvar_FindVar (var_name);
  53         if (!var)
  54                 return 0;
  55         return atof (var->string);
  56 }
  57
  58
  59 /*
  60 ============
  61 Cvar_VariableString
  62 ============
  63 */
  64 char *Cvar_VariableString (char *var_name)
  65 {
  66         cvar_t *var;
  67
  68         var = Cvar_FindVar (var_name);
  69         if (!var)
  70                 return cvar_null_string;
  71         return var->string;
  72 }
  73
  74
  75 /*
  76 ============
  77 Cvar_CompleteVariable
  78 ============
  79 */
  80 char *Cvar_CompleteVariable (char *partial)
  81 {
  82         cvar_t          *cvar;
  83         int                     len;
  84
  85         len = strlen(partial);
  86
  87         if (!len)
  88                 return NULL;
  89
  90 // check functions
  91         for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
  92                 if (!strncmp (partial,cvar->name, len))
  93                         return cvar->name;
  94
  95         return NULL;
  96 }
  97
  98
  99 /*
 100         CVar_CompleteCountPossible
 101
 102         New function for tab-completion system
 103         Added by EvilTypeGuy
 104         Thanks to Fett erich@heintz.com
 105
 106 */
 107 int
 108 Cvar_CompleteCountPossible (char *partial)
 109 {
 110         cvar_t  *cvar;
 111         int             len;
 112         int             h;
 113
 114         h = 0;
 115         len = strlen(partial);
 116
 117         if (!len)
 118                 return  0;
 119
 120         // Loop through the cvars and count all possible matches
 121         for (cvar = cvar_vars; cvar; cvar = cvar->next)
 122                 if (!strncasecmp(partial, cvar->name, len))
 123                         h++;
 124
 125         return h;
 126 }
 127
 128 /*
 129         CVar_CompleteBuildList
 130
 131         New function for tab-completion system
 132         Added by EvilTypeGuy
 133         Thanks to Fett erich@heintz.com
 134         Thanks to taniwha
 135
 136 */
 137 char    **
 138 Cvar_CompleteBuildList (char *partial)
 139 {
 140         cvar_t  *cvar;
 141         int             len = 0;
 142         int             bpos = 0;
 143         int             sizeofbuf = (Cvar_CompleteCountPossible (partial) + 1) * sizeof (char *);
 144         char    **buf;
 145
 146         len = strlen(partial);
 147         buf = Mem_Alloc(tempmempool, sizeofbuf + sizeof (char *));
 148         // Loop through the alias list and print all matches
 149         for (cvar = cvar_vars; cvar; cvar = cvar->next)
 150                 if (!strncasecmp(partial, cvar->name, len))
 151                         buf[bpos++] = cvar->name;
 152
 153         buf[bpos] = NULL;
 154         return buf;
 155 }
 156
 157 /*
 158 ============
 159 Cvar_Set
 160 ============
 161 */
 162 void Cvar_SetQuick (cvar_t *var, char *value)
 163 {
 164         qboolean changed;
 165
 166         if (var == NULL)
 167         {
 168                 Con_Printf("Cvar_SetQuick: var == NULL\n");
 169                 return;
 170         }
 171
 172         changed = strcmp(var->string, value);
 173         // LordHavoc: don't reallocate when there is no change
 174         if (!changed)
 175                 return;
 176
 177         // LordHavoc: don't reallocate when the buffer is the same size
 178         if (!var->string || strlen(var->string) != strlen(value))
 179         {
 180                 Z_Free (var->string);   // free the old value string
 181
 182                 var->string = Z_Malloc (strlen(value)+1);
 183         }
 184         strcpy (var->string, value);
 185         var->value = atof (var->string);
 186         var->integer = (int) var->value;
 187         if ((var->flags & CVAR_NOTIFY) && changed)
 188         {
 189                 if (sv.active)
 190                         SV_BroadcastPrintf ("\"%s\" changed to \"%s\"\n", var->name, var->string);
 191         }
 192 }
 193
 194 void Cvar_Set (char *var_name, char *value)
 195 {
 196         cvar_t *var;
 197         var = Cvar_FindVar (var_name);
 198         if (var == NULL)
 199         {
 200                 // there is an error in C code if this happens
 201                 Con_Printf ("Cvar_Set: variable %s not found\n", var_name);
 202                 return;
 203         }
 204
 205         Cvar_SetQuick(var, value);
 206 }
 207
 208 /*
 209 ============
 210 Cvar_SetValue
 211 ============
 212 */
 213 void Cvar_SetValueQuick (cvar_t *var, float value)
 214 {
 215         char    val[32];
 216
 217         // LordHavoc: changed from %f to %g to use shortest representation
 218         sprintf (val, "%g",value);
 219         Cvar_SetQuick (var, val);
 220 }
 221
 222 void Cvar_SetValue (char *var_name, float value)
 223 {
 224         char    val[32];
 225
 226         // LordHavoc: changed from %f to %g to use shortest representation
 227         sprintf (val, "%g",value);
 228         Cvar_Set (var_name, val);
 229 }
 230
 231 /*
 232 ============
 233 Cvar_RegisterVariable
 234
 235 Adds a freestanding variable to the variable list.
 236 ============
 237 */
 238 void Cvar_RegisterVariable (cvar_t *variable)
 239 {
 240         char    *oldstr;
 241
 242 // first check to see if it has already been defined
 243         if (Cvar_FindVar (variable->name))
 244         {
 245                 Con_Printf ("Can't register variable %s, already defined\n", variable->name);
 246                 return;
 247         }
 248
 249 // check for overlap with a command
 250         if (Cmd_Exists (variable->name))
 251         {
 252                 Con_Printf ("Cvar_RegisterVariable: %s is a command\n", variable->name);
 253                 return;
 254         }
 255
 256 // copy the value off, because future sets will Z_Free it
 257         oldstr = variable->string;
 258         variable->string = Z_Malloc (strlen(variable->string)+1);
 259         strcpy (variable->string, oldstr);
 260         variable->value = atof (variable->string);
 261         variable->integer = (int) variable->value;
 262
 263 // link the variable in
 264         variable->next = cvar_vars;
 265         cvar_vars = variable;
 266 }
 267
 268 /*
 269 ============
 270 Cvar_Command
 271
 272 Handles variable inspection and changing from the console
 273 ============
 274 */
 275 qboolean        Cvar_Command (void)
 276 {
 277         cvar_t                  *v;
 278
 279 // check variables
 280         v = Cvar_FindVar (Cmd_Argv(0));
 281         if (!v)
 282                 return false;
 283
 284 // perform a variable print or set
 285         if (Cmd_Argc() == 1)
 286         {
 287                 Con_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
 288                 return true;
 289         }
 290
 291         Cvar_Set (v->name, Cmd_Argv(1));
 292         return true;
 293 }
 294
 295
 296 /*
 297 ============
 298 Cvar_WriteVariables
 299
 300 Writes lines containing "set variable value" for all variables
 301 with the archive flag set to true.
 302 ============
 303 */
 304 void Cvar_WriteVariables (QFile *f)
 305 {
 306         cvar_t  *var;
 307
 308         for (var = cvar_vars ; var ; var = var->next)
 309                 if (var->flags & CVAR_SAVE)
 310                         Qprintf (f, "%s \"%s\"\n", var->name, var->string);
 311 }
 312
 313
 314 // Added by EvilTypeGuy eviltypeguy@qeradiant.com
 315 // 2000-01-09 CvarList command By Matthias "Maddes" Buecher, http://www.inside3d.com/qip/
 316 /*
 317 =========
 318 Cvar_List
 319 =========
 320 */
 321 void Cvar_List_f (void)
 322 {
 323         cvar_t  *cvar;
 324         char    *partial;
 325         int             len;
 326         int             count;
 327
 328         if (Cmd_Argc() > 1) {
 329                 partial = Cmd_Argv (1);
 330                 len = strlen(partial);
 331         } else {
 332                 partial = NULL;
 333                 len = 0;
 334         }
 335
 336         count = 0;
 337         for (cvar = cvar_vars; cvar; cvar = cvar->next) {
 338                 if (partial && strncmp (partial,cvar->name,len))
 339                         continue;
 340
 341                 Con_Printf ("%s is \"%s\"\n", cvar->name, cvar->string);
 342                 count++;
 343         }
 344
 345         Con_Printf ("%i cvar(s)", count);
 346         if (partial)
 347                 Con_Printf (" beginning with \"%s\"", partial);
 348         Con_Printf ("\n");
 349 }
 350 // 2000-01-09 CvarList command by Maddes
 351