Quack 3

2025-06-10 11:59:58 -05:00 · 2024-09-25 15:39:25 -05:00
parent e8bd66b89c
commit 0bf99969fd
86 changed files with 51093 additions and 0 deletions
--- a/qcommon/cmd.c
+++ b/qcommon/cmd.c
@@ -0,0 +1,892 @@
+/*
+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.
+
+*/
+// cmd.c -- Quake script command processing module
+
+#include "qcommon.h"
+
+void Cmd_ForwardToServer (void);
+
+#define	MAX_ALIAS_NAME	32
+
+typedef struct cmdalias_s
+{
+	struct cmdalias_s	*next;
+	char	name[MAX_ALIAS_NAME];
+	char	*value;
+} cmdalias_t;
+
+cmdalias_t	*cmd_alias;
+
+qboolean	cmd_wait;
+
+#define	ALIAS_LOOP_COUNT	16
+int		alias_count;		// for detecting runaway loops
+
+
+//=============================================================================
+
+/*
+============
+Cmd_Wait_f
+
+Causes execution of the remainder of the command buffer to be delayed until
+next frame.  This allows commands like:
+bind g "impulse 5 ; +attack ; wait ; -attack ; impulse 2"
+============
+*/
+void Cmd_Wait_f (void)
+{
+	cmd_wait = true;
+}
+
+
+/*
+=============================================================================
+
+						COMMAND BUFFER
+
+=============================================================================
+*/
+
+sizebuf_t	cmd_text;
+byte		cmd_text_buf[8192];
+
+byte		defer_text_buf[8192];
+
+/*
+============
+Cbuf_Init
+============
+*/
+void Cbuf_Init (void)
+{
+	SZ_Init (&cmd_text, cmd_text_buf, sizeof(cmd_text_buf));
+}
+
+/*
+============
+Cbuf_AddText
+
+Adds command text at the end of the buffer
+============
+*/
+void Cbuf_AddText (char *text)
+{
+	int		l;
+	
+	l = strlen (text);
+
+	if (cmd_text.cursize + l >= cmd_text.maxsize)
+	{
+		Com_Printf ("Cbuf_AddText: overflow\n");
+		return;
+	}
+	SZ_Write (&cmd_text, text, strlen (text));
+}
+
+
+/*
+============
+Cbuf_InsertText
+
+Adds command text immediately after the current command
+Adds a \n to the text
+FIXME: actually change the command buffer to do less copying
+============
+*/
+void Cbuf_InsertText (char *text)
+{
+	char	*temp;
+	int		templen;
+
+// copy off any commands still remaining in the exec buffer
+	templen = cmd_text.cursize;
+	if (templen)
+	{
+		temp = Z_Malloc (templen);
+		memcpy (temp, cmd_text.data, templen);
+		SZ_Clear (&cmd_text);
+	}
+	else
+		temp = NULL;	// shut up compiler
+		
+// add the entire text of the file
+	Cbuf_AddText (text);
+	
+// add the copied off data
+	if (templen)
+	{
+		SZ_Write (&cmd_text, temp, templen);
+		Z_Free (temp);
+	}
+}
+
+
+/*
+============
+Cbuf_CopyToDefer
+============
+*/
+void Cbuf_CopyToDefer (void)
+{
+	memcpy(defer_text_buf, cmd_text_buf, cmd_text.cursize);
+	defer_text_buf[cmd_text.cursize] = 0;
+	cmd_text.cursize = 0;
+}
+
+/*
+============
+Cbuf_InsertFromDefer
+============
+*/
+void Cbuf_InsertFromDefer (void)
+{
+	Cbuf_InsertText (defer_text_buf);
+	defer_text_buf[0] = 0;
+}
+
+
+/*
+============
+Cbuf_ExecuteText
+============
+*/
+void Cbuf_ExecuteText (int exec_when, char *text)
+{
+	switch (exec_when)
+	{
+	case EXEC_NOW:
+		Cmd_ExecuteString (text);
+		break;
+	case EXEC_INSERT:
+		Cbuf_InsertText (text);
+		break;
+	case EXEC_APPEND:
+		Cbuf_AddText (text);
+		break;
+	default:
+		Com_Error (ERR_FATAL, "Cbuf_ExecuteText: bad exec_when");
+	}
+}
+
+/*
+============
+Cbuf_Execute
+============
+*/
+void Cbuf_Execute (void)
+{
+	int		i;
+	char	*text;
+	char	line[1024];
+	int		quotes;
+
+	alias_count = 0;		// don't allow infinite alias loops
+
+	while (cmd_text.cursize)
+	{
+// find a \n or ; line break
+		text = (char *)cmd_text.data;
+
+		quotes = 0;
+		for (i=0 ; i< cmd_text.cursize ; i++)
+		{
+			if (text[i] == '"')
+				quotes++;
+			if ( !(quotes&1) &&  text[i] == ';')
+				break;	// don't break if inside a quoted string
+			if (text[i] == '\n')
+				break;
+		}
+			
+				
+		memcpy (line, text, i);
+		line[i] = 0;
+		
+// delete the text from the command buffer and move remaining commands down
+// this is necessary because commands (exec, alias) can insert data at the
+// beginning of the text buffer
+
+		if (i == cmd_text.cursize)
+			cmd_text.cursize = 0;
+		else
+		{
+			i++;
+			cmd_text.cursize -= i;
+			memmove (text, text+i, cmd_text.cursize);
+		}
+
+// execute the command line
+		Cmd_ExecuteString (line);
+		
+		if (cmd_wait)
+		{
+			// skip out while text still remains in buffer, leaving it
+			// for next frame
+			cmd_wait = false;
+			break;
+		}
+	}
+}
+
+
+/*
+===============
+Cbuf_AddEarlyCommands
+
+Adds command line parameters as script statements
+Commands lead with a +, and continue until another +
+
+Set commands are added early, so they are guaranteed to be set before
+the client and server initialize for the first time.
+
+Other commands are added late, after all initialization is complete.
+===============
+*/
+void Cbuf_AddEarlyCommands (qboolean clear)
+{
+	int		i;
+	char	*s;
+
+	for (i=0 ; i<COM_Argc() ; i++)
+	{
+		s = COM_Argv(i);
+		if (strcmp (s, "+set"))
+			continue;
+		Cbuf_AddText (va("set %s %s\n", COM_Argv(i+1), COM_Argv(i+2)));
+		if (clear)
+		{
+			COM_ClearArgv(i);
+			COM_ClearArgv(i+1);
+			COM_ClearArgv(i+2);
+		}
+		i+=2;
+	}
+}
+
+/*
+=================
+Cbuf_AddLateCommands
+
+Adds command line parameters as script statements
+Commands lead with a + and continue until another + or -
+quake +vid_ref gl +map amlev1
+
+Returns true if any late commands were added, which
+will keep the demoloop from immediately starting
+=================
+*/
+qboolean Cbuf_AddLateCommands (void)
+{
+	int		i, j;
+	int		s;
+	char	*text, *build, c;
+	int		argc;
+	qboolean	ret;
+
+// build the combined string to parse from
+	s = 0;
+	argc = COM_Argc();
+	for (i=1 ; i<argc ; i++)
+	{
+		s += strlen (COM_Argv(i)) + 1;
+	}
+	if (!s)
+		return false;
+		
+	text = Z_Malloc (s+1);
+	text[0] = 0;
+	for (i=1 ; i<argc ; i++)
+	{
+		strcat (text,COM_Argv(i));
+		if (i != argc-1)
+			strcat (text, " ");
+	}
+	
+// pull out the commands
+	build = Z_Malloc (s+1);
+	build[0] = 0;
+	
+	for (i=0 ; i<s-1 ; i++)
+	{
+		if (text[i] == '+')
+		{
+			i++;
+
+			for (j=i ; (text[j] != '+') && (text[j] != '-') && (text[j] != 0) ; j++)
+				;
+
+			c = text[j];
+			text[j] = 0;
+			
+			strcat (build, text+i);
+			strcat (build, "\n");
+			text[j] = c;
+			i = j-1;
+		}
+	}
+
+	ret = (build[0] != 0);
+	if (ret)
+		Cbuf_AddText (build);
+	
+	Z_Free (text);
+	Z_Free (build);
+
+	return ret;
+}
+
+
+/*
+==============================================================================
+
+						SCRIPT COMMANDS
+
+==============================================================================
+*/
+
+
+/*
+===============
+Cmd_Exec_f
+===============
+*/
+void Cmd_Exec_f (void)
+{
+	char	*f, *f2;
+	int		len;
+
+	if (Cmd_Argc () != 2)
+	{
+		Com_Printf ("exec <filename> : execute a script file\n");
+		return;
+	}
+
+	len = FS_LoadFile (Cmd_Argv(1), (void **)&f);
+	if (!f)
+	{
+		Com_Printf ("couldn't exec %s\n",Cmd_Argv(1));
+		return;
+	}
+	Com_Printf ("execing %s\n",Cmd_Argv(1));
+	
+	// the file doesn't have a trailing 0, so we need to copy it off
+	f2 = Z_Malloc(len+1);
+	memcpy (f2, f, len);
+	f2[len] = 0;
+
+	Cbuf_InsertText (f2);
+
+	Z_Free (f2);
+	FS_FreeFile (f);
+}
+
+
+/*
+===============
+Cmd_Echo_f
+
+Just prints the rest of the line to the console
+===============
+*/
+void Cmd_Echo_f (void)
+{
+	int		i;
+	
+	for (i=1 ; i<Cmd_Argc() ; i++)
+		Com_Printf ("%s ",Cmd_Argv(i));
+	Com_Printf ("\n");
+}
+
+/*
+===============
+Cmd_Alias_f
+
+Creates a new command that executes a command string (possibly ; seperated)
+===============
+*/
+void Cmd_Alias_f (void)
+{
+	cmdalias_t	*a;
+	char		cmd[1024];
+	int			i, c;
+	char		*s;
+
+	if (Cmd_Argc() == 1)
+	{
+		Com_Printf ("Current alias commands:\n");
+		for (a = cmd_alias ; a ; a=a->next)
+			Com_Printf ("%s : %s\n", a->name, a->value);
+		return;
+	}
+
+	s = Cmd_Argv(1);
+	if (strlen(s) >= MAX_ALIAS_NAME)
+	{
+		Com_Printf ("Alias name is too long\n");
+		return;
+	}
+
+	// if the alias already exists, reuse it
+	for (a = cmd_alias ; a ; a=a->next)
+	{
+		if (!strcmp(s, a->name))
+		{
+			Z_Free (a->value);
+			break;
+		}
+	}
+
+	if (!a)
+	{
+		a = Z_Malloc (sizeof(cmdalias_t));
+		a->next = cmd_alias;
+		cmd_alias = a;
+	}
+	strcpy (a->name, s);	
+
+// copy the rest of the command line
+	cmd[0] = 0;		// start out with a null string
+	c = Cmd_Argc();
+	for (i=2 ; i< c ; i++)
+	{
+		strcat (cmd, Cmd_Argv(i));
+		if (i != (c - 1))
+			strcat (cmd, " ");
+	}
+	strcat (cmd, "\n");
+	
+	a->value = CopyString (cmd);
+}
+
+/*
+=============================================================================
+
+					COMMAND EXECUTION
+
+=============================================================================
+*/
+
+typedef struct cmd_function_s
+{
+	struct cmd_function_s	*next;
+	char					*name;
+	xcommand_t				function;
+} cmd_function_t;
+
+
+static	int			cmd_argc;
+static	char		*cmd_argv[MAX_STRING_TOKENS];
+static	char		*cmd_null_string = "";
+static	char		cmd_args[MAX_STRING_CHARS];
+
+static	cmd_function_t	*cmd_functions;		// possible commands to execute
+
+/*
+============
+Cmd_Argc
+============
+*/
+int		Cmd_Argc (void)
+{
+	return cmd_argc;
+}
+
+/*
+============
+Cmd_Argv
+============
+*/
+char	*Cmd_Argv (int arg)
+{
+	if ( (unsigned)arg >= cmd_argc )
+		return cmd_null_string;
+	return cmd_argv[arg];	
+}
+
+/*
+============
+Cmd_Args
+
+Returns a single string containing argv(1) to argv(argc()-1)
+============
+*/
+char		*Cmd_Args (void)
+{
+	return cmd_args;
+}
+
+
+/*
+======================
+Cmd_MacroExpandString
+======================
+*/
+char *Cmd_MacroExpandString (char *text)
+{
+	int		i, j, count, len;
+	qboolean	inquote;
+	char	*scan;
+	static	char	expanded[MAX_STRING_CHARS];
+	char	temporary[MAX_STRING_CHARS];
+	char	*token, *start;
+
+	inquote = false;
+	scan = text;
+
+	len = strlen (scan);
+	if (len >= MAX_STRING_CHARS)
+	{
+		Com_Printf ("Line exceeded %i chars, discarded.\n", MAX_STRING_CHARS);
+		return NULL;
+	}
+
+	count = 0;
+
+	for (i=0 ; i<len ; i++)
+	{
+		if (scan[i] == '"')
+			inquote ^= 1;
+		if (inquote)
+			continue;	// don't expand inside quotes
+		if (scan[i] != '$')
+			continue;
+		// scan out the complete macro
+		start = scan+i+1;
+		token = COM_Parse (&start);
+		if (!start)
+			continue;
+	
+		token = Cvar_VariableString (token);
+
+		j = strlen(token);
+		len += j;
+		if (len >= MAX_STRING_CHARS)
+		{
+			Com_Printf ("Expanded line exceeded %i chars, discarded.\n", MAX_STRING_CHARS);
+			return NULL;
+		}
+
+		strncpy (temporary, scan, i);
+		strcpy (temporary+i, token);
+		strcpy (temporary+i+j, start);
+
+		strcpy (expanded, temporary);
+		scan = expanded;
+		i--;
+
+		if (++count == 100)
+		{
+			Com_Printf ("Macro expansion loop, discarded.\n");
+			return NULL;
+		}
+	}
+
+	if (inquote)
+	{
+		Com_Printf ("Line has unmatched quote, discarded.\n");
+		return NULL;
+	}
+
+	return scan;
+}
+
+
+/*
+============
+Cmd_TokenizeString
+
+Parses the given string into command line tokens.
+$Cvars will be expanded unless they are in a quoted token
+============
+*/
+void Cmd_TokenizeString (char *text, qboolean macroExpand)
+{
+	int		i;
+	char	*com_token;
+
+// clear the args from the last string
+	for (i=0 ; i<cmd_argc ; i++)
+		Z_Free (cmd_argv[i]);
+		
+	cmd_argc = 0;
+	cmd_args[0] = 0;
+	
+	// macro expand the text
+	if (macroExpand)
+		text = Cmd_MacroExpandString (text);
+	if (!text)
+		return;
+
+	while (1)
+	{
+// skip whitespace up to a /n
+		while (*text && *text <= ' ' && *text != '\n')
+		{
+			text++;
+		}
+		
+		if (*text == '\n')
+		{	// a newline seperates commands in the buffer
+			text++;
+			break;
+		}
+
+		if (!*text)
+			return;
+
+		// set cmd_args to everything after the first arg
+		if (cmd_argc == 1)
+		{
+			int		l;
+
+			strcpy (cmd_args, text);
+
+			// strip off any trailing whitespace
+			l = strlen(cmd_args) - 1;
+			for ( ; l >= 0 ; l--)
+				if (cmd_args[l] <= ' ')
+					cmd_args[l] = 0;
+				else
+					break;
+		}
+			
+		com_token = COM_Parse (&text);
+		if (!text)
+			return;
+
+		if (cmd_argc < MAX_STRING_TOKENS)
+		{
+			cmd_argv[cmd_argc] = Z_Malloc (strlen(com_token)+1);
+			strcpy (cmd_argv[cmd_argc], com_token);
+			cmd_argc++;
+		}
+	}
+	
+}
+
+
+/*
+============
+Cmd_AddCommand
+============
+*/
+void	Cmd_AddCommand (char *cmd_name, xcommand_t function)
+{
+	cmd_function_t	*cmd;
+	
+// fail if the command is a variable name
+	if (Cvar_VariableString(cmd_name)[0])
+	{
+		Com_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
+		return;
+	}
+	
+// fail if the command already exists
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
+	{
+		if (!strcmp (cmd_name, cmd->name))
+		{
+			Com_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
+			return;
+		}
+	}
+
+	cmd = Z_Malloc (sizeof(cmd_function_t));
+	cmd->name = cmd_name;
+	cmd->function = function;
+	cmd->next = cmd_functions;
+	cmd_functions = cmd;
+}
+
+/*
+============
+Cmd_RemoveCommand
+============
+*/
+void	Cmd_RemoveCommand (char *cmd_name)
+{
+	cmd_function_t	*cmd, **back;
+
+	back = &cmd_functions;
+	while (1)
+	{
+		cmd = *back;
+		if (!cmd)
+		{
+			Com_Printf ("Cmd_RemoveCommand: %s not added\n", cmd_name);
+			return;
+		}
+		if (!strcmp (cmd_name, cmd->name))
+		{
+			*back = cmd->next;
+			Z_Free (cmd);
+			return;
+		}
+		back = &cmd->next;
+	}
+}
+
+/*
+============
+Cmd_Exists
+============
+*/
+qboolean	Cmd_Exists (char *cmd_name)
+{
+	cmd_function_t	*cmd;
+
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
+	{
+		if (!strcmp (cmd_name,cmd->name))
+			return true;
+	}
+
+	return false;
+}
+
+
+
+/*
+============
+Cmd_CompleteCommand
+============
+*/
+char *Cmd_CompleteCommand (char *partial)
+{
+	cmd_function_t	*cmd;
+	int				len;
+	cmdalias_t		*a;
+	
+	len = strlen(partial);
+	
+	if (!len)
+		return NULL;
+		
+// check for exact match
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
+		if (!strcmp (partial,cmd->name))
+			return cmd->name;
+	for (a=cmd_alias ; a ; a=a->next)
+		if (!strcmp (partial, a->name))
+			return a->name;
+
+// check for partial match
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
+		if (!strncmp (partial,cmd->name, len))
+			return cmd->name;
+	for (a=cmd_alias ; a ; a=a->next)
+		if (!strncmp (partial, a->name, len))
+			return a->name;
+
+	return NULL;
+}
+
+
+/*
+============
+Cmd_ExecuteString
+
+A complete command line has been parsed, so try to execute it
+FIXME: lookupnoadd the token to speed search?
+============
+*/
+void	Cmd_ExecuteString (char *text)
+{	
+	cmd_function_t	*cmd;
+	cmdalias_t		*a;
+
+	Cmd_TokenizeString (text, true);
+			
+	// execute the command line
+	if (!Cmd_Argc())
+		return;		// no tokens
+
+	// check functions
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next)
+	{
+		if (!Q_strcasecmp (cmd_argv[0],cmd->name))
+		{
+			if (!cmd->function)
+			{	// forward to server command
+				Cmd_ExecuteString (va("cmd %s", text));
+			}
+			else
+				cmd->function ();
+			return;
+		}
+	}
+
+	// check alias
+	for (a=cmd_alias ; a ; a=a->next)
+	{
+		if (!Q_strcasecmp (cmd_argv[0], a->name))
+		{
+			if (++alias_count == ALIAS_LOOP_COUNT)
+			{
+				Com_Printf ("ALIAS_LOOP_COUNT\n");
+				return;
+			}
+			Cbuf_InsertText (a->value);
+			return;
+		}
+	}
+	
+	// check cvars
+	if (Cvar_Command ())
+		return;
+
+	// send it as a server command if we are connected
+	Cmd_ForwardToServer ();
+}
+
+/*
+============
+Cmd_List_f
+============
+*/
+void Cmd_List_f (void)
+{
+	cmd_function_t	*cmd;
+	int				i;
+
+	i = 0;
+	for (cmd=cmd_functions ; cmd ; cmd=cmd->next, i++)
+		Com_Printf ("%s\n", cmd->name);
+	Com_Printf ("%i commands\n", i);
+}
+
+/*
+============
+Cmd_Init
+============
+*/
+void Cmd_Init (void)
+{
+//
+// register our commands
+//
+	Cmd_AddCommand ("cmdlist",Cmd_List_f);
+	Cmd_AddCommand ("exec",Cmd_Exec_f);
+	Cmd_AddCommand ("echo",Cmd_Echo_f);
+	Cmd_AddCommand ("alias",Cmd_Alias_f);
+	Cmd_AddCommand ("wait", Cmd_Wait_f);
+}
+