qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quakeforge/libs/util/cmd.c

1061 lines
20 KiB
C
Raw Blame History

/*
cmd.c
script command processing module
Copyright (C) 1996-1997 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:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
*/
static const char rcsid[] =
"$Id$";
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <ctype.h>
#include "QF/cmd.h"
#include "QF/cvar.h"
#include "QF/hash.h"
#include "QF/qargs.h"
#include "QF/qendian.h"
#include "QF/sizebuf.h"
#include "QF/sys.h"
#include "QF/vfs.h"
#include "QF/zone.h"
#include "compat.h"
typedef struct cmdalias_s {
struct cmdalias_s *next;
const char *name;
const char *value;
} cmdalias_t;
cmdalias_t *cmd_alias;
cmd_source_t cmd_source;
qboolean cmd_wait;
cvar_t *cmd_warncmd;
hashtab_t *cmd_alias_hash;
hashtab_t *cmd_hash;
//=============================================================================
/*
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];
void
Cbuf_Init (void)
{
cmd_text.data = cmd_text_buf;
cmd_text.maxsize = sizeof (cmd_text_buf);
}
/*
Cbuf_AddText
Adds command text at the end of the buffer
*/
void
Cbuf_AddText (const char *text)
{
int l;
l = strlen (text);
if (cmd_text.cursize + l >= cmd_text.maxsize) {
Sys_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
TODO: Can we just read the buffer in the reverse order?
*/
void
Cbuf_InsertText (const char *text)
{
int textlen;
textlen = strlen (text);
if (cmd_text.cursize + 1 + textlen >= cmd_text.maxsize) {
Sys_Printf ("Cbuf_InsertText: overflow\n");
return;
}
if (!cmd_text.cursize) {
memcpy (cmd_text.data, text, textlen);
cmd_text.cursize = textlen;
return;
}
// Move up to make room for inserted text
memmove (cmd_text.data + textlen + 1, cmd_text.data, cmd_text.cursize);
cmd_text.cursize += textlen + 1;
// Insert new text
memcpy (cmd_text.data, text, textlen);
cmd_text.data[textlen] = '\n';
}
static void
extract_line (char *line)
{
int i;
char *text;
int quotes;
// 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' || text[i] == '\r')
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;
memcpy (text, text + i, cmd_text.cursize);
}
}
void
Cbuf_Execute (void)
{
char line[1024] = { 0 };
while (cmd_text.cursize) {
extract_line (line);
// execute the command line
// Sys_DPrintf("+%s\n",line),
Cmd_ExecuteString (line, src_command);
if (cmd_wait) { // skip out while text still remains
// in buffer, leaving it
// for next frame
cmd_wait = false;
break;
}
}
}
void
Cbuf_Execute_Sets (void)
{
char line[1024] = { 0 };
while (cmd_text.cursize) {
extract_line (line);
// execute the command line
if (strnequal (line, "set", 3) && isspace ((int) line[3])) {
// Sys_DPrintf ("+%s\n",line);
Cmd_ExecuteString (line, src_command);
} else if (strnequal (line, "setrom", 6) && isspace ((int) line[6])) {
// Sys_DPrintf ("+%s\n",line);
Cmd_ExecuteString (line, src_command);
}
}
}
/*
SCRIPT COMMANDS
*/
/*
Cmd_StuffCmds_f
Adds command line parameters as script statements
Commands lead with a +, and continue until a - or another +
quake +prog jctest.qp +cmd amlev1
quake -nosound +cmd amlev1
*/
void
Cmd_StuffCmds_f (void)
{
int i, j;
int s;
char *build, c;
s = strlen (com_cmdline);
if (!s)
return;
// pull out the commands
build = malloc (s + 1);
build[0] = 0;
for (i = 0; i < s - 1; i++) {
if (com_cmdline[i] == '+') {
i++;
for (j = i; !((com_cmdline[j] == '+')
|| (com_cmdline[j] == '-'
&& (j==0 || com_cmdline[j - 1] == ' '))
|| (com_cmdline[j] == 0)); j++);
c = com_cmdline[j];
com_cmdline[j] = 0;
strncat (build, com_cmdline + i, s - strlen (build));
strncat (build, "\n", s - strlen (build));
com_cmdline[j] = c;
i = j - 1;
}
}
// Sys_Printf("[\n%s]\n",build);
if (build[0])
Cbuf_InsertText (build);
free (build);
}
void
Cmd_Exec_File (const char *path)
{
char *f;
int len;
VFile *file;
if (!path || !*path)
return;
if ((file = Qopen (path, "r")) != NULL) {
len = COM_filelength (file);
f = (char *) Hunk_TempAlloc (len + 1);
if (f) {
f[len] = 0;
Qread (file, f, len);
Qclose (file);
Cbuf_InsertText (f);
}
}
}
void
Cmd_Exec_f (void)
{
char *f;
int mark;
if (Cmd_Argc () != 2) {
Sys_Printf ("exec <filename> : execute a script file\n");
return;
}
// FIXME: is this safe freeing the hunk here?
mark = Hunk_LowMark ();
f = (char *) COM_LoadHunkFile (Cmd_Argv (1));
if (!f) {
Sys_Printf ("couldn't exec %s\n", Cmd_Argv (1));
return;
}
if (!Cvar_Command () && (cmd_warncmd->int_val
|| (developer && developer->int_val)))
Sys_Printf ("execing %s\n", Cmd_Argv (1));
Cbuf_InsertText (f);
Hunk_FreeToLowMark (mark);
}
/*
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++)
Sys_Printf ("%s ", Cmd_Argv (i));
Sys_Printf ("\n");
}
/*
Cmd_Alias_f
Creates a new command that executes a command string (possibly ; seperated)
*/
char *
CopyString (char *in)
{
char *out;
out = malloc (strlen (in) + 1);
strcpy (out, in);
return out;
}
void
Cmd_Alias_f (void)
{
cmdalias_t *alias;
char *cmd;
int i, c;
const char *s;
if (Cmd_Argc () == 1) {
Sys_Printf ("Current alias commands:\n");
for (alias = cmd_alias; alias; alias = alias->next)
Sys_Printf ("%s : %s\n", alias->name, alias->value);
return;
}
s = Cmd_Argv (1);
// if the alias already exists, reuse it
alias = (cmdalias_t*)Hash_Find (cmd_alias_hash, s);
if (alias) {
free ((char*)alias->value);
} else {
cmdalias_t **a;
alias = calloc (1, sizeof (cmdalias_t));
alias->name = strdup (s);
Hash_Add (cmd_alias_hash, alias);
for (a = &cmd_alias; *a; a = &(*a)->next)
if (strcmp ((*a)->name, alias->name) >=0)
break;
alias->next = *a;
*a = alias;
}
// copy the rest of the command line
cmd = malloc (strlen (Cmd_Args (1)) + 2);// can never be longer
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, " ");
}
strncat (cmd, "\n", sizeof (cmd) - strlen (cmd));
alias->value = cmd;
}
void
Cmd_UnAlias_f (void)
{
cmdalias_t *alias;
const char *s;
if (Cmd_Argc () != 2) {
Sys_Printf ("unalias <alias>: erase an existing alias\n");
return;
}
s = Cmd_Argv (1);
alias = Hash_Del (cmd_alias_hash, s);
if (alias) {
cmdalias_t **a;
for (a = &cmd_alias; *a != alias; a = &(*a)->next)
;
*a = alias->next;
free ((char*)alias->name);
free ((char*)alias->value);
free (alias);
} else {
Sys_Printf ("Unknown alias \"%s\"\n", s);
}
}
/*
COMMAND EXECUTION
*/
typedef struct cmd_function_s {
struct cmd_function_s *next;
const char *name;
xcommand_t function;
const char *description;
} cmd_function_t;
#define MAX_ARGS 80
static int cmd_argc;
static char *cmd_argv[MAX_ARGS];
static const char *cmd_null_string = "";
static const char *cmd_args[MAX_ARGS];
static cmd_function_t *cmd_functions; // possible commands to execute
int
Cmd_Argc (void)
{
return cmd_argc;
}
const char *
Cmd_Argv (int arg)
{
if (arg >= cmd_argc)
return cmd_null_string;
return cmd_argv[arg];
}
/*
Cmd_Args
Returns a single string containing argv(1) to argv(argc()-1)
*/
const char *
Cmd_Args (int start)
{
if (start >= cmd_argc || !cmd_args[start])
return "";
return cmd_args[start];
}
/*
Cmd_TokenizeString
Parses the given string into command line tokens.
*/
void
Cmd_TokenizeString (const char *text)
{
static char argv_buf[1024];
int argv_idx;
argv_idx = 0;
cmd_argc = 0;
memset (cmd_args, 0, sizeof (cmd_args));
while (1) {
// skip whitespace up to a \n
while (*text && *(unsigned char *) text <= ' ' && *text != '\n') {
text++;
}
if (*text == '\n') { // a newline seperates commands in
// the buffer
text++;
break;
}
if (!*text)
return;
if (cmd_argc < MAX_ARGS)
cmd_args[cmd_argc] = text;
text = COM_Parse (text);
if (!text)
return;
if (cmd_argc < MAX_ARGS) {
if (argv_idx + strlen (com_token) + 1 > MAX_COM_TOKEN) {
Sys_Printf ("Cmd_TokenizeString: overflow\n");
return;
}
cmd_argv[cmd_argc] = argv_buf + argv_idx;
strcpy (cmd_argv[cmd_argc], com_token);
argv_idx += strlen (com_token) + 1;
cmd_argc++;
}
}
}
void
Cmd_AddCommand (const char *cmd_name, xcommand_t function, const char *description)
{
cmd_function_t *cmd;
cmd_function_t **c;
// fail if the command is a variable name
if (Cvar_FindVar (cmd_name)) {
Sys_Printf ("Cmd_AddCommand: %s already defined as a var\n", cmd_name);
return;
}
// fail if the command already exists
cmd = (cmd_function_t*)Hash_Find (cmd_hash, cmd_name);
if (cmd) {
Sys_Printf ("Cmd_AddCommand: %s already defined\n", cmd_name);
return;
}
cmd = malloc (sizeof (cmd_function_t));
cmd->name = cmd_name;
cmd->function = function;
cmd->description = description;
Hash_Add (cmd_hash, cmd);
for (c = &cmd_functions; *c; c = &(*c)->next)
if (strcmp ((*c)->name, cmd->name) >=0)
break;
cmd->next = *c;
*c = cmd;
}
qboolean
Cmd_Exists (const char *cmd_name)
{
cmd_function_t *cmd;
cmd = (cmd_function_t*)Hash_Find (cmd_hash, cmd_name);
if (cmd) {
return true;
}
return false;
}
const char *
Cmd_CompleteCommand (const 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 (!strcasecmp (partial, cmd->name))
return cmd->name;
for (a = cmd_alias; a; a = a->next)
if (!strcasecmp (partial, a->name))
return a->name;
// check for partial match
for (cmd = cmd_functions; cmd; cmd = cmd->next)
if (!strncasecmp (partial, cmd->name, len))
return cmd->name;
for (a = cmd_alias; a; a = a->next)
if (!strncasecmp (partial, a->name, len))
return a->name;
return NULL;
}
/*
Cmd_CompleteCountPossible
New function for tab-completion system
Added by EvilTypeGuy
Thanks to Fett erich@heintz.com
Thanks to taniwha
*/
int
Cmd_CompleteCountPossible (const char *partial)
{
cmd_function_t *cmd;
int len;
int h;
h = 0;
len = strlen(partial);
if (!len)
return 0;
// Loop through the command list and count all partial matches
for (cmd = cmd_functions; cmd; cmd = cmd->next)
if (!strncasecmp(partial, cmd->name, len))
h++;
return h;
}
/*
Cmd_CompleteBuildList
New function for tab-completion system
Added by EvilTypeGuy
Thanks to Fett erich@heintz.com
Thanks to taniwha
*/
const char **
Cmd_CompleteBuildList (const char *partial)
{
cmd_function_t *cmd;
int len = 0;
int bpos = 0;
int sizeofbuf = (Cmd_CompleteCountPossible (partial) + 1) * sizeof (char *);
const char **buf;
len = strlen(partial);
buf = malloc(sizeofbuf + sizeof (char *));
// Loop through the alias list and print all matches
for (cmd = cmd_functions; cmd; cmd = cmd->next)
if (!strncasecmp(partial, cmd->name, len))
buf[bpos++] = cmd->name;
buf[bpos] = NULL;
return buf;
}
/*
Cmd_CompleteAlias
New function for tab-completion system
Added by EvilTypeGuy
Thanks to Fett erich@heintz.com
Thanks to taniwha
*/
const char *
Cmd_CompleteAlias (const char * partial)
{
cmdalias_t *alias;
int len;
len = strlen(partial);
if (!len)
return NULL;
// Check functions
for (alias = cmd_alias; alias; alias = alias->next)
if (!strncasecmp(partial, alias->name, len))
return alias->name;
return NULL;
}
/*
Cmd_CompleteAliasCountPossible
New function for tab-completion system
Added by EvilTypeGuy
Thanks to Fett erich@heintz.com
Thanks to taniwha
*/
int
Cmd_CompleteAliasCountPossible (const char *partial)
{
cmdalias_t *alias;
int len;
int h;
h = 0;
len = strlen(partial);
if (!len)
return 0;
// Loop through the command list and count all partial matches
for (alias = cmd_alias; alias; alias = alias->next)
if (!strncasecmp(partial, alias->name, len))
h++;
return h;
}
/*
Cmd_CompleteAliasBuildList
New function for tab-completion system
Added by EvilTypeGuy
Thanks to Fett erich@heintz.com
Thanks to taniwha
*/
const char **
Cmd_CompleteAliasBuildList (const char *partial)
{
cmdalias_t *alias;
int len = 0;
int bpos = 0;
int sizeofbuf = (Cmd_CompleteAliasCountPossible (partial) + 1) *
sizeof (char *);
const char **buf;
len = strlen(partial);
buf = malloc(sizeofbuf + sizeof (char *));
// Loop through the alias list and print all matches
for (alias = cmd_alias; alias; alias = alias->next)
if (!strncasecmp(partial, alias->name, len))
buf[bpos++] = alias->name;
buf[bpos] = NULL;
return buf;
}
/*
Cmd_ExpandVariables
Expand $fov-like expressions
FIXME: better handling of buffer overflows?
*/
// dest must point to a 1024-byte buffer
void
Cmd_ExpandVariables (const char *data, char *dest)
{
unsigned int c;
char buf[1024];
int i, len;
cvar_t *var, *bestvar;
int quotes = 0;
len = 0;
// parse a regular word
while ((c = *data) != 0) {
if (c == '"')
quotes++;
if (c == '$' && !(quotes & 1)) {
data++;
// Copy the text after '$' to a temp buffer
i = 0;
buf[0] = 0;
bestvar = NULL;
while ((c = *data) > 32) {
if (c == '$')
break;
data++;
buf[i++] = c;
buf[i] = 0;
if ((var = Cvar_FindVar (buf)) != 0)
bestvar = var;
if (i >= sizeof (buf) - 1)
break;
}
if (bestvar) {
// check buffer size
if (len + strlen (bestvar->string) >= 1024 - 1)
break;
strcpy (&dest[len], bestvar->string);
len += strlen (bestvar->string);
i = strlen (bestvar->name);
while (buf[i])
dest[len++] = buf[i++];
} else {
// no matching cvar name was found
dest[len++] = '$';
if (len + strlen (buf) >= 1024 - 1)
break;
strcpy (&dest[len], buf);
len += strlen (buf);
}
} else {
dest[len] = c;
data++;
len++;
if (len >= 1024 - 1)
break;
}
};
dest[len] = 0;
}
/*
Cmd_ExecuteString
A complete command line has been parsed, so try to execute it
FIXME: lookupnoadd the token to speed search?
*/
void
Cmd_ExecuteString (const char *text, cmd_source_t src)
{
cmd_function_t *cmd;
cmdalias_t *a;
char buf[1024];
cmd_source = src;
#if 0
Cmd_TokenizeString (text);
#else
Cmd_ExpandVariables (text, buf);
Cmd_TokenizeString (buf);
#endif
// execute the command line
if (!Cmd_Argc ())
return; // no tokens
// check functions
cmd = (cmd_function_t*)Hash_Find (cmd_hash, cmd_argv[0]);
if (cmd) {
if (cmd->function)
cmd->function ();
return;
}
// Tonik: check cvars
if (Cvar_Command ())
return;
// check alias
a = (cmdalias_t*)Hash_Find (cmd_alias_hash, cmd_argv[0]);
if (a) {
Cbuf_InsertText (a->value);
return;
}
if (cmd_warncmd->int_val || developer->int_val)
Sys_Printf ("Unknown command \"%s\"\n", Cmd_Argv (0));
}
/*
Cmd_CheckParm
Returns the position (1 to argc-1) in the command's argument list
where the given parameter apears, or 0 if not present
*/
int
Cmd_CheckParm (const char *parm)
{
int i;
if (!parm)
Sys_Error ("Cmd_CheckParm: NULL");
for (i = 1; i < Cmd_Argc (); i++)
if (!strcasecmp (parm, Cmd_Argv (i)))
return i;
return 0;
}
void
Cmd_CmdList_f (void)
{
cmd_function_t *cmd;
int i;
int show_description = 0;
if (Cmd_Argc() > 1)
show_description = 1;
for (cmd = cmd_functions, i = 0; cmd; cmd = cmd->next, i++) {
if (show_description) {
Sys_Printf ("%-20s :\n%s\n", cmd->name, cmd->description);
} else {
Sys_Printf ("%s\n", cmd->name);
}
}
Sys_Printf ("------------\n%d commands\n", i);
}
void
Cmd_Help_f (void)
{
const char *name;
cvar_t *var;
cmd_function_t *cmd;
if (Cmd_Argc () != 2) {
Sys_Printf ("usage: help <cvar/command>\n");
return;
}
name = Cmd_Argv (1);
for (cmd = cmd_functions; cmd && strcasecmp (name, cmd->name);
cmd = cmd->next)
;
if (cmd) {
Sys_Printf ("%s\n", cmd->description);
return;
}
var = Cvar_FindVar (name);
if (!var)
var = Cvar_FindAlias (name);
if (var) {
Sys_Printf ("%s\n", var->description);
return;
}
Sys_Printf ("variable/command not found\n");
}
static void
cmd_alias_free (void *_a, void *unused)
{
cmdalias_t *a = (cmdalias_t*)_a;
free ((char*)a->name);
free ((char*)a->value);
free (a);
}
static const char *
cmd_alias_get_key (void *_a, void *unused)
{
cmdalias_t *a = (cmdalias_t*)_a;
return a->name;
}
static const char *
cmd_get_key (void *c, void *unused)
{
cmd_function_t *cmd = (cmd_function_t*)c;
return cmd->name;
}
/*
Cmd_Init_Hash
initialise the command and alias hash tables
*/
void
Cmd_Init_Hash (void)
{
cmd_hash = Hash_NewTable (1021, cmd_get_key, 0, 0);
cmd_alias_hash = Hash_NewTable (1021, cmd_alias_get_key, cmd_alias_free,
0);
}
void
Cmd_Init (void)
{
// register our commands
Cmd_AddCommand ("stuffcmds", Cmd_StuffCmds_f, "Execute the commands given "
"at startup again");
Cmd_AddCommand ("exec", Cmd_Exec_f, "Execute a script file");
Cmd_AddCommand ("echo", Cmd_Echo_f, "Print text to console");
Cmd_AddCommand ("alias", Cmd_Alias_f, "Used to create a reference to a "
"command or list of commands.\n"
"When used without parameters, displays all current "
"aliases.\n"
"Note: Enclose multiple commands within quotes and "
"seperate each command with a semi-colon.");
Cmd_AddCommand ("unalias", Cmd_UnAlias_f, "Remove the selected alias");
Cmd_AddCommand ("wait", Cmd_Wait_f, "Wait a game tic");
Cmd_AddCommand ("cmdlist", Cmd_CmdList_f, "List all commands");
Cmd_AddCommand ("help", Cmd_Help_f, "Display help for a command or "
"variable");
cmd_warncmd = Cvar_Get ("cmd_warncmd", "1", CVAR_NONE, NULL, "Toggles the "
"display of error messages for unknown commands");
}
char com_token[MAX_COM_TOKEN];
/*
COM_Parse
Parse a token out of a string
*/
const char *
COM_Parse (const char *data)
{
unsigned int c;
int len;
len = 0;
com_token[0] = 0;
if (!data)
return NULL;
// skip whitespace
skipwhite:
while ((c = *data) <= ' ') {
if (c == 0)
return NULL; // end of file;
data++;
}
// skip // comments
if (c == '/' && data[1] == '/') {
while (*data && *data != '\n')
data++;
goto skipwhite;
}
// handle quoted strings specially
if (c == '\"') {
data++;
while (1) {
c = *data++;
if (c == '\"' || !c) {
com_token[len] = 0;
return data;
}
com_token[len] = c;
len++;
}
}
// parse a regular word
do {
com_token[len] = c;
data++;
len++;
if (len >= MAX_COM_TOKEN - 1)
break;
c = *data;
} while (c > 32);
com_token[len] = 0;
return data;
}
Reference in New Issue View Git Blame Copy Permalink