/*
 * COMMANDS.C
 *
 * This module contains all the command parsing stuff used to parse the
 * commands in the script file.
 *
 */

#ifndef LATTICE_50
#include "system.h"
#endif

#include "bbsindex.h"

/*
 *		The list of command names and associated functions
 */

void com_append(), com_close(), com_config(), com_database(), com_echo(),
	 com_exec(), com_format(), com_list(), com_macro(), com_msg(),
	 com_open(), com_reset(), com_scan(), com_trace(), com_ignore();

struct {
	char *name;
	void (*proc)();
} com[] = {

	{	"APPEND",		com_append		},
	{	"CHECKFILES",	com_checkfiles	},
	{	"CLOSE",		com_close		},
	{	"CONFIG",		com_config		},
	{	"DATABASE",		com_database	},
	{	"ECHO",			com_echo		},
	{	"EXEC",			com_exec		},
	{	"FOREIGN",		com_foreign		},
	{	"FORMAT",		com_format		},
	{	"IGNORE",		com_ignore		},
	{	"LIST",			com_list		},
	{	"MACRO",		com_macro		},
	{	"MSG",			com_msg			},
	{	"NOREQUEST",	com_norequest	},
	{	"OPEN",			com_open		},
	{	"RESET",		com_reset		},
	{	"SCAN",			com_scan		},
	{	"SELECT",		com_select		},
	{	"SORT",			com_sort		},
	{	"TRACE",		com_trace		},
	{	NULL,			NULL			} 
};

struct constval {
	struct constval *next;
	char *name;
	char *value;
};
typedef struct constval CONST;

CONST *firstconst = NULL;		/* Pointer to first constant on list	*/

static char line[MAXCOM];	/* Temporary line buffer */

/*
 *		scripterror()
 *		-------------
 *		Prints an error message for the current script command; the filename
 *		and linenumber are automatically output, followed by the user
 *		specified message. The message should be terminated with a NL,
 *		unless the caller intends outputting any more info afterwards.
 */
void scripterror(s)
char *s;
{
	print3("===> ", scriptname, " (");
	print3(itoa(linenum), "): ",s);
}

/*
 *		addconst()
 *		--------
 *		Creates a new constant entry, and links it into the list of 
 *		existing constant definitions. The name of the constant is
 *		initialised appropriately. A pointer to the constant is returned.
 */
CONST *addconst(name)
char *name;
{
	CONST *tv;

	tv			= mymalloc(sizeof(CONST));
	tv->next	= firstconst;
	firstconst	= tv;
	tv->name	= mymalloc(strlen(name)+1);
	strcpy(tv->name, name);
	return (tv);
}

/*
 *		findconst()
 *		---------
 *		Searches constant table for specified constant, and returns a
 *		pointer to it if found, or NULL if not found.
 */
CONST *findconst(name)
char *name;
{
	CONST *tv;

	for (tv = firstconst; tv && stricmp(name, tv->name); tv = tv->next)
		;
	return (tv);
}


/*
 *		readcommand()
 *		-------------
 *		This function reads a command from the script buffer into a
 *		specified command buffer. The following modifications are made
 *		to the original script text:
 *
 *		- Anything after a # to an end of line is ignored
 *		- Any line ending with \ is continued on the next line
 *		- Everything outside quotes is capitalised.
 *		- Any white space outside quotes gets reduced to a single space
 *		- White space surrounding command lines is removed.
 *		- Any commas on the line are removed, and replaced by spaces
 *
 *		The script command is terminated by either a semicolon or a newline.
 *		The command buffer is null-terminated on return. When the end of the
 *		script is reached, a 0 is returned. The maximum size of the command
 *		line is specified in max - if this is exceeded, then an error message
 *		is generated. Normally, the length of the command line read in is
 *		returned.
 *
 *		For the technically minded, a mini state machine is setup, to handle
 *		the different requirements.
 */

#define STATE_START		1	/* Skip over space at start of command			*/
#define STATE_SPACE		2	/* Replace multiple white space by single space	*/
#define STATE_COPY		3	/* Copy normal text, capitalising				*/
#define STATE_IGNORE	4	/* If next char is newline, then skip it		*/
#define STATE_QUOTE		5	/* Copy text up until next quote				*/
#define STATE_IGQUOTE	6	/* Like STATE_IGNORE, but between quotes		*/
#define STATE_COMMENT	7	/* Ignore everything until the next newline		*/
#define STATE_CONST_ST	8	/* Starting to expand a constant $(..)			*/
#define STATE_CONST_CP  9	/* Copying constant name, and expanding it		*/

/*
 *		Retrieve next character from script buffer, updating line counter
 *		and checking for end of buffer.
 */
#define nextchar(ch) 									\
	(	(ch) = script[scriptpos++],				 		\
	 	((ch) == CHAR_NL ? linenum++ : 0),				\
	 	((scriptpos > scriptsize) ? (loop = 0) : 0) 	\
	)

/*
 *		Add character to command line, checking for end of buffer and
 *		aborting if the buffer is overrun.
 */
#define addchar(ch)										\
	(	buf[pos++] = (ch),								\
		((pos > max) ? (scripterror("line too long\n"), Cleanup(10)) : 0)	\
	)

int readcommand(buf,max)
char *buf;
int max;
{
	int pos = 0;
	int state = STATE_START;
	int laststate;
	int loop = 1;
	int ch;
	CONST *var;
	char varname[MAXCONST], *p;
	char openquote;
	int varpos;

	if (scriptpos >= scriptsize)
		return 0;

	nextchar(ch);
	while (loop) {
		switch (state) {

			case STATE_START:
				switch (ch) {

					case CHAR_SPACE:
					case CHAR_TAB:
					case CHAR_SEMI:
					case CHAR_NL:
					case CHAR_COMMA:
						nextchar(ch);
						break;

					case CHAR_HASH:
						state = STATE_COMMENT;
						break;

					default:
						state = STATE_COPY;
						break;
				}
				break;

			case STATE_SPACE:
				switch (ch) {

					case CHAR_SPACE:
					case CHAR_TAB:
					case CHAR_COMMA:
						nextchar(ch);
						break;

					case CHAR_NL:
						linenum--;
						/* Drop through */
					case CHAR_SEMI:
						scriptpos--;
						loop = 0;
						break;

					default:
						addchar(CHAR_SPACE);
						state = STATE_COPY;
						break;
				}
				break;

			case STATE_COPY:
				switch (ch) {

					/*
					 * If we get a # after a command, then we immediately
					 * stop, so that the comment will get eaten the NEXT
					 * time we call readcommand(). If we went into
					 * STATE_COMMENT, then the following command would end
					 * up getting read into the buffer as well.
					 *
					 */
					case CHAR_HASH:
						scriptpos--;
						loop = 0;
						break;

					case CHAR_QUOTE:
					case CHAR_QUOTES:
						addchar(ch);
						openquote = ch;
						state = STATE_QUOTE;
						nextchar(ch);
						break;

					case CHAR_DOLLAR:
						laststate = state;	/* Save return state */
						state = STATE_CONST_ST;
						nextchar(ch);
						break;

					case CHAR_NL:
						linenum--;
						/* Drop through */

					case CHAR_SEMI:
						loop = 0;
						scriptpos--;
						break;

					case CHAR_ESC:
						nextchar(ch);
						state = STATE_IGNORE;
						break;

					case CHAR_SPACE:
					case CHAR_TAB:
					case CHAR_COMMA:
						state = STATE_SPACE;
						break;

					default:
						addchar(toupper(ch));
						nextchar(ch);
						break;
				}
				break;

			case STATE_IGNORE:
				if (ch == CHAR_NL)
					ch = CHAR_SPACE;
				addchar(ch);
				nextchar(ch);
				state = STATE_COPY;
				break;

			case STATE_QUOTE:
				switch (ch) {

					case CHAR_NL:
						scriptpos--;
						linenum--;
						loop = 0;
						break;

					case CHAR_ESC:
						state = STATE_IGQUOTE;
						nextchar(ch);
						break;

					case CHAR_DOLLAR:
						laststate = state;
						state = STATE_CONST_ST;
						nextchar(ch);
						break;

					case CHAR_QUOTE:
					case CHAR_QUOTES:
						if (openquote == ch)
							state = STATE_COPY;
						/* Deliberate fall through to next switch */

					default:
						addchar(ch);
						nextchar(ch);
						break;
				}
				break;

			case STATE_IGQUOTE:
				if (ch != CHAR_NL) {
					addchar(CHAR_ESC);
					addchar(ch);
				}
				nextchar(ch);
				state = STATE_QUOTE;
				break;

			case STATE_COMMENT:
				if (ch == CHAR_NL)
					state = STATE_START;
				nextchar(ch);
				break;

			case STATE_CONST_ST:
				if (ch != '(') { /* If not a constant usage, copy unchanged */
					addchar(CHAR_DOLLAR);
					state = laststate;
					break;
				}
				varpos = 0;
				nextchar(ch);
				state = STATE_CONST_CP;
				break;

			case STATE_CONST_CP:
				if (ch == ')') {
					/*
					 *		Variable name has been fully entered, so now
					 *		expand it.
					 */
					varname[varpos] = CHAR_NULL;
					var = findconst(varname);
					if (!var) {
						scripterror("unknown constant ");
						print2(varname, ".\n");
						Cleanup(10);
					}
					for (p = var->value; *p; p++)
						addchar(*p);
					state = laststate;
				} else {
					/*
					 *		Else still gathering constant name, so keep
					 *		copying into array.
					 */
					if (varpos >= MAXCONST) {
						scripterror("constant name too long.\n");
						Cleanup(10);
					}
					varname[varpos++] = ch;
				}
				nextchar(ch);
				break;
		}
	}
	addchar(CHAR_NULL);	/* Null terminate command string */
	compos = 0;
	comlen = strlen(buf);
	return (comlen);
}

/*
 *		findmacro()
 *		-----------
 *		Searches the macro table for the specified macro. If found, returns
 *		pointer to the macro definition, else returns -1.
 */
int findmacro(name)
char *name;
{
	int i;

	for (i = 0; i < nummacros; i++)
		if (!strcmp(macros[i]->name, name))
			return (i);
	return (-1);
}

/*
 *		getstring()
 *		-----------
 *		This function scans the command buffer starting at position
 *		'compos', and returns a pointer to the next identifier/string in
 *		the buffer. The string is null-terminated, and if it was enclosed
 *		in quotes, these are removed. compos is left pointing to just after
 *		the string.
 */
char *getstring()
{
	char *s = combuf + compos;
	char *p, openquote;

	if (compos > comlen) {
		scripterror("missing parameter\n");
		Cleanup(10);
	}
	if (*s == CHAR_SPACE)
		s++;

	if (*s == CHAR_QUOTE || *s == CHAR_QUOTES) {
		openquote = *s++;
		for (p = s; *p && *p != openquote; p++) {
			if (*p == CHAR_ESC)
				p++;	/* Skip over possible escaped quotes */
		}
		*p = CHAR_NULL;
		compos = (p - combuf) + 1;
		return (s);
	}

	for (p = s; *p && *p != CHAR_SPACE; p++)
		;
	*p = CHAR_NULL;
	compos = (p - combuf) + 1;
	return (s);
}


/*
 *		execline()
 *		----------
 *		This function executes the current line in the command buffer,
 *		handling macro expansion as necessary.
 */
void execline()
{
	char *cmd;
	char *p, *s;
	char *equals;
	MACRO *curmac;
	CONST *var;
	int macronum;
	char *ps[10];
	PARAM *par;
	int length;
	int i;

	chkabort();
	if (tracemode) {
		if (nestlevel > 0) {
			int i;
			for (i = 0; i < nestlevel; i++)
				print("    ");
			print2(combuf, "\n");
		} else {
			print3(itoa(linenum), ":", scriptname);
			print3(": ", combuf, "\n");
		}
	}
	cmd = getstring();
	for (i = 0; com[i].name && strcmp(cmd, com[i].name); i++)
		;
	if (com[i].name) {
		/*
		 *		A valid command was found, so execute it
		 */
		com[i].proc();
	} else if ((macronum = findmacro(cmd)) == -1) {
		/*
		 *		Not a macro -- is it a constant definition?
		 */
		if (compos < comlen) {
			/*
			 *		There's a parameter after it; check is it an equals sign
			 */
			equals = getstring();
			if (equals[0] != CHAR_EQUALS || equals[1] != CHAR_NULL) {
				/*
				 *		Wasn't an equals, so probably just a wrong command
				 *		with some superfluous parameters.
				 */
				scripterror("unknown command ");
				print2(cmd, "\n");
				Cleanup(10);
			}
			/*
			 *		Okay, it's a constant definition. If it's already been
			 *		defined, print a warning but carry on anyway.
			 */
			var = findconst(cmd);
			if (var) {
				scripterror("constant ");
				print2(cmd, " redefined.\n");
			} else
				var = addconst(cmd);
			/*
			 *		Now see was a value specified for the constant.
			 *		If it was, copy it into constant, else just 
			 *		setup a null definition.
			 */
			if (compos < comlen) {
				/*
				 *		Copy user's definition
				 */
				cmd = getstring();
				if (strlen(cmd) >= MAXCONST) {
					scripterror("constant name too long.\n");
					Cleanup(10);
				}
				var->value = mymalloc(strlen(cmd)+1);
				strcpy(var->value, cmd);
			} else {
				/*
				 *		Setup null constant definition
				 */
				var->value = mymalloc(1);
				strcpy(var->value, "");
			}
		} else {
			/*
			 *		Not a command, not a macro, not a constant definition.
			 *		Therefore, must be an error.
			 */
			scripterror("unknown command ");
			print2(cmd, "\n");
			Cleanup(10);
		}
	} else {
		/*
		 *		It's a macro. Save a copy of the macro parameters into
		 *		$0 to $9, and then execute each line of the macro definition,
		 *		expanding parameter usages as necessary.
		 */
		curmac = macros[macronum];
		length = 0;
		if (nestlevel >= MAXNEST) {
			scripterror("macros can only be nested ");
			print2(MAXNEST, " deep\n");
			Cleanup(10);
		}
		par = SafeAllocMem(PARAMSIZE + comlen + 1);
		params[nestlevel++] = par;
		par->size = comlen + 1;

		/*
		 *		Now initialise parameters $0 to $9
		 */
		ps[0] = par->params;
		for (i = 1; i < 10; i++) {
			if (compos < comlen)
				/* Save parameter for later */
				ps[i] = par->params + (getstring() - combuf);
			else
				ps[i] = NULL;
		}
		memcpy(par->params, combuf, comlen+1);

		/*
		 *		Now recursively call execline() with command buffer setup
		 *		to be the current macro buffer line.
		 */
		length = 0;
		s = curmac->text;
		for (length = 0; length < curmac->size;
						length += strlen(s) + 1, s = curmac->text + length) {
			/* Copy macro line into buffer, doing expansion */
			comlen = 0;
			for (p = s; *p; p++) {
				if (*p == '$') {
					p++;
					if (!*p) {
						scripterror("'$' must be followed by something\n");
						Cleanup(10);
					}
					if (isdigit(*p)) {
						int num = *p - '0';

						if (ps[num]) {
							/* Copy macro definition */
							if ((strlen(ps[num]) + comlen) >= MAXCOM - 10)
								goto endcommand;	/* Eek! my first C Goto! */
							strcpy(combuf+comlen, ps[num]);
							comlen += strlen(ps[num]);
						}
						continue;

					}
				}
				combuf[comlen++] = *p;
			}
endcommand:
			combuf[comlen] = CHAR_NULL;
			compos = 0;
			execline();
		}
		/*
		 *		Now free memory allocated for macro parameters
		 */
		FreeMem(par, PARAMSIZE + par->size);
		nestlevel--;
	}
}


/*
 *		execscript()
 *		------------
 *		This function goes through all the commands in the script file,
 *		executing them one by one. Each command is parsed, and then
 *		the appropriate function called. Any errors that occur cause the
 *		script to be aborted, so if this call returns, the script was
 *		successfully executed.
 */
void execscript()
{
	while (readcommand(combuf, MAXCOM))
		execline();
}

/*
 *		====> Now the actual commands follow <====
 */

/*
 *		com_append()
 *		------------
 *		This file opens the specified file for appending. If there was
 *		already a file open, it is closed.
 */

void com_append()
{
	char *filename = getstring();
	BPTR lock;

	com_close();

	if (lock = Lock(filename, ACCESS_READ)) {
		UnLock(lock);
		outfile = Open(filename, MODE_OLDFILE);
	} else
		outfile = Open(filename, MODE_NEWFILE);

	if (!outfile) {
		scripterror("error appending to file ");
		print2(filename, "\n");
		Cleanup(10);
	}
	Seek(outfile, 0, OFFSET_END);
	toscreen = IsInteractive(outfile);
}

/*
 *		com_open()
 *		----------
 *		This command opens a file for output. The output of the ECHO,
 *		FOREIGN and LIST commands goes to this file. If an output file
 *		was already open, it is closed first.
 */
void com_open()
{
	char *filename = getstring();

	com_close();
	outfile = Open(filename, MODE_NEWFILE);
	if (!outfile) {
		scripterror("error opening file ");
		print2(filename, "\n");
		Cleanup(10);
	}
	toscreen = IsInteractive(outfile);
}

/*
 *		com_close()
 *		-----------
 *		Closes the current output file, if any. All future output goes to
 *		stdout.
 */
void com_close()
{
	if (outfile != Output()) {
		flushout();
		Close(outfile);
		outfile = Output();
		toscreen = IsInteractive(outfile);
	}
}

/*
 *		com_config()
 *		------------
 *		This command sets the name of the configuration file used by
 *		CHECKFILES to get the names of the directories to scan from.
 */
void com_config()
{
	strcpy(configname, getstring());
}

/*
 *		com_database()
 *		--------------
 *		This command sets the name of the database file read in
 *		which contains the details of all the file headers.
 */
void com_database()
{
	strcpy(databasename, getstring());
}

/*
 *		com_norequest()
 *		---------------
 *		This command stops AmigaDos from putting up requesters when an
 *		error occurs, or a volume isn't mounted. 
 */
void com_norequest()
{
	struct Process *me = (struct Process *)FindTask(0L);
	me->pr_WindowPtr = (APTR)-1L;
}

/*
 *		com_echo()
 *		----------
 *		This command echoes the specified string to the output file.
 *		A number of meta characters may be present in the string to be
 *		output. See the documentation for more info. If any other parameter
 *		is present on the line after the string, no newline is added
 *		to the output, otherwise a newline is added automatically.
 *
 */
void com_echo()
{
	strcpy(line, getstring());
	if (compos >= comlen) 	/* Add NL if no second parameter */
		strcat(line, "\n");
	putstring(echoformat(out, MAXOUT, line));
}

/*
 *		com_exec()
 *		----------
 *		This command executes the indicated AmigaDOS command. The output
 *		from the command goes into the current output file, if any.
 */
void com_exec()
{
	flushout();
	Execute(getstring(), NULL, outfile);
}

/*
 *		com_format()
 *		------------
 *		This command sets up the format string used by LIST and FOREIGN.
 *		For details of what the format may contain, see the documentation.
 */
void com_format()
{
	strcpy(formatstring, getstring());
	if (compos >= comlen)				/* No second parameter */
		strcat(formatstring, "\n");
}

/*
 *		com_list()
 *		----------
 *		This command is the biggy! It scans through the entire file
 *		database, selecting records as specified with SELECT, and printing
 *		them using the order specified with FORMAT. The order of printing
 *		is as specified with SORT.
 */
void com_list()
{
	int i;

	CHECKDATABASE();
	curbytes = 0;
	curfiles = 0;
    for (i = 0; i < numrecs; i++) {
        if (ptrblock[i]->type == 0 && match(ptrblock[i], tree)) {
            format(out, MAXOUT, formatstring, ptrblock[i], checkfiles);
			putstring(out);
			curfiles++;
			curbytes += ptrblock[i]->length;
		}
		chkabort();
	}
	totalbytes += curbytes;
	totalfiles += curfiles;
}

/*
 *		com_msg()
 *		---------
 *		This command is identical to the ECHO command, except that
 *		the output goes to the screen (i.e. stderr) instead of the
 *		current output file. It is intended for printing informational
 *		messages to let the user know of the program's progress, while
 *		processing a large script.
 */
void com_msg()
{
	strcpy(line, getstring());
	if (compos >= comlen) 	/* Add NL if no second parameter */
		strcat(line, "\n");
	print(echoformat(out, MAXOUT, line));
}

/*
 *		com_reset()
 *		-----------
 *		This command resets the running totals which are maintained, 
 *		which give the total number of bytes and total number of files
 *		output so far.
 */
void com_reset()
{
	totalfiles = 0;
	totalbytes = 0;
}

/*
 *		com_scan()
 *		----------
 *		This command is identical to com_list(), except that no output is
 *		produced. It is provided to allow counters to be updated, without
 *		producing output, so that for example, the total number of files
 *		in a listing can be output before the files themselves.
 */

void com_scan()
{
	int i;

	CHECKDATABASE();
	curbytes = 0;
	curfiles = 0;
    for (i = 0; i < numrecs; i++) {
        if (ptrblock[i]->type == 0 && match(ptrblock[i], tree)) {
			curfiles++;
			curbytes += ptrblock[i]->length;
		}
		chkabort();
	}
	totalbytes += curbytes;
	totalfiles += curfiles;
}

/*
 *		com_macro()
 *		-----------
 *		This command lets you define a macro. The syntax is:
 *
 *			MACRO name
 *				  ..
 *				commands
 *				  ..
 *			ENDM
 *
 *		The macro can contain $1 to $9, which will be substituted at
 *		run time by the appropriate parameters that were passed when
 *		the macro was invoked.
 */
void com_macro()
{
	static char macroname[MACROLEN];
	int curline, curpos;	/* Saves current line # and position in script */
	int length;				/* Length of macro script					   */
	int macronum;
	MACRO *curmac;
	char *buf, *p;

	if (nummacros >= MAXMACRO) {
		scripterror("maximum of ");
		print2(itoa(MAXMACRO), " macros allowed\n");
		Cleanup(10);
	}

	curline = linenum;
	curpos = scriptpos;
	
	p = getstring();
	strncpy(macroname, p, MACROLEN-1);
	macroname[MACROLEN-1] = CHAR_NULL;

	/*
	 *		First of all, find out how much space the macro occupies
	 */
	length = 0;
	while (readcommand(combuf, MAXCOM) && strcmp(combuf, "ENDM"))
		length += comlen + 1;	/* The extra 1 is for the terminating \0 */

	/*
	 *		Now, restore linenumber and script position so we can read
	 *		in macro for real the second time.
	 */
	linenum = curline;
	if (scriptpos >= scriptsize) {
		scripterror("missing ENDM in macro definition\n");
		Cleanup(10);
	}

	scriptpos = curpos;

	if ((macronum = findmacro(macroname)) == -1) 		/* New macro */
		macronum = nummacros++;
	else
		/* Macro redefinition, so release earlier definition */
		FreeMem(macros[macronum], macros[macronum]->size + MACROSIZE);

	curmac = SafeAllocMem(MACROSIZE + length);
	macros[macronum] = curmac;
	strcpy(curmac->name, macroname);
	curmac->size = length;
	buf = curmac->text;

	/*
	 *		Initialised macro definition, now copy macro text from script
	 *		file into macro buffer.
	 */
	while (readcommand(combuf, MAXCOM) && strcmp("ENDM", combuf)) {
		strcpy(buf, combuf);
		buf += comlen + 1;
	}
}

/*
 *		com_trace()
 *		-----------
 *		Turns on or off trace mode. When trace mode is on, every line that
 *		is executed is displayed first. This is handy when executing
 *		macros, to see exactly what is happening. Note that the -t option
 *		on the command line will enable tracing for the whole file,
 *		but if TRACE ON or OFF is encountered, this overrides -t.
 */
void com_trace()
{
	char *opt = getstring();

	if (!strcmp(opt, "ON"))
		tracemode = TRUE;
	else if (!strcmp(opt, "OFF"))
		tracemode = FALSE;
	else {
		scripterror("TRACE ON or TRACE OFF expected\n");
		Cleanup(10);
	}
}

/*
 *		com_ignore()
 *		------------
 *		This command takes a list of filenames. Each filename listed here
 *		is remembered, and when CHECKFILES is done, any filename listed
 *		here will be marked as valid, regardless of whether it really IS
 *		valid or not. This is useful if you have some files online which
 *		are updated by external programs (such as, for example, the output
 *		from BBSINFO), and hence have "wandering" file sizes.
 */
void com_ignore()
{
	IGNORE *ig;
	char *p;

	while (compos < comlen) {
		ig = mymalloc(sizeof(IGNORE));
		p = getstring();
		if (strlen(p) >= CAT_LEN) {
			scripterror("filename too long.\n");
			Cleanup(10);
		}
		strcpy(ig->name, p);
		ig->next = firstignore;
		firstignore = ig;
	}
}