Initial revision

1 files changed, 2374 insertions, 0 deletions

diff --git a/tecstate.c b/tecstate.c
new file mode 100644
index 0000000..d908e74
--- /dev/null
+++ b/tecstate.c
@@ -0,0 +1,2374 @@
+char *tecstate_c_version = "tecstate.c: $Revision: 1.1 $";
+
+/*
+ * $Date: 2007/12/10 21:59:21 $
+ * $Source: /cvsroot/videoteco/videoteco/tecstate.c,v $
+ * $Revision: 1.1 $
+ * $Locker:  $
+ */
+
+/* tecstate.c
+ * Main SWITCH/CASE statements to implement the parser syntax stage
+ *
+ *                     COPYRIGHT (c) 1985-2003 BY
+ *		     PAUL CANTRELL & J. M. NISHINAGA
+ *                         SUDBURY, MA 01776
+ *                        ALL RIGHTS RESERVED
+ *
+ * This software is furnished in it's current state free of  charge.
+ * The   authors   reserve  all  rights  to  the  software.  Further
+ * distribution of the software is not authorized. Modifications  to
+ * the  software  may  be made locally, but shall not be distributed
+ * without the consent of the authors. This software  or  any  other
+ * copies  thereof,  may not be provided or otherwise made available
+ * to anyone without express permission of the authors. Title to and
+ * ownership of this software remains with the authors.
+ * 
+ */
+
+#include "teco.h"
+#include "tecparse.h"
+
+    extern char immediate_execute_flag;
+    extern char trace_mode_flag;
+    extern char suspend_is_okay_flag;
+
+
+
+/* PARSE_INPUT_CHARACTER - Continue the parse with the supplied character
+ *
+ * Function:
+ *
+ *	We re-enter the parser with a new character at this point. We jump back
+ *	to the state we left before.
+ */
+void
+parse_input_character(ct,uct)
+register struct cmd_token *ct;
+struct cmd_token *uct;
+{
+char tmp_message[LINE_BUFFER_SIZE];
+register struct cmd_token *oct = NULL;
+
+    PREAMBLE();
+
+    switch(ct->ctx.state){
+/*
+ * Here on initial command state. This is the begining of a command, so we are
+ * looking for arguments that might go with a command. If there are no args,
+ * we just transfer into the main command loop.
+ */
+	case STATE_C_INITIALSTATE:
+	    ct->ctx.flags &= ~(CTOK_M_COLON_SEEN | CTOK_M_ATSIGN_SEEN);
+	    ct->flags |= TOK_M_WORDBOUNDARY;
+	case STATE_C_ACCEPT_ARGS:
+	    ct->ctx.carg = NULL;
+	    switch(ct->input_byte){
+/*
+ * If it looks like an argument, then transfer into a subexpression parser to
+ * get the value of the expression. ARG1 will stuff the result into iarg1 and
+ * also check for a comma (',') incase he is specifing a twin argument command
+ */
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		case 'Q': case 'q': case '%':
+#ifdef CLASSIC_B_BEHAVIOR
+		case 'B': case 'b':
+#endif
+		case 'Z': case 'z':
+		case '\\':
+		case '.':
+		case '-':
+		case '(':
+		case '^':
+		    ct->ctx.flags &= ~CTOK_M_STATUS_PASSED;
+		    ct->ctx.iarg1_flag = ct->ctx.iarg2_flag = NO;
+		    ct->ctx.state = STATE_C_EXPRESSION;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_ARG1;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+/*
+ * H is a special case, since the single argument actually implies two args.
+ * (H actually is the same as 0,z<cmd>)
+ */
+		case 'H': case 'h':
+		    ct->ctx.flags &= ~CTOK_M_STATUS_PASSED;
+		    ct->ctx.iarg1_flag = ct->ctx.iarg2_flag = YES;
+		    ct->ctx.state = STATE_C_MAINCOMMANDS;
+		    ct->execute_state = EXEC_C_HVALUE;
+		    return;
+/*
+ * Here on the @ command. This says to use user specified delimeters for
+ * strings, rather than just terminating with escape.
+ */
+		case '@':
+		    ct->ctx.flags |= CTOK_M_ATSIGN_SEEN;
+		    ct->ctx.state = STATE_C_ACCEPT_ARGS;
+		    return;
+/*
+ * Here on the : command. This is just a flag to many commands to tell them
+ * to work in a slightly different way. The most common usage is to mean that
+ * the command should return a value which says whether it worked or not.
+ */
+		case ':':
+		    ct->ctx.flags |= CTOK_M_COLON_SEEN;
+		    ct->ctx.state = STATE_C_ACCEPT_ARGS;
+		    return;
+/*
+ * Well, it doesn't look like he is going to be specifying any arguments, so we
+ * just go and decode the command.
+ */
+		default:
+		    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){
+			ct->ctx.state = STATE_C_MAINCOMMANDS;
+			ct->flags &= ~TOK_M_EAT_TOKEN;
+			ct->ctx.flags &= ~CTOK_M_STATUS_PASSED;
+			return;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_MAINCOMMANDS;
+		    ct->ctx.iarg1_flag = ct->ctx.iarg2_flag = NO;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+
+	    }/* End Switch */
+/*
+ * Here to parse the major commands (i.e., ones that have no lead-in)
+ */
+	case STATE_C_MAINCOMMANDS:
+	    switch(ct->input_byte){
+/*
+ * Space is a nop so that it can be used to make macros more readable
+ */
+		case ' ':
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    return;
+/*
+ * Carriage Return is a nop so that it can be used in a macro to avoid
+ * extremely long lines wrapping.
+ */
+		case '\n':
+		    ct->ctx.state = STATE_C_MAINCOMMANDS;
+		    return;
+/*
+ * Here on an escape. First of all, we have to remember that we have seen an
+ * escape since two in a row will terminate the command. Also, escape has the
+ * effect of blocking arguments from commands i.e. 2L will move two lines, but
+ * 2$L will only move one since the escape eats the argument.
+ */
+		case ESCAPE:
+		    ct->ctx.iarg1_flag = ct->ctx.iarg2_flag = NO;
+		    ct->ctx.state = STATE_C_ESCAPESEEN;
+		    return;		    
+/*
+ * Here on an Asterisk command. This causes the last double-escaped command
+ * sequence to be saved in the named q-register.
+ */
+		case '*':
+		    if(parse_any_arguments(ct,"*")) return;
+		    ct->ctx.state = STATE_C_SAVECOMMAND;
+		    return;
+/*
+ * Here on the @ command. This says to use user specified delimeters for
+ * strings, rather than just terminating with escape.
+ */
+		case '@':
+		    ct->ctx.flags |= CTOK_M_ATSIGN_SEEN;
+		    return;
+/*
+ * Here on the : command. This is just a flag to many commands to tell them
+ * to work in a slightly different way. The most common usage is to mean that
+ * the command should return a value which says whether it worked or not.
+ */
+		case ':':
+		    ct->ctx.flags |= CTOK_M_COLON_SEEN;
+		    return;
+/*
+ * Here on the [ command. This causes the specified Q register to be pushed
+ * onto the Q register pushdown stack.
+ */
+		case '[':
+		    ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    ct->ctx.state = STATE_C_PUSH_QREGISTER;
+		    return;
+
+/*
+ * Here on the ] command. This causes a Q register to be popped off of the
+ * Q register pushdown stack, and replaces the specified Q register.
+ */
+		case ']':
+		    ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    ct->ctx.state = STATE_C_POP_QREGISTER;
+		    return;
+/*
+ * The B command moves backwards by lines. It is strictly a Video TECO
+ * enhancement. In normal TECO, the B command returns the address of the
+ * begining of the buffer, i.e. 0.
+ */
+		case 'B': case 'b':
+		    if(parse_more_than_one_arg(ct,"B")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_RLINE;
+		    return;
+/*
+ * Here on the C command. The C command is a relative move command, i.e., the
+ * argument says how many spaces from the current position to move.
+ */
+		case 'C': case 'c':
+		    if(parse_more_than_one_arg(ct,"C")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_CHAR;
+		    return;
+/*
+ * The D command deletes the specified number of characters in the indicated
+ * direction.
+ */
+		case 'D': case 'd':
+		    if(parse_more_than_one_arg(ct,"D")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_DELETE;
+		    return;
+/*
+ * Here on an E command. This is simply the lead-in to any one of the many
+ * E commands.
+ */
+		case 'E': case 'e':
+		    ct->ctx.state = STATE_C_ECOMMAND;
+		    return;
+/*
+ * Here on an F command. This is a lead-in to one of the F? commands.
+ */
+		case 'F': case 'f':
+		    ct->ctx.state = STATE_C_FCOMMAND;
+		    return;
+/*
+ * The G command copies the contents of the specified q-register into the
+ * edit buffer at the current position.
+ */
+		case 'G': case 'g':
+		    if(parse_any_arguments(ct,"G")) return;
+		    ct->ctx.state = STATE_C_GQREGISTER;
+		    return;
+/*
+ * The I command inserts characters until an escape is input. If this is
+ * entered with the tab command, not only do we enter insert mode, we also
+ * insert the tab itself.
+ */
+		case '\t':
+		    if(ct->ctx.iarg1_flag == NO) ct->flags &= ~TOK_M_EAT_TOKEN;
+
+
+		case 'I': case 'i':
+		    if(parse_more_than_one_arg(ct,"I")) return;
+
+		    if(ct->ctx.iarg1_flag == YES){
+			ct->ctx.state = STATE_C_INITIALSTATE;
+			ct->execute_state = EXEC_C_INSERT;
+			return;
+		    }/* End IF */
+
+		    if(ct->ctx.flags & CTOK_M_ATSIGN_SEEN){
+			ct->ctx.state = STATE_C_ATINSERT;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_INSERT;
+		    return;
+/*
+ * Here on the J command. The J command jumps to an absolute position in the
+ * buffer.
+ */
+		case 'J': case 'j':
+		    if(parse_more_than_one_arg(ct,"J")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_JUMP;
+		    return;
+/*
+ * The K command acts just like the L command except that it deletes instead
+ * of moving over. Also, it is legal to specify an a,b range to K
+ */
+		case 'K': case 'k':
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_KILL;
+		    return;
+/*
+ * The L command moves over the specified number of new-line characters. An
+ * argument of zero means get to the begining of the current line.
+ */
+		case 'L': case 'l':
+		    if(parse_more_than_one_arg(ct,"L")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_LINE;
+		    return;
+/*
+ * The M command executes the contents of the specified Q register as a macro.
+ */
+		case 'M': case 'm':
+		    ct->ctx.state = STATE_C_MQREGISTER;
+		    return;
+/*
+ * The N command will search for the specified string across multiple edit
+ * buffers.
+ */
+		case 'N': case 'n':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_NSEARCH;
+		    return;
+/*
+ * The O command goes to the specified label
+ */
+		case 'O': case 'o':
+		    if(parse_any_arguments(ct,"O")) return;
+		    ct->ctx.state = STATE_C_GOTO;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_GOTO_BEGIN;
+		    return;
+/*
+ * The P command selects the next window
+ */
+		case 'P': case 'p':
+		    if(parse_more_than_one_arg(ct,"P")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_NEXT_WINDOW;
+		    return;
+/*
+ * The R command is exactly like the C command, except that the direction
+ * is reversed.
+ */
+		case 'R': case 'r':
+		    if(parse_more_than_one_arg(ct,"R")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_RCHAR;
+		    return;
+/*
+ * The S command will search for the specified string
+ */
+		case 'S': case 's':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_SEARCH;
+		    return;
+/*
+ * The ^L command is temporarily used to redraw the screen
+ */
+		case '\f':
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_REDRAW_SCREEN;
+		    return;
+/*
+ * The U command loads the argument into the specified Q register
+ */
+		case 'U': case 'u':
+		    if(parse_more_than_one_arg(ct,"U")) return;
+		    ct->ctx.state = STATE_C_UQREGISTER;
+		    return;
+/*
+ * The V command deletes words. This is a Vido TECO enhancement. In normal
+ * TECO, the V command was equivalent to 0TT
+ */
+		case 'V': case 'v':
+		    if(parse_more_than_one_arg(ct,"V")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_DELWORD;
+		    return;
+/*
+ * The W command moves by words
+ */
+		case 'W': case 'w':
+		    if(parse_more_than_one_arg(ct,"W")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_WORD;
+		    return;
+/*
+ * The X command moves a block of characters from the edit buffer into
+ * the specified q register.
+ */
+		case 'X': case 'x':
+		    ct->ctx.state = STATE_C_XQREGISTER;
+		    return;
+/*
+ * The Y command deletes words in reverse direction. This is a Video TECO
+ * enhancement. In classic TECO, the Y command 'yanked' input data into the
+ * edit buffer.
+ */
+		case 'Y': case 'y':
+		    if(parse_more_than_one_arg(ct,"Y")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_RDELWORD;
+		    return;
+/*
+ * The ^A command allows you to print a message to the message line
+ */
+		case CNTRL_A:
+		    if(parse_any_arguments(ct,"^A")) return;
+		    ct->ctx.state = STATE_C_MESSAGE;
+		    ct->execute_state = EXEC_C_RESET_MESSAGE;
+		    return;
+/*
+ * The < command opens an iteration
+ */
+		case '<':
+		    if(parse_more_than_one_arg(ct,"<")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_ITERATION_BEGIN;
+		    ct->ctx.inest += 1;
+		    ct->execute_state = EXEC_C_ITERATION_BEGIN;
+		    return;
+/*
+ * The > command closes an iteration
+ */
+		case '>':
+		    if(parse_more_than_one_arg(ct,">")) return;
+		    if(ct->ctx.inest == 0){
+			error_message("?No Iteration Present");
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_ITERATION_END;
+		    while((oct = oct->prev_token)){
+			if(oct->opcode != TOK_C_ITERATION_BEGIN) continue;
+			if(oct->ctx.inest != ct->ctx.inest) continue;
+			ct->ctx.caller_token = oct;
+			break;
+		    }/* End While */
+/*
+ * Preserve the arguments so that if the loop gets undone, it will get redone
+ * the correct number of iterations when the > is typed again.
+ */
+		    {
+		    register struct undo_token *ut;
+		    ut = allocate_undo_token(ct);
+		    if(ut == NULL){
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ut->opcode = UNDO_C_PRESERVEARGS;
+		    ut->iarg1 = oct->ctx.iarg1;
+		    ut->iarg2 = oct->ctx.iarg2;
+		    ut->carg1 = (char *)oct;
+
+		    ct->ctx.inest -= 1;
+		    ct->execute_state = EXEC_C_ITERATION_END;
+		    ct = allocate_cmd_token(ct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_COPYTOKEN;
+		    return;
+		    }
+/*
+ * The ; command terminates an iteration if the argument is >= 0.
+ * If there is no argument supplied, it uses the state of the last
+ * search operation performed as a value.
+ */
+		case ';':
+		    if(parse_more_than_one_arg(ct,";")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_SEMICOLON;
+		    return;
+/*
+ * The = command prints out the value of the supplied expression.
+ * A single = prints out in decimal, == prints in octal and === in hex.
+ */
+		case '=':
+		    if(parse_more_than_one_arg(ct,"=")) return;
+		    ct->ctx.state = STATE_C_ONE_EQUALS;
+		    ct->execute_state = EXEC_C_EQUALS;
+		    return;
+/*
+ * The " command is the conditional 'IF' operator. The following commands only
+ * get executed if the condition is satisfied.
+ */
+		case '"':
+		    if(parse_more_than_one_arg(ct,"\"")) return;
+		    ct->ctx.state = STATE_C_CONDITIONALS;
+		    ct->ctx.cnest += 1;
+		    return;
+/*
+ * The | command provides an else clause to a conditional expression
+ */
+		case '|':
+		    if(parse_any_arguments(ct,"|")) return;
+		    if(ct->ctx.cnest <= 0){
+			error_message("?Not in a conditional");
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_SKIP_ELSE;
+		    ct->execute_state = EXEC_C_SKIP_ELSE;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+/*
+ * The ' command ends a conditional expression.
+ */
+		case '\'':
+		    if(parse_any_arguments(ct,"'")) return;
+		    if(ct->ctx.cnest <= 0){
+			error_message("?Not in a conditional");
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_CONDITIONAL_END;
+		    ct->ctx.cnest -= 1;
+		    return;
+/*
+ * The Label command allows you to set a tag which can be jumped to with
+ * the 'O' command. It also provides a way to comment macros.
+ */
+		case '!':
+		    if(parse_any_arguments(ct,"!")) return;
+		    ct->ctx.state = STATE_C_LABEL;
+		    ct->execute_state = EXEC_C_SKIPLABEL;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_LABEL_BEGIN;
+		    return;
+/*
+ * The backslash command with an argument inserts the decimal
+ * representation of the argument into the buffer at the current position.
+ */
+		case '\\':
+		    if(ct->ctx.iarg2_flag == NO){
+			ct->ctx.iarg2 = 10;
+			ct->flags |= TOK_M_PARSELOAD_IARG2;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_BACKSLASH;
+		    return;
+/*
+ * The open-brace command copies the current command string into a special
+ * Q-register and places the user there so he can edit it.
+ */
+		case '{':
+		    if(parse_any_arguments(ct,"{")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_OPENBRACE;
+		    return;
+
+/*
+ * The close-brace command replaces the command string with the string in
+ * the special Q-register.
+ */
+		case '}':
+		    if(parse_any_arguments(ct,"}")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_CLOSEBRACE;
+		    return;
+
+/*
+ * Here on a system which doesn't really do suspend correctly
+ */
+		case CNTRL_Z:
+		    if(suspend_is_okay_flag == YES){
+			cmd_suspend();
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    return;
+
+/*
+ * Here to toggle trace mode. This inserts information into q-register ?
+ * to help us track execution.
+ */
+		case '?':
+		    trace_mode_flag = !trace_mode_flag;
+		    screen_message(trace_mode_flag ? "Trace Mode ON" :
+							"Trace Mode OFF");
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    return;
+
+/*
+ * We only get here on an error, since we should never dispatch a command that
+ * does not have a corresponding case statement.
+ */
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,
+			"?MAINCOMMANDS: unknown command <%c>",
+			UPCASE((int)ct->input_byte));
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch */
+/*
+ * Here when we have seen the begining of a conditional '"'. Now we have to
+ * look at the next character to determine what the actual condition test is.
+ */
+	case STATE_C_CONDITIONALS:
+	    switch(ct->input_byte){
+		case 'G': case 'g':
+		case '>':
+		    ct->execute_state = EXEC_C_COND_GT;
+		    break;
+		case 'L': case 'l':
+		case 'T': case 't':
+		case 'S': case 's':
+		case '<':
+		    ct->execute_state = EXEC_C_COND_LT;
+		    break;
+		case 'E': case 'e':
+		case 'F': case 'f':
+		case 'U': case 'u':
+		case '=':
+		    ct->execute_state = EXEC_C_COND_EQ;
+		    break;
+		case 'N': case 'n':
+		case '!':
+		    ct->execute_state = EXEC_C_COND_NE;
+		    break;
+		case 'C': case 'c':
+		    ct->execute_state = EXEC_C_COND_SYMBOL;
+		    break;
+		case 'D': case 'd':
+		    ct->execute_state = EXEC_C_COND_DIGIT;
+		    break;
+		case 'A': case 'a':
+		    ct->execute_state = EXEC_C_COND_ALPHA;
+		    break;
+		case 'V': case 'v':
+		    ct->execute_state = EXEC_C_COND_LOWER;
+		    break;
+		case 'W': case 'w':
+		    ct->execute_state = EXEC_C_COND_UPPER;
+		    break;
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,
+			"?Unknown conditional command '%c'",
+			UPCASE((int)ct->input_byte));
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch */
+
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    return;
+/*
+ * Here to watch for the end of a label
+ */
+	case STATE_C_LABEL:
+	    switch(ct->input_byte){
+		case '!':
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_LABEL_END;
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_LABEL;
+		    return;
+	    }/* End Switch */
+/*
+ * Here to eat the characters in a GOTO command
+ */
+	case STATE_C_GOTO:
+	    switch(ct->input_byte){
+		case ESCAPE:
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_GOTO_END;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->execute_state = EXEC_C_GOTO;
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_GOTO;
+		    return;
+	    }/* End Switch */
+/*
+ * Here if we have seen an escape. If we see another, then he wants us to
+ * complete the parse and execute any remaining commands.
+ */
+	case STATE_C_ESCAPESEEN:
+	    switch(ct->input_byte){
+		case ESCAPE:
+		    if(ct->ctx.inest){
+			error_message("?Unterminated Iteration");
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    if(ct->ctx.cnest){
+			error_message("?Unterminated Conditional");
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_FINALSTATE;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->opcode = TOK_C_FINALTOKEN;
+		    return;
+
+		default:
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+	    }/* End Switch */
+/*
+ * Here if we have seen an E as a lead-in to one of the E commands.
+ */
+	case STATE_C_ECOMMAND:
+	    switch(ct->input_byte){
+/*
+ * The EB command creates a new edit buffer and reads the specified file in.
+ * If the command is given an argument, then this is a shorthand switch to
+ * the buffer that has that number.
+ */
+		case 'B': case 'b':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    if(ct->ctx.iarg1_flag == YES){
+			ct->execute_state = EXEC_C_EDITBUF;
+			if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			    oct = ct;
+			    ct = allocate_cmd_token(oct);
+			    if(ct == NULL){
+				oct->ctx.state = STATE_C_ERRORSTATE;
+				return;
+			    }/* End IF */
+			    ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+			    ct->execute_state = EXEC_C_STORE1;
+			}/* End IF */
+			ct->ctx.state = STATE_C_INITIALSTATE;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_EDITBUF;
+		    return;
+/*
+ * The EC command allows you to execute a command, and the output is placed
+ * into the edit buffer.
+ */
+		case 'C': case 'c':
+		    if(ct->ctx.iarg1_flag == YES){
+			ct->execute_state = EXEC_C_ECCOMMAND;
+			ct->ctx.state = STATE_C_INITIALSTATE;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_ECCOMMAND;
+		    return;
+/*
+ * The EF command closes the current edit buffer. If the current buffer
+ * is modified, the command will fail unless the user specifies an argument
+ * to the command.
+ */
+		case 'F': case 'f':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->execute_state = EXEC_C_CLOSEBUF;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			oct = ct;
+			ct = allocate_cmd_token(oct);
+			if(ct == NULL){
+			    oct->ctx.state = STATE_C_ERRORSTATE;
+			    return;
+			}/* End IF */
+			ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+			ct->execute_state = EXEC_C_STORE1;
+		    }/* End IF */
+		    return;
+/*
+ * The EI command allows you to alter immediate execution mode. With no
+ * argument, execute mode is turned off for the remainder of the current
+ * command. An argument of 0 turns it off until further notice and an
+ * argument of 1 turns it back on.
+ */
+		case 'I': case 'i':
+		    if(parse_more_than_one_arg(ct,"EI")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+
+		    if(ct->ctx.iarg1_flag == NO){
+			ct->ctx.go_flag = NO;
+			return;
+		    }/* End IF */
+
+		    ct->execute_state = EXEC_C_SET_IMMEDIATE_MODE;
+		    return;
+/*
+ * The EJ command allows you to load runtime options into TECO.
+ */
+		case 'J': case 'j':
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_SETOPTIONS;
+		    return;
+		    
+/*
+ * The EP command splits the current window in half. If an argument is
+ * supplied, the command deletes the current window.
+ */
+		case 'P': case 'p':
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_WINDOW_CONTROL;
+		    return;
+/*
+ * The EV command works exactly like the EB command except that the buffer
+ * which is created is 'readonly'. Thus this command stands for 'VIEW' file.
+ */
+		case 'V': case 'v':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    if(ct->ctx.iarg1_flag == YES){
+			ct->execute_state = EXEC_C_VIEWBUF;
+			ct->ctx.state = STATE_C_INITIALSTATE;
+			return;
+		    }/* End IF */
+
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_VIEWBUF;
+		    return;
+/*
+ * The EQ command reads a file into the specified Q-register.
+ */
+		case 'Q': case 'q':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    if(parse_any_arguments(ct,"EQ")) return;
+		    ct->ctx.state = STATE_C_EQQREGISTER1;
+		    return;
+/*
+ * The ER command reads the specified file into the current buffer location.
+ */
+		case 'R': case 'r':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_READFILE;
+		    return;
+/*
+ * The ES command causes the screen to scroll
+ */
+		case 'S': case 's':
+		    if(parse_more_than_one_arg(ct,"ES")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_SCROLL;
+		    return;
+/*
+ * The ET command causes the screen to update
+ */
+		case 'T': case 't':
+		    if(parse_any_arguments(ct,"ET")) return;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_UPDATE_SCREEN;
+		    return;
+/*
+ * The EW command writes out the current buffer
+ */
+		case 'W': case 'w':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_WRITEFILE;
+		    return;
+/*
+ * The EX command causes the editor to exit
+ */
+		case 'X': case 'x':
+		    ct->execute_state = EXEC_C_EXITCOMMAND;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->ctx.go_flag = NO;
+		    return;
+
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,
+			"?Unknown command E%c",UPCASE((int)ct->input_byte));
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch */
+/*
+ * Here if we have seen an F as a lead-in to one of the F commands.
+ */
+	case STATE_C_FCOMMAND:
+	    switch(ct->input_byte){
+/*
+ * The FD command finds the string and deletes it.
+ */
+		case 'D': case 'd':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_FDCOMMAND;
+		    return;
+/*
+ * The FK command clears the text between the current position and the position
+ * of the searched for text. The searched for text is left unmodified.
+ */
+		case 'K': case 'k':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_FKCOMMAND;
+		    return;
+/*
+ * The FS command finds the first string and replaces it with the second
+ */
+		case 'S': case 's':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_FSPART1;
+		    return;
+/*
+ * The FT command is a Video TECO extension to read & use a unix style
+ * tags file.
+ */
+		case 'T': case 't':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->ctx.state = STATE_C_STRING;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_FTAGS;
+		    return;
+
+/*
+ * The FR command acts like the FS command except that if the second argument
+ * is NULL, the string is replaced with the last replace value.
+ */
+		case 'R': case 'r':
+		    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+			ct->ctx.flags |= CTOK_M_STATUS_PASSED;
+		    }/* End IF */
+		    ct->execute_state = EXEC_C_SEARCH;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->execute_state = EXEC_C_FRREPLACE;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){  /* mch */
+			ct = allocate_cmd_token(ct);
+			ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+			ct->execute_state = EXEC_C_STORE1;
+		    }/* End IF */
+
+		    return;
+/*
+ * Here when we have an 'F' command with an unknown second character. This
+ * makes it an illegal command, and we don't waste any time letting the user
+ * know about it.
+ */
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,
+			"?Unknown command F%c",UPCASE((int)ct->input_byte));
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch */
+/*
+ * The following state is the return-state from STRING when the first part
+ * of an FS command has been parsed.
+ */
+	case STATE_C_FSPART1:
+	    ct->ctx.state = STATE_C_FSPART2;
+	    ct->execute_state = EXEC_C_SEARCH;
+	    oct = ct;
+	    ct = allocate_cmd_token(oct);
+	    if(ct == NULL){
+		oct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+	    ct->execute_state = EXEC_C_FSREPLACE1;
+	    return;
+
+	case STATE_C_FSPART2:
+	    ct->flags |= TOK_M_WORDBOUNDARY;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_FSPART3;
+	    return;
+
+	case STATE_C_FSPART3:
+	    if(ct->ctx.flags & CTOK_M_ATSIGN_SEEN){
+		if(ct->input_byte == ct->ctx.delimeter){
+		    ct->ctx.state = STATE_C_ESCAPESEEN;
+		    ct->execute_state = EXEC_C_FSREPLACE3;
+		    return;
+		}
+
+		else {
+		    ct->ctx.state = STATE_C_FSPART3;
+		    ct->execute_state = EXEC_C_FSREPLACE2;
+		    return;
+
+		}
+	    }
+
+	    if(ct->input_byte == ESCAPE){
+		ct->ctx.state = STATE_C_ESCAPESEEN;
+		ct->execute_state = EXEC_C_FSREPLACE3;
+		if(ct->ctx.flags & CTOK_M_STATUS_PASSED){  /* mch */
+		    ct = allocate_cmd_token(ct);
+		    ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		    ct->execute_state = EXEC_C_STORE1;
+		}/* End IF */
+		return;
+	    }
+
+	    else {
+		ct->ctx.state = STATE_C_FSPART3;
+		ct->execute_state = EXEC_C_FSREPLACE2;
+		return;
+
+	    }
+
+#ifdef WIMPY_CODER_WHO_HAS_NOT_HANDLED_THIS_YET
+		case CNTRL_V:
+		    ct->ctx.state = STATE_C_QUOTED_INSERT;
+		    return;
+#endif /* WIMPY_CODER_WHO_HAS_NOT_HANDLED_THIS_YET */
+
+/*
+ * This state is the return state from STRING and the TAGS command is
+ * ready to execute.
+ */
+	case STATE_C_FTAGS:
+	    ct->execute_state = EXEC_C_FTAGS;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){
+		oct = ct;
+		ct = allocate_cmd_token(oct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+
+/*
+ * The following state is the return-state from STRING when a search string
+ * has been completely specified.
+ */
+	case STATE_C_SEARCH:
+	    ct->execute_state = EXEC_C_SEARCH;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){
+		oct = ct;
+		ct = allocate_cmd_token(oct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is the return-state from STRING when a search string
+ * has been completely specified for the 'N' search command.
+ */
+	case STATE_C_NSEARCH:
+	    ct->execute_state = EXEC_C_NSEARCH;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){
+		oct = ct;
+		ct = allocate_cmd_token(oct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is the return-state from STRING when the search part
+ * of an FD command has been parsed.
+ */
+	case STATE_C_FDCOMMAND:
+	    ct->execute_state = EXEC_C_SEARCH;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    oct = ct;
+	    ct = allocate_cmd_token(oct);
+	    if(ct == NULL){
+		oct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+	    ct->ctx.carg = NULL;
+	    ct->execute_state = EXEC_C_FDCOMMAND;
+	    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){  /* mch */
+		ct = allocate_cmd_token(ct);
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is the return-state from STRING when the search part
+ * of an FK command has been parsed.
+ */
+	case STATE_C_FKCOMMAND:
+	    ct->execute_state = EXEC_C_REMEMBER_DOT;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    oct = ct;
+	    ct = allocate_cmd_token(oct);
+	    if(ct == NULL){
+		oct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+	    ct->execute_state = EXEC_C_SEARCH;
+	    oct = ct;
+	    ct = allocate_cmd_token(oct);
+	    if(ct == NULL){
+		oct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+	    ct->ctx.carg = NULL;
+	    ct->execute_state = EXEC_C_FKCOMMAND;
+	    if(ct->ctx.flags & CTOK_M_STATUS_PASSED){  /* mch */
+		ct = allocate_cmd_token(ct);
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+
+	    return;
+/*
+ * The following state is a return-state from STRING when we have seen an
+ * escape terminated string which in this case is the name of the file to
+ * write.
+ */
+	case STATE_C_WRITEFILE:
+	    ct->execute_state = EXEC_C_WRITEFILE;
+	    ct->ctx.go_flag = NO;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+		oct = ct;
+		ct = allocate_cmd_token(oct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is a return-state from STRING when we have seen an
+ * escape terminated string which in this case is the name of the file to
+ * read into the current buffer location.
+ */
+	case STATE_C_READFILE:
+	    ct->execute_state = EXEC_C_READFILE;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+		oct = ct;
+		ct = allocate_cmd_token(oct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is a return-state from STRING when we have seen an
+ * escape terminated string which in this case is the name of the file which
+ * we want to create a buffer for and load.
+ */
+	case STATE_C_EDITBUF:
+	    ct->execute_state = EXEC_C_EDITBUF;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+		oct = ct;
+		ct = allocate_cmd_token(ct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is a return-state from STRING when we have seen an
+ * escape terminated string which in this case is the name of the file which
+ * we want to create a readonly buffer for and load.
+ */
+	case STATE_C_VIEWBUF:
+	    ct->execute_state = EXEC_C_VIEWBUF;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+		oct = ct;
+		ct = allocate_cmd_token(ct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state is a return-state from STRING when we have seen an
+ * escape terminated string which in this case is the command the user wants
+ * to execute.
+ */
+	case STATE_C_ECCOMMAND:
+	    ct->execute_state = EXEC_C_ECCOMMAND;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    if(ct->input_byte == ESCAPE) ct->ctx.state = STATE_C_ESCAPESEEN;
+	    return;
+/*
+ * The following state gets entered when the user has typed ^A
+ * to print out a message.
+ */
+	case STATE_C_MESSAGE:
+	    switch(ct->input_byte){
+		case CNTRL_A:
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    ct->execute_state = EXEC_C_OUTPUT_MESSAGE;
+		    return;
+		default:
+		    ct->execute_state = EXEC_C_MESSAGE;
+		    ct->ctx.state = STATE_C_MESSAGE;
+		    return;
+	    }/* End Switch */
+
+/*
+ * The following state is a return-state from EXPRESSION when we have seen
+ * what appears to be a first argument. It stashes the argument and tests if
+ * there is a second argument available (indicated by a comma).
+ */
+	case STATE_C_ARG1:
+	    ct->ctx.iarg1_flag = YES;
+	    ct->execute_state = EXEC_C_STORE1;
+	    switch(ct->input_byte){
+		case ',':
+		    ct->ctx.state = STATE_C_EXPRESSION;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_ARG2;
+		    return;
+
+		default:
+		    ct->ctx.state = STATE_C_MAINCOMMANDS;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+	    }/* End Switch */
+/*
+ * Here if the first argument was followed by a comma. This indicates that a
+ * second argument is being specified. Only certain commands accept a double
+ * argument.
+ */
+	case STATE_C_ARG2:
+	    ct->ctx.iarg2_flag = YES;
+	    ct->execute_state = EXEC_C_STORE2;
+	    switch(ct->input_byte){
+		case ',':
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    error_message("?Maximum of two arguments exceeded");
+		    return;
+
+		default:
+		    ct->ctx.state = STATE_C_MAINCOMMANDS;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+	    }/* End Switch */
+/*
+ * The next state is the expression substate. States outside of the expression
+ * parser call through here so that pnest (the current nesting level of
+ * parentheses) gets set to zero. Then it calls the expression parser's own
+ * internal sub-expression state.
+ */
+	case STATE_C_EXPRESSION:
+	    ct->ctx.pnest = 0;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_SUBEXPRESSION;
+	    return;
+/*
+ * This is the sub-expression state. It gets called from within the expression
+ * parser when we want to recursively parse an expression. This lets us handle
+ * precedence and parenthesis correctly.
+ */
+	case STATE_C_SUBEXPRESSION:
+	    switch(ct->input_byte){
+/*
+ * When we see an open parenthesis, we want to recursively call the
+ * subexpression state to parse the contents of the parenthesis. Since the open
+ * parenthesis always occurs in place of an operand, we set that to be the next
+ * state to call.
+ */
+		case '(':
+		    ct->ctx.pnest += 1;
+		    ct->ctx.state = STATE_C_OPERAND;
+
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_OPERATOR;
+
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_OPERATOR;
+		    return;
+/*
+ * If we see a minus sign here, it is a unary minus. The difference between
+ * the unary minus and the normal minus is one of precedence. The unary minus
+ * is very high precedence.
+ */
+		case '-':
+		    ct->ctx.state = STATE_C_MINUSSEEN;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_UMINUS;
+		    return;
+/*
+ * Here on a leading % command. This just means he is going to default to
+ * incrementing the queue register by one.
+ */
+		case '%':
+		    ct->ctx.tmpval = 1;
+		    ct->flags |= TOK_M_PARSELOAD_TMPVAL;
+/* ;;; the following line shouldn't be required, but is. A bug. */
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.state = STATE_C_PERCENT_OPERAND;
+		    return;
+/*
+ * Well, not much exciting going on here, so we just call the normal operand
+ * state to parse the current token.
+ */
+		default:
+		    ct->ctx.state = STATE_C_OPERAND;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_OPERATOR;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+	    }/* End Switch */
+/*
+ * Here if we saw a unary minus. The reason for calling this state at all is to
+ * catch constructs like -L which really implies -1L. In a case like this,
+ * the OPERAND state will not see anything it understands, and will return.
+ * So as to make the defaulting work correctly, we catch that case here and
+ * default so that we get our -1.
+ */
+	case STATE_C_MINUSSEEN:
+	    switch(ct->input_byte){
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		case 'Q': case 'q': case '%':
+		case '.':
+#ifdef CLASSIC_B_BEHAVIOR
+		case 'B': case 'b':
+#endif
+		case 'Z': case 'z':
+		case '(':
+		case '^':
+		    ct->ctx.state = STATE_C_OPERAND;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+
+		default:
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = 1;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_RETURN;
+		    return;
+	    }/* End Switch */
+/*
+ * Here on the return from the OPERAND state. Whatever it parsed, we want to
+ * make it minus.
+ */
+	case STATE_C_UMINUS:
+	    ct->execute_state = EXEC_C_UMINUS;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_OPERATOR;
+	    return;
+/*
+ * Here when we are expecting an operator like + = * /. Note that ')' also gets
+ * handled here since it always appears in the place an operator would be
+ * expected to appear.
+ */
+	case STATE_C_OPERATOR:
+	    switch(ct->input_byte){
+/*
+ * Here on an a-b case. Note that since minus is a low precedence operator,
+ * we stash the temporary value, and call subexpression to parse the rest
+ * of the expression. In that way, if the next operator was * or /, it will
+ * get processed first.
+ */
+		case '-':
+		    ct->execute_state = EXEC_C_STORE2;
+		    ct->ctx.state = STATE_C_OPERAND;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_MINUS;
+		    return;
+/*
+ * Here on an a+b case. This is similar to the case above in that we want to
+ * just stash the first value, and then recursively call the parser to handle
+ * the rest of the expression first. Note that this causes a+b+c to actually
+ * get handled as a+(b+c) which is a little weird, but works out ok.
+ */
+		case '+':
+		    ct->execute_state = EXEC_C_STORE2;
+		    ct->ctx.state = STATE_C_OPERAND;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_PLUS;
+		    return;
+/*
+ * Here on the a*b case. Unlike the above two cases, we want to immediately
+ * handle this case since it is the highest precedence of the four operators.
+ */
+		case '*':
+		    ct->execute_state = EXEC_C_STORE1;
+		    ct->ctx.state = STATE_C_OPERAND;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_TIMES;
+		    return;
+/*
+ * Here on the a/b case. This is just like the multiply state
+ */
+		case '/':
+		    ct->execute_state = EXEC_C_STORE1;
+		    ct->ctx.state = STATE_C_OPERAND;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_DIVIDE;
+		    return;
+
+/*
+ * Here on the n%q case. This just collapses to the value of the Q-register
+ * after it has been incremented by 'n'
+ */
+		case '%':
+		    ct->ctx.state = STATE_C_PERCENT_OPERAND;
+		    return;
+/*
+ * Here on the 'A' command which returns a value
+ */
+		case 'A': case 'a':
+		    ct->execute_state = EXEC_C_ACOMMAND;
+		    ct->ctx.state = STATE_C_OPERATOR;
+		    return;
+/*
+ * Here on a close parenthesis. This will force the end of a subexpression
+ * parse even though it would not normally have terminated yet. Note the check
+ * for the guy typing too many of these.
+ */
+		case ')':
+		    if(ct->ctx.pnest == 0){
+			error_message("?No Matching Open Parenthesis");
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.pnest -= 1;
+		    ct->ctx.state = STATE_C_RETURN;
+		    return;
+/*
+ * If this is not an operator character, it must be the end of the expression.
+ * In this case, we must be back at the zero level for parenthesis nesting.
+ */
+		default:
+		    if(ct->ctx.pnest > 0){
+			sprintf(tmp_message,"?Missing %d Close Parenthesis",
+			    ct->ctx.pnest);
+			error_message(tmp_message);
+			ct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_RETURN;
+		    return;
+	    }/* End Switch */
+/*
+ * Here when we have the 'b' part of an a+b expression. This happens either
+ * when the end of the expression has been completed, or a parenthesis has
+ * forced a temporary end as in: (a+b)
+ */
+	case STATE_C_PLUS:
+	    switch(ct->input_byte){
+		case '-':
+		case '+':
+		case ')':
+		    ct->execute_state = EXEC_C_PLUS;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_OPERATOR;
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_OPERATOR;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_DELAYED_PLUS;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+	    }/* End Switch */
+
+	case STATE_C_DELAYED_PLUS:
+	    ct->execute_state = EXEC_C_PLUS;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_OPERATOR;
+	    return;
+
+/*
+ * Here when we have the 'b' part of an a-b expression. This happens either
+ * when the end of the expression has been completed, or a parenthesis has
+ * forced a temporary end as in: (a-b)
+ */
+	case STATE_C_MINUS:
+	    switch(ct->input_byte){
+		case '-':
+		case '+':
+		case ')':
+		    ct->execute_state = EXEC_C_MINUS;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_OPERATOR;
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_OPERATOR;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    oct = ct;
+		    ct = allocate_cmd_token(oct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->ctx.caller_token = oct;
+		    ct->ctx.return_state = STATE_C_DELAYED_MINUS;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+	    }/* End Switch */
+
+	case STATE_C_DELAYED_MINUS:
+	    ct->execute_state = EXEC_C_MINUS;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_OPERATOR;
+	    return;
+
+/*
+ * Here when we have both arguments to a multiply. Because multiply is a higher
+ * precedence operator than +-, it happens immediately unless parenthesis get
+ * involved.
+ */
+	case STATE_C_TIMES:
+	    ct->execute_state = EXEC_C_TIMES;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_OPERATOR;
+	    return;
+/*
+ * Here when we have both arguments to a divide. Because division is a higher
+ * precedence operator than -+, it generally happens immediately. Note that we
+ * check to be sure that the divisor is non-zero.
+ */
+	case STATE_C_DIVIDE:
+	    ct->execute_state = EXEC_C_DIVIDE;
+	    ct->flags &= ~TOK_M_EAT_TOKEN;
+	    ct->ctx.state = STATE_C_OPERATOR;
+	    return;
+/*
+ * Here to parse any legal TECO operand. These would include numbers and
+ * commands that return values. Since open parenthesis occur in the same place
+ * as operands, we also catch them here.
+ */
+	case STATE_C_OPERAND:
+	    switch(ct->input_byte){
+/*
+ * If we see a numeric digit, call a substate which will continue eating bytes
+ * until a non-digit is seen.
+ */
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		    ct->ctx.state = STATE_C_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = ct->input_byte - '0';
+		    return;
+/*
+ * Here if he wants to input in a different radix
+ */
+		case '^':
+		    ct->ctx.state = STATE_C_RADIX;
+		    ct->ctx.tmpval = 0;
+		    return;
+/*
+ * Here if he is specifying the numeric value of a q-register. We have to go
+ * to another state to determine which q-register he wants to access.
+ */
+		case 'Q': case 'q':
+		    ct->ctx.state = STATE_C_QOPERAND;
+		    return;
+/*
+ * Here when he has specified <dot>. This will return as a value the current
+ * position in the edit buffer.
+ */
+		case '.':
+		    ct->ctx.state = STATE_C_RETURN;
+		    ct->execute_state = EXEC_C_DOTVALUE;
+		    return;
+#ifdef CLASSIC_B_BEHAVIOR
+/*
+ * B is a special operand which returns the address of the first character
+ * in the buffer. This is currently always 0, but may change if some really
+ * obscure features get put in one of these days.
+ */
+		case 'B': case 'b':
+		    ct->ctx.state = STATE_C_RETURN;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = 0;
+		    return;
+#endif
+/*
+ * Z is a special operand which is the number of characters currently in the
+ * edit buffer.
+ */
+		case 'Z': case 'z':
+		    ct->ctx.state = STATE_C_RETURN;
+		    ct->execute_state = EXEC_C_ZEEVALUE;
+		    return;
+/*
+ * BACKSLASH with no argument actually looks in the buffer at the current
+ * position and eats numeric digits until it hits a non-digit. It then
+ * returns the number as a value.
+ */
+		case '\\':
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_BACKSLASH;
+		    ct->ctx.tmpval = 10;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct = allocate_cmd_token(ct);
+		    if(ct == NULL){
+			oct->ctx.state = STATE_C_ERRORSTATE;
+			return;
+		    }/* End IF */
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->execute_state = EXEC_C_STORE1;
+		    return;
+/*
+ * If we see a parenthesis in place of an operand, we want to parse it as
+ * a complete expression of its own until a matching close parenthesis.
+ */
+		case '(':
+		    ct->ctx.state = STATE_C_SUBEXPRESSION;
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    return;
+/*
+ * We really should not get here if the guy is typing good syntax, so we
+ * tell him it is junk and we don't allow it.
+ */
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,
+			"?Unexpected character <%c> in operand",
+			ct->input_byte);
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch */
+/*
+ * The following is a substate to parse a number. It will continue until
+ * it sees a non-digit, and then return to the calling state.
+ */
+	case STATE_C_NUMBER_SUBSTATE:
+	    switch(ct->input_byte){
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		    ct->ctx.state = STATE_C_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = ct->ctx.tmpval * 10 + ct->input_byte - '0';
+		    return;
+		default:
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_RETURN;
+		    return;
+	    }/* End Switch*/
+/*
+ * The following is a substate to parse a hex number. It will continue until
+ * it sees a non hex digit, and then return to the calling state.
+ */
+	case STATE_C_HEX_NUMBER_SUBSTATE:
+	    switch(ct->input_byte){
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		    ct->ctx.state = STATE_C_HEX_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval *= 16;
+		    ct->ctx.tmpval += ct->input_byte - '0';
+		    return;
+		case 'a': case 'b': case 'c': case 'd': case 'e':
+		case 'f':
+		    ct->ctx.state = STATE_C_HEX_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval *= 16;
+		    ct->ctx.tmpval += ct->input_byte - 'a' + 10;
+		    return;
+		case 'A': case 'B': case 'C': case 'D': case 'E':
+		case 'F':
+		    ct->ctx.state = STATE_C_HEX_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval *= 16;
+		    ct->ctx.tmpval += ct->input_byte - 'A' + 10;
+		    return;
+		default:
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_RETURN;
+		    return;
+	    }/* End Switch*/
+/*
+ * The following is a substate to parse a octal number. It will continue until
+ * it sees a non octal digit, and then return to the calling state.
+ */
+	case STATE_C_OCTAL_NUMBER_SUBSTATE:
+	    switch(ct->input_byte){
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7':
+		    ct->ctx.state = STATE_C_OCTAL_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval *= 8;
+		    ct->ctx.tmpval += ct->input_byte - '0';
+		    return;
+		case '8': case '9':
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,"?Illegal octal digit <%c> in operand",
+			ct->input_byte);
+		    error_message(tmp_message);
+		    return;
+		default:
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_RETURN;
+		    return;
+	    }/* End Switch*/
+/*
+ * The following state gets the value of the specified q-register
+ */
+	case STATE_C_QOPERAND:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_RETURN;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_QVALUE;
+	    return;
+/*
+ * This is just like QOPERAND except the execute state is different
+ */
+	case STATE_C_PERCENT_OPERAND:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_OPERATOR;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_PERCENT_VALUE;
+	    return;
+/*
+ * Here on a input radix character
+ */
+	case STATE_C_RADIX:
+	    switch(ct->input_byte){
+		case 'X': case 'x':
+		    ct->ctx.state = STATE_C_HEX_NUMBER;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    return;
+		case 'O': case 'o':
+		    ct->ctx.state = STATE_C_OCTAL_NUMBER;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,"?Unknown radix ^<%c> in operand",
+			ct->input_byte);
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch */
+
+	case STATE_C_HEX_NUMBER:
+	    switch(ct->input_byte){
+		case '\\':
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_BACKSLASH;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = 16;
+		    return;
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7': case '8': case '9':
+		    ct->ctx.state = STATE_C_HEX_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = ct->input_byte - '0';
+		    return;
+		case 'a': case 'b': case 'c': case 'd': case 'e':
+		case 'f':
+		    ct->ctx.state = STATE_C_HEX_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = ct->input_byte - 'a' + 10;
+		    return;
+		case 'A': case 'B': case 'C': case 'D': case 'E':
+		case 'F':
+		    ct->ctx.state = STATE_C_HEX_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = ct->input_byte - 'A' + 10;
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,"?Illegal hex digit <%c> in operand",
+			ct->input_byte);
+		    error_message(tmp_message);
+		    return;
+	}/* End Switch */
+
+	case STATE_C_OCTAL_NUMBER:
+	    switch(ct->input_byte){
+		case '\\':
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_BACKSLASH;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = 8;
+		    return;
+		case '0': case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7':
+		    ct->ctx.state = STATE_C_OCTAL_NUMBER_SUBSTATE;
+		    ct->execute_state = EXEC_C_STOREVAL;
+		    ct->ctx.tmpval = ct->input_byte - '0';
+		    return;
+		default:
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    sprintf(tmp_message,"?Illegal octal digit <%c> in operand",
+			ct->input_byte);
+		    error_message(tmp_message);
+		    return;
+	    }/* End Switch*/
+
+/*
+ * The next state is the string substate. Outside states call in through here
+ * which does the initial tec_alloc of the string storage. Strings are limited
+ * to PARSER_STRING_MAX bytes at this time.
+ */
+	case STATE_C_STRING:
+	    if((ct->ctx.flags & CTOK_M_ATSIGN_SEEN) == 0){
+		ct->ctx.delimeter = ESCAPE;
+		ct->flags &= ~TOK_M_EAT_TOKEN;
+	    }
+	    else {
+		ct->ctx.delimeter = ct->input_byte;
+	    }
+	    ct->ctx.state = STATE_C_STRING1;
+	    return;
+
+	case STATE_C_STRING1:
+/*
+ * First, check if this is the termination character. This would normally be
+ * an escape, but could be another character if the user used the @ form.
+ */
+	    if( ( (ct->input_byte == ESCAPE) &&
+		  (!(ct->ctx.flags & CTOK_M_ATSIGN_SEEN))
+		) ||
+		( (ct->ctx.flags & CTOK_M_ATSIGN_SEEN) &&
+		  (ct->input_byte == ct->ctx.delimeter) &&
+		  (ct->ctx.carg != NULL)
+		)
+	      ){
+		ct->flags &= ~TOK_M_EAT_TOKEN;
+		ct->ctx.state = STATE_C_RETURN;
+		return;
+	    }/* End IF */
+
+/*
+ * Here when we see a normal character inside of the string. Note that we
+ * have to do the undo stuff to manage the string since it gets stored in
+ * a regular string array rather than being spread through the command
+ * tokens.
+ */
+	    {/* Local Block */
+	    register char *cp;
+	    register struct undo_token *ut;
+/*
+ * Get the address of the string
+ */
+	    cp = ct->ctx.carg;
+/*
+ * If there is no string allocated yet, then we have to allocate one.
+ * Also, if an @ was seen, then record the delimeter character.
+ */
+	    if(cp == NULL){
+		ct->ctx.carg = cp = tec_alloc(TYPE_C_CBUFF,PARSER_STRING_MAX);
+		if(cp == NULL){
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		*cp = '\0';
+		ut = allocate_undo_token(uct);
+		if(ut == NULL){
+		    ct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ut->opcode = UNDO_C_MEMFREE;
+		ut->carg1 = cp;
+	    }/* End IF */
+/*
+ * Each time we append a character to the string, we also have to allocate
+ * an undo token which will shorten the string if the input character gets
+ * rubbed out.
+ */
+	    ut = allocate_undo_token(uct);
+	    if(ut == NULL){
+		ct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+	    ut->opcode = UNDO_C_SHORTEN_STRING;
+	    ut->carg1 = cp;
+	    ut->iarg1 = 0;
+	    while(*cp){
+		ut->iarg1 += 1;
+		cp++;
+	    }/* End While */
+	    if(ut->iarg1 >= (PARSER_STRING_MAX-1)){
+		sprintf(tmp_message,"?Exceeded maximum string length of %d",
+		    PARSER_STRING_MAX-1);
+		error_message(tmp_message);
+		ct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+/*
+ * Finally, we append the input byte to the string
+ */
+	    *cp++ = ct->input_byte;
+	    *cp++ = '\0';
+	    ct->ctx.state = STATE_C_STRING1;
+	    return;
+	    }/* End Local Block */
+/*
+ * The following state gets the Q register that will be used with the
+ * G command.
+ */
+	case STATE_C_GQREGISTER:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_GQREGISTER;
+	    return;
+/*
+ * The following state gets the Q register that will be used with the
+ * M command.
+ */
+	case STATE_C_MQREGISTER:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_MQREGISTER;
+	    return;
+/*
+ * The following two states implement the EQ command which reads a file into
+ * the specified Q-register.
+ */
+	case STATE_C_EQQREGISTER1:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->execute_state = EXEC_C_STOREVAL;
+	    ct->ctx.tmpval = ct->input_byte;
+	    ct->ctx.state = STATE_C_STRING;
+
+	    oct = ct;
+	    ct = allocate_cmd_token(oct);
+	    if(ct == NULL){
+		oct->ctx.state = STATE_C_ERRORSTATE;
+		return;
+	    }/* End IF */
+	    ct->ctx.caller_token = oct;
+	    ct->ctx.return_state = STATE_C_EQQREGISTER2;
+	    return;
+	case STATE_C_EQQREGISTER2:
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->execute_state = EXEC_C_EQQREGISTER;
+	    if(ct->ctx.flags & CTOK_M_COLON_SEEN){
+		oct = ct;
+		ct = allocate_cmd_token(oct);
+		if(ct == NULL){
+		    oct->ctx.state = STATE_C_ERRORSTATE;
+		    return;
+		}/* End IF */
+		ct->ctx.iarg1_flag = YES; ct->ctx.iarg2_flag = NO;
+		ct->execute_state = EXEC_C_STORE1;
+	    }/* End IF */
+	    return;
+/*
+ * The following state gets the Q register that will be loaded with the
+ * U command.
+ */
+	case STATE_C_UQREGISTER:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_UQREGISTER;
+	    return;
+/*
+ * The following state gets the Q register that will be loaded with the
+ * X command.
+ */
+	case STATE_C_XQREGISTER:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_XQREGISTER;
+	    return;
+/*
+ * The following state gets the Q register that will be loaded with the
+ * previous command line in response to the '*' command.
+ */
+	case STATE_C_SAVECOMMAND:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_SAVECOMMAND;
+	    return;
+/*
+ * The following state gets the Q register which will be pushed onto the
+ * Q register stack.
+ */
+	case STATE_C_PUSH_QREGISTER:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_PUSH_QREGISTER;
+	    return;
+/*
+ * The following state gets the Q register which will be popped from the
+ * Q register stack.
+ */
+	case STATE_C_POP_QREGISTER:
+	    if(!parse_check_qname(ct,ct->input_byte)) return;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->q_register = ct->input_byte;
+	    ct->execute_state = EXEC_C_POP_QREGISTER;
+	    return;
+
+/*
+ * Here to insert characters. The insert state continues until an escape
+ * is seen. Escapes can also be quoted if they are to be inserted into the
+ * buffer. If there are many escapes to be inserted, it may be easier to use
+ * the @ insert command...
+ */
+	case STATE_C_INSERT:
+	    switch(ct->input_byte){
+/*
+ * Here when we see a non-quoted escape. This terminates the insert.
+ */
+		case ESCAPE:
+		    ct->flags &= ~TOK_M_EAT_TOKEN;
+		    ct->ctx.state = STATE_C_INITIALSTATE;
+		    return;
+/*
+ * Here to enter a quote character. This lets you insert characters that would
+ * normally be handled otherwise. ESCAPE is a good example of this.
+ */
+		case CNTRL_V:
+		    ct->ctx.state = STATE_C_QUOTED_INSERT;
+		    return;
+/*
+ * Here to handle a normal character. It will simply be inserted into the
+ * edit buffer.
+ */
+		default:
+		    ct->ctx.state = STATE_C_INSERT;
+		    ct->execute_state = EXEC_C_INSERT;
+		    return;
+	    }/* End Switch */
+/*
+ * Here to insert a character directly following the quote character. If
+ * this is a special character such as an escape, it will be inserted and
+ * will not terminate the insert command.
+ */
+	case STATE_C_QUOTED_INSERT:
+	    ct->ctx.state = STATE_C_INSERT;
+	    ct->execute_state = EXEC_C_INSERT;
+	    return;
+
+/*
+ * Here for the alternate form of insert, @I/text/
+ */
+	case STATE_C_ATINSERT:
+	    ct->ctx.tmpval = ct->input_byte;
+	    ct->execute_state = EXEC_C_STOREVAL;
+	    ct->ctx.state = STATE_C_ATINSERT_PART2;
+	    return;
+
+	case STATE_C_ATINSERT_PART2:
+	    if(ct->input_byte == ct->ctx.tmpval){
+		ct->ctx.state = STATE_C_INITIALSTATE;
+		return;
+	    }/* End IF */
+
+	    ct->ctx.state = STATE_C_ATINSERT_PART2;
+	    ct->execute_state = EXEC_C_INSERT;
+	    return;
+/*
+ * Here after seeing an equals command. This lets us test for two or three
+ * in a row which output in octal and hex respectively.
+ */
+	case STATE_C_ONE_EQUALS:
+	    if(ct->input_byte != '='){
+		ct->ctx.state = STATE_C_INITIALSTATE;
+		ct->flags &= ~TOK_M_EAT_TOKEN;
+		return;
+	    }/* End IF */
+	    ct->ctx.state = STATE_C_TWO_EQUALS;
+	    ct->execute_state = EXEC_C_TWO_EQUALS;
+	    return;
+	case STATE_C_TWO_EQUALS:
+	    if(ct->input_byte != '='){
+		ct->ctx.state = STATE_C_INITIALSTATE;
+		ct->flags &= ~TOK_M_EAT_TOKEN;
+		return;
+	    }/* End IF */
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    ct->execute_state = EXEC_C_THREE_EQUALS;
+	    return;
+
+/*
+ * Here when we have seen a vertical bar. We have to put a mark here so
+ * that if the condition is not met, the else clause can be found.
+ */
+	case STATE_C_SKIP_ELSE:
+	    ct->opcode = TOK_C_CONDITIONAL_ELSE;
+	    ct->ctx.state = STATE_C_INITIALSTATE;
+	    return;
+
+	case STATE_C_BACKSLASH:
+	    ct->ctx.state = STATE_C_RETURN;
+	    ct->execute_state = EXEC_C_BACKSLASHARG;
+	    return;
+
+	default:
+	    sprintf(tmp_message,"?Dispatched unknown state %d",ct->ctx.state);
+	    error_message(tmp_message);
+	    return;
+    }/* End Switch */
+
+}/* End Routine */
+
+
+
+/* PARSE_CHECK_QNAME - Check that the specified Q-register name is ok
+ *
+ * Function:
+ *
+ *	This routine is called when a parse state wants to verify that the
+ *	specified Q-register name is syntactically correct. It does not
+ *	verify that the Q-register exists, because the execute phase may just
+ *	not have got around to that yet.
+ */
+int
+parse_check_qname(ct,name)
+register struct cmd_token *ct;
+register char name;
+{
+char tmp_message[LINE_BUFFER_SIZE];
+
+    PREAMBLE();
+
+    switch(name){
+	case '*':
+	case '_':
+	case '-':
+	case '@':
+	case '?':
+	    return(SUCCESS);
+    }/* End Switch */
+
+    if(isalnum((int)name)) return(SUCCESS);
+
+    sprintf(tmp_message,"?Illegal Q-register Name <%c>",name);
+    error_message(tmp_message);
+    ct->ctx.state = STATE_C_ERRORSTATE;
+    return(FAIL);
+
+}/* End Routine */