libretro-tyrquake/NQ/cmd.c

/*
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 the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// cmd.c -- Quake script command processing module

#include "client.h"
#include "cmd.h"
#include "common.h"
#include "console.h"
#include "host.h"
#include "protocol.h"
#include "quakedef.h"
#include "shell.h"
#include "sys.h"
#include "zone.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;

//=============================================================================

/*
============
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

=============================================================================
*/

static sizebuf_t cmd_text;

/*
============
Cbuf_Init
============
*/
void
Cbuf_Init(void)
{
    SZ_Alloc(&cmd_text, 8192);	// space for commands and script files
}


/*
============
Cbuf_AddText

Adds command text at the end of the buffer
============
*/
void
Cbuf_AddText(const char *text)
{
    int l = strlen(text);

    if (cmd_text.cursize + l < cmd_text.maxsize)
	SZ_Write(&cmd_text, text, l);
    else
	Con_Printf("Cbuf_AddText: overflow\n");
}


/*
============
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);
    SZ_Write(&cmd_text, "\n", 1);

// add the copied off data
    if (templen) {
	SZ_Write(&cmd_text, temp, templen);
	Z_Free(temp);
    }
}

/*
============
Cbuf_Execute
============
*/
void
Cbuf_Execute(void)
{
    int i;
    char *text;
    char line[1024];
    int quotes;

    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;
	    memcpy(text, text + i, cmd_text.cursize);
	}

	/* execute the command 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;
	}
    }
}

/*
==============================================================================

				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 *text, *build, c;

    if (Cmd_Argc() != 1) {
	Con_Printf("stuffcmds : execute command line parameters\n");
	return;
    }
// build the combined string to parse from
    s = 0;
    for (i = 1; i < com_argc; i++) {
	if (!com_argv[i])
	    continue;		// NEXTSTEP nulls out -NXHost
	s += strlen(com_argv[i]) + 1;
    }
    if (!s)
	return;

    text = Z_Malloc(s + 1);
    text[0] = 0;
    for (i = 1; i < com_argc; i++) {
	if (!com_argv[i])
	    continue;		// NEXTSTEP nulls out -NXHost
	strcat(text, com_argv[i]);
	if (i != com_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;
	}
    }

    if (build[0])
	Cbuf_InsertText(build);

    Z_Free(text);
    Z_Free(build);
}


/*
===============
Cmd_Exec_f
===============
*/
void
Cmd_Exec_f(void)
{
    char *f;
    int mark;

    if (Cmd_Argc() != 2) {
	Con_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) {
	Con_Printf("couldn't exec %s\n", Cmd_Argv(1));
	return;
    }
    Con_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++)
	Con_Printf("%s ", Cmd_Argv(i));
    Con_Printf("\n");
}

/*
===============
Cmd_Alias_f

Creates a new command that executes a command string (possibly ; seperated)
===============
*/

char *
CopyString(char *in)
{
    char *out;

    out = Z_Malloc(strlen(in) + 1);
    strcpy(out, in);
    return out;
}

void
Cmd_Alias_f(void)
{
    cmdalias_t *a;
    char cmd[1024];
    int i, c;
    char *s;

    if (Cmd_Argc() == 1) {
	Con_Printf("Current alias commands:\n");
	for (a = cmd_alias; a; a = a->next)
	    Con_Printf("%s : %s\n", a->name, a->value);
	return;
    }

    s = Cmd_Argv(1);
    if (strlen(s) >= MAX_ALIAS_NAME) {
	Con_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);
	insert_alias_completion(a->name);
    }

// 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)
	    strcat(cmd, " ");
    }
    strcat(cmd, "\n");

    a->value = CopyString(cmd);
}

/*
=============================================================================

				COMMAND EXECUTION

=============================================================================
*/

typedef struct cmd_function_s {
    struct cmd_function_s *next;
    const char *name;
    xcommand_t function;
    cmd_arg_f completion;
} cmd_function_t;


#define	MAX_ARGS		80

static int cmd_argc;
static char *cmd_argv[MAX_ARGS];
static char *cmd_null_string = "";
static char *cmd_args = NULL;

cmd_source_t cmd_source;

static cmd_function_t *cmd_functions;	// possible commands to execute

/*
============
Cmd_Init
============
*/
void
Cmd_Init(void)
{
//
// register our commands
//
    Cmd_AddCommand("stuffcmds", Cmd_StuffCmds_f);
    Cmd_AddCommand("exec", Cmd_Exec_f);
    Cmd_AddCommand("echo", Cmd_Echo_f);
    Cmd_AddCommand("alias", Cmd_Alias_f);
    Cmd_AddCommand("cmd", Cmd_ForwardToServer);
    Cmd_AddCommand("wait", Cmd_Wait_f);
}

/*
============
Cmd_Argc
============
*/
int
Cmd_Argc(void)
{
    return cmd_argc;
}

/*
============
Cmd_Argv
============
*/
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)
============
*/
char *
Cmd_Args(void)
{
    // FIXME - check necessary?
    if (!cmd_args)
	return "";
    return cmd_args;
}


/*
============
Cmd_TokenizeString

Parses the given string into command line tokens.
============
*/
void
Cmd_TokenizeString(char *text)
{
    int i;

// clear the args from the last string
    for (i = 0; i < cmd_argc; i++)
	Z_Free(cmd_argv[i]);

    cmd_argc = 0;
    cmd_args = NULL;

    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;

	if (cmd_argc == 1)
	    cmd_args = text;

	text = COM_Parse(text);
	if (!text)
	    return;

	if (cmd_argc < MAX_ARGS) {
	    cmd_argv[cmd_argc] = Z_Malloc(strlen(com_token) + 1);
	    strcpy(cmd_argv[cmd_argc], com_token);
	    cmd_argc++;
	}
    }

}

// ---------------------------------------------------------------------------

/*
============
Cmd_AddCommand
============
*/
void
Cmd_AddCommand(const char *cmd_name, xcommand_t function)
{
    cmd_function_t *cmd;

    if (host_initialized)	// because hunk allocation would get stomped
	Sys_Error("%s: called after host_initialized", __func__);

// fail if the command is a variable name
    if (Cvar_VariableString(cmd_name)[0]) {
	Con_Printf("%s: %s already defined as a var\n", __func__, cmd_name);
	return;
    }
// fail if the command already exists
    for (cmd = cmd_functions; cmd; cmd = cmd->next) {
	if (!strcmp(cmd_name, cmd->name)) {
	    Con_Printf("%s: %s already defined\n", __func__, cmd_name);
	    return;
	}
    }

    cmd = Hunk_Alloc(sizeof(cmd_function_t));
    cmd->name = cmd_name;
    cmd->function = function;
    cmd->completion = NULL;
    cmd->next = cmd_functions;
    cmd_functions = cmd;

    insert_command_completion(cmd_name);
}

void
Cmd_SetCompletion(const char *cmd_name, cmd_arg_f completion)
{
    cmd_function_t *cmd;

    for (cmd = cmd_functions; cmd; cmd = cmd->next)
	if (!strcmp(cmd_name, cmd->name)) {
	    cmd->completion = completion;
	    break;
	}
    if (!cmd)
	Sys_Error("%s: no such command - %s", __func__, cmd_name);
}

/*
============
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_ForwardToServer

Sends the entire command line over to the server
===================
*/
void
Cmd_ForwardToServer(void)
{
    if (cls.state < ca_connected) {
	Con_Printf("Can't \"%s\", not connected\n", Cmd_Argv(0));
	return;
    }

    if (cls.demoplayback)
	return;			// not really connected

    MSG_WriteByte(&cls.message, clc_stringcmd);
    if (strcasecmp(Cmd_Argv(0), "cmd") != 0) {
	SZ_Print(&cls.message, Cmd_Argv(0));
	SZ_Print(&cls.message, " ");
    }
    if (Cmd_Argc() > 1)
	SZ_Print(&cls.message, Cmd_Args());
    else
	SZ_Print(&cls.message, "\n");
}


/*
============
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_source_t src)
{
    cmd_function_t *cmd;
    cmdalias_t *a;

    cmd_source = src;
    Cmd_TokenizeString(text);

// execute the command line
    if (!Cmd_Argc())
	return;			// no tokens

// check functions
    for (cmd = cmd_functions; cmd; cmd = cmd->next) {
	if (!strcasecmp(cmd_argv[0], cmd->name)) {
	    cmd->function();
	    return;
	}
    }

// check alias
    for (a = cmd_alias; a; a = a->next) {
	if (!strcasecmp(cmd_argv[0], a->name)) {
	    Cbuf_InsertText(a->value);
	    return;
	}
    }

// check cvars
    if (!Cvar_Command())
	Con_Printf("Unknown command \"%s\"\n", Cmd_Argv(0));
}

/*
 * Return a string tree with all possible argument completions of the given
 * buffer for the given command.
 */
struct rb_string_root *
Cmd_ArgCompletions(const char *name, const char *buf)
{
    cmd_function_t *cmd;
    struct rb_string_root *root = NULL;

    for (cmd = cmd_functions; cmd; cmd = cmd->next) {
	if (!strcasecmp(name, cmd->name) && cmd->completion) {
	    /* FIXME - ST_AllocInit? */
	    root = cmd->completion(buf);
	    break;
	}
    }

    return root;
}

/*
 * Call the argument completion function for cmd "name".
 * Returned result should be Z_Free'd after use.
 */
char *
Cmd_ArgComplete(const char *name, const char *buf)
{
    char *result = NULL;
    struct rb_string_root *root;

    root = Cmd_ArgCompletions(name, buf);
    if (root) {
	result = ST_MaxMatch(root, buf);
	Z_Free(root);
    }

    return result;
}


/*
================
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(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;
}