command.c

/*
 * Copyright (C) 1984-2026  Mark Nudelman
 *
 * You may distribute under the terms of either the GNU General Public
 * License or the Less License, as specified in the README file.
 *
 * For more information, see the README file.
 */


/*
 * User-level command processor.
 */

#include "less.h"
#if MSDOS_COMPILER==WIN32C
#include <windows.h>
#endif
#include "position.h"
#include "option.h"
#include "cmd.h"

extern int erase_char, erase2_char, kill_char;
extern int sigs;
extern int quit_if_one_screen;
extern lbool one_screen;
extern int sc_width;
extern int sc_height;
extern char *kent;
extern lbool kent_mapped;
extern int swindow;
extern int jump_sline;
extern lbool quitting;
extern int wscroll;
extern int top_scroll;
extern lbool ignore_eoi;
extern int hshift;
extern int bs_mode;
extern int proc_backspace;
extern int show_attn;
extern int chopline;
extern POSITION highest_hilite;
extern char *every_first_cmd;
extern char version[];
extern struct scrpos initial_scrpos;
extern IFILE curr_ifile;
extern void *ml_search;
extern void *ml_examine;
extern int wheel_lines;
extern int def_search_type;
extern int hilite_target;
extern lbool search_wrapped;
extern int no_paste;
extern lbool pasting;
extern int no_edit_warn;
extern lbool read_error;
extern POSITION soft_eof;
extern POSITION search_incr_start;
extern char *first_cmd_at_prompt;
extern lbool prompting;
#if SHELL_ESCAPE || PIPEC
extern void *ml_shell;
#endif
#if EDITOR
extern constant char *editproto;
#endif
#if OSC8_LINK
extern char *osc8_uri;
#endif
extern int shift_count;
extern lbool forw_prompt;
extern int incr_search;
extern lbool full_screen;
#if MSDOS_COMPILER==WIN32C
extern int utf_mode;
extern unsigned less_acp;
#endif

#if SHELL_ESCAPE
static char *shellcmd = NULL;   /* For holding last shell command for "!!" */
#endif
static int mca;                 /* The multicharacter command (action) */
static int search_type;         /* The previous type of search */
static int last_search_type;    /* Type of last executed search */
static LINENUM number;          /* The number typed by the user */
static long fraction;           /* The fractional part of the number */
static struct loption *curropt;
static lbool opt_lower;
static int optflag;
static lbool optgetname;
static POSITION toppos;
static POSITION bottompos;
static int save_hshift;
static int save_bs_mode;
static int save_proc_backspace;
static int screen_trashed_value = 0;
static lbool literal_char = FALSE;
static lbool ignoring_input = FALSE;
static struct scrpos search_incr_pos = { NULL_POSITION, 0 };
static int search_incr_hshift;
#if HAVE_TIME
static time_type ignoring_input_time;
#endif
#if PIPEC
static POSITION pipe_pos1;
static POSITION pipe_pos2;
#endif

/* Stack of ungotten chars (via ungetcc) */
struct ungot {
	struct ungot *ug_next;
	char ug_char;
	lbool ug_end_command;
};
static struct ungot* ungot = NULL;

static void multi_search(constant char *pattern, int n, int silent);

/*
 * Move the cursor to start of prompt line before executing a command.
 * This looks nicer if the command takes a long time before
 * updating the screen.
 */
public void cmd_exec(void)
{
	clear_attn();
	clear_bot();
	flush();
}

/*
 * Indicate we are reading a multi-character command.
 */
static void set_mca(int action)
{
	mca = action;
	clear_bot();
	clear_cmd();
}

/*
 * Indicate we are not reading a multi-character command.
 */
static void clear_mca(void)
{
	if (mca == 0)
		return;
	mca = 0;
}

/*
 * Set up the display to start a new multi-character command.
 */
static void start_mca(int action, constant char *prompt, void *mlist, int cmdflags)
{
	set_mca(action);
	cmd_putstr(prompt);
	set_mlist(mlist, cmdflags);
}

public lbool in_mca(void)
{
	return (mca != 0 && mca != A_PREFIX);
}

/*
 * Set up the display to start a new search command.
 */
static void mca_search1(void)
{
	int i;

#if HILITE_SEARCH
	if (search_type & SRCH_FILTER)
		set_mca(A_FILTER);
	else 
#endif
	if (search_type & SRCH_FORW)
		set_mca(A_F_SEARCH);
	else
		set_mca(A_B_SEARCH);

	if (search_type & SRCH_NO_MATCH)
		cmd_putstr(LM(Non_match));
	if (search_type & SRCH_FIRST_FILE)
		cmd_putstr(LM(First_file));
	if (search_type & SRCH_PAST_EOF)
		cmd_putstr(LM(EOF_ignore));
	if (search_type & SRCH_NO_MOVE)
		cmd_putstr(LM(Keep_pos));
	if (search_type & SRCH_NO_REGEX)
		cmd_putstr(LM(Regex_off));
	if (search_type & SRCH_WRAP)
		cmd_putstr(LM(Wrap));
	for (i = 1; i <= NUM_SEARCH_COLORS; i++)
	{
		if (search_type & SRCH_SUBSEARCH(i))
		{
			static char *buf = NULL;
			static size_t buflen;
			if (buf == NULL)
			{
				buflen = INT_STRLEN_BOUND(int)+strlen(LM(Sub_X)+1);
				buf = ecalloc(buflen, sizeof(char));
			}
			SNPRINTF1(buf, buflen, LM(Sub_X), i);
			cmd_putstr(buf);
		}
	}
	if (literal_char)
		cmd_putstr(LM(Lit));

#if HILITE_SEARCH
	if (search_type & SRCH_FILTER)
		cmd_putstr("&/");
	else 
#endif
	if (search_type & SRCH_FORW)
		cmd_putstr("/");
	else
		cmd_putstr("?");
	forw_prompt = FALSE;
}

static void mca_search(void)
{
	if (incr_search)
	{
		/* Remember where the incremental search started. */
		get_scrpos(&search_incr_pos, TOP);
		search_incr_start = search_pos(search_type);
		search_incr_hshift = hshift;
	}
	mca_search1();
	set_mlist(ml_search, 0);
}

/*
 * Set up the display to start a new toggle-option command.
 */
static void mca_opt_toggle(void)
{
	int no_prompt = (optflag & OPT_NO_PROMPT);
	int flag = (optflag & ~OPT_NO_PROMPT);
	constant char *dash = (flag == OPT_NO_TOGGLE) ? "_" : "-";
	
	set_mca(A_OPT_TOGGLE);
	cmd_putstr(dash);
	if (optgetname)
		cmd_putstr(dash);
	if (no_prompt)
		cmd_putstr("(P)");
	switch (flag)
	{
	case OPT_UNSET:
		cmd_putstr("+");
		break;
	case OPT_SET:
		cmd_putstr("!");
		break;
	}
	forw_prompt = FALSE;
	set_mlist(NULL, CF_OPTION);
}

/*
 * Execute a multicharacter command.
 */
static void exec_mca(void)
{
	constant char *cbuf;

	cmd_exec();
	cbuf = get_cmdbuf();
	if (cbuf == NULL)
		return;

	switch (mca)
	{
	case A_F_SEARCH:
	case A_B_SEARCH:
		multi_search(cbuf, (int) number, 0);
		break;
#if HILITE_SEARCH
	case A_FILTER:
		search_type ^= SRCH_NO_MATCH;
		set_filter_pattern(cbuf, search_type);
		soft_eof = NULL_POSITION;
		break;
#endif
	case A_FIRSTCMD:
		/*
		 * Skip leading spaces or + signs in the string.
		 */
		while (*cbuf == '+' || *cbuf == ' ')
			cbuf++;
		if (every_first_cmd != NULL)
			free(every_first_cmd);
		if (*cbuf == '\0')
			every_first_cmd = NULL;
		else
			every_first_cmd = save(cbuf);
		break;
	case A_OPT_TOGGLE:
		toggle_option(curropt, opt_lower, cbuf, optflag);
		curropt = NULL;
		break;
	case A_F_BRACKET:
		match_brac(cbuf[0], cbuf[1], TRUE, (int) number);
		break;
	case A_B_BRACKET:
		match_brac(cbuf[1], cbuf[0], FALSE, (int) number);
		break;
#if EXAMINE
	case A_EXAMINE: {
		char *p;
		if (!secure_allow(SF_EXAMINE))
			break;
		p = save(cbuf);
		edit_list(p);
		free(p);
#if TAGS
		/* If tag structure is loaded then clean it up. */
		cleantags();
#endif
		break; }
#endif
#if SHELL_ESCAPE
	case A_SHELL: {
		/*
		 * !! just uses whatever is in shellcmd.
		 * Otherwise, copy cmdbuf to shellcmd,
		 * expanding any special characters ("%" or "#").
		 */
		constant char *done_msg = (*cbuf == CONTROL('P')) ? NULL : LM(shell_done);
		if (done_msg == NULL)
			++cbuf;
		if (strcmp(cbuf, "!") != 0)
		{
			if (shellcmd != NULL)
				free(shellcmd);
			shellcmd = fexpand(cbuf);
		}
		if (!secure_allow(SF_SHELL))
			break;
		lsystem(shellcmd == NULL ? "" : shellcmd, done_msg);
		break; }
	case A_PSHELL: {
		constant char *done_msg = (*cbuf == CONTROL('P')) ? NULL : LM(hash_done);
		if (done_msg == NULL)
			++cbuf;
		if (!secure_allow(SF_SHELL))
			break;
		lsystem(pr_expand(cbuf), done_msg);
		break; }
#endif
#if PIPEC
	case A_PIPE: {
		constant char *done_msg = (*cbuf == CONTROL('P')) ? NULL : LM(pipe_done);
		if (done_msg == NULL)
			++cbuf;
		if (!secure_allow(SF_PIPE))
			break;
		(void) pipe_pos(cbuf, pipe_pos1, pipe_pos2, done_msg);
		break; }
#endif
	}
}

/*
 * Is a character an erase or kill char?
 */
static lbool is_erase_char(char c)
{
	return (c == erase_char || c == erase2_char || c == kill_char);
}

/*
 * Is a character a carriage return or newline?
 */
static lbool is_newline_char(char c)
{
	return (c == '\n' || c == '\r');
}

/*
 * Handle the first char of an option (after the initial dash).
 */
static int mca_opt_first_char(char c)
{
	int no_prompt = (optflag & OPT_NO_PROMPT);
	int flag = (optflag & ~OPT_NO_PROMPT);
	if (flag == OPT_NO_TOGGLE)
	{
		switch (c)
		{
		case '_':
			/* "__" = long option name. */
			optgetname = TRUE;
			mca_opt_toggle();
			return (MCA_MORE);
		}
	} else
	{
		switch (c)
		{
		case '+':
			/* "-+" = UNSET. */
			optflag = no_prompt | ((flag == OPT_UNSET) ?
				OPT_TOGGLE : OPT_UNSET);
			mca_opt_toggle();
			return (MCA_MORE);
		case '!':
			/* "-!" = SET */
			optflag = no_prompt | ((flag == OPT_SET) ?
				OPT_TOGGLE : OPT_SET);
			mca_opt_toggle();
			return (MCA_MORE);
		case CONTROL('P'):
			optflag ^= OPT_NO_PROMPT;
			mca_opt_toggle();
			return (MCA_MORE);
		case '-':
			/* "--" = long option name. */
			optgetname = TRUE;
			mca_opt_toggle();
			return (MCA_MORE);
		}
	}
	/* Char was not handled here. */
	return (NO_MCA);
}

/*
 * Add a char to a long option name.
 * See if we've got a match for an option name yet.
 * If so, display the complete name and stop 
 * accepting chars until user hits RETURN.
 */
static int mca_opt_nonfirst_char(char c)
{
	constant char *p;
	constant char *oname;
	lbool ambig;
	struct loption *was_curropt;

	if (curropt != NULL)
	{
		/* Already have a match for the name. */
		if (is_erase_char(c))
			return (MCA_DONE);
		/* {{ Checking for TAB here is ugly.
		 *    Also doesn't extend well -- can't do BACKTAB this way
		 *    because it's a multichar sequence. }} */
		if (c != '\t') 
			return (MCA_MORE);
	}
	/*
	 * Add char to cmd buffer and try to match
	 * the option name.
	 */
	if (cmd_char(c) == CC_QUIT)
		return (MCA_DONE);
	p = get_cmdbuf();
	if (p == NULL || p[0] == '\0')
		return (MCA_MORE);
	opt_lower = ASCII_IS_LOWER(p[0]);
	was_curropt = curropt;
	curropt = findopt_name(&p, &oname, &ambig);
	if (curropt != NULL)
	{
		if (was_curropt == NULL)
		{
			/*
			 * Got a match.
			 * Remember the option and
			 * display the full option name.
			 */
			cmd_reset();
			mca_opt_toggle();
			cmd_setstring(oname, !opt_lower);
		}
	} else if (!ambig)
	{
		lbell();
	}
	return (MCA_MORE);
}

/*
 * Handle a char of an option toggle command.
 */
static int mca_opt_char(char c)
{
	PARG parg;

	/*
	 * This may be a short option (single char),
	 * or one char of a long option name,
	 * or one char of the option parameter.
	 */
	if (curropt == NULL && cmdbuf_empty())
	{
		int ret = mca_opt_first_char(c);
		if (ret != NO_MCA)
			return (ret);
	}
	if (optgetname)
	{
		/* We're getting a long option name.  */
		if (!is_newline_char(c) && c != '=')
			return (mca_opt_nonfirst_char(c));
		if (curropt == NULL)
		{
			parg.p_string = get_cmdbuf();
			if (parg.p_string == NULL)
				return (MCA_MORE);
			error(LM(There_is_no__X_option), &parg);
			return (MCA_DONE);
		}
		optgetname = FALSE;
		cmd_reset();
	} else
	{
		if (is_erase_char(c))
			return (NO_MCA);
		if (curropt != NULL)
			/* We're getting the option parameter. */
			return (NO_MCA);
		curropt = findopt(c);
		if (curropt == NULL)
		{
			parg.p_string = propt(c);
			error(LM(There_is_no_X_option), &parg);
			return (MCA_DONE);
		}
		opt_lower = ASCII_IS_LOWER(c);
	}
	/*
	 * If the option which was entered does not take a 
	 * parameter, toggle the option immediately,
	 * so user doesn't have to hit RETURN.
	 */
	if ((optflag & ~OPT_NO_PROMPT) != OPT_TOGGLE ||
	    !opt_has_param(curropt))
	{
		toggle_option(curropt, opt_lower, "", optflag);
		return (MCA_DONE);
	}
	/*
	 * Display a prompt appropriate for the option parameter.
	 */
	start_mca(A_OPT_TOGGLE, opt_prompt(curropt), NULL, CF_OPTION);
	return (MCA_MORE);
}

/*
 * Normalize search type.
 */
public int norm_search_type(int st)
{
	/* WRAP and PAST_EOF are mutually exclusive. */
	if ((st & (SRCH_PAST_EOF|SRCH_WRAP)) == (SRCH_PAST_EOF|SRCH_WRAP))
		st ^= SRCH_PAST_EOF;
	return st;
}

/*
 * Handle a char of a search command.
 */
static int mca_search_char(char c)
{
	int flag = 0;

	/*
	 * Certain characters as the first char of 
	 * the pattern have special meaning:
	 *      !  Toggle the NO_MATCH flag
	 *      *  Toggle the PAST_EOF flag
	 *      @  Toggle the FIRST_FILE flag
	 */
	if (!cmdbuf_empty() || literal_char)
	{
		lbool was_literal_char = literal_char;
		literal_char = FALSE;
		if (was_literal_char)
			mca_search1();
		return (NO_MCA);
	}

	switch (c)
	{
	case CONTROL('E'): /* ignore END of file */
	case '*':
		if (mca != A_FILTER)
			flag = SRCH_PAST_EOF;
		search_type &= ~SRCH_WRAP;
		break;
	case CONTROL('F'): /* FIRST file */
	case '@':
		if (mca != A_FILTER)
			flag = SRCH_FIRST_FILE;
		break;
	case CONTROL('K'): /* KEEP position */
		if (mca != A_FILTER)
			flag = SRCH_NO_MOVE;
		break;
	case CONTROL('S'): { /* SUBSEARCH */
		static char *buf = NULL;
		static size_t buflen;
		if (buf == NULL)
		{
			buflen = INT_STRLEN_BOUND(int)+strlen(LM(Sub_pattern_1_X))+1;
			buf = ecalloc(buflen, sizeof(char));
		}
		SNPRINTF1(buf, buflen, LM(Sub_pattern_1_X), NUM_SEARCH_COLORS);
		clear_bot();
		cmd_putstr(buf);
		flush();
		c = getcc();
		if (c >= '1' && c <= '0'+NUM_SEARCH_COLORS)
			flag = SRCH_SUBSEARCH(c-'0');
		else
			flag = -1; /* calls mca_search() below to repaint */
		break; }
	case CONTROL('W'): /* WRAP around */
		if (mca != A_FILTER)
			flag = SRCH_WRAP;
		break;
	case CONTROL('R'): /* Don't use REGULAR EXPRESSIONS */
		flag = SRCH_NO_REGEX;
		break;
	case CONTROL('N'): /* NOT match */
	case '!':
		flag = SRCH_NO_MATCH;
		break;
	case CONTROL('L'):
		literal_char = TRUE;
		flag = -1;
		break;
	}

	if (flag != 0)
	{
		if (flag != -1)
			search_type = norm_search_type(search_type ^ flag);
		mca_search();
		return (MCA_MORE);
	}
	return (NO_MCA);
}

/*
 * Jump back to the starting position of an incremental search.
 */
static void jump_search_incr_pos(void)
{
	if (search_incr_pos.pos == NULL_POSITION)
		return;
	hshift = search_incr_hshift;
	jump_loc(search_incr_pos.pos, search_incr_pos.ln);
}

/*
 * Handle a character of a multi-character command.
 */
static int mca_char(char c)
{
	int ret;

	switch (mca)
	{
	case 0:
		/*
		 * We're not in a multicharacter command.
		 */
		return (NO_MCA);

	case A_PREFIX:
		/*
		 * In the prefix of a command.
		 * This not considered a multichar command
		 * (even tho it uses cmdbuf, etc.).
		 * It is handled in the commands() switch.
		 */
		return (NO_MCA);

	case A_DIGIT:
		/*
		 * Entering digits of a number.
		 * Terminated by a non-digit.
		 */
		if ((c >= '0' && c <= '9') || c == '.')
			break;
		switch (editchar(c, ECF_PEEK|ECF_NOHISTORY|ECF_NOCOMPLETE|ECF_NORIGHTLEFT))
		{
		case A_NOACTION:
			/*
			 * Ignore this char and get another one.
			 */
			return (MCA_MORE);
		case A_INVALID:
			/*
			 * Not part of the number.
			 * End the number and treat this char 
			 * as a normal command character.
			 */
			number = cmd_int(&fraction);
			clear_mca();
			cmd_accept();
			return (NO_MCA);
		}
		break;

	case A_OPT_TOGGLE:
		ret = mca_opt_char(c);
		if (ret != NO_MCA)
			return (ret);
		break;

	case A_F_SEARCH:
	case A_B_SEARCH:
	case A_FILTER:
		ret = mca_search_char(c);
		if (ret != NO_MCA)
			return (ret);
		break;

	default:
		/* Other multicharacter command. */
		break;
	}

	/*
	 * The multichar command is terminated by a newline.
	 */
	if (is_newline_char(c))
	{
		if (pasting && no_paste)
		{
			/* Ignore pasted input after (and including) the first newline */
			start_ignoring_input();
			return (MCA_MORE);
		}
		/* Execute the command. */
		exec_mca();
		return (MCA_DONE);
	}

	/*
	 * Append the char to the command buffer.
	 */
	if (cmd_char(c) == CC_QUIT)
		/*
		 * Abort the multi-char command.
		 */
		return (MCA_DONE);

	switch (mca)
	{
	case A_F_BRACKET:
	case A_B_BRACKET:
		if (len_cmdbuf() >= 2)
		{
			/*
			 * Special case for the bracket-matching commands.
			 * Execute the command after getting exactly two
			 * characters from the user.
			 */
			exec_mca();
			return (MCA_DONE);
		}
		break;
	case A_F_SEARCH:
	case A_B_SEARCH:
		if (incr_search)
		{
			/* Incremental search: do a search after every input char. */
			int st = (search_type & (SRCH_FORW|SRCH_BACK|SRCH_NO_MATCH|SRCH_NO_REGEX|SRCH_NO_MOVE|SRCH_WRAP|SRCH_SUBSEARCH_ALL));
			ssize_t save_updown;
			constant char *pattern = get_cmdbuf();
			if (pattern == NULL)
				return (MCA_MORE);
			/* Defer searching if more chars of the pattern are available. */
			if (ttyin_ready())
				return (MCA_MORE);
			/*
			 * Must save updown_match because mca_search
			 * reinits it. That breaks history scrolling.
			 * {{ This is ugly. mca_search probably shouldn't call set_mlist. }}
			 */
			save_updown = save_updown_match();
			cmd_exec();
			if (*pattern == '\0')
			{
				/* User has backspaced to an empty pattern. */
				undo_search(TRUE);
				jump_search_incr_pos();
			} else
			{
				if (search(st | SRCH_INCR, pattern, 1) != 0)
				{
					/* No match, invalid pattern, etc. */
					undo_search(TRUE);
					jump_search_incr_pos();
				}
			}
			/* Redraw the search prompt and search string. */
			if (is_screen_trashed() || !full_screen)
			{
				lclear();
				repaint();
			}
			mca_search1();
			restore_updown_match(save_updown);
			cmd_repaint(NULL);
		}
		break;
	}

	/*
	 * Need another character.
	 */
	return (MCA_MORE);
}

/*
 * Discard any buffered file data.
 */
static void clear_buffers(void)
{
	if (!(ch_getflags() & CH_CANSEEK))
		return;
	ch_flush();
	clr_linenum();
#if HILITE_SEARCH
	clr_hilite();
#endif
	set_line_contig_pos(NULL_POSITION);
}

public void screen_trashed_num(int trashed)
{
	screen_trashed_value = trashed;
}

public void screen_trashed(void)
{
	screen_trashed_num(1);
}

public int is_screen_trashed(void)
{
	return screen_trashed_value;
}

/*
 * Make sure the screen is displayed.
 */
static void make_display(void)
{
	/*
	 * If nothing is displayed yet, display starting from initial_scrpos.
	 */
	if (empty_screen())
	{
		if (initial_scrpos.pos == NULL_POSITION)
			jump_loc(ch_zero(), 1);
		else
			jump_loc(initial_scrpos.pos, initial_scrpos.ln);
	} else if (is_screen_trashed() || !full_screen)
	{
		int save_top_scroll = top_scroll;
		lbool save_ignore_eoi = ignore_eoi;
		top_scroll = 1;
		ignore_eoi = FALSE;
		if (is_screen_trashed() == 2)
		{
			/* Special case used by ignore_eoi: re-open the input file
			 * and jump to the end of the file. */
			reopen_curr_ifile();
			jump_forw();
		}
		repaint();
		top_scroll = save_top_scroll;
		ignore_eoi = save_ignore_eoi;
	}
}

/*
 * Display any message that needs to be displayed before the prompt.
 */
static void prompt_message(void)
{
	if (read_error)
	{
		error(LM(read_error), NULL_PARG);
		read_error = FALSE;
	}
	if (search_wrapped)
	{
		if (search_type & SRCH_BACK)
			error(LM(Search_hit_top), NULL_PARG);
		else
			error(LM(Search_hit_bottom), NULL_PARG);
		search_wrapped = FALSE;
	}
#if OSC8_LINK
	if (osc8_uri != NULL)
	{
		PARG parg;
		parg.p_string = osc8_uri;
		error(LM(Link_X), &parg);
		free(osc8_uri);
		osc8_uri = NULL;
	}
#endif
}

/*
 * Display the appropriate prompt.
 */
static void prompt(void)
{
	constant char *p;
	int attr;
#if MSDOS_COMPILER==WIN32C
	WCHAR w[MAX_PATH*2];
	char  a[MAX_PATH*2];
#endif

	if (ungot != NULL && !ungot->ug_end_command)
	{
		/*
		 * No prompt necessary if commands are from 
		 * ungotten chars rather than from the user.
		 */
		return;
	}

	/*
	 * Make sure the screen is displayed.
	 */
	make_display();

	if (hilite_target)
		draw_target_attn(TRUE); /* Redraw target line for --hilite-target. */
	toppos = position(TOP);
	bottompos = position(BOTTOM_PLUS_ONE);

	/*
	 * If we've hit EOF on the last file and the -E flag is set, quit.
	 */
	if (get_quit_at_eof() == OPT_ONPLUS &&
	    eof_displayed(FALSE) && !(ch_getflags() & CH_HELPFILE) && 
	    next_ifile(curr_ifile) == NULL_IFILE)
		quit(QUIT_OK);

	/*
	 * If the entire file is displayed and the -F flag is set, quit.
	 */
	if (quit_if_one_screen &&
	    entire_file_displayed() && !(ch_getflags() & CH_HELPFILE) && 
	    next_ifile(curr_ifile) == NULL_IFILE)
		quit(QUIT_OK);
	quit_if_one_screen = 0; /* only get one chance at this */
	if (first_cmd_at_prompt != NULL)
	{
		ungetsc(first_cmd_at_prompt);
		ungetcc_end_command();
		first_cmd_at_prompt = NULL;
		return;
	}

#if MSDOS_COMPILER==WIN32C
	/* 
	 * In Win32, display the file name in the window title.
	 * {{ Seems like this should be done in edit_ifile, not on every prompt. }}
	 */
	if (!(ch_getflags() & CH_HELPFILE))
	{
		WCHAR w[MAX_PATH+16];
		p = pr_expand("Less?f - %f.");
		MultiByteToWideChar(less_acp, 0, p, -1, w, countof(w));
		SetConsoleTitleW(w);
	}
#endif

	/*
	 * Select the proper prompt and display it.
	 */
	/*
	 * If the previous action was a forward movement, 
	 * don't clear the bottom line of the display;
	 * just print the prompt since the forward movement guarantees 
	 * that we're in the right position to display the prompt.
	 * Clearing the line could cause a problem: for example, if the last
	 * line displayed ended at the right screen edge without a newline,
	 * then clearing would clear the last displayed line rather than
	 * the prompt line.
	 */
	if (!forw_prompt)
		clear_bot();
	clear_cmd();
	forw_prompt = FALSE;
	prompt_message();
	/* We called make_display above, but if prompt_message displayed
	 * a message longer than the screen width, we may have trashed
	 * the screen and need to call make_display again. */
	if (is_screen_trashed())
		make_display();
	p = pr_string();
	if (p == NULL || *p == '\0')
	{
		p = ":";
		attr = AT_NORMAL|AT_COLOR_PROMPT;
	} else
	{
		attr = AT_STANDOUT|AT_COLOR_PROMPT;
#if MSDOS_COMPILER==WIN32C
		MultiByteToWideChar(less_acp, 0, p, -1, w, countof(w));
		WideCharToMultiByte(utf_mode ? CP_UTF8 : GetConsoleOutputCP(),
		                    0, w, -1, a, sizeof(a), NULL, NULL);
		p = a;
#endif
	}
#if HILITE_SEARCH
	if (is_filtering())
	{
		constant char *amp = "& ";
		load_line(p, attr, strlen(amp)+1);
		putstr(amp);
	} else
#endif
	{
		load_line(p, attr, 1);
	}
	put_line(FALSE);
	clear_eol();
	resume_screen();
	prompting = TRUE;
}

/*
 * Display the less version message.
 */
public void dispversion(void)
{
	PARG parg;

	parg.p_string = version;
	error("less %s", &parg);
}

/*
 * Return a character to complete a partial command, if possible.
 */
static char getcc_end_command(void)
{
	int ch;
	switch (mca)
	{
	case A_DIGIT:
		/* We have a number but no command.  Treat as #g. */
		return ('g');
	case A_F_SEARCH:
	case A_B_SEARCH:
	case A_FILTER:
		/* We have "/string" but no newline.  Add the \n. */
		return ('\n'); 
	default:
		/* Some other incomplete command.  Let user complete it. */
		if (ungot != NULL)
			return ('\0');
		ch = getchr();
		if (ch < 0) ch = '\0';
		return (char) ch;
	}
}

/*
 * Get a command character from the ungotten stack.
 */
static char get_ungot(lbool *p_end_command)
{
	struct ungot *ug = ungot;
	char c = ug->ug_char;
	if (p_end_command != NULL)
		*p_end_command = ug->ug_end_command;
	ungot = ug->ug_next;
	free(ug);
	return c;
}

/*
 * Delete all ungotten characters.
 */
public void getcc_clear(void)
{
	while (ungot != NULL)
		(void) get_ungot(NULL);
}

/*
 * Get command character.
 * The character normally comes from the keyboard,
 * but may come from ungotten characters
 * (characters previously given to ungetcc or ungetsc).
 */
static int getccu(unsigned long timeout_ms)
{
	int c = 0;
	while (c == 0 && sigs == 0)
	{
		if (ungot == NULL)
		{
			/* Normal case: no ungotten chars.
			 * Get char from the user. */
			c = getchr_timeout(timeout_ms);
			if (c == READ_TIMEOUT)
				return -1;
			if (c < 0) c = '\0';
		} else
		{
			/* Ungotten chars available:
			 * Take the top of stack (most recent). */
			lbool end_command;
			c = get_ungot(&end_command);
			if (end_command)
				c = getcc_end_command();
		}
	}
	return (unsigned char) c;
}

/*
 * Get a command character, but if we receive the orig sequence,
 * convert it to the repl sequence.
 */
static char getcc_repl(char constant *orig, char constant *repl)
{
	int c;
	char keys[16];
	size_t ki = 0;
	constant unsigned long esc_seq_timeout_ms = 15;

	c = getccu(0);
	if (c < 0)
		return '\0';
	if (orig == NULL || orig[0] == '\0')
		return c;
	for (;;)
	{
		if (c < 0)
			--ki;
		else
			keys[ki] = (char) c;
		if (c < 0 || (char) c != orig[ki] || ki >= sizeof(keys)-1)
		{
			/* This is not orig we have been receiving.
			 * If we have stashed chars in keys[],
			 * unget them and return the first one. */
			while (ki > 0)
				ungetcc(keys[ki--]);
			return keys[0];
		}
		if (orig[++ki] == '\0')
		{
			/* We've received the full orig sequence.
			 * Return the repl sequence. */
			ki = strlen(repl)-1;
			while (ki > 0)
				ungetcc(repl[ki--]);
			return repl[0];
		}
		/* We've received a partial orig sequence (ki chars of it).
		 * Get next char and see if it continues to match orig. */
		c = getccu(esc_seq_timeout_ms);
	}
}

/*
 * Get command character.
 */
public char getcc(void)
{
	/* Replace kent (keypad Enter) with a newline.
	 * However don't do this if kent is mapped to a command via lesskey. */
	return getcc_repl(kent_mapped ? NULL : kent, "\n");
}

/*
 * "Unget" a command character.
 * The next getcc() will return this character.
 */
public void ungetcc(char c)
{
	struct ungot *ug = (struct ungot *) ecalloc(1, sizeof(struct ungot));

	ug->ug_char = c;
	ug->ug_next = ungot;
	ungot = ug;
}

/*
 * "Unget" a command character.
 * If any other chars are already ungotten, put this one after those.
 */
static void ungetcc_back1(char c, lbool end_command)
{
	struct ungot *ug = (struct ungot *) ecalloc(1, sizeof(struct ungot));
	ug->ug_char = c;
	ug->ug_end_command = end_command;
	ug->ug_next = NULL;
	if (ungot == NULL)
		ungot = ug;
	else
	{
		struct ungot *pu;
		for (pu = ungot; pu->ug_next != NULL; pu = pu->ug_next)
			continue;
		pu->ug_next = ug;
	}
}

public void ungetcc_back(char c)
{
	ungetcc_back1(c, FALSE);
}

public void ungetcc_end_command(void)
{
	ungetcc_back1('\0', TRUE);
}

/*
 * Unget a whole string of command characters.
 * The next sequence of getcc()'s will return this string.
 */
public void ungetsc(constant char *s)
{
	while (*s != '\0')
		ungetcc_back(*s++);
}

/*
 * Peek the next command character, without consuming it.
 */
public char peekcc(void)
{
	char c = getcc();
	ungetcc(c);
	return c;
}

/*
 * Search for a pattern, possibly in multiple files.
 * If SRCH_FIRST_FILE is set, begin searching at the first file.
 * If SRCH_PAST_EOF is set, continue the search thru multiple files.
 */
static void multi_search(constant char *pattern, int n, int silent)
{
	int nomore;
	IFILE save_ifile;
	lbool changed_file;

	changed_file = FALSE;
	save_ifile = save_curr_ifile();

	if ((search_type & (SRCH_FORW|SRCH_BACK)) == 0)
		search_type |= SRCH_FORW;
	if (search_type & SRCH_FIRST_FILE)
	{
		/*
		 * Start at the first (or last) file 
		 * in the command line list.
		 */
		if (search_type & SRCH_FORW)
			nomore = edit_first();
		else
			nomore = edit_last();
		if (nomore)
		{
			unsave_ifile(save_ifile);
			return;
		}
		changed_file = TRUE;
		search_type &= ~SRCH_FIRST_FILE;
	}

	for (;;)
	{
		n = search(search_type, pattern, n);
		/*
		 * The SRCH_NO_MOVE flag doesn't "stick": it gets cleared
		 * after being used once.  This allows "n" to work after
		 * using a /@@ search.
		 */
		search_type &= ~SRCH_NO_MOVE;
		last_search_type = search_type;
		if (n == 0)
		{
			/*
			 * Found it.
			 */
			unsave_ifile(save_ifile);
			return;
		}

		if (n < 0)
			/*
			 * Some kind of error in the search.
			 * Error message has been printed by search().
			 */
			break;

		if ((search_type & SRCH_PAST_EOF) == 0)
			/*
			 * We didn't find a match, but we're
			 * supposed to search only one file.
			 */
			break;
		/*
		 * Move on to the next file.
		 */
		if (search_type & SRCH_FORW)
			nomore = edit_next(1);
		else
			nomore = edit_prev(1);
		if (nomore)
			break;
		changed_file = TRUE;
	}

	/*
	 * Didn't find it.
	 * Print an error message if we haven't already.
	 */
	if (n > 0 && !silent)
	{
		PARG parg;
		parg.p_string = prev_pattern_text();
		if (parg.p_string == NULL) /* {{ can this happen? }} */
			error(LM(Pattern_not_found), NULL_PARG);
		else
			error(LM(Pattern_not_found_X), &parg);
	}

	if (changed_file)
	{
		/*
		 * Restore the file we were originally viewing.
		 */
		reedit_ifile(save_ifile);
	} else
	{
		unsave_ifile(save_ifile);
	}
}

/*
 * Forward forever, or until a highlighted line appears.
 */
static int forw_loop(int action)
{
	POSITION prev_hilite;

	if (ch_getflags() & CH_HELPFILE)
		return (A_NOACTION);

	cmd_exec();
	jump_forw_buffered();
	highest_hilite = prev_hilite = 0;
	ignore_eoi = TRUE;
	while (!sigs)
	{
		if (action != A_F_FOREVER && highest_hilite > prev_hilite)
		{
			lbell();
			if (action == A_F_UNTIL_HILITE)
				break;
			prev_hilite = highest_hilite;
		}
		make_display();
		forward(1, FALSE, FALSE, FALSE);
	}
	highest_hilite = NULL_POSITION;
	ignore_eoi = FALSE;
	ch_set_eof();

	/*
	 * This gets us back in "F mode" after processing 
	 * a non-abort signal (e.g. window-change).  
	 */
	if (sigs && !ABORT_SIGS())
		return (action);

	return (A_NOACTION);
}

/*
 * Ignore subsequent (pasted) input chars.
 */
public void start_ignoring_input(void)
{
	ignoring_input = TRUE;
#if HAVE_TIME
	ignoring_input_time = get_time();
#endif
}

/*
 * Stop ignoring input chars.
 */
public void stop_ignoring_input(void)
{
	ignoring_input = FALSE;
	pasting = FALSE;
}

/*
 * Are we ignoring input chars?
 */
public lbool is_ignoring_input(int action)
{
	if (!ignoring_input)
		return FALSE;
	if (action == A_END_PASTE)
		stop_ignoring_input();
#if HAVE_TIME
	if (get_time() >= ignoring_input_time + MAX_PASTE_IGNORE_SEC)
		stop_ignoring_input();
#endif
	/*
	 * Don't ignore prefix chars so we can parse a full command
	 * (which might be A_END_PASTE).
	 */
	return (action != A_PREFIX);
}

#if PIPEC
/*
 * Read a mark char or line number from the user for use by the pipe command.
 * If mark_char != NULL, accept *mark_char as well as the normal mark chars.
 * Also return the entered mark char in *mark_char.
 */
static POSITION get_pipe_pos(constant char *mark_msg, constant char *line_msg, mutable char *mark_char)
{
	lbool get_line = FALSE;
	char spec_char = '\0';
	char c;

	start_mca(A_PIPE, mark_msg, NULL, 0);
	if (mark_char != NULL)
	{
		spec_char = *mark_char;
		*mark_char = '\0';
	}
	for (;;)
	{
		c = getcc();
		if (spec_char != '\0' && c == spec_char)
		{
			*mark_char = c;
			return NULL_POSITION;
		}
		if (c == CONTROL('N')) /* toggle between reading mark and line number */
		{
			get_line = !get_line;
			cmd_reset();
			start_mca(A_PIPE, get_line ? line_msg : mark_msg, NULL, 0);
		} else if (get_line) /* reading line number */
		{
			if ((c >= '0' && c <= '9') || is_erase_char(c))
			{
				if (cmd_char(c) == CC_QUIT)
					return NULL_POSITION;
			} else if (is_newline_char(c))
			{
				POSITION pos;
				LINENUM lnum = cmd_int(NULL);
				cmd_reset();
				if (lnum == 0 || (pos = find_pos(lnum)) == NULL_POSITION)
				{
					error(LM(Invalid_line_number), NULL_PARG);
					return NULL_POSITION;
				}
				return pos;
			} else
				lbell();
		} else /* reading mark char */
		{
			if (is_erase_char(c))
				return NULL_POSITION;
			if (is_newline_char(c))
				c = '.';
			if (badmark(c))
				return NULL_POSITION;
			if (mark_char != NULL)
				*mark_char = c;
			return markpos(c);
		}
	}
}
#endif /* PIPEC */

/*
 * Main command processor.
 * Accept and execute commands until a quit command.
 */
public void commands(void)
{
	char c = '\0'; /* Silence warning on older gcc versions */
	int action;
	constant char *cbuf;
	constant char *msg;
	int newaction;
	int save_jump_sline;
	int save_search_type;
	constant char *extra;
	PARG parg;
	IFILE old_ifile;
	IFILE new_ifile;
#if TAGS
	constant char *tagfile;
#endif

	search_type = SRCH_FORW;
	newaction = A_NOACTION;

	for (;;)
	{
		clear_mca();
		cmd_accept();
		number = 0;
		curropt = NULL;

		/*
		 * See if any signals need processing.
		 */
		if (sigs)
		{
			psignals();
			if (quitting)
				quit(QUIT_SAVED_STATUS);
		}

		/*
		 * See if window size changed, for systems that don't
		 * generate SIGWINCH.
		 */
		check_winch();

		/*
		 * Display prompt and accept a character.
		 */
		cmd_reset();
		prompt();
		if (sigs)
			continue;
		if (newaction == A_NOACTION)
			c = getcc();

	again:
		if (c == READ_AGAIN)
			continue;
		if (sigs)
			continue;

		if (newaction != A_NOACTION)
		{
			action = newaction;
			newaction = A_NOACTION;
		} else
		{
			/*
			 * If we are in a multicharacter command, call mca_char.
			 * Otherwise we call fcmd_decode to determine the
			 * action to be performed.
			 */
			if (mca)
				switch (mca_char(c))
				{
				case MCA_MORE:
					/*
					 * Need another character.
					 */
					c = getcc();
					goto again;
				case MCA_DONE:
					/*
					 * Command has been handled by mca_char.
					 * Start clean with a prompt.
					 */
					continue;
				case NO_MCA:
					/*
					 * Not a multi-char command
					 * (at least, not anymore).
					 */
					break;
				}

			/*
			 * Decode the command character and decide what to do.
			 */
			extra = NULL;
			if (mca)
			{
				/*
				 * We're in a multichar command.
				 * Add the character to the command buffer
				 * and display it on the screen.
				 * If the user backspaces past the start 
				 * of the line, abort the command.
				 */
				if (cmd_char(c) == CC_QUIT || cmdbuf_empty())
					continue;
				cbuf = get_cmdbuf();
				if (cbuf == NULL)
				{
					c = getcc();
					goto again;
				}
				action = fcmd_decode(cbuf, &extra);
			} else
			{
				/*
				 * Don't use cmd_char if we're starting fresh
				 * at the beginning of a command, because we
				 * don't want to echo the command until we know
				 * it is a multichar command.  We also don't
				 * want erase_char/kill_char to be treated
				 * as line editing characters.
				 */
				char tbuf[2];
				tbuf[0] = c;
				tbuf[1] = '\0';
				action = fcmd_decode(tbuf, &extra);
			}
			/*
			 * If an "extra" string was returned,
			 * process it as a string of command characters.
			 */
			if (extra != NULL)
				ungetsc(extra);
		}
		/*
		 * Clear the cmdbuf string.
		 * (But not if we're in the prefix of a command,
		 * because the partial command string is kept there.)
		 */
		if (action != A_PREFIX)
			cmd_reset();

		if (is_ignoring_input(action))
			continue;

		switch (action)
		{
		case A_START_PASTE:
			if (no_paste)
				start_ignoring_input();
			break;

		case A_DIGIT:
			/*
			 * First digit of a number.
			 */
			start_mca(A_DIGIT, ":", NULL, CF_QUIT_ON_ERASE);
			goto again;

		case A_F_WINDOW:
			/*
			 * Forward one window (and set the window size).
			 */
			if (number > 0)
				swindow = (int) number;
			/* FALLTHRU */
		case A_F_SCREEN:
			/*
			 * Forward one screen.
			 */
			if (number <= 0)
				number = get_swindow();
			cmd_exec();
			if (show_attn)
				set_attnpos(bottompos);
			forward((int) number, FALSE, TRUE, FALSE);
			break;

		case A_B_WINDOW:
			/*
			 * Backward one window (and set the window size).
			 */
			if (number > 0)
				swindow = (int) number;
			/* FALLTHRU */
		case A_B_SCREEN:
			/*
			 * Backward one screen.
			 */
			if (number <= 0)
				number = get_swindow();
			cmd_exec();
			if (show_attn && toppos != NULL_POSITION && toppos > ch_zero())
				set_attnpos(toppos-1);
			backward((int) number, FALSE, TRUE, FALSE);
			break;

		case A_F_LINE:
		case A_F_NEWLINE:
			/*
			 * Forward N (default 1) line.
			 */
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (show_attn == OPT_ONPLUS && number > 1)
				set_attnpos(bottompos);
			forward((int) number, FALSE, FALSE, action == A_F_NEWLINE && !chopline);
			break;

		case A_B_LINE:
		case A_B_NEWLINE:
			/*
			 * Backward N (default 1) line.
			 */
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (show_attn == OPT_ONPLUS && number > 1 && toppos != NULL_POSITION && toppos > ch_zero())
				set_attnpos(toppos-1);
			backward((int) number, FALSE, FALSE, action == A_B_NEWLINE && !chopline);
			break;

		case A_F_MOUSE:
			/*
			 * Forward wheel_lines lines.
			 */
			cmd_exec();
			forward(wheel_lines, FALSE, FALSE, FALSE);
			break;

		case A_B_MOUSE:
			/*
			 * Backward wheel_lines lines.
			 */
			cmd_exec();
			backward(wheel_lines, FALSE, FALSE, FALSE);
			break;

		case A_L_MOUSE:
			/*
			 * Left wheel_lines columns.
			 */
			cmd_exec();
			pos_rehead(FALSE);
			if (wheel_lines > hshift)
				hshift = 0;
			else
				hshift -= wheel_lines;
			screen_trashed();
			break;

		case A_R_MOUSE:
			/*
			 * Right wheel_lines columns.
			 */
			cmd_exec();
			pos_rehead(FALSE);
			hshift += wheel_lines;
			screen_trashed();
			break;

		case A_FF_LINE:
			/*
			 * Force forward N (default 1) line.
			 */
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (show_attn == OPT_ONPLUS && number > 1)
				set_attnpos(bottompos);
			forward((int) number, TRUE, FALSE, FALSE);
			break;

		case A_BF_LINE:
			/*
			 * Force backward N (default 1) line.
			 */
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (show_attn == OPT_ONPLUS && number > 1 && toppos != NULL_POSITION && toppos > ch_zero())
				set_attnpos(toppos-1);
			backward((int) number, TRUE, FALSE, FALSE);
			break;
		
		case A_FF_SCREEN:
			/*
			 * Force forward one screen.
			 */
			if (number <= 0)
				number = get_swindow();
			cmd_exec();
			if (show_attn == OPT_ONPLUS)
				set_attnpos(bottompos);
			forward((int) number, TRUE, FALSE, FALSE);
			break;

		case A_BF_SCREEN:
			/*
			 * Force backward one screen.
			 */
			if (number <= 0)
				number = get_swindow();
			cmd_exec();
			if (show_attn == OPT_ONPLUS && toppos != NULL_POSITION && toppos > ch_zero())
				set_attnpos(toppos-1);
			backward((int) number, TRUE, FALSE, FALSE);
			break;

		case A_F_FOREVER:
		case A_F_FOREVER_BELL:
		case A_F_UNTIL_HILITE:
			/*
			 * Forward forever, ignoring EOF.
			 */
			if (get_altfilename(curr_ifile) != NULL)
				error(LM(command_may_not_work_correctly_with_LESSOPEN), NULL_PARG);
			if (show_attn)
				set_attnpos(bottompos);
			newaction = forw_loop(action);
			break;

		case A_F_SCROLL:
			/*
			 * Forward N lines 
			 * (default same as last 'd' or 'u' command).
			 */
			if (number > 0)
				wscroll = (int) number;
			cmd_exec();
			if (show_attn == OPT_ONPLUS)
				set_attnpos(bottompos);
			forward(wscroll, FALSE, FALSE, FALSE);
			break;

		case A_B_SCROLL:
			/*
			 * Forward N lines 
			 * (default same as last 'd' or 'u' command).
			 */
			if (number > 0)
				wscroll = (int) number;
			cmd_exec();
			if (show_attn == OPT_ONPLUS && toppos != NULL_POSITION && toppos > ch_zero())
				set_attnpos(toppos-1);
			backward(wscroll, FALSE, FALSE, FALSE);
			break;

		case A_FREPAINT:
			/*
			 * Flush buffers, then repaint screen.
			 * Don't flush the buffers on a pipe!
			 */
			clear_buffers();
			/* FALLTHRU */
		case A_REPAINT:
			/*
			 * Repaint screen.
			 */
			cmd_exec();
			repaint();
			break;

		case A_GOLINE:
			/*
			 * Go to line N, default beginning of file.
			 * If N <= 0, ignore jump_sline in order to avoid
			 * empty lines before the beginning of the file.
			 */
			save_jump_sline = jump_sline;
			if (number <= 0)
			{
				number = 1;
				jump_sline = 0;
			}
			cmd_exec();
			jump_back(number);
			jump_sline = save_jump_sline;
			break;

		case A_PERCENT:
			/*
			 * Go to a specified percentage into the file.
			 */
			if (number < 0)
			{
				number = 0;
				fraction = 0;
			}
			if (number > 100 || (number == 100 && fraction != 0))
			{
				number = 100;
				fraction = 0;
			}
			cmd_exec();
			jump_percent((int) number, fraction);
			break;

		case A_GOEND:
			/*
			 * Go to line N, default end of file.
			 */
			cmd_exec();
			if (number <= 0)
				jump_forw();
			else
				jump_back(number);
			break;

		case A_GOEND_BUF:
			/*
			 * Go to line N, default last buffered byte.
			 */
			cmd_exec();
			if (number <= 0)
				jump_forw_buffered();
			else
				jump_back(number);
			break;

		case A_GOPOS:
			/*
			 * Go to a specified byte position in the file.
			 */
			cmd_exec();
			if (number < 0)
				number = 0;
			jump_line_loc((POSITION) number, jump_sline);
			break;

		case A_STAT:
			/*
			 * Print file name, etc.
			 */
			if (ch_getflags() & CH_HELPFILE)
				break;
			cmd_exec();
			parg.p_string = eq_message();
			error("%s", &parg);
			break;

		case A_VERSION:
			/*
			 * Print version number.
			 */
			cmd_exec();
			dispversion();
			break;

		case A_QUIT:
			/*
			 * Exit.
			 */
			cmd_exec();
			if (curr_ifile != NULL_IFILE && 
			    ch_getflags() & CH_HELPFILE)
			{
				/*
				 * Quit while viewing the help file
				 * just means return to viewing the
				 * previous file.
				 */
				hshift = save_hshift;
				bs_mode = save_bs_mode;
				proc_backspace = save_proc_backspace;
				if (edit_prev(1) == 0)
					break;
			}
			if (extra != NULL)
				quit(*extra);
			quit(QUIT_OK);
			break;

/*
 * Define abbreviation for a commonly used sequence below.
 */
#define DO_SEARCH() \
			if (number <= 0) number = 1;    \
			mca_search();                   \
			cmd_exec();                     \
			multi_search(NULL, (int) number, 0);

		case A_F_SEARCH:
			/*
			 * Search forward for a pattern.
			 * Get the first char of the pattern.
			 */
			search_type = SRCH_FORW | def_search_type;
			if (number <= 0)
				number = 1;
			literal_char = FALSE;
			mca_search();
			c = getcc();
			goto again;

		case A_B_SEARCH:
			/*
			 * Search backward for a pattern.
			 * Get the first char of the pattern.
			 */
			search_type = SRCH_BACK | def_search_type;
			if (number <= 0)
				number = 1;
			literal_char = FALSE;
			mca_search();
			c = getcc();
			goto again;

		case A_OSC8_F_SEARCH:
#if OSC8_LINK
			cmd_exec();
			if (number <= 0)
				number = 1;
			osc8_search(SRCH_FORW, NULL, (int) number);
#else
			error(LM(Command_not_available), NULL_PARG);
#endif
			break;

		case A_OSC8_B_SEARCH:
#if OSC8_LINK
			cmd_exec();
			if (number <= 0)
				number = 1;
			osc8_search(SRCH_BACK, NULL, (int) number);
#else
			error(LM(Command_not_available), NULL_PARG);
#endif
			break;

		case A_OSC8_OPEN:
#if OSC8_LINK
			if (secure_allow(SF_OSC8_OPEN))
			{
				cmd_exec();
				osc8_open();
				break;
			}
#endif
			error(LM(Command_not_available), NULL_PARG);
			break;

		case A_OSC8_JUMP:
#if OSC8_LINK
			cmd_exec();
			osc8_jump();
#else
			error(LM(Command_not_available), NULL_PARG);
#endif
			break;

		case A_FILTER:
#if HILITE_SEARCH
			search_type = SRCH_FORW | SRCH_FILTER;
			literal_char = FALSE;
			mca_search();
			c = getcc();
			goto again;
#else
			error(LM(Command_not_available), NULL_PARG);
			break;
#endif

		case A_AGAIN_SEARCH:
			/*
			 * Repeat previous search.
			 */
			search_type = last_search_type;
			DO_SEARCH();
			break;
		
		case A_T_AGAIN_SEARCH:
			/*
			 * Repeat previous search, multiple files.
			 */
			search_type = last_search_type | SRCH_PAST_EOF;
			DO_SEARCH();
			break;

		case A_REVERSE_SEARCH:
			/*
			 * Repeat previous search, in reverse direction.
			 */
			save_search_type = search_type = last_search_type;
			search_type = SRCH_REVERSE(search_type);
			DO_SEARCH();
			last_search_type = save_search_type;
			break;

		case A_T_REVERSE_SEARCH:
			/* 
			 * Repeat previous search, 
			 * multiple files in reverse direction.
			 */
			save_search_type = search_type = last_search_type;
			search_type = SRCH_REVERSE(search_type) | SRCH_PAST_EOF;
			DO_SEARCH();
			last_search_type = save_search_type;
			break;

		case A_UNDO_SEARCH:
		case A_CLR_SEARCH:
			/*
			 * Clear search string highlighting.
			 */
			cmd_exec();
			undo_search(action == A_CLR_SEARCH);
			break;

		case A_HELP:
			/*
			 * Help.
			 */
			if (ch_getflags() & CH_HELPFILE)
				break;
			cmd_exec();
			save_hshift = hshift;
			hshift = 0;
			save_bs_mode = bs_mode;
			bs_mode = BS_SPECIAL;
			save_proc_backspace = proc_backspace;
			proc_backspace = OPT_OFF;
			(void) edit(FAKE_HELPFILE);
			break;

		case A_EXAMINE:
			/*
			 * Edit a new file.  Get the filename.
			 */
#if EXAMINE
			if (secure_allow(SF_EXAMINE))
			{
				start_mca(A_EXAMINE, LM(Examine), ml_examine, 0);
				c = getcc();
				goto again;
			}
#endif
			error(LM(Command_not_available), NULL_PARG);
			break;
			
		case A_VISUAL:
			/*
			 * Invoke an editor on the input file.
			 */
#if EDITOR
			if (secure_allow(SF_EDIT))
			{
				if (ch_getflags() & CH_HELPFILE)
					break;
				if (strcmp(get_filename(curr_ifile), "-") == 0)
				{
					error(LM(Cannot_edit_standard_input), NULL_PARG);
					break;
				}
				if (!no_edit_warn && get_altfilename(curr_ifile) != NULL)
				{
					error(LM(This_file_was_viewed_via_LESSOPEN), NULL_PARG);
				}
				start_mca(A_SHELL, "!", ml_shell, 0);
				/*
				 * Expand the editor prototype string
				 * and pass it to the system to execute.
				 * (Make sure the screen is displayed so the
				 * expansion of "+%lm" works.)
				 */
				make_display();
				cmd_exec();
				lsystem(pr_expand(editproto), NULL);
				break;
			}
#endif
			error(LM(Command_not_available), NULL_PARG);
			break;

		case A_NEXT_FILE:
			/*
			 * Examine next file.
			 */
#if TAGS
			if (ntags())
			{
				error(LM(No_next_file), NULL_PARG);
				break;
			}
#endif
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (edit_next((int) number))
			{
				if (get_quit_at_eof() && eof_displayed(FALSE) && 
				    !(ch_getflags() & CH_HELPFILE))
					quit(QUIT_OK);
				parg.p_string = (number > 1) ? "(N-th) " : "";
				error(LM(No_X_next_file), &parg);
			}
			break;

		case A_PREV_FILE:
			/*
			 * Examine previous file.
			 */
#if TAGS
			if (ntags())
			{
				error(LM(No_previous_file), NULL_PARG);
				break;
			}
#endif
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (edit_prev((int) number))
			{
				parg.p_string = (number > 1) ? "(N-th) " : "";
				error(LM(No_X_previous_file), &parg);
			}
			break;

		case A_NEXT_TAG:
			/*
			 * Jump to the next tag in the current tag list.
			 */
#if TAGS
			if (number <= 0)
				number = 1;
			tagfile = nexttag((int) number);
			if (tagfile == NULL)
			{
				error(LM(No_next_tag), NULL_PARG);
				break;
			}
			cmd_exec();
			if (edit(tagfile) == 0)
			{
				POSITION pos = tagsearch();
				if (pos != NULL_POSITION)
					jump_loc(pos, jump_sline);
			}
#else
			error(LM(Command_not_available), NULL_PARG);
#endif
			break;

		case A_PREV_TAG:
			/*
			 * Jump to the previous tag in the current tag list.
			 */
#if TAGS
			if (number <= 0)
				number = 1;
			tagfile = prevtag((int) number);
			if (tagfile == NULL)
			{
				error(LM(No_previous_tag), NULL_PARG);
				break;
			}
			cmd_exec();
			if (edit(tagfile) == 0)
			{
				POSITION pos = tagsearch();
				if (pos != NULL_POSITION)
					jump_loc(pos, jump_sline);
			}
#else
			error(LM(Command_not_available), NULL_PARG);
#endif
			break;

		case A_INDEX_FILE:
			/*
			 * Examine a particular file.
			 */
			if (number <= 0)
				number = 1;
			cmd_exec();
			if (edit_index((int) number))
				error(LM(No_such_file), NULL_PARG);
			break;

		case A_REMOVE_FILE:
			/*
			 * Remove a file from the input file list.
			 */
			if (ch_getflags() & CH_HELPFILE)
				break;
			old_ifile = curr_ifile;
			new_ifile = getoff_ifile(curr_ifile);
			cmd_exec();
			if (new_ifile == NULL_IFILE)
			{
				lbell();
				break;
			}
			if (edit_ifile(new_ifile) != 0)
			{
				reedit_ifile(old_ifile);
				break;
			}
			del_ifile(old_ifile);
			break;

		case A_OPT_TOGGLE:
			/*
			 * Change the setting of an  option.
			 */
			optflag = OPT_TOGGLE;
			optgetname = FALSE;
			mca_opt_toggle();
			c = getcc();
			msg = opt_toggle_disallowed(c);
			if (msg != NULL)
			{
				error(msg, NULL_PARG);
				break;
			}
			goto again;

		case A_DISP_OPTION:
			/*
			 * Report the setting of an option.
			 */
			optflag = OPT_NO_TOGGLE;
			optgetname = FALSE;
			mca_opt_toggle();
			c = getcc();
			goto again;

		case A_FIRSTCMD:
			/*
			 * Set an initial command for new files.
			 */
			start_mca(A_FIRSTCMD, "+", NULL, 0);
			c = getcc();
			goto again;

		case A_SHELL:
		case A_PSHELL:
			/*
			 * Shell escape.
			 */
#if SHELL_ESCAPE
			if (secure_allow(SF_SHELL))
			{
				start_mca(action, (action == A_SHELL) ? "!" : "#", ml_shell, 0);
				c = getcc();
				goto again;
			}
#endif
			error(LM(Command_not_available), NULL_PARG);
			break;

		case A_SETMARK:
		case A_SETMARKBOT:
			/*
			 * Set a mark.
			 */
			if (ch_getflags() & CH_HELPFILE)
			{
				if (ungot != NULL)
				{
					/*
					 * Probably from a lesskey file, in which case there 
					 * is probably an ungotten letter from the "extra" string.
					 * Eat it so it is not interpreted as a command.
					 */
					(void) getcc();
				}
				break;
			}
			start_mca(A_SETMARK, LM(set_mark), NULL, 0);
			c = getcc();
			make_display();
			cmd_exec();
			if (is_erase_char(c) || is_newline_char(c))
				break;
			setmark(c, action == A_SETMARKBOT ? BOTTOM : TOP, number);
			repaint();
			break;

		case A_CLRMARK:
			/*
			 * Clear a mark.
			 */
			start_mca(A_CLRMARK, LM(clear_mark), NULL, 0);
			c = getcc();
			cmd_exec();
			if (is_erase_char(c) || is_newline_char(c))
				break;
			clrmark(c);
			repaint();
			break;

		case A_GOMARK:
			/*
			 * Jump to a marked position.
			 */
			start_mca(A_GOMARK, LM(goto_mark), NULL, 0);
			c = getcc();
			if (is_erase_char(c) || is_newline_char(c))
				break;
			cmd_exec();
			gomark(c, (int) number);
			break;

		case A_PIPE:
			/*
			 * Write part of the input to a pipe to a shell command.
			 */
#if PIPEC
			if (secure_allow(SF_PIPE))
			{
				char mark_char = '|';
				pipe_pos1 = get_pipe_pos(LM(pipe_mark), LM(pipe_line_number), &mark_char);
				if (mark_char == '|') /* double pipe: read two marks */
				{
					if ((pipe_pos1 = get_pipe_pos(LM(pipe_first_mark), LM(pipe_first_line_number), NULL)) == NULL_POSITION ||
					    (pipe_pos2 = get_pipe_pos(LM(pipe_second_mark), LM(pipe_second_line_number), NULL)) == NULL_POSITION)
					{
						getcc_clear();
						break;
					}
				} else
				{
					if (pipe_pos1 == NULL_POSITION)
					{
						getcc_clear();
						break;
					}
					if (mark_char == '.') /* special case: pipe current screen */
					{
						pipe_pos1 = markpos(':');
						pipe_pos2 = markpos(';');
					} else
					{
						pipe_pos2 = NULL_POSITION;
					}
				}
				start_mca(A_PIPE, "!", ml_shell, 0);
				c = getcc();
				goto again;
			}
#endif
			error(LM(Command_not_available), NULL_PARG);
			break;

		case A_B_BRACKET:
		case A_F_BRACKET:
			start_mca(action, LM(Brackets), NULL, 0);
			c = getcc();
			goto again;

		case A_LSHIFT:
			/*
			 * Shift view left.
			 */
			if (number > 0)
				shift_count = (int) number;
			else
				number = (shift_count > 0) ? shift_count : sc_width / 2;
			if (number > hshift)
				number = hshift;
			pos_rehead(FALSE);
			hshift -= (int) number;
			screen_trashed();
			cmd_exec();
			break;

		case A_RSHIFT:
		case A_RSHIFT_LIMIT:
			/*
			 * Shift view right.
			 */
			if (number > 0)
				shift_count = (int) number;
			else
				number = (shift_count > 0) ? shift_count : sc_width / 2;
			pos_rehead(FALSE);
			if (action == A_RSHIFT_LIMIT)
			{
				int ll = longest_line_width();
				if (hshift + sc_width + (int) number > ll)
					number = ll - hshift - sc_width;
			}
			hshift += (int) number;
			screen_trashed();
			cmd_exec();
			break;

		case A_LLSHIFT:
			/*
			 * Shift view left to margin.
			 */
			pos_rehead(FALSE);
			hshift = 0;
			screen_trashed();
			cmd_exec();
			break;

		case A_RRSHIFT:
			/*
			 * Shift view right to view rightmost char on screen.
			 */
			pos_rehead(FALSE);
			hshift = rrshift();
			screen_trashed();
			cmd_exec();
			break;

		case A_PREFIX:
			/*
			 * The command is incomplete (more chars are needed).
			 * Display the current char, so the user knows
			 * what's going on, and get another character.
			 */
			if (mca != A_PREFIX)
			{
				cmd_reset();
				start_mca(A_PREFIX, " ", NULL, CF_QUIT_ON_ERASE);
				(void) cmd_char(c);
			}
			c = getcc();
			goto again;

		case A_NOACTION:
			break;

		default:
			lbell();
			break;
		}
	}
}