#include "../game/q_shared.h"
#include "qcommon.h"
Include dependency graph for cvar.c:

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_t * | Cvar_FindVar (const char *var_name) |
| cvar_t * | Cvar_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_t * | Cvar_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_t * | cvar_cheats |
| cvar_t | cvar_indexes [MAX_CVARS] |
| int | cvar_modifiedFlags |
| int | cvar_numIndexes |
| cvar_t * | cvar_vars |
| cvar_t * | hashTable [FILE_HASH_SIZE] |
|
|
Definition at line 35 of file cvar.c. Referenced by Com_HashString(), generateHashValue(), GeneratePermanentShader(), R_FindShader(), R_FindShaderByName(), R_RemapShader(), and RE_RegisterShaderFromImage(). |
|
|
|
|
|
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:

|
|
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 }
|
|
|
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:

|
||||||||||||||||
|
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:

|
|
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:

|
|
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:

|
||||||||||||||||
|
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:

|
|
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:

|
|
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:

|
||||||||||||||||||||
|
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:

|
|
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:

|
|
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:

|
|
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:

|
||||||||||||
Here is the call graph for this function:

|
||||||||||||||||
|
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:

|
|
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:

|
|
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:

|
|
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:

|
||||||||||||
|
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:

|
|
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:

|
|
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:

|
||||||||||||
|
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:

|