/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// cvar.c -- dynamic variable tracking

#include "com_local.h"
#include "cl_public.h"
#include "files.h"

cvar_t    *cvar_vars;

int        cvar_modified;

#define Cvar_Malloc( size )        Z_TagMalloc( size, TAG_CVAR )

#define CVARHASH_SIZE    256

static cvar_t *cvarHash[CVARHASH_SIZE];

static cvar_t    *cvar_silent;

/*
============
Cvar_FindVar
============
*/
cvar_t *Cvar_FindVar( const char *var_name ) {
    cvar_t    *var;
    unsigned hash;

    hash = Com_HashString( var_name, CVARHASH_SIZE );
    
    for( var = cvarHash[hash]; var; var = var->hashNext ) {
        if( !strcmp( var_name, var->name ) ) {
            return var;
        }
    }

    return NULL;
}

xgenerator_t Cvar_FindGenerator( const char *var_name ) {
    cvar_t *var = Cvar_FindVar( var_name );

    return var ? var->generator : NULL;
}

/*
============
Cvar_Exists
============
*/
qboolean Cvar_Exists( const char *name ) {
    if( Cvar_FindVar( name ) ) {
        return qtrue;
    }
    return qfalse;
}

/*
============
Cvar_VariableValue
============
*/
float Cvar_VariableValue( const char *var_name ) {
    cvar_t    *var;
    
    var = Cvar_FindVar( var_name );
    if( !var )
        return 0;

    return var->value;
}

/*
============
Cvar_VariableInteger
============
*/
int Cvar_VariableInteger( const char *var_name ) {
    cvar_t    *var;
    
    var = Cvar_FindVar( var_name );
    if( !var )
        return 0;

    return var->integer;
}


/*
============
Cvar_VariableString
============
*/
char *Cvar_VariableString( const char *var_name ) {
    cvar_t *var;
    
    var = Cvar_FindVar( var_name );
    if( !var )
        return "";

    return var->string;
}

void Cvar_Variable_g( genctx_t *ctx ) {
    cvar_t *c;
    
    for( c = cvar_vars; c; c = c->next ) {
        if( !Prompt_AddMatch( ctx, c->name ) ) {
            break;
        }
    }
}

void Cvar_Default_g( genctx_t *ctx ) {
    cvar_t *c = ctx->data;

    if( c ) {
        if( strcmp( c->string, c->default_string ) ) {
            Prompt_AddMatch( ctx, c->string );
        }
        Prompt_AddMatch( ctx, c->default_string );
    }
}

static void Cvar_ParseString( cvar_t *var ) {
    char *s = var->string;
    
    if( s[0] == '0' && s[1] == 'x' ) {
        var->integer = COM_ParseHex( s + 2 );
        var->value = ( float )var->integer;
    } else {
        var->integer = atoi( var->string );
        var->value = atof( var->string );
    }
}

static void Cvar_ChangeString( cvar_t *var, const char *value, cvarSetSource_t source ) {
    // free the old value string
    Z_Free( var->string );

    var->string = Cvar_CopyString( value );
    Cvar_ParseString( var );

    if( var->flags & CVAR_INFOMASK ) {
#if USE_CLIENT
        if( var->flags & CVAR_USERINFO ) {
            CL_UpdateUserinfo( var, source );
        }
#endif
    }

    var->modified = qtrue;
    if( source != CVAR_SET_DIRECT ) {
        cvar_modified |= var->flags & CVAR_MODIFYMASK;
        var->flags |= CVAR_MODIFIED;
        if( var->changed ) {
            var->changed( var );
        }
    }
}

/*
============
Cvar_EngineGet

Cvar_Get has been called from subsystem initialization routine.
============
*/
static void Cvar_EngineGet( cvar_t *var, const char *var_value, int flags ) {
    if( var->flags & (CVAR_CUSTOM|CVAR_VOLATILE) ) {
        // update default string if cvar was set from command line
        Z_Free( var->default_string );
        var->default_string = Cvar_CopyString( var_value );

        // optionally reset cvar back to default value
        if( ( ( flags & CVAR_ROM ) ||
              ( ( flags & CVAR_NOSET ) && com_initialized ) ||
              ( ( flags & CVAR_CHEAT ) && !CL_CheatsOK() ) ||
              ( var->flags & CVAR_VOLATILE ) ) &&
            strcmp( var_value, var->string ) )
        {
            Cvar_ChangeString( var, var_value, CVAR_SET_DIRECT );
        }
    }

    // some flags are not saved
    var->flags &= ~(CVAR_GAME|CVAR_CUSTOM|CVAR_VOLATILE);
    var->flags |= flags;
}


/*
============
Cvar_Get

If the non-volatile variable already exists, the value will not be set.
The flags will be or'ed in if the variable exists.
============
*/
cvar_t *Cvar_Get( const char *var_name, const char *var_value, int flags ) {
    cvar_t    *var, *c, **p;
    unsigned hash;
    size_t length;

    if( !var_name ) {
        Com_Error( ERR_FATAL, "Cvar_Get: NULL var_name" );
    }
    if( !var_value ) {
        return Cvar_FindVar( var_name );
    }

    if( flags & CVAR_INFOMASK ) {
        if( Info_SubValidate( var_name ) == -1 ) {
            Com_WPrintf( "Invalid info cvar name '%s'.\n", var_name );
            return NULL;
        }
        if( Info_SubValidate( var_value ) == -1 ) {
            Com_WPrintf( "Invalid info cvar value '%s' for '%s'.\n", var_value, var_name );
            return NULL;
        }
    }

    var = Cvar_FindVar( var_name );
    if( var ) {
        if( !( flags & (CVAR_VOLATILE|CVAR_CUSTOM) ) ) {
            Cvar_EngineGet( var, var_value, flags );
        }
        return var;
    }


    // create new variable
    length = strlen( var_name ) + 1;
    var = Cvar_Malloc( sizeof( *var ) + length );
    var->name = ( char * )( var + 1 );
    memcpy( var->name, var_name, length );
    var->string = Cvar_CopyString( var_value );
    var->latched_string = NULL;
    var->default_string = Cvar_CopyString( var_value );
    Cvar_ParseString( var );
    var->flags = flags;
    var->changed = NULL;
    var->generator = Cvar_Default_g;
    var->modified = qtrue;

    // sort the variable in
    for( c = cvar_vars, p = &cvar_vars; c; p = &c->next, c = c->next ) {
        if( strcmp( var->name, c->name ) < 0 ) {
            break;
        }
    }
    var->next = c;
    *p = var;

    // link the variable in
    hash = Com_HashString( var_name, CVARHASH_SIZE );
    var->hashNext = cvarHash[hash];
    cvarHash[hash] = var;

    return var;
}

/*
============
Cvar_Ref
============
*/
cvar_t *Cvar_Ref( const char *var_name ) {
    return Cvar_Get( var_name, "", CVAR_VOLATILE );
}

/*
============
Cvar_SetByVar
============
*/
void Cvar_SetByVar( cvar_t *var, const char *value, cvarSetSource_t source ) {
    if( !value ) {
        value = "";
    }
    if( !strcmp( value, var->string ) && !( var->flags & CVAR_LATCH ) ) {
        return;        // not changed
    }

    if( var->flags & CVAR_INFOMASK ) {
        if( Info_SubValidate( value ) == -1 ) {
            Com_WPrintf( "Invalid info cvar value '%s' for '%s'.\n", value, var->name );
            return;
        }
    }

    // some cvars may not be changed by user at all
    if( source != CVAR_SET_DIRECT ) {
        if( var->flags & CVAR_ROM ) {
            Com_Printf( "%s is read-only.\n", var->name );
            return;
        }

        if( var->flags & CVAR_CHEAT ) {
            if( !CL_CheatsOK() ) {
                Com_Printf( "%s is cheat protected.\n", var->name );
                return;
            }
        }
    }

    // some cvars may require special processing if set by user from console
    if( source == CVAR_SET_CONSOLE && com_initialized ) {
        if( var->flags & CVAR_NOSET ) {
            Com_Printf( "%s may be set from command line only.\n", var->name );
            return;
        }

        if( var->flags & CVAR_LATCH ) {
            if( !strcmp( var->string, value ) ) {
                // set back to current value
                if( var->latched_string ) {
                    Z_Free( var->latched_string );
                    var->latched_string = NULL;
                }
                return;
            }
            if( var->latched_string ) {
                if( !strcmp( var->latched_string, value ) ) {
                    return; // latched string not changed
                }
                Z_Free( var->latched_string );
                var->latched_string = NULL;
            }

            if( var->flags & CVAR_LATCH ) {
                if( sv_running->integer ) {
                    if( !cvar_silent->integer ) {
                        Com_Printf( "%s will be changed for next game.\n",
                            var->name );
                    }
                    var->latched_string = Cvar_CopyString( value );
                    return;
                }
                // server is down, it's ok to update this cvar now
            } else {
                //char *subsystem;

                var->latched_string = Cvar_CopyString( value );
                //cvar_latchedModified |= 1 << var->subsystem;
                if( cvar_silent->integer ) {
                    return;
                }

#if 0
                switch( var->subsystem ) {
                case CVAR_SYSTEM_GENERIC:
                    subsystem = "desired subsystem";
                    break;
                case CVAR_SYSTEM_VIDEO:
                    subsystem = "video subsystem";
                    break;
                case CVAR_SYSTEM_SOUND:
                    subsystem = "sound subsystem";
                    break;
                case CVAR_SYSTEM_INPUT:
                    subsystem = "input subsystem";
                    break;
                case CVAR_SYSTEM_NET:
                    subsystem = "network subsystem";
                    break;
                case CVAR_SYSTEM_FILES:
                    subsystem = "filesystem";
                    break;
                default:
                    Com_Error( ERR_FATAL, "Cvar_SetByVar: invalid subsystem %u",
                            var->subsystem );
                    subsystem = NULL;
                    break;
                }
                Com_Printf( "%s will be changed upon restarting the %s.\n",
                    var->name, subsystem );
#else
                Com_Printf( "%s will be changed upon restarting.\n", var->name );
#endif
                return;
            }
        }

    }

    // free latched string, if any
    if( var->latched_string ) {
        Z_Free( var->latched_string );
        var->latched_string = NULL;
    }

    Cvar_ChangeString( var, value, source );
}

/*
============
Cvar_SetEx
============
*/
cvar_t *Cvar_SetEx( const char *var_name, const char *value,
        cvarSetSource_t source )
{
    cvar_t    *var;

    var = Cvar_FindVar( var_name );
    if( !var ) {    
        // create it
        return Cvar_Get( var_name, value, CVAR_CUSTOM );
    }

    Cvar_SetByVar( var, value, source );

    return var;
}

/*
============
Cvar_FullSet
============
*/
cvar_t *Cvar_FullSet( const char *var_name, const char *value, int flags, cvarSetSource_t source ) {
    cvar_t *var;

    var = Cvar_FindVar( var_name );
    if( !var ) {    
        // create it
        return Cvar_Get( var_name, value, flags | CVAR_CUSTOM );
    }

    Cvar_SetByVar( var, value, source );

#if USE_CLIENT
    // force retransmit of userinfo variables
    // needed for compatibility with q2admin
    if( ( var->flags | flags ) & CVAR_USERINFO ) {
        CL_UpdateUserinfo( var, source );
    }
#endif

    var->flags &= ~CVAR_INFOMASK;
    var->flags |= flags;

    return var;
}

/*
============
Cvar_Set
============
*/
cvar_t *Cvar_Set( const char *var_name, const char *value ) {
    return Cvar_SetEx( var_name, value, CVAR_SET_DIRECT );
}

/*
============
Cvar_UserSet
============
*/
cvar_t *Cvar_UserSet( const char *var_name, const char *value ) {
    return Cvar_SetEx( var_name, value, CVAR_SET_CONSOLE );
}


/*
============
Cvar_SetValue
============
*/
void Cvar_SetValue( cvar_t *var, float value, cvarSetSource_t source ) {
    char    val[32];

    if( value == (int)value )
        Q_snprintf( val, sizeof( val ), "%i", (int)value );
    else
        Q_snprintf( val, sizeof( val ), "%f", value);

    Cvar_SetByVar( var, val, source );
}

/*
============
Cvar_SetInteger
============
*/
void Cvar_SetInteger( cvar_t *var, int value, cvarSetSource_t source ) {
    char    val[32];

    Q_snprintf( val, sizeof( val ), "%i", value );

    Cvar_SetByVar( var, val, source );
}

/*
============
Cvar_SetHex
============
*/
void Cvar_SetHex( cvar_t *var, int value, cvarSetSource_t source ) {
    char    val[32];

    Q_snprintf( val, sizeof( val ), "0x%X", value );

    Cvar_SetByVar( var, val, source );
}

/*
============
Cvar_ClampInteger
============
*/
int Cvar_ClampInteger( cvar_t *var, int min, int max ) {
    char    val[32];

    if( var->integer < min ) {
        Q_snprintf( val, sizeof( val ), "%i", min );
        Cvar_SetByVar( var, val, CVAR_SET_DIRECT );
        return min;
    }
    if( var->integer > max ) {
        Q_snprintf( val, sizeof( val ), "%i", max );
        Cvar_SetByVar( var, val, CVAR_SET_DIRECT );
        return max;
    }
    return var->integer;
}

/*
============
Cvar_ClampValue
============
*/
float Cvar_ClampValue( cvar_t *var, float min, float max ) {
    char    val[32];

    if( var->value < min ) {
        if( min == (int)min ) {
            Q_snprintf( val, sizeof( val ), "%i", (int)min );
        } else {
            Q_snprintf( val, sizeof( val ), "%f", min );
        }
        Cvar_SetByVar( var, val, CVAR_SET_DIRECT );
        return min;
    }
    if( var->value > max ) {
        if( max == (int)max ) {
            Q_snprintf( val, sizeof( val ), "%i", (int)max );
        } else {
            Q_snprintf( val, sizeof( val ), "%f", max );
        }
        Cvar_SetByVar( var, val, CVAR_SET_DIRECT );
        return max;
    }
    return var->value;
}

/*
==================
Cvar_FixCheats
==================
*/
void Cvar_FixCheats( void ) {
    cvar_t *var;

    if( CL_CheatsOK() ) {
        return;
    }

    // fix any cheating cvars
    for( var = cvar_vars; var; var = var->next ) {
        if( var->flags & CVAR_CHEAT ) {
            Cvar_SetByVar( var, var->default_string, CVAR_SET_DIRECT );
        }
    }
}

/*
============
Cvar_GetLatchedVars

Any variables with latched values will now be updated
Only used for game latched cvars now
============
*/
void Cvar_GetLatchedVars( void ) {
    cvar_t    *var;

    for( var = cvar_vars; var; var = var->next ) {
        if( var->flags & CVAR_GAME )
            var->flags &= ~CVAR_SERVERINFO;
        if( !(var->flags & CVAR_LATCH) )
            continue;
        if( !var->latched_string )
            continue;
        Z_Free( var->string );
        var->string = var->latched_string;
        var->latched_string = NULL;
        Cvar_ParseString( var );
        var->modified = qtrue;
        cvar_modified |= var->flags & CVAR_MODIFYMASK;
    }
}

/*
============
Cvar_Command

Handles variable inspection and changing from the console
============
*/
void Cvar_Command( cvar_t *v ) {
// perform a variable print or set
    if( Cmd_Argc() < 2 ) {
        Com_Printf( "\"%s\" is \"%s\"", v->name, v->string );
        if( strcmp( v->string, v->default_string ) ) {
            Com_Printf( "  default: \"%s\"", v->default_string );
        }
        if( v->latched_string && strcmp( v->latched_string, v->string ) ) {
            Com_Printf( "  latched: \"%s\"", v->latched_string );
        }
        Com_Printf( "\n" );
    } else {
        Cvar_SetByVar( v, Cmd_ArgsFrom( 1 ), CVAR_SET_CONSOLE );
    }
}

static void Cvar_Set_c( genctx_t *ctx, int argnum ) {
    char *s;
    cvar_t *var;
    xgenerator_t g;

    if( argnum == 1 ) {
        Cvar_Variable_g( ctx );
    } else if( argnum == 2 ) {
        s = Cmd_Argv( ctx->argnum - 1 );
        if( ( var = Cvar_FindVar( s ) ) != NULL ) {
            g = var->generator;
            if( g ) {
                ctx->data = var;
                g( ctx );
            }
        }
    }
}


/*
============
Cvar_Set_f

Allows setting and defining of arbitrary cvars from console
============
*/
void Cvar_Set_f( void ) {
    int        c, flags;
    char    *f;

    c = Cmd_Argc();
    if( c < 3 ) {
        Com_Printf( "Usage: set <variable> <value> [u / s]\n" );
        return;
    }

    if( c == 3 ) {
        Cvar_SetEx( Cmd_Argv( 1 ), Cmd_Argv( 2 ), CVAR_SET_CONSOLE );
        return;
    }

    if( c == 4 ) {
        f = Cmd_Argv( 3 );
        if( !strcmp( f, "u" ) ) {
            flags = CVAR_USERINFO;
        } else if( !strcmp( f, "s" ) ) {
            flags = CVAR_SERVERINFO;
        } else {
            goto set;
        }
        Cvar_FullSet( Cmd_Argv( 1 ), Cmd_Argv( 2 ), flags, CVAR_SET_CONSOLE );
        return;
    }

set:
    Cvar_SetEx( Cmd_Argv( 1 ), Cmd_ArgsFrom( 2 ), CVAR_SET_CONSOLE );
}

/*
============
Cvar_SetFlag_f

Allows setting and defining of arbitrary cvars from console
============
*/
static void Cvar_SetFlag_f( void ) {
    char    *s = Cmd_Argv( 0 );
    int        flags;

    if( Cmd_Argc() < 3 ) {
        Com_Printf( "Usage: %s <variable> <value>\n", s );
        return;
    }

    if( !Q_stricmp( s, "setu" ) ) {
        flags = CVAR_USERINFO;
    } else if( !Q_stricmp( s, "sets" ) ) {
        flags = CVAR_SERVERINFO;
    } else if( !Q_stricmp( s, "seta" ) ) {
        flags = CVAR_ARCHIVE;
    } else {
        return;
    }

    Cvar_FullSet( Cmd_Argv( 1 ), Cmd_ArgsFrom( 2 ), flags, CVAR_SET_CONSOLE );
}

#if USE_CLIENT

/*
============
Cvar_WriteVariables

Appends lines containing "set variable value" for all variables
with the archive flag set to true.
============
*/
void Cvar_WriteVariables( fileHandle_t f, int mask, qboolean modified ) {
    cvar_t    *var;
    char *string;

    for( var = cvar_vars; var; var = var->next ) {
        if( var->flags & CVAR_PRIVATE ) {
            continue;
        }
        if( var->flags & mask ) {
            if( var->latched_string ) {
                string = var->latched_string;
            } else {
                string = var->string;
            }
            if( !modified || strcmp( string, var->default_string ) ) {
                FS_FPrintf( f, "set %s \"%s\"\n", var->name, string );
            }
        }
    }    
}

#endif

/*
============
Cvar_List_f

============
*/

static const cmd_option_t o_cvarlist[] = {
    { "a", "archive", "list archived cvars" },
    { "c", "cheat", "list cheat protected cvars" },
    { "h", "help", "display this help message" },
    { "l", "latched", "list latched cvars" },
    { "m", "modified", "list modified cvars" },
    { "n", "noset", "list command line cvars" },
    { "r", "rom", "list read-only cvars" },
    { "s", "serverinfo", "list serverinfo cvars" },
    { "t", "custom", "list user-created cvars" },
    { "u", "userinfo", "list userinfo cvars" },
    { "v", "verbose", "display flags of each cvar" },
    { "w:string", "wildcard", "list cvars matching wildcard" },
    { NULL }
};

static void Cvar_List_c( genctx_t *ctx, int argnum ) {
    Cmd_Option_c( o_cvarlist, NULL, ctx, argnum );
}

static void Cvar_List_f( void ) {
    cvar_t    *var;
    int        i, total;
    qboolean verbose = qfalse, modified = qfalse, latched = qfalse;
    int mask = 0;
    char *wildcard = NULL;
    char buffer[6];
    int c;

    while( ( c = Cmd_ParseOptions( o_cvarlist ) ) != -1 ) {
        switch( c ) {
        case 'a':
            mask |= CVAR_ARCHIVE;
            break;
        case 'c':
            mask |= CVAR_CHEAT;
            break;
        case 'h':
            Cmd_PrintUsage( o_cvarlist, NULL );
            Com_Printf( "List registered console variables.\n" );
            Cmd_PrintHelp( o_cvarlist );
            Com_Printf(
                        "Flags legend:\n"
                        "C: cheat protected\n"
                        "A: archived in config file\n"
                        "U: included in userinfo\n"
                        "S: included in serverinfo\n"
                        "N: set from command line only\n"
                        "R: read-only variable\n"
                        "L: latched\n"
                        "?: created by user\n" );
            return;
        case 'l':
            latched = qtrue;
            break;
        case 'm':
            modified = qtrue;
            break;
        case 'n':
            mask |= CVAR_NOSET;
            break;
        case 'r':
            mask |= CVAR_ROM;
            break;
        case 's':
            mask |= CVAR_SERVERINFO;
            break;
        case 't':
            mask |= CVAR_CUSTOM;
            break;
        case 'u':
            mask |= CVAR_USERINFO;
            break;
        case 'v':
            verbose = qtrue;
            break;
        case 'w':
            wildcard = cmd_optarg;
            break;
        default:
            return;
        }
    }

    buffer[sizeof( buffer ) - 1] = 0;
    i = 0;
    for( var = cvar_vars, total = 0; var; var = var->next, total++ ) {
        if( latched && !var->latched_string ) {
            continue;
        }
        if( mask && !( var->flags & mask ) ) {
            continue;
        }
        if( wildcard && !Com_WildCmp( wildcard, var->name, qtrue ) ) {
            continue;
        }
        if( modified && ( !strcmp( var->latched_string ? var->latched_string :
            var->string, var->default_string ) || ( var->flags & CVAR_ROM ) ) )
        {
            continue;
        }

        if( verbose ) {
            memset( buffer, ' ', sizeof( buffer ) - 1 );

            if( var->flags & CVAR_CHEAT )
                buffer[0] = 'C';

            if( var->flags & CVAR_ARCHIVE )
                buffer[1] = 'A';

            if( var->flags & CVAR_USERINFO )
                buffer[2] = 'U';

            if( var->flags & CVAR_SERVERINFO )
                buffer[3] = 'S';

            if( var->flags & CVAR_ROM )
                buffer[4] = 'R';
            else if( var->flags & CVAR_NOSET )
                buffer[4] = 'N';
            else if( var->flags & CVAR_LATCH )
                buffer[4] = 'L';
            else if( var->flags & CVAR_CUSTOM )
                buffer[4] = '?';

            Com_Printf( "%s ", buffer );
        }

        Com_Printf( "%s \"%s\"\n", var->name, var->string );

        i++;
    }
    Com_Printf( "%i of %i cvars\n", i, total );
}

/*
============
Cvar_Toggle_f
============
*/
static void Cvar_Toggle_f( void ) {
    cvar_t *var;
    int i, argc = Cmd_Argc();

    if( argc < 2 ) {
        Com_Printf( "Usage: %s <variable> [values]\n", Cmd_Argv( 0 ) );
        return;
    }

    var = Cvar_FindVar( Cmd_Argv( 1 ) );
    if( !var ) {
        Com_Printf( "%s is not a variable\n", Cmd_Argv( 1 ) );
        return;
    }

    if( argc < 3 ) {
        if( !strcmp( var->string, "0" ) ) {
            Cvar_SetByVar( var, "1", CVAR_SET_CONSOLE );
        } else if( !strcmp( var->string, "1" ) ) {
            Cvar_SetByVar( var, "0", CVAR_SET_CONSOLE );
        } else {
            Com_Printf( "\"%s\" is \"%s\", can't toggle\n",
                var->name, var->string );
        }
        return;
    }

    for( i = 0; i < argc - 2; i++ ) {
        if( !Q_stricmp( var->string, Cmd_Argv( 2 + i ) ) ) {
            i = ( i + 1 ) % ( argc - 2 );
            Cvar_SetByVar( var, Cmd_Argv( 2 + i ), CVAR_SET_CONSOLE );
            return;
        }
    }

    Com_Printf( "\"%s\" is \"%s\", can't cycle\n", var->name, var->string );
}

static void Cvar_Toggle_c( genctx_t *ctx, int argnum ) {
    char *s;
    xgenerator_t g;

    if( argnum == 1 ) {
        Cvar_Variable_g( ctx );
    } else {
        s = Cmd_Argv( ctx->argnum - argnum + 1 );
        if( ( g = Cvar_FindGenerator( s ) ) != NULL ) {
            g( ctx );
        }
    }
}

/*
============
Cvar_Inc_f
============
*/
static void Cvar_Inc_f( void ) {
    cvar_t *var;
    float value;
    char val[32];

    if( Cmd_Argc() < 2 ) {
        Com_Printf( "Usage: %s <variable> [value]\n", Cmd_Argv( 0 ) );
        return;
    }

    var = Cvar_FindVar( Cmd_Argv( 1 ) );
    if( !var ) {
        Com_Printf( "%s is not a variable\n", Cmd_Argv( 1 ) );
        return;
    }

    if( !COM_IsFloat( var->string ) ) {
        Com_Printf( "\"%s\" is \"%s\", can't %s\n",
            var->name, var->string, Cmd_Argv( 0 ) );
        return;
    }

    value = 1;
    if( Cmd_Argc() > 2 ) {
        value = atof( Cmd_Argv( 2 ) );
    }
    if( !strcmp( Cmd_Argv( 0 ), "dec" ) ) {
        value = -value;
    }
    value += var->value;

    if( value == ( int )value )
        Q_snprintf( val, sizeof( val ), "%i", ( int )value );
    else
        Q_snprintf( val, sizeof( val ), "%f", value );

    Cvar_SetByVar( var, val, CVAR_SET_CONSOLE );
}

/*
============
Cvar_Reset_f
============
*/
static void Cvar_Reset_f( void ) {
    cvar_t *var;

    if( Cmd_Argc() < 2 ) {
        Com_Printf( "Usage: %s <variable>\n", Cmd_Argv( 0 ) );
        return;
    }

    var = Cvar_FindVar( Cmd_Argv( 1 ) );
    if( !var ) {
        Com_Printf( "%s is not a variable\n", Cmd_Argv( 1 ) );
        return;
    }

    Cvar_SetByVar( var, var->default_string, CVAR_SET_CONSOLE );
}

static void Cvar_Reset_c( genctx_t *ctx, int argnum ) {
    if( argnum == 1 ) {
        Cvar_Variable_g( ctx );
    }
}

size_t Cvar_BitInfo( char *info, int bit ) {
    char    newi[MAX_INFO_STRING];
    cvar_t  *var;
    size_t  len, total = 0;

    for( var = cvar_vars; var; var = var->next ) {
        if( !( var->flags & bit ) ) {
            continue;
        }
        if( !var->string[0] ) {
            continue;
        }
        len = Q_concat( newi, sizeof( newi ),
            "\\", var->name, "\\", var->string, NULL );
        if( len >= sizeof( newi ) ) {
            continue;
        }
        if( total + len >= MAX_INFO_STRING ) {
            break;
        }
        memcpy( info + total, newi, len );
        total += len;
    }
    info[total] = 0;
    return total;
}

static const cmdreg_t c_cvar[] = {
    { "set", Cvar_Set_f, Cvar_Set_c },
    { "setu", Cvar_SetFlag_f, Cvar_Set_c },
    { "sets", Cvar_SetFlag_f, Cvar_Set_c },
    { "seta", Cvar_SetFlag_f, Cvar_Set_c },
    { "cvarlist", Cvar_List_f, Cvar_List_c },
    { "toggle", Cvar_Toggle_f, Cvar_Toggle_c },
    { "inc", Cvar_Inc_f, Cvar_Reset_c },
    { "dec", Cvar_Inc_f, Cvar_Reset_c },
    { "reset", Cvar_Reset_f, Cvar_Reset_c },

    { NULL }
};

/*
============
Cvar_Init
============
*/
void Cvar_Init( void ) {
    cvar_silent = Cvar_Get( "cvar_silent", "0", 0 );
    
    Cmd_Register( c_cvar );
}