957 lines
23 KiB
C
957 lines
23 KiB
C
/* $Header: /p/tcsh/cvsroot/tcsh/ed.inputl.c,v 3.70 2009/06/25 21:15:37 christos Exp $ */
|
|
/*
|
|
* ed.inputl.c: Input line handling.
|
|
*/
|
|
/*-
|
|
* Copyright (c) 1980, 1991 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
#include "sh.h"
|
|
|
|
RCSID("$tcsh: ed.inputl.c,v 3.70 2009/06/25 21:15:37 christos Exp $")
|
|
|
|
#include "ed.h"
|
|
#include "ed.defns.h" /* for the function names */
|
|
#include "tw.h" /* for twenex stuff */
|
|
|
|
#define OKCMD INT_MAX
|
|
|
|
/* ed.inputl -- routines to get a single line from the input. */
|
|
|
|
extern int MapsAreInited;
|
|
|
|
/* mismatched first character */
|
|
static Char mismatch[] = { '\\', '-', '%', '\0' };
|
|
/* don't Strchr() for '\0', obey current history character settings */
|
|
#define MISMATCH(c) ((c) == '\0' || (c) == HIST || (c) == HISTSUB || \
|
|
Strchr(mismatch, (c)))
|
|
|
|
static int Repair (void);
|
|
static int GetNextCommand (KEYCMD *, Char *);
|
|
static int SpellLine (int);
|
|
static int CompleteLine (void);
|
|
static void RunCommand (Char *);
|
|
static void doeval1 (Char **);
|
|
|
|
static int rotate = 0;
|
|
|
|
|
|
static int
|
|
Repair(void)
|
|
{
|
|
if (NeedsRedraw) {
|
|
ClearLines();
|
|
ClearDisp();
|
|
NeedsRedraw = 0;
|
|
}
|
|
Refresh();
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
curchoice = -1;
|
|
return (int) (LastChar - InputBuf);
|
|
}
|
|
|
|
/* CCRETVAL */
|
|
int
|
|
Inputl(void)
|
|
{
|
|
CCRETVAL retval;
|
|
KEYCMD cmdnum = 0;
|
|
unsigned char tch; /* the place where read() goes */
|
|
Char ch;
|
|
int num; /* how many chars we have read at NL */
|
|
int expnum;
|
|
struct varent *crct = inheredoc ? NULL : adrof(STRcorrect);
|
|
struct varent *autol = adrof(STRautolist);
|
|
struct varent *matchbeep = adrof(STRmatchbeep);
|
|
struct varent *imode = adrof(STRinputmode);
|
|
Char *SaveChar, *CorrChar;
|
|
int matchval; /* from tenematch() */
|
|
int nr_history_exp; /* number of (attempted) history expansions */
|
|
COMMAND fn;
|
|
int curlen = 0;
|
|
int newlen;
|
|
int idx;
|
|
Char *autoexpand;
|
|
|
|
if (!MapsAreInited) /* double extra just in case */
|
|
ed_InitMaps();
|
|
|
|
ClearDisp(); /* reset the display stuff */
|
|
ResetInLine(0); /* reset the input pointers */
|
|
if (GettingInput)
|
|
MacroLvl = -1; /* editor was interrupted during input */
|
|
|
|
if (imode && imode->vec != NULL) {
|
|
if (!Strcmp(*(imode->vec), STRinsert))
|
|
inputmode = MODE_INSERT;
|
|
else if (!Strcmp(*(imode->vec), STRoverwrite))
|
|
inputmode = MODE_REPLACE;
|
|
}
|
|
|
|
#if defined(FIONREAD) && !defined(OREO)
|
|
if (!Tty_raw_mode && MacroLvl < 0) {
|
|
# ifdef SUNOS4
|
|
long chrs = 0;
|
|
# else /* !SUNOS4 */
|
|
/*
|
|
* *Everyone* else has an int, but SunOS wants long!
|
|
* This breaks where int != long (alpha)
|
|
*/
|
|
int chrs = 0;
|
|
# endif /* SUNOS4 */
|
|
|
|
(void) ioctl(SHIN, FIONREAD, (ioctl_t) & chrs);
|
|
if (chrs == 0) {
|
|
if (Rawmode() < 0)
|
|
return 0;
|
|
}
|
|
}
|
|
#endif /* FIONREAD && !OREO */
|
|
|
|
GettingInput = 1;
|
|
NeedsRedraw = 0;
|
|
tellwhat = 0;
|
|
|
|
if (RestoreSaved) {
|
|
copyn(InputBuf, SavedBuf.s, INBUFSIZE);/*FIXBUF*/
|
|
LastChar = InputBuf + LastSaved;
|
|
Cursor = InputBuf + CursSaved;
|
|
Hist_num = HistSaved;
|
|
HistSaved = 0;
|
|
RestoreSaved = 0;
|
|
}
|
|
if (HistSaved) {
|
|
Hist_num = HistSaved;
|
|
GetHistLine();
|
|
HistSaved = 0;
|
|
}
|
|
if (Expand) {
|
|
(void) e_up_hist(0);
|
|
Expand = 0;
|
|
}
|
|
Refresh(); /* print the prompt */
|
|
|
|
for (num = OKCMD; num == OKCMD;) { /* while still editing this line */
|
|
#ifdef DEBUG_EDIT
|
|
if (Cursor > LastChar)
|
|
xprintf("Cursor > LastChar\r\n");
|
|
if (Cursor < InputBuf)
|
|
xprintf("Cursor < InputBuf\r\n");
|
|
if (Cursor > InputLim)
|
|
xprintf("Cursor > InputLim\r\n");
|
|
if (LastChar > InputLim)
|
|
xprintf("LastChar > InputLim\r\n");
|
|
if (InputLim != &InputBuf[INBUFSIZE - 2])/*FIXBUF*/
|
|
xprintf("InputLim != &InputBuf[INBUFSIZE-2]\r\n");
|
|
if ((!DoingArg) && (Argument != 1))
|
|
xprintf("(!DoingArg) && (Argument != 1)\r\n");
|
|
if (CcKeyMap[0] == 0)
|
|
xprintf("CcKeyMap[0] == 0 (maybe not inited)\r\n");
|
|
#endif
|
|
|
|
/* if EOF or error */
|
|
if ((num = GetNextCommand(&cmdnum, &ch)) != OKCMD) {
|
|
break;
|
|
}
|
|
|
|
if (cmdnum >= NumFuns) {/* BUG CHECK command */
|
|
#ifdef DEBUG_EDIT
|
|
xprintf(CGETS(6, 1, "ERROR: illegal command from key 0%o\r\n"), ch);
|
|
#endif
|
|
continue; /* try again */
|
|
}
|
|
|
|
/* now do the real command */
|
|
retval = (*CcFuncTbl[cmdnum]) (ch);
|
|
|
|
/* save the last command here */
|
|
LastCmd = cmdnum;
|
|
|
|
/* make sure fn is initialized */
|
|
fn = (retval == CC_COMPLETE_ALL) ? LIST_ALL : LIST;
|
|
|
|
/* use any return value */
|
|
switch (retval) {
|
|
|
|
case CC_REFRESH:
|
|
Refresh();
|
|
/*FALLTHROUGH*/
|
|
case CC_NORM: /* normal char */
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
/*FALLTHROUGH*/
|
|
case CC_ARGHACK: /* Suggested by Rich Salz */
|
|
/* <rsalz@pineapple.bbn.com> */
|
|
curchoice = -1;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
break; /* keep going... */
|
|
|
|
case CC_EOF: /* end of file typed */
|
|
curchoice = -1;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
num = 0;
|
|
break;
|
|
|
|
case CC_WHICH: /* tell what this command does */
|
|
tellwhat = 1;
|
|
*LastChar++ = '\n'; /* for the benifit of CSH */
|
|
num = (int) (LastChar - InputBuf); /* number characters read */
|
|
break;
|
|
|
|
case CC_NEWLINE: /* normal end of line */
|
|
curlen = 0;
|
|
curchoice = -1;
|
|
matchval = 1;
|
|
if (crct && crct->vec != NULL && (!Strcmp(*(crct->vec), STRcmd) ||
|
|
!Strcmp(*(crct->vec), STRall))) {
|
|
Char *Origin;
|
|
|
|
PastBottom();
|
|
Origin = Strsave(InputBuf);
|
|
cleanup_push(Origin, xfree);
|
|
SaveChar = LastChar;
|
|
if (SpellLine(!Strcmp(*(crct->vec), STRcmd)) == 1) {
|
|
Char *Change;
|
|
|
|
PastBottom();
|
|
Change = Strsave(InputBuf);
|
|
cleanup_push(Change, xfree);
|
|
*Strchr(Change, '\n') = '\0';
|
|
CorrChar = LastChar; /* Save the corrected end */
|
|
LastChar = InputBuf; /* Null the current line */
|
|
SoundBeep();
|
|
printprompt(2, short2str(Change));
|
|
cleanup_until(Change);
|
|
Refresh();
|
|
if (xread(SHIN, &tch, 1) < 0) {
|
|
#ifdef convex
|
|
/*
|
|
* need to print error message in case file
|
|
* is migrated
|
|
*/
|
|
if (errno)
|
|
stderror(ERR_SYSTEM, progname, strerror(errno));
|
|
#else
|
|
cleanup_until(Origin);
|
|
break;
|
|
#endif
|
|
}
|
|
ch = tch;
|
|
if (ch == 'y' || ch == ' ') {
|
|
LastChar = CorrChar; /* Restore the corrected end */
|
|
xprintf("%s", CGETS(6, 2, "yes\n"));
|
|
}
|
|
else {
|
|
Strcpy(InputBuf, Origin);
|
|
LastChar = SaveChar;
|
|
if (ch == 'e') {
|
|
xprintf("%s", CGETS(6, 3, "edit\n"));
|
|
*LastChar-- = '\0';
|
|
Cursor = LastChar;
|
|
printprompt(3, NULL);
|
|
ClearLines();
|
|
ClearDisp();
|
|
Refresh();
|
|
cleanup_until(Origin);
|
|
break;
|
|
}
|
|
else if (ch == 'a') {
|
|
xprintf("%s", CGETS(6, 4, "abort\n"));
|
|
LastChar = InputBuf; /* Null the current line */
|
|
Cursor = LastChar;
|
|
printprompt(0, NULL);
|
|
Refresh();
|
|
cleanup_until(Origin);
|
|
break;
|
|
}
|
|
xprintf("%s", CGETS(6, 5, "no\n"));
|
|
}
|
|
flush();
|
|
}
|
|
cleanup_until(Origin);
|
|
} else if (crct && crct->vec != NULL &&
|
|
!Strcmp(*(crct->vec), STRcomplete)) {
|
|
if (LastChar > InputBuf && LastChar[-1] == '\n') {
|
|
LastChar[-1] = '\0';
|
|
LastChar--;
|
|
Cursor = LastChar;
|
|
}
|
|
match_unique_match = 1; /* match unique matches */
|
|
matchval = CompleteLine();
|
|
match_unique_match = 0;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
if (matchval != 1) {
|
|
PastBottom();
|
|
}
|
|
if (matchval == 0) {
|
|
xprintf("%s", CGETS(6, 6, "No matching command\n"));
|
|
} else if (matchval == 2) {
|
|
xprintf("%s", CGETS(6, 7, "Ambiguous command\n"));
|
|
}
|
|
if (NeedsRedraw) {
|
|
ClearLines();
|
|
ClearDisp();
|
|
NeedsRedraw = 0;
|
|
}
|
|
Refresh();
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
if (matchval == 1) {
|
|
PastBottom();
|
|
*LastChar++ = '\n';
|
|
*LastChar = '\0';
|
|
}
|
|
curlen = (int) (LastChar - InputBuf);
|
|
}
|
|
else
|
|
PastBottom();
|
|
|
|
if (matchval == 1) {
|
|
tellwhat = 0; /* just in case */
|
|
Hist_num = 0; /* for the history commands */
|
|
/* return the number of chars read */
|
|
num = (int) (LastChar - InputBuf);
|
|
/*
|
|
* For continuation lines, we set the prompt to prompt 2
|
|
*/
|
|
printprompt(1, NULL);
|
|
}
|
|
break;
|
|
|
|
case CC_CORRECT:
|
|
if (tenematch(InputBuf, Cursor - InputBuf, SPELL) < 0)
|
|
SoundBeep(); /* Beep = No match/ambiguous */
|
|
curlen = Repair();
|
|
break;
|
|
|
|
case CC_CORRECT_L:
|
|
if (SpellLine(FALSE) < 0)
|
|
SoundBeep(); /* Beep = No match/ambiguous */
|
|
curlen = Repair();
|
|
break;
|
|
|
|
|
|
case CC_COMPLETE:
|
|
case CC_COMPLETE_ALL:
|
|
case CC_COMPLETE_FWD:
|
|
case CC_COMPLETE_BACK:
|
|
switch (retval) {
|
|
case CC_COMPLETE:
|
|
fn = RECOGNIZE;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
curchoice = -1;
|
|
rotate = 0;
|
|
break;
|
|
case CC_COMPLETE_ALL:
|
|
fn = RECOGNIZE_ALL;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
curchoice = -1;
|
|
rotate = 0;
|
|
break;
|
|
case CC_COMPLETE_FWD:
|
|
fn = RECOGNIZE_SCROLL;
|
|
curchoice++;
|
|
rotate = 1;
|
|
break;
|
|
case CC_COMPLETE_BACK:
|
|
fn = RECOGNIZE_SCROLL;
|
|
curchoice--;
|
|
rotate = 1;
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
if (InputBuf[curlen] && rotate) {
|
|
newlen = (int) (LastChar - InputBuf);
|
|
for (idx = (int) (Cursor - InputBuf);
|
|
idx <= newlen; idx++)
|
|
InputBuf[idx - newlen + curlen] =
|
|
InputBuf[idx];
|
|
LastChar = InputBuf + curlen;
|
|
Cursor = Cursor - newlen + curlen;
|
|
}
|
|
curlen = (int) (LastChar - InputBuf);
|
|
|
|
|
|
nr_history_exp = 0;
|
|
autoexpand = varval(STRautoexpand);
|
|
if (autoexpand != STRNULL)
|
|
nr_history_exp += ExpandHistory();
|
|
|
|
/* try normal expansion only if no history references were found */
|
|
if (nr_history_exp == 0 ||
|
|
Strcmp(autoexpand, STRonlyhistory) != 0) {
|
|
/*
|
|
* Modified by Martin Boyer (gamin@ireq-robot.hydro.qc.ca):
|
|
* A separate variable now controls beeping after
|
|
* completion, independently of autolisting.
|
|
*/
|
|
expnum = (int) (Cursor - InputBuf);
|
|
switch (matchval = tenematch(InputBuf, Cursor-InputBuf, fn)){
|
|
case 1:
|
|
if (non_unique_match && matchbeep &&
|
|
matchbeep->vec != NULL &&
|
|
(Strcmp(*(matchbeep->vec), STRnotunique) == 0))
|
|
SoundBeep();
|
|
break;
|
|
case 0:
|
|
if (matchbeep && matchbeep->vec != NULL) {
|
|
if (Strcmp(*(matchbeep->vec), STRnomatch) == 0 ||
|
|
Strcmp(*(matchbeep->vec), STRambiguous) == 0 ||
|
|
Strcmp(*(matchbeep->vec), STRnotunique) == 0)
|
|
SoundBeep();
|
|
}
|
|
else
|
|
SoundBeep();
|
|
break;
|
|
default:
|
|
if (matchval < 0) { /* Error from tenematch */
|
|
curchoice = -1;
|
|
SoundBeep();
|
|
break;
|
|
}
|
|
if (matchbeep && matchbeep->vec != NULL) {
|
|
if ((Strcmp(*(matchbeep->vec), STRambiguous) == 0 ||
|
|
Strcmp(*(matchbeep->vec), STRnotunique) == 0))
|
|
SoundBeep();
|
|
}
|
|
else
|
|
SoundBeep();
|
|
/*
|
|
* Addition by David C Lawrence <tale@pawl.rpi.edu>: If an
|
|
* attempted completion is ambiguous, list the choices.
|
|
* (PWP: this is the best feature addition to tcsh I have
|
|
* seen in many months.)
|
|
*/
|
|
if (autol && autol->vec != NULL &&
|
|
(Strcmp(*(autol->vec), STRambiguous) != 0 ||
|
|
expnum == Cursor - InputBuf)) {
|
|
if (adrof(STRhighlight) && MarkIsSet) {
|
|
/* clear highlighting before showing completions */
|
|
MarkIsSet = 0;
|
|
ClearLines();
|
|
ClearDisp();
|
|
Refresh();
|
|
MarkIsSet = 1;
|
|
}
|
|
PastBottom();
|
|
fn = (retval == CC_COMPLETE_ALL) ? LIST_ALL : LIST;
|
|
(void) tenematch(InputBuf, Cursor-InputBuf, fn);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (NeedsRedraw) {
|
|
PastBottom();
|
|
ClearLines();
|
|
ClearDisp();
|
|
NeedsRedraw = 0;
|
|
}
|
|
Refresh();
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
break;
|
|
|
|
case CC_LIST_CHOICES:
|
|
case CC_LIST_ALL:
|
|
if (InputBuf[curlen] && rotate) {
|
|
newlen = (int) (LastChar - InputBuf);
|
|
for (idx = (int) (Cursor - InputBuf);
|
|
idx <= newlen; idx++)
|
|
InputBuf[idx - newlen + curlen] =
|
|
InputBuf[idx];
|
|
LastChar = InputBuf + curlen;
|
|
Cursor = Cursor - newlen + curlen;
|
|
}
|
|
curlen = (int) (LastChar - InputBuf);
|
|
if (curchoice >= 0)
|
|
curchoice--;
|
|
|
|
fn = (retval == CC_LIST_ALL) ? LIST_ALL : LIST;
|
|
/* should catch ^C here... */
|
|
if (tenematch(InputBuf, Cursor - InputBuf, fn) < 0)
|
|
SoundBeep();
|
|
Refresh();
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
break;
|
|
|
|
|
|
case CC_LIST_GLOB:
|
|
if (tenematch(InputBuf, Cursor - InputBuf, GLOB) < 0)
|
|
SoundBeep();
|
|
curlen = Repair();
|
|
break;
|
|
|
|
case CC_EXPAND_GLOB:
|
|
if (tenematch(InputBuf, Cursor - InputBuf, GLOB_EXPAND) <= 0)
|
|
SoundBeep(); /* Beep = No match */
|
|
curlen = Repair();
|
|
break;
|
|
|
|
case CC_NORMALIZE_PATH:
|
|
if (tenematch(InputBuf, Cursor - InputBuf, PATH_NORMALIZE) <= 0)
|
|
SoundBeep(); /* Beep = No match */
|
|
curlen = Repair();
|
|
break;
|
|
|
|
case CC_EXPAND_VARS:
|
|
if (tenematch(InputBuf, Cursor - InputBuf, VARS_EXPAND) <= 0)
|
|
SoundBeep(); /* Beep = No match */
|
|
curlen = Repair();
|
|
break;
|
|
|
|
case CC_NORMALIZE_COMMAND:
|
|
if (tenematch(InputBuf, Cursor - InputBuf, COMMAND_NORMALIZE) <= 0)
|
|
SoundBeep(); /* Beep = No match */
|
|
curlen = Repair();
|
|
break;
|
|
|
|
case CC_HELPME:
|
|
xputchar('\n');
|
|
/* should catch ^C here... */
|
|
(void) tenematch(InputBuf, LastChar - InputBuf, PRINT_HELP);
|
|
Refresh();
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
curchoice = -1;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
break;
|
|
|
|
case CC_FATAL: /* fatal error, reset to known state */
|
|
#ifdef DEBUG_EDIT
|
|
xprintf(CGETS(7, 8, "*** editor fatal ERROR ***\r\n\n"));
|
|
#endif /* DEBUG_EDIT */
|
|
/* put (real) cursor in a known place */
|
|
ClearDisp(); /* reset the display stuff */
|
|
ResetInLine(1); /* reset the input pointers */
|
|
Refresh(); /* print the prompt again */
|
|
Argument = 1;
|
|
DoingArg = 0;
|
|
curchoice = -1;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
break;
|
|
|
|
case CC_ERROR:
|
|
default: /* functions we don't know about */
|
|
if (adrof(STRhighlight)) {
|
|
ClearLines();
|
|
ClearDisp();
|
|
Refresh();
|
|
}
|
|
DoingArg = 0;
|
|
Argument = 1;
|
|
SoundBeep();
|
|
flush();
|
|
curchoice = -1;
|
|
curlen = (int) (LastChar - InputBuf);
|
|
break;
|
|
}
|
|
}
|
|
(void) Cookedmode(); /* make sure the tty is set up correctly */
|
|
GettingInput = 0;
|
|
flush(); /* flush any buffered output */
|
|
return num;
|
|
}
|
|
|
|
void
|
|
PushMacro(Char *str)
|
|
{
|
|
if (str != NULL && MacroLvl + 1 < MAXMACROLEVELS) {
|
|
MacroLvl++;
|
|
KeyMacro[MacroLvl] = str;
|
|
}
|
|
else {
|
|
SoundBeep();
|
|
flush();
|
|
}
|
|
}
|
|
|
|
struct eval1_state
|
|
{
|
|
Char **evalvec, *evalp;
|
|
};
|
|
|
|
static void
|
|
eval1_cleanup(void *xstate)
|
|
{
|
|
struct eval1_state *state;
|
|
|
|
state = xstate;
|
|
evalvec = state->evalvec;
|
|
evalp = state->evalp;
|
|
doneinp = 0;
|
|
}
|
|
|
|
/*
|
|
* Like eval, only using the current file descriptors
|
|
*/
|
|
static void
|
|
doeval1(Char **v)
|
|
{
|
|
struct eval1_state state;
|
|
Char **gv;
|
|
int gflag;
|
|
|
|
gflag = tglob(v);
|
|
if (gflag) {
|
|
gv = v = globall(v, gflag);
|
|
if (v == 0)
|
|
stderror(ERR_NOMATCH);
|
|
v = copyblk(v);
|
|
}
|
|
else {
|
|
gv = NULL;
|
|
v = copyblk(v);
|
|
trim(v);
|
|
}
|
|
if (gv)
|
|
cleanup_push(gv, blk_cleanup);
|
|
|
|
state.evalvec = evalvec;
|
|
state.evalp = evalp;
|
|
evalvec = v;
|
|
evalp = 0;
|
|
cleanup_push(&state, eval1_cleanup);
|
|
process(0);
|
|
cleanup_until(&state);
|
|
if (gv)
|
|
cleanup_until(gv);
|
|
}
|
|
|
|
static void
|
|
RunCommand(Char *str)
|
|
{
|
|
Char *cmd[2];
|
|
|
|
xputchar('\n'); /* Start on a clean line */
|
|
|
|
cmd[0] = str;
|
|
cmd[1] = NULL;
|
|
|
|
(void) Cookedmode();
|
|
GettingInput = 0;
|
|
|
|
doeval1(cmd);
|
|
|
|
(void) Rawmode();
|
|
GettingInput = 1;
|
|
|
|
ClearLines();
|
|
ClearDisp();
|
|
NeedsRedraw = 0;
|
|
Refresh();
|
|
}
|
|
|
|
static int
|
|
GetNextCommand(KEYCMD *cmdnum, Char *ch)
|
|
{
|
|
KEYCMD cmd = 0;
|
|
int num;
|
|
|
|
while (cmd == 0 || cmd == F_XKEY) {
|
|
if ((num = GetNextChar(ch)) != 1) { /* if EOF or error */
|
|
return num;
|
|
}
|
|
#ifdef KANJI
|
|
if (
|
|
#ifdef DSPMBYTE
|
|
_enable_mbdisp &&
|
|
#else
|
|
MB_LEN_MAX == 1 &&
|
|
#endif
|
|
!adrof(STRnokanji) && (*ch & META)) {
|
|
MetaNext = 0;
|
|
cmd = F_INSERT;
|
|
break;
|
|
}
|
|
else
|
|
#endif /* KANJI */
|
|
if (MetaNext) {
|
|
MetaNext = 0;
|
|
*ch |= META;
|
|
}
|
|
/* XXX: This needs to be fixed so that we don't just truncate
|
|
* the character, we unquote it.
|
|
*/
|
|
if (*ch < NT_NUM_KEYS)
|
|
cmd = CurrentKeyMap[*ch];
|
|
else
|
|
#ifdef WINNT_NATIVE
|
|
cmd = CurrentKeyMap[(unsigned char) *ch];
|
|
#else
|
|
cmd = F_INSERT;
|
|
#endif
|
|
if (cmd == F_XKEY) {
|
|
XmapVal val;
|
|
CStr cstr;
|
|
cstr.buf = ch;
|
|
cstr.len = 1;
|
|
switch (GetXkey(&cstr, &val)) {
|
|
case XK_CMD:
|
|
cmd = val.cmd;
|
|
break;
|
|
case XK_STR:
|
|
PushMacro(val.str.buf);
|
|
break;
|
|
case XK_EXE:
|
|
RunCommand(val.str.buf);
|
|
break;
|
|
default:
|
|
abort();
|
|
break;
|
|
}
|
|
}
|
|
if (!AltKeyMap)
|
|
CurrentKeyMap = CcKeyMap;
|
|
}
|
|
*cmdnum = cmd;
|
|
return OKCMD;
|
|
}
|
|
|
|
static Char ungetchar;
|
|
static int haveungetchar;
|
|
|
|
void
|
|
UngetNextChar(Char cp)
|
|
{
|
|
ungetchar = cp;
|
|
haveungetchar = 1;
|
|
}
|
|
|
|
int
|
|
GetNextChar(Char *cp)
|
|
{
|
|
int num_read;
|
|
int tried = 0;
|
|
char cbuf[MB_LEN_MAX];
|
|
size_t cbp;
|
|
|
|
if (haveungetchar) {
|
|
haveungetchar = 0;
|
|
*cp = ungetchar;
|
|
return 1;
|
|
}
|
|
for (;;) {
|
|
if (MacroLvl < 0) {
|
|
if (!Load_input_line())
|
|
break;
|
|
}
|
|
if (*KeyMacro[MacroLvl] == 0) {
|
|
MacroLvl--;
|
|
continue;
|
|
}
|
|
*cp = *KeyMacro[MacroLvl]++ & CHAR;
|
|
if (*KeyMacro[MacroLvl] == 0) { /* Needed for QuoteMode On */
|
|
MacroLvl--;
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
if (Rawmode() < 0) /* make sure the tty is set up correctly */
|
|
return 0; /* oops: SHIN was closed */
|
|
|
|
#ifdef WINNT_NATIVE
|
|
__nt_want_vcode = 1;
|
|
#endif /* WINNT_NATIVE */
|
|
#ifdef SIG_WINDOW
|
|
if (windowchg)
|
|
(void) check_window_size(0); /* for window systems */
|
|
#endif /* SIG_WINDOW */
|
|
cbp = 0;
|
|
for (;;) {
|
|
while ((num_read = xread(SHIN, cbuf + cbp, 1)) == -1) {
|
|
if (!tried && fixio(SHIN, errno) != -1)
|
|
tried = 1;
|
|
else {
|
|
# ifdef convex
|
|
/* need to print error message in case the file is migrated */
|
|
stderror(ERR_SYSTEM, progname, strerror(errno));
|
|
# endif /* convex */
|
|
# ifdef WINNT_NATIVE
|
|
__nt_want_vcode = 0;
|
|
# endif /* WINNT_NATIVE */
|
|
*cp = '\0'; /* Loses possible partial character */
|
|
return -1;
|
|
}
|
|
}
|
|
if (AsciiOnly) {
|
|
*cp = (unsigned char)*cbuf;
|
|
} else {
|
|
cbp++;
|
|
if (normal_mbtowc(cp, cbuf, cbp) == -1) {
|
|
reset_mbtowc();
|
|
if (cbp < MB_CUR_MAX)
|
|
continue; /* Maybe a partial character */
|
|
/* And drop the following bytes, if any */
|
|
*cp = (unsigned char)*cbuf | INVALID_BYTE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
#ifdef WINNT_NATIVE
|
|
/* This is the part that doesn't work with WIDE_STRINGS */
|
|
if (__nt_want_vcode == 2)
|
|
*cp = __nt_vcode;
|
|
__nt_want_vcode = 0;
|
|
#endif /* WINNT_NATIVE */
|
|
return num_read;
|
|
}
|
|
|
|
/*
|
|
* SpellLine - do spelling correction on the entire command line
|
|
* (which may have trailing newline).
|
|
* If cmdonly is set, only check spelling of command words.
|
|
* Return value:
|
|
* -1: Something was incorrectible, and nothing was corrected
|
|
* 0: Everything was correct
|
|
* 1: Something was corrected
|
|
*/
|
|
static int
|
|
SpellLine(int cmdonly)
|
|
{
|
|
int endflag, matchval;
|
|
Char *argptr, *OldCursor, *OldLastChar;
|
|
|
|
OldLastChar = LastChar;
|
|
OldCursor = Cursor;
|
|
argptr = InputBuf;
|
|
endflag = 1;
|
|
matchval = 0;
|
|
do {
|
|
while (ismetahash(*argptr) || iscmdmeta(*argptr))
|
|
argptr++;
|
|
for (Cursor = argptr;
|
|
*Cursor != '\0' && ((Cursor != argptr && Cursor[-1] == '\\') ||
|
|
(!ismetahash(*Cursor) && !iscmdmeta(*Cursor)));
|
|
Cursor++)
|
|
continue;
|
|
if (*Cursor == '\0') {
|
|
Cursor = LastChar;
|
|
if (LastChar[-1] == '\n')
|
|
Cursor--;
|
|
endflag = 0;
|
|
}
|
|
if (!MISMATCH(*argptr) &&
|
|
(!cmdonly || starting_a_command(argptr, InputBuf))) {
|
|
#ifdef WINNT_NATIVE
|
|
/*
|
|
* This hack avoids correcting drive letter changes
|
|
*/
|
|
if((Cursor - InputBuf) != 2 || (char)InputBuf[1] != ':')
|
|
#endif /* WINNT_NATIVE */
|
|
{
|
|
#ifdef HASH_SPELL_CHECK
|
|
Char save;
|
|
size_t len = Cursor - InputBuf;
|
|
|
|
save = InputBuf[len];
|
|
InputBuf[len] = '\0';
|
|
if (find_cmd(InputBuf, 0) != 0) {
|
|
InputBuf[len] = save;
|
|
argptr = Cursor;
|
|
continue;
|
|
}
|
|
InputBuf[len] = save;
|
|
#endif /* HASH_SPELL_CHECK */
|
|
switch (tenematch(InputBuf, Cursor - InputBuf, SPELL)) {
|
|
case 1: /* corrected */
|
|
matchval = 1;
|
|
break;
|
|
case -1: /* couldn't be corrected */
|
|
if (!matchval)
|
|
matchval = -1;
|
|
break;
|
|
default: /* was correct */
|
|
break;
|
|
}
|
|
}
|
|
if (LastChar != OldLastChar) {
|
|
if (argptr < OldCursor)
|
|
OldCursor += (LastChar - OldLastChar);
|
|
OldLastChar = LastChar;
|
|
}
|
|
}
|
|
argptr = Cursor;
|
|
} while (endflag);
|
|
Cursor = OldCursor;
|
|
return matchval;
|
|
}
|
|
|
|
/*
|
|
* CompleteLine - do command completion on the entire command line
|
|
* (which may have trailing newline).
|
|
* Return value:
|
|
* 0: No command matched or failure
|
|
* 1: One command matched
|
|
* 2: Several commands matched
|
|
*/
|
|
static int
|
|
CompleteLine(void)
|
|
{
|
|
int endflag, tmatch;
|
|
Char *argptr, *OldCursor, *OldLastChar;
|
|
|
|
OldLastChar = LastChar;
|
|
OldCursor = Cursor;
|
|
argptr = InputBuf;
|
|
endflag = 1;
|
|
do {
|
|
while (ismetahash(*argptr) || iscmdmeta(*argptr))
|
|
argptr++;
|
|
for (Cursor = argptr;
|
|
*Cursor != '\0' && ((Cursor != argptr && Cursor[-1] == '\\') ||
|
|
(!ismetahash(*Cursor) && !iscmdmeta(*Cursor)));
|
|
Cursor++)
|
|
continue;
|
|
if (*Cursor == '\0') {
|
|
Cursor = LastChar;
|
|
if (LastChar[-1] == '\n')
|
|
Cursor--;
|
|
endflag = 0;
|
|
}
|
|
if (!MISMATCH(*argptr) && starting_a_command(argptr, InputBuf)) {
|
|
tmatch = tenematch(InputBuf, Cursor - InputBuf, RECOGNIZE);
|
|
if (tmatch <= 0) {
|
|
return 0;
|
|
} else if (tmatch > 1) {
|
|
return 2;
|
|
}
|
|
if (LastChar != OldLastChar) {
|
|
if (argptr < OldCursor)
|
|
OldCursor += (LastChar - OldLastChar);
|
|
OldLastChar = LastChar;
|
|
}
|
|
}
|
|
argptr = Cursor;
|
|
} while (endflag);
|
|
Cursor = OldCursor;
|
|
return 1;
|
|
}
|
|
|