cvar.c

Go to the documentation of this file.

/*
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 "qcommon.h"
 
cvar_t  *cvar_vars;
 
/*
============
Cvar_InfoValidate
============
*/
static qboolean Cvar_InfoValidate (char *s)
{
    if (strstr (s, "\\"))
        return false;
    if (strstr (s, "\""))
        return false;
    if (strstr (s, ";"))
        return false;
    return true;
}
 
/*
============
Cvar_FindVar
============
*/
static cvar_t *Cvar_FindVar (char *var_name)
{
    cvar_t  *var;
    
    for (var=cvar_vars ; var ; var=var->next)
        if (!strcmp (var_name, var->name))
            return var;
 
    return NULL;
}
 
/*
============
Cvar_VariableValue
============
*/
float Cvar_VariableValue (char *var_name)
{
    cvar_t  *var;
    
    var = Cvar_FindVar (var_name);
    if (!var)
        return 0;
    return atof (var->string);
}
 
 
/*
============
Cvar_VariableString
============
*/
char *Cvar_VariableString (char *var_name)
{
    cvar_t *var;
    
    var = Cvar_FindVar (var_name);
    if (!var)
        return "";
    return var->string;
}
 
 
/*
============
Cvar_CompleteVariable
============
*/
char *Cvar_CompleteVariable (char *partial)
{
    cvar_t      *cvar;
    int         len;
    
    len = strlen(partial);
    
    if (!len)
        return NULL;
        
    // check exact match
    for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
        if (!strcmp (partial,cvar->name))
            return cvar->name;
 
    // check partial match
    for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
        if (!strncmp (partial,cvar->name, len))
            return cvar->name;
 
    return NULL;
}
 
 
/*
============
Cvar_Get
 
If the variable already exists, the value will not be set
The flags will be or'ed in if the variable exists.
============
*/
cvar_t *Cvar_Get (char *var_name, char *var_value, int flags)
{
    cvar_t  *var;
    
    if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
    {
        if (!Cvar_InfoValidate (var_name))
        {
            Com_Printf("invalid info cvar name\n");
            return NULL;
        }
    }
 
    var = Cvar_FindVar (var_name);
    if (var)
    {
        var->flags |= flags;
        return var;
    }
 
    if (!var_value)
        return NULL;
 
    if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
    {
        if (!Cvar_InfoValidate (var_value))
        {
            Com_Printf("invalid info cvar value\n");
            return NULL;
        }
    }
 
    var = Z_Malloc (sizeof(*var));
    var->name = CopyString (var_name);
    var->string = CopyString (var_value);
    var->modified = true;
    var->value = atof (var->string);
 
    // link the variable in
    var->next = cvar_vars;
    cvar_vars = var;
 
    var->flags = flags;
 
    return var;
}
 
/*
============
Cvar_Set2
============
*/
cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
{
    cvar_t  *var;
 
    var = Cvar_FindVar (var_name);
    if (!var)
    {   // create it
        return Cvar_Get (var_name, value, 0);
    }
 
    if (var->flags & (CVAR_USERINFO | CVAR_SERVERINFO))
    {
        if (!Cvar_InfoValidate (value))
        {
            Com_Printf("invalid info cvar value\n");
            return var;
        }
    }
 
    if (!force)
    {
        if (var->flags & CVAR_NOSET)
        {
            Com_Printf ("%s is write protected.\n", var_name);
            return var;
        }
 
        if (var->flags & CVAR_LATCH)
        {
            if (var->latched_string)
            {
                if (strcmp(value, var->latched_string) == 0)
                    return var;
                Z_Free (var->latched_string);
            }
            else
            {
                if (strcmp(value, var->string) == 0)
                    return var;
            }
 
            if (Com_ServerState())
            {
                Com_Printf ("%s will be changed for next game.\n", var_name);
                var->latched_string = CopyString(value);
            }
            else
            {
                var->string = CopyString(value);
                var->value = atof (var->string);
                if (!strcmp(var->name, "game"))
                {
                    FS_SetGamedir (var->string);
                    FS_ExecAutoexec ();
                }
            }
            return var;
        }
    }
    else
    {
        if (var->latched_string)
        {
            Z_Free (var->latched_string);
            var->latched_string = NULL;
        }
    }
 
    if (!strcmp(value, var->string))
        return var;     // not changed
 
    var->modified = true;
 
    if (var->flags & CVAR_USERINFO)
        userinfo_modified = true;   // transmit at next oportunity
    
    Z_Free (var->string);   // free the old value string
    
    var->string = CopyString(value);
    var->value = atof (var->string);
 
    return var;
}
 
/*
============
Cvar_ForceSet
============
*/
cvar_t *Cvar_ForceSet (char *var_name, char *value)
{
    return Cvar_Set2 (var_name, value, true);
}
 
/*
============
Cvar_Set
============
*/
cvar_t *Cvar_Set (char *var_name, char *value)
{
    return Cvar_Set2 (var_name, value, false);
}
 
/*
============
Cvar_FullSet
============
*/
cvar_t *Cvar_FullSet (char *var_name, char *value, int flags)
{
    cvar_t  *var;
    
    var = Cvar_FindVar (var_name);
    if (!var)
    {   // create it
        return Cvar_Get (var_name, value, flags);
    }
 
    var->modified = true;
 
    if (var->flags & CVAR_USERINFO)
        userinfo_modified = true;   // transmit at next oportunity
    
    Z_Free (var->string);   // free the old value string
    
    var->string = CopyString(value);
    var->value = atof (var->string);
    var->flags = flags;
 
    return var;
}
 
/*
============
Cvar_SetValue
============
*/
void Cvar_SetValue (char *var_name, float value)
{
    char    val[32];
 
    if (value == (int)value)
        Com_sprintf (val, sizeof(val), "%i",(int)value);
    else
        Com_sprintf (val, sizeof(val), "%f",value);
    Cvar_Set (var_name, val);
}
 
 
/*
============
Cvar_GetLatchedVars
 
Any variables with latched values will now be updated
============
*/
void Cvar_GetLatchedVars (void)
{
    cvar_t  *var;
 
    for (var = cvar_vars ; var ; var = var->next)
    {
        if (!var->latched_string)
            continue;
        Z_Free (var->string);
        var->string = var->latched_string;
        var->latched_string = NULL;
        var->value = atof(var->string);
        if (!strcmp(var->name, "game"))
        {
            FS_SetGamedir (var->string);
            FS_ExecAutoexec ();
        }
    }
}
 
/*
============
Cvar_Command
 
Handles variable inspection and changing from the console
============
*/
qboolean Cvar_Command (void)
{
    cvar_t          *v;
 
// check variables
    v = Cvar_FindVar (Cmd_Argv(0));
    if (!v)
        return false;
        
// perform a variable print or set
    if (Cmd_Argc() == 1)
    {
        Com_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
        return true;
    }
 
    Cvar_Set (v->name, Cmd_Argv(1));
    return true;
}
 
 
/*
============
Cvar_Set_f
 
Allows setting and defining of arbitrary cvars from console
============
*/
void Cvar_Set_f (void)
{
    int     c;
    int     flags;
 
    c = Cmd_Argc();
    if (c != 3 && c != 4)
    {
        Com_Printf ("usage: set <variable> <value> [u / s]\n");
        return;
    }
 
    if (c == 4)
    {
        if (!strcmp(Cmd_Argv(3), "u"))
            flags = CVAR_USERINFO;
        else if (!strcmp(Cmd_Argv(3), "s"))
            flags = CVAR_SERVERINFO;
        else
        {
            Com_Printf ("flags can only be 'u' or 's'\n");
            return;
        }
        Cvar_FullSet (Cmd_Argv(1), Cmd_Argv(2), flags);
    }
    else
        Cvar_Set (Cmd_Argv(1), Cmd_Argv(2));
}
 
 
/*
============
Cvar_WriteVariables
 
Appends lines containing "set variable value" for all variables
with the archive flag set to true.
============
*/
void Cvar_WriteVariables (char *path)
{
    cvar_t  *var;
    char    buffer[1024];
    FILE    *f;
 
    f = fopen (path, "a");
    for (var = cvar_vars ; var ; var = var->next)
    {
        if (var->flags & CVAR_ARCHIVE)
        {
            Com_sprintf (buffer, sizeof(buffer), "set %s \"%s\"\n", var->name, var->string);
            fprintf (f, "%s", buffer);
        }
    }
    fclose (f);
}
 
/*
============
Cvar_List_f
 
============
*/
void Cvar_List_f (void)
{
    cvar_t  *var;
    int     i;
 
    i = 0;
    for (var = cvar_vars ; var ; var = var->next, i++)
    {
        if (var->flags & CVAR_ARCHIVE)
            Com_Printf ("*");
        else
            Com_Printf (" ");
        if (var->flags & CVAR_USERINFO)
            Com_Printf ("U");
        else
            Com_Printf (" ");
        if (var->flags & CVAR_SERVERINFO)
            Com_Printf ("S");
        else
            Com_Printf (" ");
        if (var->flags & CVAR_NOSET)
            Com_Printf ("-");
        else if (var->flags & CVAR_LATCH)
            Com_Printf ("L");
        else
            Com_Printf (" ");
        Com_Printf (" %s \"%s\"\n", var->name, var->string);
    }
    Com_Printf ("%i cvars\n", i);
}
 
 
qboolean userinfo_modified;
 
 
char    *Cvar_BitInfo (int bit)
{
    static char info[MAX_INFO_STRING];
    cvar_t  *var;
 
    info[0] = 0;
 
    for (var = cvar_vars ; var ; var = var->next)
    {
        if (var->flags & bit)
            Info_SetValueForKey (info, var->name, var->string);
    }
    return info;
}
 
// returns an info string containing all the CVAR_USERINFO cvars
char    *Cvar_Userinfo (void)
{
    return Cvar_BitInfo (CVAR_USERINFO);
}
 
// returns an info string containing all the CVAR_SERVERINFO cvars
char    *Cvar_Serverinfo (void)
{
    return Cvar_BitInfo (CVAR_SERVERINFO);
}
 
/*
============
Cvar_Init
 
Reads in all archived cvars
============
*/
void Cvar_Init (void)
{
    Cmd_AddCommand ("set", Cvar_Set_f);
    Cmd_AddCommand ("cvarlist", Cvar_List_f);
 
}