cvar.cpp

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"
#include <vector>
 
#define CVAR_HASH_SIZE 64
 
static cvar_t* cvarVarsHash[CVAR_HASH_SIZE];
 
// @todo This uses the STL, however, in a recent discussion on the forum it was stated that there
// should be no use of STL due to memory issues, so this needs to change
typedef std::vector<CvarListenerPtr> CvarListeners;
static CvarListeners cvarListeners;

static bool renderModified;

static bool userinfoModified;
 
void Com_SetUserinfoModified (bool modified)
{
    userinfoModified = modified;
}
 
bool Com_IsUserinfoModified (void)
{
    return userinfoModified;
}
 
void Com_SetRenderModified (bool modified)
{
    renderModified = modified;
}
 
bool Com_IsRenderModified (void)
{
    return renderModified;
}

static cvar_t* cvarVars;
 
cvar_t* Cvar_GetFirst (void)
{
    return cvarVars;
}
 

static bool Cvar_InfoValidate (const char* s)
{
    return s[strcspn(s, "\\\";")] == '\0';
}

cvar_t* Cvar_FindVar (const char* varName)
{
    const unsigned hash = Com_HashKey(varName, CVAR_HASH_SIZE);
 
    for (cvar_t* var = cvarVarsHash[hash]; var; var = var->hash_next) {
        if (Q_streq(varName, var->name))
            return var;
    }
 
    return nullptr;
}

float Cvar_GetValue (const char* varName)
{
    const cvar_t* var = Cvar_FindVar(varName);
    if (!var)
        return 0.0f;
    return atof(var->string);
}
 

bool Cvar_SetCheckFunction (const char* varName, bool (*check) (cvar_t* cvar))
{
    cvar_t* var = Cvar_FindVar(varName);
    if (!var) {
        Com_Printf("Could not set check function for cvar '%s'\n", varName);
        return false;
    }
    var->check = check;
    /* execute the check */
    var->check(var);
    return true;
}

bool Cvar_AssertValue (cvar_t* cvar, float minVal, float maxVal, bool 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, "%d", cvar->integer);
            return true;
        }
    }
 
    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 true;
    } 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 true;
    }
 
    /* no changes */
    return false;
}

int Cvar_GetInteger (const char* varName)
{
    const cvar_t* var = Cvar_FindVar(varName);
    if (!var)
        return 0;
    return var->integer;
}

const char* Cvar_GetString (const char* varName)
{
    const cvar_t* var = Cvar_FindVar(varName);
    if (!var)
        return "";
    return var->string;
}

const char* Cvar_VariableStringOld (const char* varName)
{
    const cvar_t* var = Cvar_FindVar(varName);
    if (!var)
        return "";
    if (var->oldString)
        return var->oldString;
    else
        return "";
}

void Cvar_Reset (cvar_t* cvar)
{
    if (cvar->oldString == nullptr)
        return;
 
    char* str = Mem_StrDup(cvar->oldString);
    Cvar_Set(cvar->name, "%s", str);
    Mem_Free(str);
}

int Cvar_CompleteVariable (const char* partial, const char** match)
{
    int n = 0;
    for (cvar_t const* cvar = cvarVars; cvar; cvar = cvar->next) {
#ifndef DEBUG
        if (cvar->flags & CVAR_DEVELOPER)
            continue;
#endif
        if (Cmd_GenericCompleteFunction(cvar->name, partial, match)) {
            Com_Printf("[var] %-20s = \"%s\"\n", cvar->name, cvar->string);
            if (cvar->description)
                Com_Printf(S_COLOR_GREEN "      %s\n", cvar->description);
            ++n;
        }
    }
    return n;
}

bool Cvar_Delete (const char* varName)
{
    const unsigned hash = Com_HashKey(varName, CVAR_HASH_SIZE);
    for (cvar_t** anchor = &cvarVarsHash[hash]; *anchor; anchor = &(*anchor)->hash_next) {
        cvar_t* const var = *anchor;
        if (!Q_strcasecmp(varName, var->name)) {
            if (var->flags != 0) {
                Com_Printf("Can't delete the cvar '%s' - it's a special cvar\n", varName);
                return false;
            }
            HASH_Delete(anchor);
            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;
            }
 
            for (CvarListeners::iterator i = cvarListeners.begin(); i != cvarListeners.end(); ++i) {
                (*i)->onDelete(var);
            }
 
            Mem_Free(var->name);
            Mem_Free(var->string);
            Mem_Free(var->description);
            Mem_Free(var->oldString);
            Mem_Free(var->defaultString);
            /* latched cvars should not be removable */
            assert(var->latchedString == nullptr);
            cvarChangeListener_t* changeListener = var->changeListener;
            while (changeListener) {
                cvarChangeListener_t* changeListener2 = changeListener->next;
                Mem_Free(changeListener);
                changeListener = changeListener2;
            }
            Mem_Free(var);
 
            return true;
        }
    }
    Com_Printf("Cvar '%s' wasn't found\n", varName);
    return false;
}

cvar_t* Cvar_Get (const char* var_name, const char* var_value, int flags, const char* desc)
{
    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 nullptr;
        }
    }
 
    if (cvar_t* const var = Cvar_FindVar(var_name)) {
        if (!var->defaultString && (flags & CVAR_CHEAT))
            var->defaultString = Mem_PoolStrDup(var_value, com_cvarSysPool, 0);
        var->flags |= flags;
        if (desc) {
            Mem_Free(var->description);
            var->description = Mem_PoolStrDup(desc, com_cvarSysPool, 0);
        }
        return var;
    }
 
    if (!var_value)
        return nullptr;
 
    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 nullptr;
        }
    }
 
    cvar_t* const var = Mem_PoolAllocType(cvar_t, com_cvarSysPool);
    var->name = Mem_PoolStrDup(var_name, com_cvarSysPool, 0);
    var->string = Mem_PoolStrDup(var_value, com_cvarSysPool, 0);
    var->oldString = nullptr;
    var->modified = true;
    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);
 
    for (CvarListeners::iterator i = cvarListeners.begin(); i != cvarListeners.end(); ++i) {
        (*i)->onCreate(var);
    }
 
    return var;
}

void Cvar_RegisterCvarListener (CvarListenerPtr listener)
{
    cvarListeners.push_back(listener);
}

void Cvar_UnRegisterCvarListener (CvarListenerPtr listener)
{
    cvarListeners.erase(std::remove(cvarListeners.begin(), cvarListeners.end(), listener), cvarListeners.end());
}

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->data);
        listener = listener->next;
    }
}
 
static cvarChangeListener_t* Cvar_GetChangeListener (cvarChangeListenerFunc_t listenerFunc)
{
    cvarChangeListener_t* const listener = Mem_PoolAllocType(cvarChangeListener_t, com_cvarSysPool);
    listener->exec = listenerFunc;
    return listener;
}

cvarChangeListener_t* Cvar_RegisterChangeListener (const char* varName, cvarChangeListenerFunc_t listenerFunc)
{
    cvar_t* var = Cvar_FindVar(varName);
    if (!var) {
        Com_Printf("Could not register change listener, cvar '%s' wasn't found\n", varName);
        return nullptr;
    }
 
    if (!var->changeListener) {
        cvarChangeListener_t* l = Cvar_GetChangeListener(listenerFunc);
        var->changeListener = l;
        return l;
    } else {
        cvarChangeListener_t* l = var->changeListener;
        while (l) {
            if (l->exec == listenerFunc) {
                return l;
            }
            l = l->next;
        }
 
        l = var->changeListener;
        while (l) {
            if (!l->next) {
                cvarChangeListener_t* listener = Cvar_GetChangeListener(listenerFunc);
                l->next = listener;
                l->next->next = nullptr;
                return listener;
            }
            l = l->next;
        }
    }
 
    return nullptr;
}

void Cvar_UnRegisterChangeListener (const char* varName, cvarChangeListenerFunc_t listenerFunc)
{
    cvar_t* var = Cvar_FindVar(varName);
    if (!var) {
        Com_Printf("Could not unregister change listener, cvar '%s' wasn't found\n", varName);
        return;
    }
 
    for (cvarChangeListener_t** anchor = &var->changeListener; *anchor; anchor = &(*anchor)->next) {
        cvarChangeListener_t* const l = *anchor;
        if (l->exec == listenerFunc) {
            *anchor = l->next;
            Mem_Free(l);
            return;
        }
    }
}

static cvar_t* Cvar_Set2 (const char* varName, const char* value, bool force)
{
    if (!value)
        return nullptr;
 
    cvar_t* var = Cvar_FindVar(varName);
    /* create it */
    if (!var)
        return Cvar_Get(varName, value);
 
    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 (Q_streq(value, var->latchedString))
                    return var;
                Mem_Free(var->latchedString);
                var->latchedString = nullptr;
            } else {
                if (Q_streq(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 {
                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 && var->check(var))
                Com_Printf("Invalid value for cvar %s\n", varName);
 
            return var;
        }
    } else {
        Mem_Free(var->latchedString);
        var->latchedString = nullptr;
    }
 
    if (Q_streq(value, var->string))
        return var;             /* not changed */
 
    if (var->flags & CVAR_R_MASK)
        Com_SetRenderModified(true);
 
    Mem_Free(var->oldString);       /* free the old value string */
    var->oldString = var->string;
    var->modified = true;
 
    if (var->flags & CVAR_USERINFO)
        Com_SetUserinfoModified(true);  /* 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 && 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, true);
}

cvar_t* Cvar_Set (const char* varName, const char* value, ...)
{
    va_list argptr;
    char text[512];
    va_start(argptr, value);
    Q_vsnprintf(text, sizeof(text), value, argptr);
    va_end(argptr);
 
    return Cvar_Set2(varName, text, false);
}

cvar_t* Cvar_FullSet (const char* varName, const char* value, int flags)
{
    if (!value)
        return nullptr;
 
    cvar_t* var = Cvar_FindVar(varName);
    /* create it */
    if (!var)
        return Cvar_Get(varName, value, flags);
 
    var->modified = true;
 
    /* transmit at next opportunity */
    if (var->flags & CVAR_USERINFO)
        Com_SetUserinfoModified(true);
 
    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)
{
    if (value == (int) value)
        Cvar_Set(varName, "%i", (int)value);
    else
        Cvar_Set(varName, "%1.2f", value);
}

void Cvar_UpdateLatchedVars (void)
{
    for (cvar_t* var = cvarVars; var; var = var->next) {
        if (!var->latchedString)
            continue;
        var->oldString = var->string;
        var->string = var->latchedString;
        var->latchedString = nullptr;
        var->value = atof(var->string);
        var->integer = atoi(var->string);
    }
}

bool Cvar_Command (void)
{
    /* check variables */
    cvar_t* 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, "%s", Cmd_Argv(1));
    return true;
}

static void Cvar_SetOld_f (void)
{
    if (Cmd_Argc() != 2) {
        Com_Printf("Usage: %s <variable>\n", Cmd_Argv(0));
        return;
    }
 
    /* check variables */
    cvar_t* 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), "%s", v->oldString);
}
 
static void Cvar_Define_f (void)
{
    if (Cmd_Argc() < 2) {
        Com_Printf("Usage: %s <cvarname> <value>\n", Cmd_Argv(0));
        return;
    }
 
    const char* name = Cmd_Argv(1);
 
    if (Cvar_FindVar(name) == nullptr)
        Cvar_Set(name, "%s", 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 / a]\n", Cmd_Argv(0));
        return;
    }
 
    if (c == 4) {
        const cvar_t* const var = Cvar_FindVar(Cmd_Argv(1));
        if (var && (var->flags & (CVAR_NOSET | CVAR_LATCH))) {
            Com_Printf("Can't set %s: is a special cvar\n", Cmd_Argv(1));
            return;
        }
 
        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]);
                break;
            }
            arg++;
        }
        Cvar_FullSet(Cmd_Argv(1), Cmd_Argv(2), flags);
    } else {
        Cvar_Set(Cmd_Argv(1), "%s", Cmd_Argv(2));
    }
}

static void Cvar_Switch_f (void)
{
    const int c = Cmd_Argc();
    if (c != 2 && c != 3) {
        Com_Printf("Usage: %s <variable> [u / s / a]\n", Cmd_Argv(0));
        return;
    }
 
    if (c == 3) {
        const cvar_t* const var = Cvar_FindVar(Cmd_Argv(1));
        if (var && (var->flags & (CVAR_NOSET | CVAR_LATCH))) {
            Com_Printf("Can't switch %s: is a special cvar\n", Cmd_Argv(1));
            return;
        }
 
        const char* arg = Cmd_Argv(2);
        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]);
                break;
            }
            arg++;
        }
        Cvar_FullSet(Cmd_Argv(1), va("%i", !Cvar_GetInteger(Cmd_Argv(1))), flags);
    } else {
        Com_Printf("val: %i\n", Cvar_GetInteger(Cmd_Argv(1)));
        Cvar_Set(Cmd_Argv(1), "%i", !Cvar_GetInteger(Cmd_Argv(1)));
    }
}

static void Cvar_Copy_f (void)
{
    const int c = Cmd_Argc();
    if (c < 3) {
        Com_Printf("Usage: %s <target> <source>\n", Cmd_Argv(0));
        return;
    }
 
    Cvar_Set(Cmd_Argv(1), "%s", Cvar_GetString(Cmd_Argv(2)));
}
 

void Cvar_WriteVariables (qFILE* f)
{
    for (const cvar_t* var = cvarVars; var; var = var->next) {
        if (var->flags & CVAR_ARCHIVE)
            FS_Printf(f, "set %s \"%s\" a\n", var->name, var->string);
    }
}

bool Cvar_PendingCvars (int flags)
{
    for (const cvar_t* var = cvarVars; var; var = var->next) {
        if ((var->flags & flags) && var->modified)
            return true;
    }
 
    return false;
}
 
void Cvar_ClearVars (int flags)
{
    for (cvar_t* var = cvarVars; var; var = var->next) {
        if (var->flags & flags)
            var->modified = false;
    }
}

static void Cvar_List_f (void)
{
    int l = 0;
    const char* token = nullptr;
    const int c = Cmd_Argc();
 
    if (c == 2) {
        token = Cmd_Argv(1);
        l = strlen(token);
    }
 
    int i = 0;
    for (cvar_t* var = cvarVars; var; var = var->next, i++) {
        if (token && strncmp(var->name, token, l)) {
            i--;
            continue;
        }
#ifndef DEBUG
        /* don't show developer cvars in release mode */
        if (var->flags & CVAR_DEVELOPER)
            continue;
#endif
 
        Com_Printf(var->flags & CVAR_ARCHIVE    ? "A" : " ");
        Com_Printf(var->flags & CVAR_USERINFO   ? "U" : " ");
        Com_Printf(var->flags & CVAR_SERVERINFO ? "S" : " ");
        Com_Printf(var->modified                ? "M" : " ");
        Com_Printf(var->flags & CVAR_DEVELOPER  ? "D" : " ");
        Com_Printf(var->flags & CVAR_R_IMAGES   ? "I" : " ");
        Com_Printf(var->flags & CVAR_NOSET      ? "-" :
                   var->flags & CVAR_LATCH      ? "L" : " ");
        Com_Printf(" %-20s \"%s\"\n", var->name, var->string);
        if (var->description)
            Com_Printf(S_COLOR_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, char* info, size_t infoSize)
{
    for (cvar_t* var = cvarVars; var; var = var->next) {
        if (var->flags & bit)
            Info_SetValueForKey(info, infoSize, var->name, var->string);
    }
    return info;
}

const char* Cvar_Userinfo (char* info, size_t infoSize)
{
    info[0] = '\0';
    return Cvar_BitInfo(CVAR_USERINFO, info, infoSize);
}

const char* Cvar_Serverinfo (char* info, size_t infoSize)
{
    info[0] = '\0';
    return Cvar_BitInfo(CVAR_SERVERINFO, info, infoSize);
}

static void Cvar_Del_f (void)
{
    const int 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)
{
    if (Cmd_Argc() != 3) {
        Com_Printf("Usage: %s <variable> <value>\n", Cmd_Argv(0));
        return;
    }
 
    const cvar_t* cvar = Cvar_FindVar(Cmd_Argv(1));
    if (!cvar) {
        Com_Printf("Cvar_Add_f: %s does not exist\n", Cmd_Argv(1));
        return;
    }
 
    const float value = cvar->value + atof(Cmd_Argv(2));
    Cvar_SetValue(Cmd_Argv(1), value);
}

static void Cvar_Mod_f (void)
{
    if (Cmd_Argc() != 3) {
        Com_Printf("Usage: %s <variable> <value>\n", Cmd_Argv(0));
        return;
    }
 
    const cvar_t* cvar = Cvar_FindVar(Cmd_Argv(1));
    if (!cvar) {
        Com_Printf("Cvar_Mod_f: %s does not exist\n", Cmd_Argv(1));
        return;
    }
 
    const int value = cvar->integer % atoi(Cmd_Argv(2));
    Cvar_SetValue(Cmd_Argv(1), value);
}

void Cvar_FixCheatVars (void)
{
    if (!(Com_ServerState() && !Cvar_GetInteger("sv_cheats")))
        return;
 
    for (cvar_t* 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 (Q_streq(var->string, var->defaultString))
            continue;
 
        /* also remove the oldString value here */
        Mem_Free(var->oldString);
        var->oldString = nullptr;
        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)
{
    Com_Printf("Debug cvars:\n");
    for (const cvar_t* 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("switch", Cvar_Switch_f, "Switch a boolean 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 = nullptr;
    OBJZERO(cvarVarsHash);
}