first

Quake/cvar.c

@@ -0,0 +1,652 @@
+/*
+Copyright (C) 1996-2001 Id Software, Inc.
+Copyright (C) 2002-2009 John Fitzgibbons and others
+Copyright (C) 2010-2014 QuakeSpasm developers
+
+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 "quakedef.h"
+
+static cvar_t	*cvar_vars;
+static char	cvar_null_string[] = "";
+
+//==============================================================================
+//
+//  USER COMMANDS
+//
+//==============================================================================
+
+void Cvar_Reset (const char *name); //johnfitz
+
+/*
+============
+Cvar_List_f -- johnfitz
+============
+*/
+void Cvar_List_f (void)
+{
+	cvar_t	*cvar;
+	const char 	*partial;
+	int		len, count;
+
+	if (Cmd_Argc() > 1)
+	{
+		partial = Cmd_Argv (1);
+		len = Q_strlen(partial);
+	}
+	else
+	{
+		partial = NULL;
+		len = 0;
+	}
+
+	count = 0;
+	for (cvar = cvar_vars ; cvar ; cvar = cvar->next)
+	{
+		if (partial && Q_strncmp(partial, cvar->name, len))
+		{
+			continue;
+		}
+		Con_SafePrintf ("%s%s %s \"%s\"\n",
+			(cvar->flags & CVAR_ARCHIVE) ? "*" : " ",
+			(cvar->flags & CVAR_NOTIFY)  ? "s" : " ",
+			cvar->name,
+			cvar->string);
+		count++;
+	}
+
+	Con_SafePrintf ("%i cvars", count);
+	if (partial)
+	{
+		Con_SafePrintf (" beginning with \"%s\"", partial);
+	}
+	Con_SafePrintf ("\n");
+}
+
+/*
+============
+Cvar_Inc_f -- johnfitz
+============
+*/
+void Cvar_Inc_f (void)
+{
+	switch (Cmd_Argc())
+	{
+	default:
+	case 1:
+		Con_Printf("inc <cvar> [amount] : increment cvar\n");
+		break;
+	case 2:
+		Cvar_SetValue (Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + 1);
+		break;
+	case 3:
+		Cvar_SetValue (Cmd_Argv(1), Cvar_VariableValue(Cmd_Argv(1)) + Q_atof(Cmd_Argv(2)));
+		break;
+	}
+}
+
+/*
+============
+Cvar_Toggle_f -- johnfitz
+============
+*/
+void Cvar_Toggle_f (void)
+{
+	switch (Cmd_Argc())
+	{
+	default:
+	case 1:
+		Con_Printf("toggle <cvar> : toggle cvar\n");
+		break;
+	case 2:
+		if (Cvar_VariableValue(Cmd_Argv(1)))
+			Cvar_Set (Cmd_Argv(1), "0");
+		else
+			Cvar_Set (Cmd_Argv(1), "1");
+		break;
+	}
+}
+
+/*
+============
+Cvar_Cycle_f -- johnfitz
+============
+*/
+void Cvar_Cycle_f (void)
+{
+	int i;
+
+	if (Cmd_Argc() < 3)
+	{
+		Con_Printf("cycle <cvar> <value list>: cycle cvar through a list of values\n");
+		return;
+	}
+
+	//loop through the args until you find one that matches the current cvar value.
+	//yes, this will get stuck on a list that contains the same value twice.
+	//it's not worth dealing with, and i'm not even sure it can be dealt with.
+	for (i = 2; i < Cmd_Argc(); i++)
+	{
+		//zero is assumed to be a string, even though it could actually be zero.  The worst case
+		//is that the first time you call this command, it won't match on zero when it should, but after that,
+		//it will be comparing strings that all had the same source (the user) so it will work.
+		if (Q_atof(Cmd_Argv(i)) == 0)
+		{
+			if (!strcmp(Cmd_Argv(i), Cvar_VariableString(Cmd_Argv(1))))
+				break;
+		}
+		else
+		{
+			if (Q_atof(Cmd_Argv(i)) == Cvar_VariableValue(Cmd_Argv(1)))
+				break;
+		}
+	}
+
+	if (i == Cmd_Argc())
+		Cvar_Set (Cmd_Argv(1), Cmd_Argv(2)); // no match
+	else if (i + 1 == Cmd_Argc())
+		Cvar_Set (Cmd_Argv(1), Cmd_Argv(2)); // matched last value in list
+	else
+		Cvar_Set (Cmd_Argv(1), Cmd_Argv(i+1)); // matched earlier in list
+}
+
+/*
+============
+Cvar_Reset_f -- johnfitz
+============
+*/
+void Cvar_Reset_f (void)
+{
+	switch (Cmd_Argc())
+	{
+	default:
+	case 1:
+		Con_Printf ("reset <cvar> : reset cvar to default\n");
+		break;
+	case 2:
+		Cvar_Reset (Cmd_Argv(1));
+		break;
+	}
+}
+
+/*
+============
+Cvar_ResetAll_f -- johnfitz
+============
+*/
+void Cvar_ResetAll_f (void)
+{
+	cvar_t	*var;
+
+	for (var = cvar_vars ; var ; var = var->next)
+		Cvar_Reset (var->name);
+}
+
+/*
+============
+Cvar_ResetCfg_f -- QuakeSpasm
+============
+*/
+void Cvar_ResetCfg_f (void)
+{
+	cvar_t	*var;
+
+	for (var = cvar_vars ; var ; var = var->next)
+		if (var->flags & CVAR_ARCHIVE) Cvar_Reset (var->name);
+}
+
+//==============================================================================
+//
+//  INIT
+//
+//==============================================================================
+
+/*
+============
+Cvar_Init -- johnfitz
+============
+*/
+
+void Cvar_Init (void)
+{
+	Cmd_AddCommand ("cvarlist", Cvar_List_f);
+	Cmd_AddCommand ("toggle", Cvar_Toggle_f);
+	Cmd_AddCommand ("cycle", Cvar_Cycle_f);
+	Cmd_AddCommand ("inc", Cvar_Inc_f);
+	Cmd_AddCommand ("reset", Cvar_Reset_f);
+	Cmd_AddCommand ("resetall", Cvar_ResetAll_f);
+	Cmd_AddCommand ("resetcfg", Cvar_ResetCfg_f);
+}
+
+//==============================================================================
+//
+//  CVAR FUNCTIONS
+//
+//==============================================================================
+
+/*
+============
+Cvar_FindVar
+============
+*/
+cvar_t *Cvar_FindVar (const char *var_name)
+{
+	cvar_t	*var;
+
+	for (var = cvar_vars ; var ; var = var->next)
+	{
+		if (!Q_strcmp(var_name, var->name))
+			return var;
+	}
+
+	return NULL;
+}
+
+cvar_t *Cvar_FindVarAfter (const char *prev_name, unsigned int with_flags)
+{
+	cvar_t	*var;
+
+	if (*prev_name)
+	{
+		var = Cvar_FindVar (prev_name);
+		if (!var)
+			return NULL;
+		var = var->next;
+	}
+	else
+		var = cvar_vars;
+
+	// search for the next cvar matching the needed flags
+	while (var)
+	{
+		if ((var->flags & with_flags) || !with_flags)
+			break;
+		var = var->next;
+	}
+	return var;
+}
+
+/*
+============
+Cvar_LockVar
+============
+*/
+void Cvar_LockVar (const char *var_name)
+{
+	cvar_t	*var = Cvar_FindVar (var_name);
+	if (var)
+		var->flags |= CVAR_LOCKED;
+}
+
+void Cvar_UnlockVar (const char *var_name)
+{
+	cvar_t	*var = Cvar_FindVar (var_name);
+	if (var)
+		var->flags &= ~CVAR_LOCKED;
+}
+
+void Cvar_UnlockAll (void)
+{
+	cvar_t	*var;
+
+	for (var = cvar_vars ; var ; var = var->next)
+	{
+		var->flags &= ~CVAR_LOCKED;
+	}
+}
+
+/*
+============
+Cvar_VariableValue
+============
+*/
+float	Cvar_VariableValue (const char *var_name)
+{
+	cvar_t	*var;
+
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return 0;
+	return Q_atof (var->string);
+}
+
+
+/*
+============
+Cvar_VariableString
+============
+*/
+const char *Cvar_VariableString (const char *var_name)
+{
+	cvar_t *var;
+
+	var = Cvar_FindVar (var_name);
+	if (!var)
+		return cvar_null_string;
+	return var->string;
+}
+
+
+/*
+============
+Cvar_CompleteVariable
+============
+*/
+const char *Cvar_CompleteVariable (const char *partial)
+{
+	cvar_t	*cvar;
+	int	len;
+
+	len = Q_strlen(partial);
+	if (!len)
+		return NULL;
+
+// check functions
+	for (cvar = cvar_vars ; cvar ; cvar = cvar->next)
+	{
+		if (!Q_strncmp(partial, cvar->name, len))
+			return cvar->name;
+	}
+
+	return NULL;
+}
+
+/*
+============
+Cvar_Reset -- johnfitz
+============
+*/
+void Cvar_Reset (const char *name)
+{
+	cvar_t	*var;
+
+	var = Cvar_FindVar (name);
+	if (!var)
+		Con_Printf ("variable \"%s\" not found\n", name);
+	else
+		Cvar_SetQuick (var, var->default_string);
+}
+
+void Cvar_SetQuick (cvar_t *var, const char *value)
+{
+	if (var->flags & (CVAR_ROM|CVAR_LOCKED))
+		return;
+	if (!(var->flags & CVAR_REGISTERED))
+		return;
+
+	if (!var->string)
+		var->string = Z_Strdup (value);
+	else
+	{
+		int	len;
+
+		if (!strcmp(var->string, value))
+			return;	// no change
+
+		var->flags |= CVAR_CHANGED;
+		len = Q_strlen (value);
+		if (len != Q_strlen(var->string))
+		{
+			Z_Free ((void *)var->string);
+			var->string = (char *) Z_Malloc (len + 1);
+		}
+		memcpy ((char *)var->string, value, len + 1);
+	}
+
+	var->value = Q_atof (var->string);
+
+	//johnfitz -- save initial value for "reset" command
+	if (!var->default_string)
+		var->default_string = Z_Strdup (var->string);
+	//johnfitz -- during initialization, update default too
+	else if (!host_initialized)
+	{
+	//	Sys_Printf("changing default of %s: %s -> %s\n",
+	//		   var->name, var->default_string, var->string);
+		Z_Free ((void *)var->default_string);
+		var->default_string = Z_Strdup (var->string);
+	}
+	//johnfitz
+
+	if (var->callback)
+		var->callback (var);
+}
+
+void Cvar_SetValueQuick (cvar_t *var, const float value)
+{
+	char	val[32], *ptr = val;
+
+	if (value == (float)((int)value))
+		q_snprintf (val, sizeof(val), "%i", (int)value);
+	else
+	{
+		q_snprintf (val, sizeof(val), "%f", value);
+		// kill trailing zeroes
+		while (*ptr)
+			ptr++;
+		while (--ptr > val && *ptr == '0' && ptr[-1] != '.')
+			*ptr = '\0';
+	}
+
+	Cvar_SetQuick (var, val);
+}
+
+/*
+============
+Cvar_Set
+============
+*/
+void Cvar_Set (const char *var_name, const char *value)
+{
+	cvar_t		*var;
+
+	var = Cvar_FindVar (var_name);
+	if (!var)
+	{	// there is an error in C code if this happens
+		Con_Printf ("Cvar_Set: variable %s not found\n", var_name);
+		return;
+	}
+
+	Cvar_SetQuick (var, value);
+}
+
+/*
+============
+Cvar_SetValue
+============
+*/
+void Cvar_SetValue (const char *var_name, const float value)
+{
+	char	val[32], *ptr = val;
+
+	if (value == (float)((int)value))
+		q_snprintf (val, sizeof(val), "%i", (int)value);
+	else
+	{
+		q_snprintf (val, sizeof(val), "%f", value);
+		// kill trailing zeroes
+		while (*ptr)
+			ptr++;
+		while (--ptr > val && *ptr == '0' && ptr[-1] != '.')
+			*ptr = '\0';
+	}
+
+	Cvar_Set (var_name, val);
+}
+
+/*
+============
+Cvar_SetROM
+============
+*/
+void Cvar_SetROM (const char *var_name, const char *value)
+{
+	cvar_t *var = Cvar_FindVar (var_name);
+	if (var)
+	{
+		var->flags &= ~CVAR_ROM;
+		Cvar_SetQuick (var, value);
+		var->flags |= CVAR_ROM;
+	}
+}
+
+/*
+============
+Cvar_SetValueROM
+============
+*/
+void Cvar_SetValueROM (const char *var_name, const float value)
+{
+	cvar_t *var = Cvar_FindVar (var_name);
+	if (var)
+	{
+		var->flags &= ~CVAR_ROM;
+		Cvar_SetValueQuick (var, value);
+		var->flags |= CVAR_ROM;
+	}
+}
+
+/*
+============
+Cvar_RegisterVariable
+
+Adds a freestanding variable to the variable list.
+============
+*/
+void Cvar_RegisterVariable (cvar_t *variable)
+{
+	char	value[512];
+	qboolean	set_rom;
+	cvar_t	*cursor,*prev; //johnfitz -- sorted list insert
+
+// first check to see if it has already been defined
+	if (Cvar_FindVar (variable->name))
+	{
+		Con_Printf ("Can't register variable %s, already defined\n", variable->name);
+		return;
+	}
+
+// check for overlap with a command
+	if (Cmd_Exists (variable->name))
+	{
+		Con_Printf ("Cvar_RegisterVariable: %s is a command\n", variable->name);
+		return;
+	}
+
+// link the variable in
+	//johnfitz -- insert each entry in alphabetical order
+	if (cvar_vars == NULL ||
+	    strcmp(variable->name, cvar_vars->name) < 0) // insert at front
+	{
+		variable->next = cvar_vars;
+		cvar_vars = variable;
+	}
+	else //insert later
+	{
+		prev = cvar_vars;
+		cursor = cvar_vars->next;
+		while (cursor && (strcmp(variable->name, cursor->name) > 0))
+		{
+			prev = cursor;
+			cursor = cursor->next;
+		}
+		variable->next = prev->next;
+		prev->next = variable;
+	}
+	//johnfitz
+	variable->flags |= CVAR_REGISTERED;
+
+// copy the value off, because future sets will Z_Free it
+	q_strlcpy (value, variable->string, sizeof(value));
+	variable->string = NULL;
+	variable->default_string = NULL;
+
+	if (!(variable->flags & CVAR_CALLBACK))
+		variable->callback = NULL;
+
+// set it through the function to be consistent
+	set_rom = (variable->flags & CVAR_ROM);
+	variable->flags &= ~CVAR_ROM;
+	Cvar_SetQuick (variable, value);
+	if (set_rom)
+		variable->flags |= CVAR_ROM;
+}
+
+/*
+============
+Cvar_SetCallback
+
+Set a callback function to the var
+============
+*/
+void Cvar_SetCallback (cvar_t *var, cvarcallback_t func)
+{
+	var->callback = func;
+	if (func)
+		var->flags |= CVAR_CALLBACK;
+	else	var->flags &= ~CVAR_CALLBACK;
+}
+
+/*
+============
+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)
+	{
+		Con_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
+		return true;
+	}
+
+	Cvar_Set (v->name, Cmd_Argv(1));
+	return true;
+}
+
+
+/*
+============
+Cvar_WriteVariables
+
+Writes lines containing "set variable value" for all variables
+with the archive flag set to true.
+============
+*/
+void Cvar_WriteVariables (FILE *f)
+{
+	cvar_t	*var;
+
+	for (var = cvar_vars ; var ; var = var->next)
+	{
+		if (var->flags & CVAR_ARCHIVE)
+			fprintf (f, "%s \"%s\"\n", var->name, var->string);
+	}
+}
+