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.

*/

#include "common.h"
#include "../shared/infostring.h"

#define CVAR_HASH_SIZE          64

static cvar_t *cvarVarsHash[CVAR_HASH_SIZE];

static qboolean renderModified;

static qboolean userinfoModified;

void Com_SetUserinfoModified (qboolean modified)
{
    userinfoModified = modified;
}

qboolean Com_IsUserinfoModified (void)
{
    return userinfoModified;
}

void Com_SetRenderModified (qboolean modified)
{
    renderModified = modified;
}

qboolean Com_IsRenderModified (void)
{
    return renderModified;
}

static cvar_t *cvarVars;

static qboolean Cvar_InfoValidate (const char *s)
{
    if (strstr(s, "\\"))
        return qfalse;
    if (strstr(s, "\""))
        return qfalse;
    if (strstr(s, ";"))
        return qfalse;
    return qtrue;
}

cvar_t *Cvar_FindVar (const char *varName)
{
    cvar_t *var;
    const unsigned hash = Com_HashKey(varName, CVAR_HASH_SIZE);

    for (var = cvarVarsHash[hash]; var; var = var->hash_next)
        if (!strcmp(varName, var->name))
            return var;

    return NULL;
}

float Cvar_GetValue (const char *varName)
{
    cvar_t *var;

    var = Cvar_FindVar(varName);
    if (!var)
        return 0.0;
    return atof(var->string);
}


qboolean Cvar_SetCheckFunction (const char *varName, qboolean (*check) (cvar_t* cvar))
{
    cvar_t *var;

    var = Cvar_FindVar(varName);
    if (!var) {
        Com_Printf("Could not set check function for cvar '%s'\n", varName);
        return qfalse;
    }
    var->check = check;
    /* execute the check */
    var->check(var);
    return qtrue;
}

qboolean Cvar_AssertValue (cvar_t * cvar, float minVal, float maxVal, qboolean shouldBeIntegral)
{
    assert(cvar);

    if (shouldBeIntegral) {
        if ((int)cvar->value != cvar->integer) {
            Com_Printf("WARNING: cvar '%s' must be integral (%f)\n", cvar->name, cvar->value);
            Cvar_Set(cvar->name, va("%d", cvar->integer));
            return qtrue;
        }
    }

    if (cvar->value < minVal) {
        Com_Printf("WARNING: cvar '%s' out of range (%f < %f)\n", cvar->name, cvar->value, minVal);
        Cvar_SetValue(cvar->name, minVal);
        return qtrue;
    } else if (cvar->value > maxVal) {
        Com_Printf("WARNING: cvar '%s' out of range (%f > %f)\n", cvar->name, cvar->value, maxVal);
        Cvar_SetValue(cvar->name, maxVal);
        return qtrue;
    }

    /* no changes */
    return qfalse;
}

qboolean Cvar_AssertString (cvar_t * cvar, char **array, int arraySize)
{
    int i;
    char *string;

    assert(cvar);

    for (i = 0; i < arraySize; i++) {
        string = array[i];
        if (strncmp(cvar->string, string, sizeof(cvar->string))) {
            /* valid value */
            return qfalse;
        }
    }

    Com_Printf("Cvar '%s' has not a valid value\n", cvar->name);

    if (cvar->oldString)
        Cvar_Set(cvar->name, cvar->oldString);

    /* not a valid value */
    return qtrue;
}

int Cvar_GetInteger (const char *varName)
{
    const cvar_t *var;

    var = Cvar_FindVar(varName);
    if (!var)
        return 0;
    return var->integer;
}

const char *Cvar_GetString (const char *varName)
{
    const cvar_t *var;

    var = Cvar_FindVar(varName);
    if (!var)
        return "";
    return var->string;
}

const char *Cvar_VariableStringOld (const char *varName)
{
    cvar_t *var;

    var = Cvar_FindVar(varName);
    if (!var)
        return "";
    if (var->oldString)
        return var->oldString;
    else
        return "";
}

int Cvar_CompleteVariable (const char *partial, const char **match)
{
    int matches = 0;
    const char *localMatch[MAX_COMPLETE];
    cvar_t* cvar;
    size_t len;

    len = strlen(partial);
    if (!len)
        return 0;

    localMatch[matches] = NULL;

    /* check for partial matches */
    for (cvar = cvarVars; cvar; cvar = cvar->next)
        if (!strncmp(partial, cvar->name, len)) {
#ifndef DEBUG
            if (cvar->flags & CVAR_DEVELOPER)
                continue;
#endif
            Com_Printf("[var] %-20s = \"%s\"\n", cvar->name, cvar->string);
            if (cvar->description)
                Com_Printf(COLORED_GREEN "      %s\n", cvar->description);
            localMatch[matches++] = cvar->name;
            if (matches >= MAX_COMPLETE)
                break;
        }

    return Cmd_GenericCompleteFunction(len, match, matches, localMatch);
}

qboolean Cvar_Delete (const char *varName)
{
    unsigned hash;
    cvar_t *var, *previousVar = NULL;

    hash = Com_HashKey(varName, CVAR_HASH_SIZE);
    for (var = cvarVarsHash[hash]; var; var = var->hash_next) {
        if (!Q_strcasecmp(varName, var->name)) {
            cvarChangeListener_t *changeListener;
            if (var->flags & (CVAR_USERINFO | CVAR_SERVERINFO | CVAR_NOSET | CVAR_LATCH)) {
                Com_Printf("Can't delete the cvar '%s' - it's a special cvar\n", varName);
                return qfalse;
            }
            if (var->prev) {
                assert(var->prev->next == var);
                var->prev->next = var->next;
            } else
                cvarVars = var->next;
            if (var->next) {
                assert(var->next->prev == var);
                var->next->prev = var->prev;
            }
            if (previousVar) {
                assert(previousVar->hash_next == var);
                previousVar->hash_next = var->hash_next;
            } else {
                cvarVarsHash[hash] = var->hash_next;
            }
            Mem_Free(var->name);
            Mem_Free(var->string);
            if (var->description)
                Mem_Free(var->description);
            if (var->oldString)
                Mem_Free(var->oldString);
            if (var->defaultString)
                Mem_Free(var->defaultString);
            /* latched cvars should not be removable */
            assert(var->latchedString == NULL);
            changeListener = var->changeListener;
            while (changeListener) {
                cvarChangeListener_t *changeListener2 = changeListener->next;
                Mem_Free(changeListener);
                changeListener = changeListener2;
            }
            Mem_Free(var);

            return qtrue;
        }
        previousVar = var;
    }
    Com_Printf("Cvar '%s' wasn't found\n", varName);
    return qfalse;
}

cvar_t *Cvar_Get (const char *var_name, const char *var_value, int flags, const char* desc)
{
    cvar_t *var;
    const unsigned hash = Com_HashKey(var_name, CVAR_HASH_SIZE);

    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) {
        if (!var->defaultString && flags & CVAR_CHEAT)
            var->defaultString = Mem_PoolStrDup(var_value, com_cvarSysPool, 0);
        var->flags |= flags;
        if (desc) {
            if (var->description)
                Mem_Free(var->description);
            var->description = Mem_PoolStrDup(desc, com_cvarSysPool, 0);
        }
        return var;
    }

    if (!var_value)
        return NULL;

    if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
        if (!Cvar_InfoValidate(var_value)) {
            Com_Printf("invalid info cvar value '%s' of cvar '%s'\n", var_value, var_name);
            return NULL;
        }

    var = Mem_PoolAlloc(sizeof(*var), com_cvarSysPool, 0);
    var->name = Mem_PoolStrDup(var_name, com_cvarSysPool, 0);
    var->string = Mem_PoolStrDup(var_value, com_cvarSysPool, 0);
    var->oldString = NULL;
    var->modified = qtrue;
    var->value = atof(var->string);
    var->integer = atoi(var->string);
    if (desc)
        var->description = Mem_PoolStrDup(desc, com_cvarSysPool, 0);

    HASH_Add(cvarVarsHash, var, hash);
    /* link the variable in */
    var->next = cvarVars;
    cvarVars = var;
    if (var->next)
        var->next->prev = var;

    var->flags = flags;
    if (var->flags & CVAR_CHEAT)
        var->defaultString = Mem_PoolStrDup(var_value, com_cvarSysPool, 0);

    return var;
}

static void Cvar_ExecuteChangeListener (const cvar_t* cvar)
{
    const cvarChangeListener_t *listener = cvar->changeListener;
    while (listener) {
        listener->exec(cvar->name, cvar->oldString, cvar->string);
        listener = listener->next;
    }
}

static cvarChangeListener_t *Cvar_GetChangeListener (cvarChangeListenerFunc_t listenerFunc)
{
    cvarChangeListener_t *listener = Mem_PoolAlloc(sizeof(*listener), com_cvarSysPool, 0);
    listener->exec = listenerFunc;
    return listener;
}

void Cvar_RegisterChangeListener (const char *varName, cvarChangeListenerFunc_t listenerFunc)
{
    cvarChangeListener_t *listener;
    cvar_t *var = Cvar_FindVar(varName);
    if (!var) {
        Com_Printf("Could not register change listener, cvar '%s' wasn't found\n", varName);
        return;
    }

    listener = Cvar_GetChangeListener(listenerFunc);
    if (!var->changeListener) {
        var->changeListener = listener;
    } else {
        cvarChangeListener_t *l = var->changeListener;
        while (l) {
            if (l->exec == listenerFunc) {
                Com_Printf("Cvar change listener already registered\n");
                return;
            }
            l = l->next;
        }

        l = var->changeListener;
        while (l) {
            if (!l->next) {
                l->next = listener;
                l->next->next = NULL;
                break;
            }
            l = l->next;
        }
    }
}

void Cvar_UnRegisterChangeListener (const char *varName, cvarChangeListenerFunc_t listenerFunc)
{
    cvar_t *var = Cvar_FindVar(varName);
    cvarChangeListener_t *l, *prev;

    if (!var) {
        Com_Printf("Could not unregister change listener, cvar '%s' wasn't found\n", varName);
        return;
    }

    l = var->changeListener;
    prev = NULL;
    while (l) {
        if (l->exec == listenerFunc) {
            if (prev) {
                prev->next = l->next;
            } else {
                var->changeListener = l->next;
            }
            Mem_Free(l);
            return;
        }
        prev = l;
        l = l->next;
    }
}

static cvar_t *Cvar_Set2 (const char *varName, const char *value, qboolean force)
{
    cvar_t *var;

    if (!value)
        return NULL;

    var = Cvar_FindVar(varName);
    /* create it */
    if (!var)
        return Cvar_Get(varName, value, 0, NULL);

    if (var->flags & (CVAR_USERINFO | CVAR_SERVERINFO))
        if (!Cvar_InfoValidate(value)) {
            Com_Printf("invalid info cvar value '%s' of cvar '%s'\n", value, varName);
            return var;
        }

    if (!force) {
        if (var->flags & CVAR_NOSET) {
            Com_Printf("%s is write protected.\n", varName);
            return var;
        }
#ifndef DEBUG
        if (var->flags & CVAR_DEVELOPER) {
            Com_Printf("%s is a developer cvar.\n", varName);
            return var;
        }
#endif

        if (var->flags & CVAR_LATCH) {
            if (var->latchedString) {
                if (!strcmp(value, var->latchedString))
                    return var;
                Mem_Free(var->latchedString);
                var->latchedString = NULL;
            } else {
                if (!strcmp(value, var->string))
                    return var;
            }

            /* if we are running a server */
            if (Com_ServerState()) {
                Com_Printf("%s will be changed for next game.\n", varName);
                var->latchedString = Mem_PoolStrDup(value, com_cvarSysPool, 0);
            } else {
                if (var->oldString)
                    Mem_Free(var->oldString);
                var->oldString = var->string;
                var->string = Mem_PoolStrDup(value, com_cvarSysPool, 0);
                var->value = atof(var->string);
                var->integer = atoi(var->string);
            }

            if (var->check)
                if (var->check(var))
                    Com_Printf("Invalid value for cvar %s\n", varName);

            return var;
        }
    } else {
        if (var->latchedString) {
            Mem_Free(var->latchedString);
            var->latchedString = NULL;
        }
    }

    if (!strcmp(value, var->string))
        return var;             /* not changed */

    if (var->flags & CVAR_R_MASK)
        Com_SetRenderModified(qtrue);

    if (var->oldString)
        Mem_Free(var->oldString);       /* free the old value string */
    var->oldString = var->string;
    var->modified = qtrue;

    if (var->flags & CVAR_USERINFO)
        Com_SetUserinfoModified(qtrue); /* transmit at next opportunity */

    var->string = Mem_PoolStrDup(value, com_cvarSysPool, 0);
    var->value = atof(var->string);
    var->integer = atoi(var->string);

    if (var->check)
        if (var->check(var)) {
            Com_Printf("Invalid value for cvar %s\n", varName);
            return var;
        }

    Cvar_ExecuteChangeListener(var);

    return var;
}

cvar_t *Cvar_ForceSet (const char *varName, const char *value)
{
    return Cvar_Set2(varName, value, qtrue);
}

cvar_t *Cvar_Set (const char *varName, const char *value)
{
    return Cvar_Set2(varName, value, qfalse);
}

cvar_t *Cvar_FullSet (const char *varName, const char *value, int flags)
{
    cvar_t *var;

    if (!value)
        return NULL;

    var = Cvar_FindVar(varName);
    /* create it */
    if (!var)
        return Cvar_Get(varName, value, flags, NULL);

    var->modified = qtrue;

    /* transmit at next opportunity */
    if (var->flags & CVAR_USERINFO)
        Com_SetUserinfoModified(qtrue);

    if (var->oldString)
        Mem_Free(var->oldString);       /* free the old value string */
    var->oldString = var->string;

    var->string = Mem_PoolStrDup(value, com_cvarSysPool, 0);
    var->value = atof(var->string);
    var->integer = atoi(var->string);
    var->flags = flags;

    return var;
}

void Cvar_SetValue (const char *varName, float value)
{
    char val[32];

    if (value == (int) value)
        Com_sprintf(val, sizeof(val), "%i", (int) value);
    else
        Com_sprintf(val, sizeof(val), "%1.2f", value);
    Cvar_Set(varName, val);
}


void Cvar_UpdateLatchedVars (void)
{
    cvar_t *var;

    for (var = cvarVars; var; var = var->next) {
        if (!var->latchedString)
            continue;
        var->oldString = var->string;
        var->string = var->latchedString;
        var->latchedString = NULL;
        var->value = atof(var->string);
        var->integer = atoi(var->string);
    }
}

qboolean Cvar_Command (void)
{
    cvar_t *v;

    /* check variables */
    v = Cvar_FindVar(Cmd_Argv(0));
    if (!v)
        return qfalse;

    /* perform a variable print or set */
    if (Cmd_Argc() == 1) {
        Com_Printf("\"%s\" is \"%s\"\n", v->name, v->string);
        return qtrue;
    }

    Cvar_Set(v->name, Cmd_Argv(1));
    return qtrue;
}

static void Cvar_SetOld_f (void)
{
    cvar_t *v;

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

    /* check variables */
    v = Cvar_FindVar(Cmd_Argv(1));
    if (!v) {
        Com_Printf("cvar '%s' not found\n", Cmd_Argv(1));
        return;
    }
    if (v->oldString)
        Cvar_Set(Cmd_Argv(1), v->oldString);
}

static void Cvar_Define_f (void)
{
    const char *name;

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

    name = Cmd_Argv(1);

    if (Cvar_FindVar(name) == NULL)
        Cvar_Set(name, Cmd_Argc() == 3 ? Cmd_Argv(2) : "");
}

static void Cvar_Set_f (void)
{
    const int c = Cmd_Argc();
    if (c != 3 && c != 4) {
        Com_Printf("Usage: %s <variable> <value> [u / s]\n", Cmd_Argv(0));
        return;
    }

    if (c == 4) {
        const char *arg = Cmd_Argv(3);
        int flags = 0;

        while (arg[0] != '\0') {
            switch (arg[0]) {
            case 'u':
                flags |= CVAR_USERINFO;
                break;
            case 's':
                flags |= CVAR_SERVERINFO;
                break;
            case 'a':
                flags |= CVAR_ARCHIVE;
                break;
            default:
                Com_Printf("invalid flags %c given\n", arg[0]);
            }
            arg++;
        }
        Cvar_FullSet(Cmd_Argv(1), Cmd_Argv(2), flags);
    } else
        Cvar_Set(Cmd_Argv(1), Cmd_Argv(2));
}


static void Cvar_Copy_f (void)
{
    int c;

    c = Cmd_Argc();
    if (c < 3) {
        Com_Printf("Usage: %s <target> <source>\n", Cmd_Argv(0));
        return;
    }

    Cvar_Set(Cmd_Argv(1), Cvar_GetString(Cmd_Argv(2)));
}


void Cvar_WriteVariables (qFILE *f)
{
    const cvar_t *var;

    for (var = cvarVars; var; var = var->next)
        if (var->flags & CVAR_ARCHIVE)
            FS_Printf(f, "set %s \"%s\" a\n", var->name, var->string);
}

qboolean Cvar_PendingCvars (int flags)
{
    const cvar_t *var;

    for (var = cvarVars; var; var = var->next)
        if ((var->flags & flags) && var->modified)
            return qtrue;

    return qfalse;
}

void Cvar_ClearVars (int flags)
{
    cvar_t *var;

    for (var = cvarVars; var; var = var->next)
        if ((var->flags & flags) && var->modified)
            var->modified = qfalse;
}

static void Cvar_List_f (void)
{
    cvar_t *var;
    int i, c, l = 0;
    const char *token = NULL;

    c = Cmd_Argc();

    if (c == 2) {
        token = Cmd_Argv(1);
        l = strlen(token);
    }

    i = 0;
    for (var = cvarVars; var; var = var->next, i++) {
        if (c == 2 && strncmp(var->name, token, l)) {
            i--;
            continue;
        }
#ifndef DEBUG
        /* don't show developer cvars in release mode */
        if (var->flags & CVAR_DEVELOPER)
            continue;
#endif

        if (var->flags & CVAR_ARCHIVE)
            Com_Printf("A");
        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->modified)
            Com_Printf("M");
        else
            Com_Printf(" ");
        if (var->flags & CVAR_DEVELOPER)
            Com_Printf("D");
        else
            Com_Printf(" ");
        if (var->flags & CVAR_R_IMAGES)
            Com_Printf("I");
        else
            Com_Printf(" ");
        if (var->flags & CVAR_NOSET)
            Com_Printf("-");
        else if (var->flags & CVAR_LATCH)
            Com_Printf("L");
        else
            Com_Printf(" ");
        Com_Printf(" %-20s \"%s\"\n", var->name, var->string);
        if (var->description)
            Com_Printf(COLORED_GREEN "        %s\n", var->description);
    }
    Com_Printf("%i cvars\n", i);
    Com_Printf("legend:\n"
        "S: Serverinfo\n"
        "L: Latched\n"
        "D: Developer\n"
        "U: Userinfo\n"
        "I: Image\n"
        "*: Archive\n"
        "-: Not changeable\n"
    );
}

static char *Cvar_BitInfo (int bit)
{
    static char info[MAX_INFO_STRING];
    cvar_t *var;

    info[0] = 0;

    for (var = cvarVars; var; var = var->next)
        if (var->flags & bit)
            Info_SetValueForKey(info, sizeof(info), var->name, var->string);
    return info;
}

const char *Cvar_Userinfo (void)
{
    return Cvar_BitInfo(CVAR_USERINFO);
}

const char *Cvar_Serverinfo (void)
{
    return Cvar_BitInfo(CVAR_SERVERINFO);
}

static void Cvar_Del_f (void)
{
    int c;

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

    Cvar_Delete(Cmd_Argv(1));
}

static void Cvar_Add_f (void)
{
    cvar_t *cvar;
    float value;
    if (Cmd_Argc() != 3) {
        Com_Printf("Usage: %s <variable> <value>\n", Cmd_Argv(0));
        return;
    }

    cvar = Cvar_FindVar(Cmd_Argv(1));
    if (!cvar) {
        Com_Printf("Cvar_Add_f: %s not exists\n", Cmd_Argv(1));
        return;
    }

    value = cvar->value + atof(Cmd_Argv(2));
    Cvar_SetValue(Cmd_Argv(1), value);
}

static void Cvar_Mod_f (void)
{
    cvar_t *cvar;
    int value;
    if (Cmd_Argc() != 3) {
        Com_Printf("Usage: %s <variable> <value>\n", Cmd_Argv(0));
        return;
    }

    cvar = Cvar_FindVar(Cmd_Argv(1));
    if (!cvar) {
        Com_Printf("Cvar_Mod_f: %s not exists\n", Cmd_Argv(1));
        return;
    }

    value = cvar->integer % atoi(Cmd_Argv(2));
    Cvar_SetValue(Cmd_Argv(1), value);
}

void Cvar_FixCheatVars (void)
{
    cvar_t *var;

    if (!(Com_ServerState() && !Cvar_GetInteger("sv_cheats")))
        return;

    for (var = cvarVars; var; var = var->next) {
        if (!(var->flags & CVAR_CHEAT))
            continue;

        if (!var->defaultString) {
            Com_Printf("Cheat cvars: Cvar %s has no default value\n", var->name);
            continue;
        }

        if (!strcmp(var->string, var->defaultString))
            continue;

        /* also remove the oldString value here */
        if (var->oldString) {
            Mem_Free(var->oldString);
            var->oldString = NULL;
        }
        Mem_Free(var->string);
        var->string = Mem_PoolStrDup(var->defaultString, com_cvarSysPool, 0);
        var->value = atof(var->string);
        var->integer = atoi(var->string);

        Com_Printf("'%s' is a cheat cvar - activate sv_cheats to use it.\n", var->name);
    }
}

#ifdef DEBUG
void Cvar_PrintDebugCvars (void)
{
    const cvar_t *var;

    Com_Printf("Debug cvars:\n");
    for (var = cvarVars; var; var = var->next) {
        if ((var->flags & CVAR_DEVELOPER) || !strncmp(var->name, "debug_", 6))
            Com_Printf(" * %s (%s)\n   %s\n", var->name, var->string, var->description ? var->description : "");
    }
    Com_Printf("\n");
}
#endif

void Cvar_Init (void)
{
    Cmd_AddCommand("setold", Cvar_SetOld_f, "Restore the cvar old value");
    Cmd_AddCommand("del", Cvar_Del_f, "Delete a cvar");
    Cmd_AddCommand("set", Cvar_Set_f, "Set a cvar value");
    Cmd_AddCommand("add", Cvar_Add_f, "Add a value to a cvar");
    Cmd_AddCommand("define", Cvar_Define_f, "Defines a cvar if it does not exist");
    Cmd_AddCommand("mod", Cvar_Mod_f, "Apply a modulo on a cvar");
    Cmd_AddCommand("copy", Cvar_Copy_f, "Copy cvar target to source");
    Cmd_AddCommand("cvarlist", Cvar_List_f, "Show all cvars");
}

void Cvar_Shutdown (void)
{
    cvarVars = NULL;
    memset(cvarVarsHash, 0, sizeof(cvarVarsHash));
}