Main Page | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals

cvar.c File Reference

#include "../game/q_shared.h"
#include "qcommon.h"

Include dependency graph for cvar.c:

Include dependency graph

Go to the source code of this file.

Defines

#define FILE_HASH_SIZE   256
#define MAX_CVARS   1024

Functions

qboolean Cvar_Command (void)
void Cvar_CommandCompletion (void(*callback)(const char *s))
cvar_tCvar_FindVar (const char *var_name)
cvar_tCvar_Get (const char *var_name, const char *var_value, int flags)
char * Cvar_InfoString (int bit)
char * Cvar_InfoString_Big (int bit)
void Cvar_InfoStringBuffer (int bit, char *buff, int buffsize)
void Cvar_Init (void)
void Cvar_List_f (void)
void Cvar_Register (vmCvar_t *vmCvar, const char *varName, const char *defaultValue, int flags)
void Cvar_Reset (const char *var_name)
void Cvar_Reset_f (void)
void Cvar_Restart_f (void)
void Cvar_Set (const char *var_name, const char *value)
cvar_tCvar_Set2 (const char *var_name, const char *value, qboolean force)
void Cvar_Set_f (void)
void Cvar_SetA_f (void)
void Cvar_SetCheatState (void)
void Cvar_SetLatched (const char *var_name, const char *value)
void Cvar_SetS_f (void)
void Cvar_SetU_f (void)
void Cvar_SetValue (const char *var_name, float value)
void Cvar_Toggle_f (void)
void Cvar_Update (vmCvar_t *vmCvar)
qboolean Cvar_ValidateString (const char *s)
int Cvar_VariableIntegerValue (const char *var_name)
char * Cvar_VariableString (const char *var_name)
void Cvar_VariableStringBuffer (const char *var_name, char *buffer, int bufsize)
float Cvar_VariableValue (const char *var_name)
void Cvar_WriteVariables (fileHandle_t f)
long generateHashValue (const char *fname)

Variables

cvar_tcvar_cheats
cvar_t cvar_indexes [MAX_CVARS]
int cvar_modifiedFlags
int cvar_numIndexes
cvar_tcvar_vars
cvar_thashTable [FILE_HASH_SIZE]


Define Documentation

#define FILE_HASH_SIZE   256
 

Definition at line 35 of file cvar.c.

Referenced by Com_HashString(), generateHashValue(), GeneratePermanentShader(), R_FindShader(), R_FindShaderByName(), R_RemapShader(), and RE_RegisterShaderFromImage().

#define MAX_CVARS   1024
 

Definition at line 31 of file cvar.c.


Function Documentation

qboolean Cvar_Command void   ) 
 

Definition at line 471 of file cvar.c.

References Cmd_Argc(), Cmd_Argv(), Com_Printf(), Cvar_FindVar(), Cvar_Set2(), cvar_t, cvar_s::latchedString, cvar_s::name, qboolean, qfalse, cvar_s::resetString, S_COLOR_WHITE, cvar_s::string, and v.

Referenced by Cmd_ExecuteString().

00471                               {
00472     cvar_t          *v;
00473 
00474     // check variables
00475     v = Cvar_FindVar (Cmd_Argv(0));
00476     if (!v) {
00477         return qfalse;
00478     }
00479 
00480     // perform a variable print or set
00481     if ( Cmd_Argc() == 1 ) {
00482         Com_Printf ("\"%s\" is:\"%s" S_COLOR_WHITE "\" default:\"%s" S_COLOR_WHITE "\"\n", v->name, v->string, v->resetString );
00483         if ( v->latchedString ) {
00484             Com_Printf( "latched: \"%s\"\n", v->latchedString );
00485         }
00486         return qtrue;
00487     }
00488 
00489     // set the value if forcing isn't required
00490     Cvar_Set2 (v->name, Cmd_Argv(1), qfalse);
00491     return qtrue;
00492 }

Here is the call graph for this function:

void Cvar_CommandCompletion void(*)(const char *s)  callback  ) 
 

Definition at line 170 of file cvar.c.

References cvar_t, cvar_s::name, and cvar_s::next.

Referenced by Field_CompleteCommand().

00170                                                                  {
00171     cvar_t      *cvar;
00172     
00173     for ( cvar = cvar_vars ; cvar ; cvar = cvar->next ) {
00174         callback( cvar->name );
00175     }
00176 }

cvar_t* Cvar_FindVar const char *  var_name  )  [static]
 

Definition at line 87 of file cvar.c.

References cvar_t, generateHashValue(), cvar_s::hashNext, hashTable, cvar_s::name, and Q_stricmp().

Referenced by Cvar_Command(), Cvar_Get(), Cvar_Set2(), Cvar_SetA_f(), Cvar_SetS_f(), Cvar_SetU_f(), Cvar_VariableIntegerValue(), Cvar_VariableString(), Cvar_VariableStringBuffer(), and Cvar_VariableValue().

00087                                                     {
00088     cvar_t  *var;
00089     long hash;
00090 
00091     hash = generateHashValue(var_name);
00092     
00093     for (var=hashTable[hash] ; var ; var=var->hashNext) {
00094         if (!Q_stricmp(var_name, var->name)) {
00095             return var;
00096         }
00097     }
00098 
00099     return NULL;
00100 }

Here is the call graph for this function:

cvar_t* Cvar_Get const char *  var_name,
const char *  var_value,
int  flags
 

Definition at line 187 of file cvar.c.

References atof(), atoi, Com_DPrintf(), Com_Error(), Com_Printf(), CopyString(), Cvar_FindVar(), cvar_indexes, cvar_modifiedFlags, cvar_numIndexes, Cvar_Set2(), cvar_t, Cvar_ValidateString(), cvar_vars, ERR_FATAL, cvar_s::flags, generateHashValue(), cvar_s::hashNext, hashTable, cvar_s::integer, cvar_s::latchedString, cvar_s::modificationCount, cvar_s::modified, cvar_s::name, cvar_s::next, qtrue, cvar_s::resetString, s, strcmp(), cvar_s::string, cvar_s::value, and Z_Free().

Referenced by BotDrawDebugPolygons(), CL_Init(), CL_InitInput(), CL_RequestAuthorization(), CL_UISystemCalls(), CLUI_GetCDKey(), CLUI_SetCDKey(), CM_DrawDebugSurface(), CM_LoadMap(), CM_TracePointThroughPatchCollide(), CM_TraceThroughPatchCollide(), Com_Frame(), Com_Init(), Com_InitHunkMemory(), Com_InitJournaling(), Com_InitZoneMemory(), Com_StartupVariable(), Com_WriteConfiguration(), Con_Init(), Cvar_Init(), Cvar_Register(), Cvar_Set2(), FS_Startup(), GLimp_SetGamma(), IN_Init(), MainWndProc(), NET_GetCvars(), NET_Init(), NET_OpenIP(), NET_OpenIPX(), Netchan_Init(), S_Init(), SCR_Init(), SND_setup(), SNDDMA_Init(), SV_BotInitCvars(), SV_BoundMaxClients(), SV_GetChallenge(), SV_Init(), SV_InitGameProgs(), SV_Map_f(), Sys_ConsoleInputInit(), Sys_DisplayToUse(), Sys_Init(), Sys_InitInput(), and VM_Init().

00187                                                                            {
00188     cvar_t  *var;
00189     long    hash;
00190 
00191   if ( !var_name || ! var_value ) {
00192         Com_Error( ERR_FATAL, "Cvar_Get: NULL parameter" );
00193   }
00194 
00195     if ( !Cvar_ValidateString( var_name ) ) {
00196         Com_Printf("invalid cvar name string: %s\n", var_name );
00197         var_name = "BADNAME";
00198     }
00199 
00200 #if 0       // FIXME: values with backslash happen
00201     if ( !Cvar_ValidateString( var_value ) ) {
00202         Com_Printf("invalid cvar value string: %s\n", var_value );
00203         var_value = "BADVALUE";
00204     }
00205 #endif
00206 
00207     var = Cvar_FindVar (var_name);
00208     if ( var ) {
00209         // if the C code is now specifying a variable that the user already
00210         // set a value for, take the new value as the reset value
00211         if ( ( var->flags & CVAR_USER_CREATED ) && !( flags & CVAR_USER_CREATED )
00212             && var_value[0] ) {
00213             var->flags &= ~CVAR_USER_CREATED;
00214             Z_Free( var->resetString );
00215             var->resetString = CopyString( var_value );
00216 
00217             // ZOID--needs to be set so that cvars the game sets as 
00218             // SERVERINFO get sent to clients
00219             cvar_modifiedFlags |= flags;
00220         }
00221 
00222         var->flags |= flags;
00223         // only allow one non-empty reset string without a warning
00224         if ( !var->resetString[0] ) {
00225             // we don't have a reset string yet
00226             Z_Free( var->resetString );
00227             var->resetString = CopyString( var_value );
00228         } else if ( var_value[0] && strcmp( var->resetString, var_value ) ) {
00229             Com_DPrintf( "Warning: cvar \"%s\" given initial values: \"%s\" and \"%s\"\n",
00230                 var_name, var->resetString, var_value );
00231         }
00232         // if we have a latched string, take that value now
00233         if ( var->latchedString ) {
00234             char *s;
00235 
00236             s = var->latchedString;
00237             var->latchedString = NULL;  // otherwise cvar_set2 would free it
00238             Cvar_Set2( var_name, s, qtrue );
00239             Z_Free( s );
00240         }
00241 
00242 // use a CVAR_SET for rom sets, get won't override
00243 #if 0
00244         // CVAR_ROM always overrides
00245         if ( flags & CVAR_ROM ) {
00246             Cvar_Set2( var_name, var_value, qtrue );
00247         }
00248 #endif
00249         return var;
00250     }
00251 
00252     //
00253     // allocate a new cvar
00254     //
00255     if ( cvar_numIndexes >= MAX_CVARS ) {
00256         Com_Error( ERR_FATAL, "MAX_CVARS" );
00257     }
00258     var = &cvar_indexes[cvar_numIndexes];
00259     cvar_numIndexes++;
00260     var->name = CopyString (var_name);
00261     var->string = CopyString (var_value);
00262     var->modified = qtrue;
00263     var->modificationCount = 1;
00264     var->value = atof (var->string);
00265     var->integer = atoi(var->string);
00266     var->resetString = CopyString( var_value );
00267 
00268     // link the variable in
00269     var->next = cvar_vars;
00270     cvar_vars = var;
00271 
00272     var->flags = flags;
00273 
00274     hash = generateHashValue(var_name);
00275     var->hashNext = hashTable[hash];
00276     hashTable[hash] = var;
00277 
00278     return var;
00279 }

Here is the call graph for this function:

char* Cvar_InfoString int  bit  ) 
 

Definition at line 780 of file cvar.c.

References cvar_t, cvar_s::flags, Info_SetValueForKey(), cvar_s::name, cvar_s::next, and cvar_s::string.

Referenced by CL_CheckForResend(), CL_CheckUserinfo(), CL_Clientinfo_f(), Cvar_InfoStringBuffer(), SV_Frame(), SV_GetServerinfo(), SV_Serverinfo_f(), SV_SpawnServer(), SV_Systeminfo_f(), and SVC_Status().

00780                                     {
00781     static char info[MAX_INFO_STRING];
00782     cvar_t  *var;
00783 
00784     info[0] = 0;
00785 
00786     for (var = cvar_vars ; var ; var = var->next) {
00787         if (var->flags & bit) {
00788             Info_SetValueForKey (info, var->name, var->string);
00789         }
00790     }
00791     return info;
00792 }

Here is the call graph for this function:

char* Cvar_InfoString_Big int  bit  ) 
 

Definition at line 801 of file cvar.c.

References cvar_t, cvar_s::flags, Info_SetValueForKey_Big(), cvar_s::name, cvar_s::next, and cvar_s::string.

Referenced by SV_Frame(), and SV_SpawnServer().

00801                                         {
00802     static char info[BIG_INFO_STRING];
00803     cvar_t  *var;
00804 
00805     info[0] = 0;
00806 
00807     for (var = cvar_vars ; var ; var = var->next) {
00808         if (var->flags & bit) {
00809             Info_SetValueForKey_Big (info, var->name, var->string);
00810         }
00811     }
00812     return info;
00813 }

Here is the call graph for this function:

void Cvar_InfoStringBuffer int  bit,
char *  buff,
int  buffsize
 

Definition at line 822 of file cvar.c.

References Cvar_InfoString(), and Q_strncpyz().

Referenced by CL_UISystemCalls().

00822                                                                 {
00823     Q_strncpyz(buff,Cvar_InfoString(bit),buffsize);
00824 }

Here is the call graph for this function:

void Cvar_Init void   ) 
 

Definition at line 895 of file cvar.c.

References Cmd_AddCommand(), cvar_cheats, Cvar_Get(), Cvar_List_f(), Cvar_Reset_f(), Cvar_Restart_f(), CVAR_ROM, Cvar_Set_f(), Cvar_SetA_f(), Cvar_SetS_f(), Cvar_SetU_f(), CVAR_SYSTEMINFO, and Cvar_Toggle_f().

Referenced by Com_Init().

00895                       {
00896     cvar_cheats = Cvar_Get("sv_cheats", "1", CVAR_ROM | CVAR_SYSTEMINFO );
00897 
00898     Cmd_AddCommand ("toggle", Cvar_Toggle_f);
00899     Cmd_AddCommand ("set", Cvar_Set_f);
00900     Cmd_AddCommand ("sets", Cvar_SetS_f);
00901     Cmd_AddCommand ("setu", Cvar_SetU_f);
00902     Cmd_AddCommand ("seta", Cvar_SetA_f);
00903     Cmd_AddCommand ("reset", Cvar_Reset_f);
00904     Cmd_AddCommand ("cvarlist", Cvar_List_f);
00905     Cmd_AddCommand ("cvar_restart", Cvar_Restart_f);
00906 }

Here is the call graph for this function:

void Cvar_List_f void   ) 
 

Definition at line 662 of file cvar.c.

References Cmd_Argc(), Cmd_Argv(), Com_Filter(), Com_Printf(), cvar_numIndexes, cvar_t, cvar_s::flags, i, match(), cvar_s::name, cvar_s::next, qfalse, and cvar_s::string.

Referenced by Cvar_Init().

00662                          {
00663     cvar_t  *var;
00664     int     i;
00665     char    *match;
00666 
00667     if ( Cmd_Argc() > 1 ) {
00668         match = Cmd_Argv( 1 );
00669     } else {
00670         match = NULL;
00671     }
00672 
00673     i = 0;
00674     for (var = cvar_vars ; var ; var = var->next, i++)
00675     {
00676         if (match && !Com_Filter(match, var->name, qfalse)) continue;
00677 
00678         if (var->flags & CVAR_SERVERINFO) {
00679             Com_Printf("S");
00680         } else {
00681             Com_Printf(" ");
00682         }
00683         if (var->flags & CVAR_USERINFO) {
00684             Com_Printf("U");
00685         } else {
00686             Com_Printf(" ");
00687         }
00688         if (var->flags & CVAR_ROM) {
00689             Com_Printf("R");
00690         } else {
00691             Com_Printf(" ");
00692         }
00693         if (var->flags & CVAR_INIT) {
00694             Com_Printf("I");
00695         } else {
00696             Com_Printf(" ");
00697         }
00698         if (var->flags & CVAR_ARCHIVE) {
00699             Com_Printf("A");
00700         } else {
00701             Com_Printf(" ");
00702         }
00703         if (var->flags & CVAR_LATCH) {
00704             Com_Printf("L");
00705         } else {
00706             Com_Printf(" ");
00707         }
00708         if (var->flags & CVAR_CHEAT) {
00709             Com_Printf("C");
00710         } else {
00711             Com_Printf(" ");
00712         }
00713 
00714         Com_Printf (" %s \"%s\"\n", var->name, var->string);
00715     }
00716 
00717     Com_Printf ("\n%i total cvars\n", i);
00718     Com_Printf ("%i cvar indexes\n", cvar_numIndexes);
00719 }

Here is the call graph for this function:

void Cvar_Register vmCvar_t vmCvar,
const char *  varName,
const char *  defaultValue,
int  flags
 

Definition at line 833 of file cvar.c.

References Cvar_Get(), cvar_t, Cvar_Update(), vmCvar_t::handle, and vmCvar_t::modificationCount.

Referenced by CL_CgameSystemCalls(), CL_UISystemCalls(), and SV_GameSystemCalls().

00833                                                                                                     {
00834     cvar_t  *cv;
00835 
00836     cv = Cvar_Get( varName, defaultValue, flags );
00837     if ( !vmCvar ) {
00838         return;
00839     }
00840     vmCvar->handle = cv - cvar_indexes;
00841     vmCvar->modificationCount = -1;
00842     Cvar_Update( vmCvar );
00843 }

Here is the call graph for this function:

void Cvar_Reset const char *  var_name  ) 
 

Definition at line 432 of file cvar.c.

References Cvar_Set2(), NULL, and qfalse.

Referenced by CL_UISystemCalls(), and Cvar_Reset_f().

00432                                         {
00433     Cvar_Set2( var_name, NULL, qfalse );
00434 }

Here is the call graph for this function:

void Cvar_Reset_f void   ) 
 

Definition at line 621 of file cvar.c.

References Cmd_Argc(), Cmd_Argv(), Com_Printf(), and Cvar_Reset().

Referenced by Cvar_Init().

00621                           {
00622     if ( Cmd_Argc() != 2 ) {
00623         Com_Printf ("usage: reset <variable>\n");
00624         return;
00625     }
00626     Cvar_Reset( Cmd_Argv( 1 ) );
00627 }

Here is the call graph for this function:

void Cvar_Restart_f void   ) 
 

Definition at line 728 of file cvar.c.

References Com_Memset(), CVAR_INIT, CVAR_ROM, Cvar_Set(), cvar_t, cvar_s::flags, cvar_s::latchedString, cvar_s::name, cvar_s::next, cvar_s::resetString, cvar_s::string, and Z_Free().

Referenced by Cvar_Init().

00728                             {
00729     cvar_t  *var;
00730     cvar_t  **prev;
00731 
00732     prev = &cvar_vars;
00733     while ( 1 ) {
00734         var = *prev;
00735         if ( !var ) {
00736             break;
00737         }
00738 
00739         // don't mess with rom values, or some inter-module
00740         // communication will get broken (com_cl_running, etc)
00741         if ( var->flags & ( CVAR_ROM | CVAR_INIT | CVAR_NORESTART ) ) {
00742             prev = &var->next;
00743             continue;
00744         }
00745 
00746         // throw out any variables the user created
00747         if ( var->flags & CVAR_USER_CREATED ) {
00748             *prev = var->next;
00749             if ( var->name ) {
00750                 Z_Free( var->name );
00751             }
00752             if ( var->string ) {
00753                 Z_Free( var->string );
00754             }
00755             if ( var->latchedString ) {
00756                 Z_Free( var->latchedString );
00757             }
00758             if ( var->resetString ) {
00759                 Z_Free( var->resetString );
00760             }
00761             // clear the var completely, since we
00762             // can't remove the index from the list
00763             Com_Memset( var, 0, sizeof( var ) );
00764             continue;
00765         }
00766 
00767         Cvar_Set( var->name, var->resetString );
00768 
00769         prev = &var->next;
00770     }
00771 }

Here is the call graph for this function:

void Cvar_Set const char *  var_name,
const char *  value
 

Definition at line 397 of file cvar.c.

References Cvar_Set2(), qtrue, and value.

Referenced by CL_BeginDownload(), CL_CgameSystemCalls(), CL_Connect_f(), CL_Disconnect(), CL_Disconnect_f(), CL_DisconnectPacket(), CL_DownloadsComplete(), CL_FirstSnapshot(), CL_Init(), CL_InitRef(), CL_KeyEvent(), CL_MapLoading(), CL_MotdPacket(), CL_NextDemo(), CL_ParseDownload(), CL_ParseGamestate(), CL_PlayDemo_f(), CL_ReadyToSendPacket(), CL_Reconnect_f(), CL_SetModel_f(), CL_Shutdown(), CL_SystemInfoChanged(), CL_UISystemCalls(), CL_Vid_Restart_f(), CL_WritePacket(), Com_Error(), Com_Init(), Com_InitJournaling(), Com_StartupVariable(), ConWndProc(), Cvar_Restart_f(), Cvar_SetCheatState(), Cvar_SetValue(), FS_Restart(), FS_SetRestrictions(), Hunk_Trash(), IN_ActivateDIMouse(), IN_StartupMouse(), RoQShutdown(), SV_BoundMaxClients(), SV_CheckPaused(), SV_Frame(), SV_GameSystemCalls(), SV_Map_f(), SV_MapRestart_f(), SV_MasterHeartbeat(), SV_RankBegin(), SV_RankCloseContext(), SV_RankEnd(), SV_RankError(), SV_RankNewGameCBF(), SV_RateMsec(), SV_Shutdown(), SV_SpawnServer(), SV_Startup(), SV_WriteDownloadToClient(), Sys_ConsoleInputInit(), Sys_Init(), and Sys_InitInput().

00397                                                         {
00398     Cvar_Set2 (var_name, value, qtrue);
00399 }

Here is the call graph for this function:

cvar_t * Cvar_Set2 const char *  var_name,
const char *  value,
qboolean  force
 

Definition at line 286 of file cvar.c.

References atof(), atoi, Com_DPrintf(), Com_Printf(), CopyString(), cvar_cheats, Cvar_FindVar(), Cvar_Get(), cvar_modifiedFlags, cvar_t, CVAR_USER_CREATED, Cvar_ValidateString(), cvar_s::flags, cvar_s::integer, cvar_s::latchedString, cvar_s::modificationCount, cvar_s::modified, cvar_s::resetString, strcmp(), cvar_s::string, cvar_s::value, value, and Z_Free().

Referenced by Cvar_Command(), Cvar_Get(), Cvar_Reset(), Cvar_Set(), Cvar_Set_f(), Cvar_SetLatched(), and Cvar_Toggle_f().

00286                                                                              {
00287     cvar_t  *var;
00288 
00289     Com_DPrintf( "Cvar_Set2: %s %s\n", var_name, value );
00290 
00291     if ( !Cvar_ValidateString( var_name ) ) {
00292         Com_Printf("invalid cvar name string: %s\n", var_name );
00293         var_name = "BADNAME";
00294     }
00295 
00296 #if 0   // FIXME
00297     if ( value && !Cvar_ValidateString( value ) ) {
00298         Com_Printf("invalid cvar value string: %s\n", value );
00299         var_value = "BADVALUE";
00300     }
00301 #endif
00302 
00303     var = Cvar_FindVar (var_name);
00304     if (!var) {
00305         if ( !value ) {
00306             return NULL;
00307         }
00308         // create it
00309         if ( !force ) {
00310             return Cvar_Get( var_name, value, CVAR_USER_CREATED );
00311         } else {
00312             return Cvar_Get (var_name, value, 0);
00313         }
00314     }
00315 
00316     if (!value ) {
00317         value = var->resetString;
00318     }
00319 
00320     if (!strcmp(value,var->string)) {
00321         return var;
00322     }
00323     // note what types of cvars have been modified (userinfo, archive, serverinfo, systeminfo)
00324     cvar_modifiedFlags |= var->flags;
00325 
00326     if (!force)
00327     {
00328         if (var->flags & CVAR_ROM)
00329         {
00330             Com_Printf ("%s is read only.\n", var_name);
00331             return var;
00332         }
00333 
00334         if (var->flags & CVAR_INIT)
00335         {
00336             Com_Printf ("%s is write protected.\n", var_name);
00337             return var;
00338         }
00339 
00340         if (var->flags & CVAR_LATCH)
00341         {
00342             if (var->latchedString)
00343             {
00344                 if (strcmp(value, var->latchedString) == 0)
00345                     return var;
00346                 Z_Free (var->latchedString);
00347             }
00348             else
00349             {
00350                 if (strcmp(value, var->string) == 0)
00351                     return var;
00352             }
00353 
00354             Com_Printf ("%s will be changed upon restarting.\n", var_name);
00355             var->latchedString = CopyString(value);
00356             var->modified = qtrue;
00357             var->modificationCount++;
00358             return var;
00359         }
00360 
00361         if ( (var->flags & CVAR_CHEAT) && !cvar_cheats->integer )
00362         {
00363             Com_Printf ("%s is cheat protected.\n", var_name);
00364             return var;
00365         }
00366 
00367     }
00368     else
00369     {
00370         if (var->latchedString)
00371         {
00372             Z_Free (var->latchedString);
00373             var->latchedString = NULL;
00374         }
00375     }
00376 
00377     if (!strcmp(value, var->string))
00378         return var;     // not changed
00379 
00380     var->modified = qtrue;
00381     var->modificationCount++;
00382     
00383     Z_Free (var->string);   // free the old value string
00384     
00385     var->string = CopyString(value);
00386     var->value = atof (var->string);
00387     var->integer = atoi (var->string);
00388 
00389     return var;
00390 }

Here is the call graph for this function:

void Cvar_Set_f void   ) 
 

Definition at line 524 of file cvar.c.

References c, Cmd_Argc(), Cmd_Argv(), Com_Printf(), Cvar_Set2(), i, l, MAX_STRING_TOKENS, qfalse, strcat(), and strlen().

Referenced by Cvar_Init(), Cvar_SetA_f(), Cvar_SetS_f(), and Cvar_SetU_f().

00524                         {
00525     int     i, c, l, len;
00526     char    combined[MAX_STRING_TOKENS];
00527 
00528     c = Cmd_Argc();
00529     if ( c < 3 ) {
00530         Com_Printf ("usage: set <variable> <value>\n");
00531         return;
00532     }
00533 
00534     combined[0] = 0;
00535     l = 0;
00536     for ( i = 2 ; i < c ; i++ ) {
00537         len = strlen ( Cmd_Argv( i ) + 1 );
00538         if ( l + len >= MAX_STRING_TOKENS - 2 ) {
00539             break;
00540         }
00541         strcat( combined, Cmd_Argv( i ) );
00542         if ( i != c-1 ) {
00543             strcat( combined, " " );
00544         }
00545         l += len;
00546     }
00547     Cvar_Set2 (Cmd_Argv(1), combined, qfalse);
00548 }

Here is the call graph for this function:

void Cvar_SetA_f void   ) 
 

Definition at line 601 of file cvar.c.

References Cmd_Argc(), Cmd_Argv(), Com_Printf(), Cvar_FindVar(), Cvar_Set_f(), cvar_t, cvar_s::flags, and v.

Referenced by Cvar_Init().

00601                          {
00602     cvar_t  *v;
00603 
00604     if ( Cmd_Argc() != 3 ) {
00605         Com_Printf ("usage: seta <variable> <value>\n");
00606         return;
00607     }
00608     Cvar_Set_f();
00609     v = Cvar_FindVar( Cmd_Argv( 1 ) );
00610     if ( !v ) {
00611         return;
00612     }
00613     v->flags |= CVAR_ARCHIVE;
00614 }

Here is the call graph for this function:

void Cvar_SetCheatState void   ) 
 

Definition at line 444 of file cvar.c.

References Cvar_Set(), cvar_t, cvar_s::flags, cvar_s::latchedString, cvar_s::name, cvar_s::next, cvar_s::resetString, strcmp(), cvar_s::string, and Z_Free().

Referenced by CL_SystemInfoChanged().

00444                                 {
00445     cvar_t  *var;
00446 
00447     // set all default vars to the safe value
00448     for ( var = cvar_vars ; var ; var = var->next ) {
00449         if ( var->flags & CVAR_CHEAT ) {
00450       // the CVAR_LATCHED|CVAR_CHEAT vars might escape the reset here 
00451       // because of a different var->latchedString
00452       if (var->latchedString)
00453       {
00454         Z_Free(var->latchedString);
00455         var->latchedString = NULL;
00456       }
00457             if (strcmp(var->resetString,var->string)) {
00458         Cvar_Set( var->name, var->resetString );
00459             }
00460         }
00461     }
00462 }

Here is the call graph for this function:

void Cvar_SetLatched const char *  var_name,
const char *  value
 

Definition at line 406 of file cvar.c.

References Cvar_Set2(), qfalse, and value.

Referenced by SV_Map_f().

00406                                                                {
00407     Cvar_Set2 (var_name, value, qfalse);
00408 }

Here is the call graph for this function:

void Cvar_SetS_f void   ) 
 

Definition at line 579 of file cvar.c.

References Cmd_Argc(), Cmd_Argv(), Com_Printf(), Cvar_FindVar(), Cvar_Set_f(), cvar_t, cvar_s::flags, and v.

Referenced by Cvar_Init().

00579                          {
00580     cvar_t  *v;
00581 
00582     if ( Cmd_Argc() != 3 ) {
00583         Com_Printf ("usage: sets <variable> <value>\n");
00584         return;
00585     }
00586     Cvar_Set_f();
00587     v = Cvar_FindVar( Cmd_Argv( 1 ) );
00588     if ( !v ) {
00589         return;
00590     }
00591     v->flags |= CVAR_SERVERINFO;
00592 }

Here is the call graph for this function:

void Cvar_SetU_f void   ) 
 

Definition at line 557 of file cvar.c.

References Cmd_Argc(), Cmd_Argv(), Com_Printf(), Cvar_FindVar(), Cvar_Set_f(), cvar_t, cvar_s::flags, and v.

Referenced by Cvar_Init().

00557                          {
00558     cvar_t  *v;
00559 
00560     if ( Cmd_Argc() != 3 ) {
00561         Com_Printf ("usage: setu <variable> <value>\n");
00562         return;
00563     }
00564     Cvar_Set_f();
00565     v = Cvar_FindVar( Cmd_Argv( 1 ) );
00566     if ( !v ) {
00567         return;
00568     }
00569     v->flags |= CVAR_USERINFO;
00570 }

Here is the call graph for this function:

void Cvar_SetValue const char *  var_name,
float  value
 

Definition at line 415 of file cvar.c.

References Com_sprintf(), Cvar_Set(), and value.

Referenced by CL_BeginDownload(), CL_ParseDownload(), CL_UISystemCalls(), MainWndProc(), NET_OpenIP(), SV_Map_f(), and Sys_Init().

00415                                                        {
00416     char    val[32];
00417 
00418     if ( value == (int)value ) {
00419         Com_sprintf (val, sizeof(val), "%i",(int)value);
00420     } else {
00421         Com_sprintf (val, sizeof(val), "%f",value);
00422     }
00423     Cvar_Set (var_name, val);
00424 }

Here is the call graph for this function:

void Cvar_Toggle_f