[moira.git] / clients / mmoira / parser.c

/* $Header$
 *
 * TOPS-20 style command parser
 *
 */

#include <stdio.h>
#include <ctype.h>
#include <sys/signal.h>
#include <X11/Intrinsic.h>
#include "mmoira.h"
#include "parser.h"


/* trivial absolute-value macro */
#define abs(i)	((i) < 0 ? -(i) : (i))

/* message used when end of parse tree is reached */
char	eolmsg[] = "return to execute command";


/* main entry point.  Takes the prompt and top node of the parse tree, and
 * will collect user's input, providing help and completion.  When entry
 * is complete (<return> is pressed), the actions called for by each node
 * in the parse tree which is traversed will be executed.
 */

int	parser(prompt, nd)
char	*prompt;
struct parse_node	*nd;
{
    char line[BUFLEN];
    char *p, c;
    int	val;

    p = &line[0];
    *p = 0;
    write(1, prompt, strlen(prompt));
    for (c = (getchar() & 0x7F); 1; c = (getchar() & 0x7F)) {
	if (c == 0)
	  continue;
	switch (c) {
	case 127:
	case '\b':
	    if (p == &line[0]) {
		putchar(7);
		break;
	    }
	    if (*(--p) == 'I' - '@') {
		*p = 0;
		printf("\r%s%s", prompt, line);
		fflush(stdout);
		break;
	    }
	    *p = 0;
	    write(1, "\b \b", 3);
	    break;
	case 'C' - '@':
	case 'G' - '@':
	    write(1, " \007ABORT\r\n", 9);
	    return(ABORT);
	case 'Q' - '@':
	case 'V' - '@':
	    putchar('\\');
	    c = getchar();
	    if (c < ' ')
	      printf("\b^%c", c + '@');
	    else
	      printf("\b%c", c);
	    fflush(stdout);
	    *p++ = c;
	    break;
	case 'W' - '@':
	    if (p > &line[0])
	      p--;
	    while ((p >= &line[0]) && isspace(*p)) {
		write(1, "\b \b", 3);
		p--;
	    }
	    while ((p >= &line[0]) && !isspace(*p)) {
		write(1, "\b \b", 3);
		p--;
	    }
	    if (p > &line[0]) {
		p++;
	    } else {
		p = &line[0];
	    }
	    *p = 0;
	    break;
	case '?':
	    write(1, "?  ", 3);
	    *p = 0;
	    do_help(&line[0], nd, prompt);
	    p = &line[strlen(line)];
	    printf("\n\r%s%s", prompt, line);
	    fflush(stdout);
	    break;
	case '[' - '@':
	case '\t':
	    *p = 0;
	    do_complete(&line[0], nd, prompt);
	    p = &line[strlen(line)];
	    break;
	case 'Z' - '@':
	    printf("\r\n");
	    cooked_mode();
	    kill(getpid(), SIGSTOP);
	    raw_mode();
	    /* when continued, fall through to */
	case 'R' - '@':
	    *p = 0;
	    printf("\r\n%s%s", prompt, line);
	    fflush(stdout);
	    break;
	case 'U' - '@':
	    while (p-- > &line[0])
	      write(1, "\b \b", 3);
	    *(++p) = 0;
	    printf("\r%s", prompt);
	    fflush(stdout);
	    break;
	case '\n':
	case '\r':
	    if ((val = do_parse(line, nd, prompt)) != ERROR) {
		write(1, "\r\n", 2);
		return(val);
	    }
	    p = &line[strlen(line)];
	    *p = 0;
	    printf("\r\n%s%s", prompt, line);
	    fflush(stdout);
	    break;
	default:
	    putchar(c);
	    *p++ = c;
	    *p = 0;
	}
    }
}


/* called when a ? is typed.  This parses the line as far as possible, then
 * displays possible completions and help strings.
 */

do_help(line, nod, prompt)
char *line;
struct parse_node *nod;
char *prompt;
{
    char *ln;
    struct parse_node *n, *nd, *last;
    int kw, state, nomatch;
    struct parse_node *best, *ambig;

    n = nod;
    state = MATCH;
    best = NULNODE;
    for (ln = line; n && state == MATCH; best && (n = best->p_next)) {
	last = best;
	state = single_parse(&ln, n, &best, &ambig, &nomatch);
    }
    if (*ln && ((best && best->p_menu) || n == NULNODE))
      state = NOMATCH;
    switch (state) {
    case NOMATCH:
	if (!*ln) {
	    if (last && last->p_menu  && *line)
	      printf("Carriage return, or ");
	    break;
	}
	ln += nomatch;
	*ln = 0;
	write(1, "\r\nNOT a valid command line", 26);
	return;
    case AMBIG:
	write(1, "one of the following:\r\n   ", 26);
	for (; ambig; ambig = ambig->p_link)
	  printf("%s ", ambig->p_word);
	fflush(stdout);
	return;
    case INCOMP:
	printf("one of the following:\r\n   %s", best->p_word);
	fflush(stdout);
	return;
    default:
	write(1, eolmsg, strlen(eolmsg));
	return;
    }
    kw = 0;
    for (nd = n; nd; nd = nd->p_peer) {
	if (!kw) {
	    write(1, "one of the following:\r\n   ", 26);
	    kw = 3;
	}
	if (kw + strlen(nd->p_word) > 72) {
	    printf("\r\n   %s ", nd->p_word);
	    fflush(stdout);
	    kw = 4 + strlen(nd->p_word);
	} else {
	    printf("%s ", nd->p_word);
	    fflush(stdout);
	    kw += 1 + strlen(nd->p_word);
	}
    }
}


/* Do escape processing.  If a unique completion exists, use it.  Otherwise,
 * do the same as ?.
 */

do_complete(line, nod, prompt)
char *line;
struct parse_node *nod;
char *prompt;
{
    struct parse_node *n, *nd;
    char *ln;
    char *tmp;
    int	state, nomatch;
    struct parse_node *best, *ambig;

    ln = line;
    state = MATCH;
    nd = nod;
    while (state == MATCH) {
	tmp = ln;
	state = single_parse(&ln, nd, &best, &ambig, &nomatch);
	if (state == MATCH)
	  nd = best->p_next;
    }
    switch (state) {
    case AMBIG:
/*	printf("ln %X, tmp %X, ln - tmp %d, nomatch %d\r\n", ln, tmp, ln-tmp, nomatch);
	if (ln - tmp < nomatch) {
	    printf("attempting partial complete\r\n");
	    fflush(stdout);
	    sleep(1);
	    while ((ln > line) && !isspace(*ln))
	      ln--;
	    tmp = ambig->p_word;
	    while (nomatch--)
	      *ln++ = *tmp++;
	    *ln = 0;
	    putchar(7);
	    return;
	} */
	/* fall through to: */
    case NOMATCH:
	if (!(nd) || (nd->p_peer)) {
	    write(1, "  ", 2);
	    do_help(line, nod, prompt);
	    printf("\r\n%s%s", prompt, line);
	    fflush(stdout);
	    return;
	}
	best = nd;
	*ln++ = 'x';
	/* fall through to incomplete case */
    case INCOMP:
	ln = tmp;
	do {
	    tmp = best->p_word;
	    while (*tmp)
	      *ln++ = *tmp++;
	    *ln++ = ' ';
	    *ln = 0;
	} while (best->p_next && !best->p_next->p_peer &&
		 !best->p_menu && (best = best->p_next));
	printf("\r%s%s", prompt, line);
	fflush(stdout);
	break;
    default:
	write(1, "We shouldn't get here (parser error)\r\n", 38);
    }
}


/* Single parse parses through a single level of the parse tree.
 * There are 4 possible outcomes:
 *	an exact match is made: the matching node is returned, ambig = 0
 *	an incomplete match: the matching node is returned, ambig = node
 *	ambiguous: nothing is returned, ambig = list of completions
 *	no matches: nothing is returned, ambig = 0
 */

int single_parse(line, nd, best, ambig, nomatch)
char **line;
struct parse_node *nd;
struct parse_node **best;
struct parse_node **ambig;
int *nomatch;
{
    char *p;
    char c;			/* char we're working on (from line) */
    struct parse_node *n;	/* node loop counter */
    struct parse_node *tail;	/* tmp used to build chains */
    int i;			/* loop counter */
    int	match;			/* how many chars have we matched? */
    int len;			/* length of this keyword */

#ifdef DEBUG
    printf("single_parse(\"%s\") -> ", *line);
#endif /* DEBUG */
    *ambig = tail = *best = NULNODE;
    match = *nomatch = 0;
    /* skip leading whitespace */
    while (isspace(**line))
      (*line)++;
    /* step through each node */
    for (n = nd; n; n = n->p_peer) {
	len = strlen(n->p_word);
	/* step through each character in line */
	for (i = 0; 1; i++) {
	    /* if at end of word on line */
	    if (isspace((*line)[i]) || (*line)[i] == 0) {
		/* another ambiguous match */
		if (i == match && i) {
		    tail->p_link = n;
		    tail = n;
		    n->p_link = NULNODE;
		}
		/* a better match */
		if (i > match) {
		    match = i;
		    *best = tail = *ambig = n;
		    n->p_link = NULNODE;
		}
		break;
	    }
	    if (isupper(c = (*line)[i]))
	      c = tolower(c);
	    if (c != n->p_word[i]) {
		if (i > *nomatch)
		  *nomatch = i;
		break;
	    }
	}
    }
    if (match > 0) {
	(*line) += match;
	if (tail != *ambig) {
	    *best = NULNODE;
	    *nomatch = match;
	    if (isspace(**line)) {
#ifdef DEBUG
		printf("NOMATCH\n");
#endif /* DEBUG */
		return(NOMATCH);
	    } else {
#ifdef DEBUG
		printf("AMBIG\n");
#endif /* DEBUG */
		return(AMBIG);
	    }
	}
	if (isspace(**line)) {
	    *ambig = NULNODE;
	    while (isspace(**line))
	      (*line)++;
#ifdef DEBUG
	    printf("MATCH\n");
#endif /* DEBUG */
	    return(MATCH);
	}
#ifdef DEBUG
	printf("INCOMP\n");
#endif /* DEBUG */
	return(INCOMP);
    }
    *ambig = tail = *best = NULNODE;
#ifdef DEBUG
    printf("NOMATCH\n");
#endif /* DEBUG */
    return(NOMATCH);
}


/* execute the line.  First check to see that the line is legal.  If not,
 * do_help the line & return ERROR.  If so, execute each node passed through,
 * and return OK (or EXIT if an EXIT node was encountered).
 */

int do_parse(line, nod, prompt)
char *line;
struct parse_node *nod;
char *prompt;
{
    struct parse_node *n, *nd, *last;
    char *ln, *tmp;
    int state, i;
    struct parse_node *best, *ambig;
    int	nomatch;
    EntryForm *f;

    ln = line;
    n = nod;
    state = MATCH;
    best = NULNODE;
    while (n && ((state == MATCH) || (state == INCOMP))) {
	last = best;
	state = single_parse(&ln, n, &best, &ambig, &nomatch);
#ifdef DEBUG
	printf("best = %s, best->next = 0x%x\r\n", best ? best->p_word : "",
	       best ? best->p_next : 0);
#endif /* DEBUG */
	if ((state == NOMATCH) && (!*ln) && (n == nod))
	  return(OK);
	if ((state == MATCH) || (state == INCOMP)) {
	    n = best->p_next;
	}
    }
    if (((state == AMBIG) || (state == NOMATCH)) && !*ln)
      for (; n; n = n->p_peer)
	if (last && last->p_menu) {
	    n = last;
	    state = MATCH;
	    break;
	}
    if (state == NOMATCH && !*ln) {
	while (last && last->p_next && !last->p_next->p_peer && !last->p_menu)
	  last = last->p_next;
	if (last && last->p_menu) {
	    state = MATCH;
	    best = last;
	}
    }

    if ((state == NOMATCH) || (state == AMBIG)) {
	write(1, "  BAD command,  ", 16);
	do_help(line, nod, prompt);
	return(ERROR);
    }
    if (!best)
      best = n;
    write(1, "\r\n", 2);
    cooked_mode();
    for (i = 0; line[i] && !isspace(line[i]); i++);
    if (!strncmp("help", line, i))
      help(best->p_menu->form);
    else
      MoiraMenuRequest(best->p_menu);
    raw_mode();
    return(OK);
}
Commit	Line	Data
053a78b2	1	/* $Header$
	2	*
	3	* TOPS-20 style command parser
	4	*
	5	*/
	6
	7	#include <stdio.h>
	8	#include <ctype.h>
	9	#include <sys/signal.h>
	10	#include <X11/Intrinsic.h>
	11	#include "mmoira.h"
	12	#include "parser.h"
	13
	14
	15	/* trivial absolute-value macro */
	16	#define abs(i) ((i) < 0 ? -(i) : (i))
	17
	18	/* message used when end of parse tree is reached */
	19	char eolmsg[] = "return to execute command";
	20
	21
	22	/* main entry point. Takes the prompt and top node of the parse tree, and
	23	* will collect user's input, providing help and completion. When entry
	24	* is complete (<return> is pressed), the actions called for by each node
	25	* in the parse tree which is traversed will be executed.
	26	*/
	27
	28	int parser(prompt, nd)
	29	char *prompt;
	30	struct parse_node *nd;
	31	{
	32	char line[BUFLEN];
	33	char *p, c;
	34	int val;
	35
	36	p = &line[0];
	37	*p = 0;
	38	write(1, prompt, strlen(prompt));
	39	for (c = (getchar() & 0x7F); 1; c = (getchar() & 0x7F)) {
	40	if (c == 0)
	41	continue;
	42	switch (c) {
	43	case 127:
	44	case '\b':
	45	if (p == &line[0]) {
	46	putchar(7);
	47	break;
	48	}
	49	if (*(--p) == 'I' - '@') {
	50	*p = 0;
	51	printf("\r%s%s", prompt, line);
	52	fflush(stdout);
	53	break;
	54	}
	55	*p = 0;
	56	write(1, "\b \b", 3);
	57	break;
	58	case 'C' - '@':
	59	case 'G' - '@':
	60	write(1, " \007ABORT\r\n", 9);
	61	return(ABORT);
	62	case 'Q' - '@':
	63	case 'V' - '@':
	64	putchar('\\');
65	c = getchar();
66	if (c < ' ')
67	printf("\b^%c", c + '@');
68	else
69	printf("\b%c", c);
70	fflush(stdout);
71	*p++ = c;
72	break;
73	case 'W' - '@':
74	if (p > &line[0])
75	p--;
76	while ((p >= &line[0]) && isspace(*p)) {
77	write(1, "\b \b", 3);
78	p--;
79	}
80	while ((p >= &line[0]) && !isspace(*p)) {
81	write(1, "\b \b", 3);
82	p--;
83	}
84	if (p > &line[0]) {
85	p++;
86	} else {
87	p = &line[0];
88	}
89	*p = 0;
90	break;
91	case '?':
92	write(1, "? ", 3);
93	*p = 0;
94	do_help(&line[0], nd, prompt);
95	p = &line[strlen(line)];
96	printf("\n\r%s%s", prompt, line);
97	fflush(stdout);
98	break;
99	case '[' - '@':
100	case '\t':
101	*p = 0;
102	do_complete(&line[0], nd, prompt);
103	p = &line[strlen(line)];
104	break;
105	case 'Z' - '@':
106	printf("\r\n");
f631c332	107	cooked_mode();
053a78b2	108	kill(getpid(), SIGSTOP);
f631c332	109	raw_mode();
053a78b2	110	/* when continued, fall through to */
	111	case 'R' - '@':
	112	*p = 0;
	113	printf("\r\n%s%s", prompt, line);
	114	fflush(stdout);
	115	break;
	116	case 'U' - '@':
	117	while (p-- > &line[0])
	118	write(1, "\b \b", 3);
	119	*(++p) = 0;
	120	printf("\r%s", prompt);
	121	fflush(stdout);
	122	break;
	123	case '\n':
	124	case '\r':
	125	if ((val = do_parse(line, nd, prompt)) != ERROR) {
	126	write(1, "\r\n", 2);
	127	return(val);
	128	}
	129	p = &line[strlen(line)];
	130	*p = 0;
	131	printf("\r\n%s%s", prompt, line);
	132	fflush(stdout);
	133	break;
	134	default:
	135	putchar(c);
	136	*p++ = c;
	137	*p = 0;
	138	}
	139	}
	140	}
	141
	142
	143	/* called when a ? is typed. This parses the line as far as possible, then
	144	* displays possible completions and help strings.
	145	*/
	146
	147	do_help(line, nod, prompt)
	148	char *line;
	149	struct parse_node *nod;
	150	char *prompt;
	151	{
	152	char *ln;
	153	struct parse_node n, nd, *last;
	154	int kw, state, nomatch;
	155	struct parse_node best, ambig;
	156
	157	n = nod;
	158	state = MATCH;
e8e78110	159	best = NULNODE;
053a78b2	160	for (ln = line; n && state == MATCH; best && (n = best->p_next)) {
	161	last = best;
	162	state = single_parse(&ln, n, &best, &ambig, &nomatch);
	163	}
	164	if (*ln && ((best && best->p_menu) \|\| n == NULNODE))
	165	state = NOMATCH;
	166	switch (state) {
	167	case NOMATCH:
	168	if (!*ln) {
	169	if (last && last->p_menu && *line)
	170	printf("Carriage return, or ");
	171	break;
	172	}
	173	ln += nomatch;
	174	*ln = 0;
	175	write(1, "\r\nNOT a valid command line", 26);
	176	return;
	177	case AMBIG:
	178	write(1, "one of the following:\r\n ", 26);
	179	for (; ambig; ambig = ambig->p_link)
	180	printf("%s ", ambig->p_word);
	181	fflush(stdout);
	182	return;
	183	case INCOMP:
	184	printf("one of the following:\r\n %s", best->p_word);
	185	fflush(stdout);
	186	return;
	187	default:
	188	write(1, eolmsg, strlen(eolmsg));
	189	return;
	190	}
	191	kw = 0;
	192	for (nd = n; nd; nd = nd->p_peer) {
	193	if (!kw) {
	194	write(1, "one of the following:\r\n ", 26);
	195	kw = 3;
	196	}
	197	if (kw + strlen(nd->p_word) > 72) {
	198	printf("\r\n %s ", nd->p_word);
	199	fflush(stdout);
	200	kw = 4 + strlen(nd->p_word);
	201	} else {
	202	printf("%s ", nd->p_word);
	203	fflush(stdout);
	204	kw += 1 + strlen(nd->p_word);
	205	}
	206	}
	207	}
	208
	209
	210	/* Do escape processing. If a unique completion exists, use it. Otherwise,
	211	* do the same as ?.
	212	*/
	213
	214	do_complete(line, nod, prompt)
	215	char *line;
	216	struct parse_node *nod;
	217	char *prompt;
	218	{
	219	struct parse_node n, nd;
	220	char *ln;
	221	char *tmp;
	222	int state, nomatch;
	223	struct parse_node best, ambig;
224
225	ln = line;
226	state = MATCH;
227	nd = nod;
228	while (state == MATCH) {
229	tmp = ln;
230	state = single_parse(&ln, nd, &best, &ambig, &nomatch);
231	if (state == MATCH)
232	nd = best->p_next;
233	}
234	switch (state) {
235	case AMBIG:
236	/* printf("ln %X, tmp %X, ln - tmp %d, nomatch %d\r\n", ln, tmp, ln-tmp, nomatch);
237	if (ln - tmp < nomatch) {
238	printf("attempting partial complete\r\n");
239	fflush(stdout);
240	sleep(1);
241	while ((ln > line) && !isspace(*ln))
242	ln--;
243	tmp = ambig->p_word;
244	while (nomatch--)
245	ln++ = tmp++;
246	*ln = 0;
247	putchar(7);
248	return;
249	} */
250	/* fall through to: */
251	case NOMATCH:
252	if (!(nd) \|\| (nd->p_peer)) {
253	write(1, " ", 2);
254	do_help(line, nod, prompt);
255	printf("\r\n%s%s", prompt, line);
256	fflush(stdout);
257	return;
258	}
259	best = nd;
260	*ln++ = 'x';
261	/* fall through to incomplete case */
262	case INCOMP:
263	ln = tmp;
264	do {
265	tmp = best->p_word;
266	while (*tmp)
267	ln++ = tmp++;
268	*ln++ = ' ';
269	*ln = 0;
270	} while (best->p_next && !best->p_next->p_peer &&
271	!best->p_menu && (best = best->p_next));
272	printf("\r%s%s", prompt, line);
273	fflush(stdout);
274	break;
275	default:
276	write(1, "We shouldn't get here (parser error)\r\n", 38);
277	}
278	}
279
280
281	/* Single parse parses through a single level of the parse tree.
282	* There are 4 possible outcomes:
283	* an exact match is made: the matching node is returned, ambig = 0
284	* an incomplete match: the matching node is returned, ambig = node
285	* ambiguous: nothing is returned, ambig = list of completions
286	* no matches: nothing is returned, ambig = 0
287	*/
288
289	int single_parse(line, nd, best, ambig, nomatch)
290	char **line;
291	struct parse_node *nd;
292	struct parse_node **best;
293	struct parse_node **ambig;
294	int *nomatch;
295	{
296	char *p;
297	char c; /* char we're working on (from line) */
298	struct parse_node n; / node loop counter */
299	struct parse_node tail; / tmp used to build chains */
300	int i; /* loop counter */
301	int match; /* how many chars have we matched? */
302	int len; /* length of this keyword */
303
304	#ifdef DEBUG
305	printf("single_parse(\"%s\") -> ", *line);
306	#endif /* DEBUG */
307	ambig = tail = best = NULNODE;
308	match = *nomatch = 0;
309	/* skip leading whitespace */
310	while (isspace(**line))
311	(*line)++;
312	/* step through each node */
313	for (n = nd; n; n = n->p_peer) {
314	len = strlen(n->p_word);
315	/* step through each character in line */
316	for (i = 0; 1; i++) {
317	/* if at end of word on line */
318	if (isspace((line)[i]) \|\| (line)[i] == 0) {
319	/* another ambiguous match */
320	if (i == match && i) {
321	tail->p_link = n;
322	tail = n;
323	n->p_link = NULNODE;
324	}
325	/* a better match */
326	if (i > match) {
327	match = i;
328	best = tail = ambig = n;
329	n->p_link = NULNODE;
330	}
331	break;
332	}
333	if (isupper(c = (*line)[i]))
334	c = tolower(c);
335	if (c != n->p_word[i]) {
336	if (i > *nomatch)
337	*nomatch = i;
338	break;
339	}
340	}
341	}
342	if (match > 0) {
343	(*line) += match;
344	if (tail != *ambig) {
345	*best = NULNODE;
346	*nomatch = match;
347	if (isspace(**line)) {
348	#ifdef DEBUG
349	printf("NOMATCH\n");
350	#endif /* DEBUG */
351	return(NOMATCH);
352	} else {
353	#ifdef DEBUG
354	printf("AMBIG\n");
355	#endif /* DEBUG */
356	return(AMBIG);
357	}
358	}
359	if (isspace(**line)) {
360	*ambig = NULNODE;
361	while (isspace(**line))
362	(*line)++;
363	#ifdef DEBUG
364	printf("MATCH\n");
365	#endif /* DEBUG */
366	return(MATCH);
367	}
368	#ifdef DEBUG
369	printf("INCOMP\n");
370	#endif /* DEBUG */
371	return(INCOMP);
372	}
373	ambig = tail = best = NULNODE;
374	#ifdef DEBUG
375	printf("NOMATCH\n");
376	#endif /* DEBUG */
377	return(NOMATCH);
378	}
379
380
381	/* execute the line. First check to see that the line is legal. If not,
382	* do_help the line & return ERROR. If so, execute each node passed through,
383	* and return OK (or EXIT if an EXIT node was encountered).
384	*/
385
386	int do_parse(line, nod, prompt)
387	char *line;
388	struct parse_node *nod;
389	char *prompt;
390	{
391	struct parse_node n, nd, *last;
392	char ln, tmp;
393	int state, i;
394	struct parse_node best, ambig;
395	int nomatch;
396	EntryForm *f;
397
398	ln = line;
399	n = nod;
400	state = MATCH;
401	best = NULNODE;
402	while (n && ((state == MATCH) \|\| (state == INCOMP))) {
403	last = best;
404	state = single_parse(&ln, n, &best, &ambig, &nomatch);
405	#ifdef DEBUG
406	printf("best = %s, best->next = 0x%x\r\n", best ? best->p_word : "",
407	best ? best->p_next : 0);
408	#endif /* DEBUG */
409	if ((state == NOMATCH) && (!*ln) && (n == nod))
410	return(OK);
411	if ((state == MATCH) \|\| (state == INCOMP)) {
412	n = best->p_next;
413	}
414	}
415	if (((state == AMBIG) \|\| (state == NOMATCH)) && !*ln)
416	for (; n; n = n->p_peer)
417	if (last && last->p_menu) {
418	n = last;
419	state = MATCH;
420	break;
421	}
422	if (state == NOMATCH && !*ln) {
423	while (last && last->p_next && !last->p_next->p_peer && !last->p_menu)
424	last = last->p_next;
425	if (last && last->p_menu) {
426	state = MATCH;
427	best = last;
428	}
429	}
430
431	if ((state == NOMATCH) \|\| (state == AMBIG)) {
432	write(1, " BAD command, ", 16);
433	do_help(line, nod, prompt);
434	return(ERROR);
435	}
436	if (!best)
437	best = n;
438	write(1, "\r\n", 2);
439	cooked_mode();
440	for (i = 0; line[i] && !isspace(line[i]); i++);
441	if (!strncmp("help", line, i))
442	help(best->p_menu->form);
443	else
444	MoiraMenuRequest(best->p_menu);
445	raw_mode();
446	return(OK);
447	}