1444 lines
36 KiB
C
1444 lines
36 KiB
C
/*****************************************************************************
|
|
|
|
ExeE()
|
|
|
|
This function executes a E command.
|
|
|
|
EA Select secondary output stream
|
|
EBfilespec$ Open file for input and output
|
|
:EBfilespec$ EB, return status
|
|
EC Close out (copy in to out and close)
|
|
ED Edit mode flag
|
|
EE Escape surrogate character
|
|
EF Close output file
|
|
EG Close out and exit, run last COMPIL class command
|
|
:EGcmd args$ Performs operating system function
|
|
:EGtext$ Close out and exit, run "text"
|
|
EH Help level flag
|
|
EI Close current indirect command file
|
|
EIfilespec$ Open indirect command file
|
|
m,nEJ Set environment characteristics
|
|
nEJ Return environment characteristics
|
|
EK Kill output file
|
|
ELfilespec$ Open log file
|
|
mEM Position mag tape
|
|
EN Wildcard lookup
|
|
:EN EN, return status
|
|
ENfilespec$ Preset wildcard lookup
|
|
EO Version of TECO
|
|
nEO Set TECO to function as version n
|
|
EP Select secondary input stream
|
|
EQqfilespec$ Read file into Q-register q
|
|
ER Select primary input stream
|
|
ERfilespec$ Open input file
|
|
:ERfilespec$ ER, return status
|
|
ES Search verification flag
|
|
ET Type out control flag
|
|
EU Case flagging flag
|
|
EV Edit verify flag
|
|
EWfilespec$ Open output file
|
|
EW Select primary output stream
|
|
EX Close out and exit
|
|
EY Read without yank protection
|
|
EZ System-dependent mode control flags
|
|
E%qfilespec$ Write Q-register q into a file
|
|
nE_ Search without yank protection
|
|
|
|
*****************************************************************************/
|
|
|
|
#include "zport.h" /* define portability identifiers */
|
|
#include "tecoc.h" /* define general identifiers */
|
|
#include "defext.h" /* define external global variables */
|
|
#include "chmacs.h" /* define character processing macros */
|
|
#include "dchars.h" /* define identifiers for characters */
|
|
#include "deferr.h" /* define identifiers for error messages */
|
|
|
|
#if USE_PROTOTYPES
|
|
static DEFAULT DoEI(DEFAULT IfIndx);
|
|
static DEFAULT ExeEA(void);
|
|
static DEFAULT ExeEB(void);
|
|
static DEFAULT ExeEC(void);
|
|
static DEFAULT ExeED(void);
|
|
static DEFAULT ExeEF(void);
|
|
static DEFAULT ExeEG(void);
|
|
static DEFAULT ExeEH(void);
|
|
static DEFAULT ExeEI(void);
|
|
static DEFAULT ExeEK(void);
|
|
static DEFAULT ExeEN(void);
|
|
static DEFAULT ExeEO(void);
|
|
static DEFAULT ExeEP(void);
|
|
static DEFAULT ExeEPr(void);
|
|
static DEFAULT ExeEQ(void);
|
|
static DEFAULT ExeER(void);
|
|
static DEFAULT ExeES(void);
|
|
static DEFAULT ExeET(void);
|
|
static DEFAULT ExeEU(void);
|
|
static DEFAULT ExeEUn(void);
|
|
static DEFAULT ExeEV(void);
|
|
static DEFAULT ExeEW(void);
|
|
static DEFAULT ExeEX(void);
|
|
static DEFAULT ExeEZ(void);
|
|
static DEFAULT GetWha(charptr TxtPtr, ptrdiff_t TxtLen);
|
|
static DEFAULT OpnEI(DEFAULT EInd);
|
|
static DEFAULT OpnInp(DEFAULT IfIndx, BOOLEAN EIFile, BOOLEAN RepFNF);
|
|
static DEFAULT OpnOut(DEFAULT OfIndx, BOOLEAN RepErr, BOOLEAN Backup);
|
|
static DEFAULT ReadEI(DEFAULT IfIndx, charptr *ZBfPtr, charptr *EscPtr);
|
|
#endif
|
|
|
|
charptr ZBfBeg;
|
|
charptr ZBfEnd;
|
|
charptr ZBfRdP; /* pointer where to start reading into ZBf */
|
|
|
|
/*****************************************************************************
|
|
|
|
OpnInp()
|
|
|
|
This function opens an input file. The name of the file is pointed
|
|
to by FBfBeg. FBfPtr points to the character following the last character of
|
|
the file name.
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT OpnInp(IfIndx, EIFile, RepFNF)
|
|
DEFAULT IfIndx; /* output file indicator */
|
|
BOOLEAN EIFile; /* is it a macro file? */
|
|
BOOLEAN RepFNF; /* report "file not found" error? */
|
|
{
|
|
DEFAULT status;
|
|
|
|
DBGFEN(2,"OpnInp",NULL);
|
|
|
|
ZIClos(IfIndx); /* close input file, if any */
|
|
|
|
status = ZOpInp(IfIndx, EIFile, RepFNF);
|
|
if (status != SUCCESS) {
|
|
if (!RepFNF && (status == FILENF)) {
|
|
DBGFEX(2,DbgFNm,"FILENF");
|
|
return FILENF;
|
|
}
|
|
ErrPSt(ERR_UFI, FBfBeg, FBfPtr);
|
|
DBGFEX(2,DbgFNm,"status");
|
|
return status;
|
|
}
|
|
|
|
IsOpnI[IfIndx] = TRUE; /* mark the file as open */
|
|
IsEofI[IfIndx] = FALSE; /* end-of-file indicator */
|
|
|
|
DBGFEX(2,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
OpnOut()
|
|
|
|
This function creates and opens an output file. The name of the file
|
|
to be created is pointed to by FBfBeg. FBfPtr points to the character
|
|
following the last character of the file name.
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
static DEFAULT OpnOut(OfIndx, RepErr, Backup)
|
|
DEFAULT OfIndx; /* output file indicator */
|
|
BOOLEAN RepErr; /* report errors? */
|
|
BOOLEAN Backup; /* create backup? TAA Added */
|
|
{
|
|
DBGFEN(2,"OpnOut",NULL);
|
|
|
|
if (IsOpnO[OfIndx]) { /* if output file is open */
|
|
ErrMsg(ERR_OFO); /* OFO = output file already open */
|
|
DBGFEX(2,DbgFNm,"FAILURE");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (ZOpOut(OfIndx, RepErr, Backup) == FAILURE) {
|
|
if (RepErr) {
|
|
ErrPSt(ERR_UFO, FBfBeg, FBfPtr);
|
|
}
|
|
DBGFEX(2,DbgFNm,"FAILURE");
|
|
return FAILURE;
|
|
}
|
|
|
|
IsOpnO[OfIndx] = TRUE;
|
|
|
|
DBGFEX(2,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEA()
|
|
|
|
This function executes an EA command.
|
|
|
|
EA Select secondary output stream
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEA() /* execute an EA command */
|
|
{
|
|
DBGFEN(1,"ExeEA",NULL);
|
|
|
|
CurOut = SOUTFL;
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEB()
|
|
|
|
This function executes an EB command.
|
|
|
|
EBfilespec$ Open file for input and output
|
|
:EBfilespec$ EB, return status
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEB() /* execute an EB command */
|
|
{
|
|
BOOLEAN RepFNF; /* report "file not found" ? */
|
|
DEFAULT status; /* OpnInp() status */
|
|
|
|
DBGFEN(1,"ExeEB",NULL);
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
RepFNF = !(CmdMod & COLON); /* report file not found? */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
status = OpnInp(CurInp, FALSE, RepFNF); /* open input file */
|
|
if (status != SUCCESS) {
|
|
if (status == FILENF) {
|
|
if (!RepFNF) { /* if it's :EB */
|
|
DBGFEX(1,DbgFNm,"PushEx(0)");
|
|
return PushEx(0L,OPERAND);
|
|
}
|
|
}
|
|
DBGFEX(1,DbgFNm,"FAILURE, OpnInp() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
ZMKOFN(); /* kludge for VMS filenames */
|
|
|
|
if (OpnOut(CurOut, RepFNF, TRUE) == FAILURE) {/* open output file */
|
|
#if DEBUGGING
|
|
sprintf(DbgSBf,"%s, OpnOut() failed",
|
|
(RepFNF) ? "FAILURE" : "PushEx(0)");
|
|
DbgFEx(1,DbgFNm,DbgSBf);
|
|
#endif
|
|
return (RepFNF) ? FAILURE : PushEx(0L,OPERAND);
|
|
}
|
|
|
|
if (!RepFNF) { /* if it's :EB */
|
|
DBGFEX(1,DbgFNm,"PushEx(-1)");
|
|
return PushEx(-1L,OPERAND);
|
|
}
|
|
|
|
EStTop = EStBot; /* clear expression stack */
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEC()
|
|
|
|
This function executes an EC command.
|
|
|
|
EC Close out (copy in to out and close)
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEC() /* execute an EC command */
|
|
{
|
|
DBGFEN(1,"ExeEC",NULL);
|
|
|
|
if (EStTop > EStBot) { /* if numeric argument */
|
|
if (GetNmA() == FAILURE) { /* get numeric argument */
|
|
DBGFEX(1,DbgFNm,"FAILURE, GetNmA() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
/* ??? */ ZDspBf("memory expand as per page 84\r\n", 29);
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (IsOpnO[CurOut]) {
|
|
|
|
/*
|
|
* if there's text in the edit buffer, or if the form feed flag indicates
|
|
* that the current page needs to be output, call WrPage to write the page,
|
|
* then clear the edit buffer.
|
|
*/
|
|
|
|
if ((GapBeg > EBfBeg) || (GapEnd < EBfEnd) || FFPage) {
|
|
if (WrPage(CurOut, EBfBeg, EBfEnd, FFPage) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, WrPage() failed");
|
|
return FAILURE;
|
|
}
|
|
GapBeg = EBfBeg; /* clear the... */
|
|
GapEnd = EBfEnd; /* ...edit buffer */
|
|
}
|
|
|
|
/*
|
|
* Move the remainder of the current input file, if any, to the currenti
|
|
* output file.
|
|
*/
|
|
|
|
if (IsOpnI[CurInp]) { /* if input file is open */
|
|
while (!IsEofI[CurInp]) { /* while not end-of-file */
|
|
if (RdPage() == FAILURE) { /* read a page */
|
|
DBGFEX(1,DbgFNm,"FAILURE, RdPage() failed");
|
|
return FAILURE;
|
|
}
|
|
if (WrPage(CurOut, EBfBeg, EBfEnd, FFPage) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, WrPage() failed");
|
|
return FAILURE;
|
|
}
|
|
GapBeg = EBfBeg; /* clear the... */
|
|
GapEnd = EBfEnd; /* ...edit buffer */
|
|
}
|
|
}
|
|
}
|
|
|
|
ZIClos(PINPFL); /* close primary input file */
|
|
ZIClos(SINPFL); /* close secondary input file */
|
|
ZOClos(POUTFL); /* close primary output file */
|
|
ZOClos(SOUTFL); /* close secondary output file */
|
|
|
|
CmdMod = '\0'; /* clear modifiers flag */
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeED()
|
|
|
|
This function executes an ED command.
|
|
|
|
ED Edit mode flag
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeED() /* execute an ED command */
|
|
{
|
|
DBGFEN(1,"ExeED",NULL);
|
|
DBGFEX(1,DbgFNm,"DoFlag(&EdFlag)");
|
|
return DoFlag(&EdFlag);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEF()
|
|
|
|
This function executes an EF command.
|
|
|
|
EF Close output file
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEF() /* execute an EF command */
|
|
{
|
|
DBGFEN(1,"ExeEF",NULL);
|
|
|
|
ZOClos(CurOut); /* close output file */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEG()
|
|
|
|
This function implements the EG command. If the EG command is not
|
|
colon modified, it terminates TECO and passes a command line to the command
|
|
line interpreter.
|
|
|
|
EG Close out and exit
|
|
EGtext$ Close out and exit, execute "text" command
|
|
|
|
If the EG command is colon modified, then it implements one of the "special
|
|
functions" as follows:
|
|
|
|
:EGINI$ gets, sets or clears the initialization file name
|
|
:EGLIB$ gets, sets or clears the macro library directory
|
|
:EGMEM$ gets, sets or clears the file name memory
|
|
:EGVTE$ gets, sets or clears the video macro file name
|
|
|
|
other, system-dependent functions may be defined. See the ZClnEG function.
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT GetWha(TxtPtr, TxtLen) /* get "what to operate on" */
|
|
charptr TxtPtr; /* string to parse */
|
|
ptrdiff_t TxtLen; /* length of string */
|
|
{
|
|
if (TxtLen >= 3) { /* it's long enough */
|
|
switch(To_Upper(*TxtPtr)) {
|
|
case 'I': /* INI (init macro) */
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'N') {
|
|
++TxtPtr;
|
|
if (To_Upper(*TxtPtr) == 'I') {
|
|
return EG_INI;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'L': /* LIB (macro directory) */
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'I') {
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'B') {
|
|
return EG_LIB;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'M': /* MEM (filename memory) */
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'E') {
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'M') {
|
|
return EG_MEM;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'V': /* VTE (vtedit macro) */
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'T') {
|
|
TxtPtr++;
|
|
if (To_Upper(*TxtPtr) == 'E') {
|
|
return EG_VTE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return EG_OTHER;
|
|
}
|
|
|
|
#define GBFSIZE 256
|
|
|
|
static DEFAULT ExeEG() /* perform operating system function */
|
|
{
|
|
DEFAULT EGWhat; /* what to operate on: INI, VTE, etc. */
|
|
unsigned char GBfBeg[GBFSIZE];
|
|
charptr GBfPtr;
|
|
ptrdiff_t GBfLen;
|
|
|
|
DBGFEN(1,"ExeEG",NULL);
|
|
|
|
if (BldStr(GBfBeg, GBfBeg+GBFSIZE-2, &GBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
GBfLen = GBfPtr - GBfBeg;
|
|
if (CmdMod & COLON) { /* if it's :EG */
|
|
DEFAULT EGOper = GET_VAL; /* get, set or clear */
|
|
charptr TmpPtr;
|
|
CmdMod &= ~COLON; /* clear colon flag */
|
|
EGWhat = GetWha(GBfBeg,GBfLen);
|
|
TmpPtr = (charptr)GBfBeg;
|
|
if (EGWhat != EG_OTHER) {
|
|
if (GBfLen == 4) { /* if it's "clear" */
|
|
if (*(TmpPtr+3) != ' ') {
|
|
DBGFEX(1,DbgFNm,"PushEx(0)");
|
|
return PushEx(0L,OPERAND);
|
|
}
|
|
EGOper = CLEAR_VAL;
|
|
} else if (GBfLen != 3) { /* it it's not "get" */
|
|
EGOper = SET_VAL;
|
|
TmpPtr += 4;
|
|
}
|
|
}
|
|
*GBfPtr = '\0';
|
|
DBGFEX(1,DbgFNm,"PushEx(ZClnEG())");
|
|
return PushEx(ZClnEG(EGWhat,EGOper,TmpPtr),OPERAND);
|
|
}
|
|
|
|
if (ExeEC() == FAILURE) { /* do an EC command */
|
|
DBGFEX(1,DbgFNm,"FAILURE, ExeEC() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (GBfLen == 0) { /* if it was EC$ */
|
|
TAbort(EXIT_SUCCESS); /* just exit TECO-C */
|
|
}
|
|
|
|
ZDoCmd(GBfBeg, GBfPtr); /* exit with a command */
|
|
DBGFEX(1,DbgFNm,"SUCCESS"); /* we should never reach this */
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEH()
|
|
|
|
This function executes an EH command.
|
|
|
|
EH Help level flag
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEH() /* execute an EH command */
|
|
{
|
|
DBGFEN(1,"ExeEH",NULL);
|
|
DBGFEX(1,DbgFNm,"DoFlag()");
|
|
return DoFlag(&EhFlag);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ReadEI()
|
|
|
|
This function reads an EI file. It is passed an index for the file
|
|
data block of the open EI file, and a buffer. It reads the contents of the
|
|
file into the buffer, stopping when a double ESCAPE or end-of-file is
|
|
encountered.
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ReadEI(IfIndx, ZBfPtr, EscPtr)
|
|
DEFAULT IfIndx; /* index into IFiles array */
|
|
charptr *ZBfPtr; /* returned ptr to end of EI string (+1) */
|
|
charptr *EscPtr; /* returned ptr to $$ in EI string (+1) */
|
|
{
|
|
DEFAULT line_len;
|
|
charptr NewBuf;
|
|
SIZE_T NewSiz;
|
|
BOOLEAN previous_char_was_escape;
|
|
charptr TmpPtr;
|
|
|
|
#if DEBUGGING
|
|
static char *DbgFNm = "ReadEI";
|
|
sprintf(DbgSBf,"ZBfBeg = %ld, ZBfEnd = %ld",
|
|
Zcp2ul(ZBfBeg), Zcp2ul(ZBfEnd));
|
|
DbgFEn(1,DbgFNm,DbgSBf);
|
|
#endif
|
|
|
|
FOREVER {
|
|
|
|
/*
|
|
* potentially reallocate ZBf
|
|
*/
|
|
|
|
if ((ZBfEnd - ZBfRdP) < ZBFMIN) {
|
|
NewSiz = (ZBfEnd - ZBfBeg) + ZBFEXP;
|
|
NewBuf = (charptr)ZRaloc(ZBfBeg, NewSiz);
|
|
if (NewBuf == NULL) {
|
|
ErrMsg(ERR_MEM); /* MEM = memory overflow */
|
|
DBGFEX(1,DbgFNm,"FAILURE, ZRaloc() failed");
|
|
return (FAILURE);
|
|
}
|
|
ZBfRdP = NewBuf + (ZBfRdP - ZBfBeg);
|
|
ZBfEnd = NewBuf + NewSiz;
|
|
ZBfBeg = NewBuf;
|
|
}
|
|
/*
|
|
* append a line from the EI file to ZBf
|
|
*/
|
|
|
|
if (ZRdLin(ZBfRdP,ZBfEnd-ZBfRdP,IfIndx,&line_len) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, ZRdLin() failed");
|
|
return (FAILURE);
|
|
}
|
|
|
|
/*
|
|
* break out of FOREVER loop if we tried reading past end of file.
|
|
*/
|
|
|
|
if (IsEofI[IfIndx]) {
|
|
DBGFMS(1,DbgFNm,"ran into EOF");
|
|
break;
|
|
}
|
|
|
|
#if DEBUGGING
|
|
sprintf(DbgSBf,"read %d bytes: \"%.*s\"",
|
|
(int)line_len, (int)line_len, ZBfRdP);
|
|
DbgFMs(1,DbgFNm,DbgSBf);
|
|
#endif
|
|
|
|
/*
|
|
* go through the line we've read, looking for $$.
|
|
*/
|
|
|
|
TmpPtr = ZBfRdP;
|
|
ZBfRdP += line_len;
|
|
previous_char_was_escape = FALSE;
|
|
for (; TmpPtr < ZBfRdP; ++TmpPtr) {
|
|
if (*TmpPtr == ESCAPE) {
|
|
if (previous_char_was_escape) {
|
|
*ZBfPtr = ZBfRdP;
|
|
*EscPtr = ++TmpPtr;
|
|
DBGFEX(1,DbgFNm,
|
|
"SUCCESS, ran into $$");
|
|
return (SUCCESS);
|
|
}
|
|
previous_char_was_escape = TRUE;
|
|
} else {
|
|
previous_char_was_escape = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
*ZBfPtr = ZBfRdP;
|
|
*EscPtr = NULL;
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
OpnEI()
|
|
|
|
This function opens an EI file. The file name given by the user may
|
|
find the file one of the following ways:
|
|
|
|
1. as given (current directory)
|
|
2. as given, but with a ".TEC" type (current directory)
|
|
3. as given, in the default directory, with a ".TEC" type
|
|
3. as given, in the default directory
|
|
|
|
As soon as one of these forms is found and opened, this function returns.
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT OpnEI(EInd) /* open an EI file */
|
|
DEFAULT EInd;
|
|
{
|
|
#ifdef OPNEI_FINISHED
|
|
if (OpnInp(EInd, FALSE, TRUE) == SUCCESS)
|
|
return(SUCCESS);
|
|
if (OpnInp(EInd, TRUE, TRUE) == SUCCESS)
|
|
return(SUCCESS);
|
|
save contents of FBf
|
|
use :EGDEF command to fill FBf with default directory (how?)
|
|
append saved FBf to actual FBf
|
|
if (OpnInp(EInd, FALSE, TRUE) == SUCCESS)
|
|
return(SUCCESS);
|
|
if (OpnInp(EInd, TRUE, TRUE) == SUCCESS)
|
|
return(SUCCESS);
|
|
#else
|
|
return OpnInp(EInd, TRUE, TRUE);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
DoEI()
|
|
|
|
This function performs the execution part of an EI command. It is
|
|
called by the ExeEI function. It is passed an index to a file data block in
|
|
the IFiles array that has been opened. It is also passed a memory buffer.
|
|
This function reads text from the file into the buffer and calls ExeCSt to
|
|
execute the text.
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT DoEI(IfIndx) /* do an EI command */
|
|
DEFAULT IfIndx; /* index into IFiles array */
|
|
{
|
|
charptr ZBfPtr; /* pointer to end of command string in ZBf */
|
|
charptr EscPtr; /* ptr into ZBf past second $ of $$ pair */
|
|
DEFAULT status; /* return status of ExeCSt() */
|
|
|
|
DBGFEN(1,"DoEI",NULL);
|
|
|
|
status = SUCCESS; /* in case we try doing an empty EI file */
|
|
ZBfRdP = ZBfBeg; /* start reading into beginning of ZBf */
|
|
do {
|
|
/*
|
|
* Read EI file into ZBf until $$ or EOF, whichever comes first
|
|
*/
|
|
if (ReadEI(IfIndx, &ZBfPtr, &EscPtr) == FAILURE) {
|
|
ErrMsg(ERR_URE); /* Unable to Read EI file */
|
|
DBGFEX(1,DbgFNm,"FAILURE, ReadEI() failed");
|
|
return FAILURE;
|
|
}
|
|
/*
|
|
* save the current execution state and make ZBf the current command string
|
|
* to execute
|
|
*/
|
|
if (PshMac(ZBfBeg, (EscPtr) ? EscPtr : ZBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, PshMac() failed");
|
|
return FAILURE;
|
|
}
|
|
/*
|
|
* execute macro in ZBf
|
|
*/
|
|
status = ExeCSt();
|
|
|
|
#if DEBUGGING
|
|
if (status == FAILURE) {
|
|
DbgFMs(1,DbgFNm,"ExeCSt() failed");
|
|
}
|
|
#endif
|
|
/*
|
|
* restore old execution state
|
|
*/
|
|
if (PopMac() == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, PopMac() failed");
|
|
return FAILURE;
|
|
}
|
|
/*
|
|
* if we ran into an $$ that was in the middle of a line, then we want to
|
|
* move it to the beginning of ZBf and append the rest of the EI file to
|
|
* it; otherwise, we'll just start reading into the beginning of ZBf.
|
|
*/
|
|
if (EscPtr) {
|
|
ptrdiff_t LeftOver;
|
|
|
|
LeftOver = ZBfPtr - EscPtr;
|
|
MEMMOVE(ZBfBeg, EscPtr, LeftOver);
|
|
ZBfRdP = ZBfBeg + LeftOver;
|
|
} else {
|
|
ZBfRdP = ZBfBeg;
|
|
}
|
|
|
|
} while (!IsEofI[IfIndx] && !GotCtC && status != FAILURE);
|
|
|
|
DBGFEX(1,DbgFNm,(status == FAILURE) ? "FAILURE" : "SUCCESS");
|
|
|
|
return status; /* return ExeCSt() status */
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEI()
|
|
|
|
This function executes an EI command. This function does only part of
|
|
the work; the DoEI function does the rest. This function opens/closes the
|
|
file and allocates/deallocates an input buffer. The code executes such that
|
|
no matter what happens, an open file will always be closed and allocated
|
|
memory will always be freed.
|
|
|
|
EI Close current indirect command file
|
|
EIfilespec$ Open indirect command file
|
|
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
* EIIndx is an index into the IFiles array. It is incremented each time an
|
|
* EI command is executed and decremented each time an EI command completes.
|
|
* It is the index of the file data block of the currently open EI input file.
|
|
* When EIIndx equals EIFL-1, no EI files are open.
|
|
*/
|
|
|
|
static DEFAULT EIIndx = EIFL-1;
|
|
|
|
static DEFAULT ExeEI() /* execute an EI command */
|
|
{
|
|
int status;
|
|
|
|
DBGFEN(1,"ExeEI",NULL);
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FBfPtr == FBfBeg) { /* if it's EI$ */
|
|
if (EIIndx >= EIFL) { /* if EI file is open */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
}
|
|
EStTop = EStBot; /* clear expression stack */
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (++EIIndx > NIFDBS) { /* If EI nesting too deep */
|
|
EIIndx--;
|
|
ErrMsg(ERR_MEM); /* ERR_MEM=memory overflow */
|
|
DBGFEX(1,DbgFNm,"FAILURE, EI nested too deep");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (OpnEI(EIIndx) != SUCCESS) { /* open EI file */
|
|
status = FAILURE;
|
|
} else {
|
|
ZBfBeg = (charptr)ZAlloc(ZBFINIT); /* allocate input buffer */
|
|
if (ZBfBeg == NULL) { /* if allocation failed */
|
|
ErrMsg(ERR_MEM); /* MEM = memory overflow */
|
|
status = FAILURE;
|
|
} else { /* else allocation ok */
|
|
ZBfEnd = ZBfBeg + ZBFINIT;
|
|
status = DoEI(EIIndx);
|
|
ZFree((voidptr)ZBfBeg); /* free allocated memory */
|
|
}
|
|
ZIClos(EIIndx);
|
|
}
|
|
EIIndx--; /* decrement nesting count */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
|
|
return status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEK()
|
|
|
|
This function executes an EK command.
|
|
|
|
EK Kill output file
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEK() /* execute an EK command */
|
|
{
|
|
DBGFEN(1,"ExeEK",NULL);
|
|
|
|
ZOClDe(CurOut); /* close and delete output file */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEN()
|
|
|
|
This function executes an EN command.
|
|
|
|
EN Wildcard lookup
|
|
:EN EN, return status
|
|
ENfilespec$ Preset wildcard lookup
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEN() /* execute an EN command */
|
|
{
|
|
DBGFEN(1,"ExeEN",NULL);
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FBfPtr == FBfBeg) { /* if it's EN$ or :EN$ */
|
|
switch (ZSWild()) {
|
|
case FAILURE:
|
|
DBGFEX(1,DbgFNm,"FAILURE, ZSWild() failed");
|
|
return FAILURE;
|
|
|
|
case FILENF:
|
|
if (CmdMod & COLON) { /* if it's :EN */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot;/* clear expression stack */
|
|
DBGFEX(1,DbgFNm,"PushEx(0)");
|
|
return PushEx(0L,OPERAND);
|
|
}
|
|
ErrStr(ERR_FNF, ""); /* file not found */
|
|
DBGFEX(1,DbgFNm,"FAILURE");
|
|
return FAILURE;
|
|
|
|
case SUCCESS:
|
|
if (CmdMod & COLON) { /* if it's :EN */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
DBGFEX(1,DbgFNm,"PushEx(-1)");
|
|
return PushEx(-1L,OPERAND);
|
|
}
|
|
EStTop = EStBot;/* clear expression stack */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (ZPWild() == FAILURE) { /* preset wildcard filepsec */
|
|
DBGFEX(1,DbgFNm,"FAILURE, ZPWild() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
EStTop = EStBot; /* clear expression stack */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEO()
|
|
|
|
This function executes an EO command. TECO-C's version numbers
|
|
started at 100 and went up. Other implementations of TECO have version
|
|
numbers less than 100.
|
|
|
|
EO Version of TECO
|
|
nEO Set TECO to function as version n
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEO() /* execute an EO command */
|
|
{
|
|
return ((EStTop > EStBot) /* is it nEO ? */
|
|
? ExeNYI() /* ...yes, not supported */
|
|
: PushEx((LONG)TVERSION,OPERAND)); /* ...no, return version */
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEP()
|
|
|
|
This function executes an EP command.
|
|
|
|
EP Select secondary input stream
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEP() /* execute an EP command */
|
|
{
|
|
DBGFEN(1,"ExeEP",NULL);
|
|
|
|
CurInp = SINPFL; /* select secondary input stream */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEPr()
|
|
|
|
This function executes an E% command.
|
|
|
|
E%qfilespec$ Write Q-register q into a file
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEPr() /* execute an E% command */
|
|
{
|
|
BOOLEAN RepErr; /* report errors? */
|
|
|
|
DBGFEN(1,"ExeEPr",NULL);
|
|
|
|
if (IncCBP() == FAILURE) { /* move to char after % */
|
|
DBGFEX(1,DbgFNm,"FAILURE, IncCBP() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FindQR() == FAILURE) { /* find q-register */
|
|
DBGFEX(1,DbgFNm,"FAILURE, FindQR() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FBfPtr == FBfBeg) { /* if it's E%q$ */
|
|
ErrUTC(); /* unterminated command */
|
|
DBGFEX(1,DbgFNm,"FAILURE, unterminated command");
|
|
return FAILURE;
|
|
}
|
|
|
|
RepErr = !(CmdMod & COLON);
|
|
CmdMod = '\0';
|
|
if (OpnOut(EPRCFL, RepErr, FALSE) == FAILURE) {
|
|
#if DEBUGGING
|
|
sprintf(DbgSBf,"%s, OpnOut() failed",
|
|
(RepErr) ? "FAILURE" : "PushEx(0)");
|
|
DbgFEx(1,DbgFNm,DbgSBf);
|
|
#endif
|
|
return ((RepErr) ? FAILURE : PushEx(0L,OPERAND));
|
|
}
|
|
|
|
if (QR->Start != NULL) { /* if it's not empty */
|
|
if (ZWrBfr(EPRCFL, QR->Start, QR->End_P1-1) == FAILURE) {
|
|
#if DEBUGGING
|
|
sprintf(DbgSBf,"%s, ZWrBfr() failed",
|
|
(RepErr) ? "FAILURE" : "PushEx(0)");
|
|
DbgFEx(1,DbgFNm,DbgSBf);
|
|
#endif
|
|
return ((RepErr) ? FAILURE : PushEx(0L,OPERAND));
|
|
}
|
|
}
|
|
|
|
ZOClos(EPRCFL); /* close the file */
|
|
|
|
if (!RepErr) {
|
|
DBGFEX(1,DbgFNm,"PushEx(-1)");
|
|
return PushEx(-1L,OPERAND);
|
|
}
|
|
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEQ()
|
|
|
|
This function executes an EQ command. The EQ command reads a file
|
|
directly into a q-register. This command uses the RdPage function to
|
|
temporarily append the contents of the file to the end of the edit buffer.
|
|
It then copies the text to a q-register.
|
|
|
|
EQqfilespec$ Read file into Q-register q
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEQ() /* execute an EQ command */
|
|
{
|
|
ptrdiff_t FSize; /* file size */
|
|
LONG SvFFPg; /* saved FFPage value */
|
|
DEFAULT SvCrIn; /* saved CurInp value */
|
|
ptrdiff_t SvEbSz; /* saved edit buffer size */
|
|
DEFAULT Status;
|
|
|
|
DBGFEN(1,"ExeEQ",NULL);
|
|
|
|
if (IncCBP() == FAILURE) { /* move to char after Q */
|
|
DBGFEX(1,DbgFNm,"FAILURE, IncCBP() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FindQR() == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, FindQR() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FBfPtr == FBfBeg) { /* if it's EQq$ */
|
|
ErrUTC(); /* unterminated command */
|
|
DBGFEX(1,DbgFNm,"FAILURE, unterminated command");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (OpnInp(EQFL, FALSE, TRUE) != SUCCESS) { /* open the file */
|
|
DBGFEX(1,DbgFNm,"FAILURE, OpnInp() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
/*
|
|
* We borrow RdPage's ability to read files correctly. RdPage reads file
|
|
* CurInp, so we need to temporarily set CurInp to the EQ file data block.
|
|
* The data is appended to the edit buffer, so we need to save the pointer
|
|
* to the current end of the edit buffer.
|
|
*/
|
|
SvCrIn = CurInp; /* save CurInp */
|
|
SvEbSz = (EBfEnd - EBfBeg) - (GapEnd - GapBeg); /* save EBfEnd */
|
|
SvFFPg = FFPage; /* save FFPage */
|
|
CurInp = EQFL;
|
|
do {
|
|
if (RdPage() == FAILURE) {
|
|
Status = FAILURE;
|
|
goto exeeqdone;
|
|
}
|
|
} while (!IsEofI[EQFL]);
|
|
|
|
/*
|
|
* Make room in the q-register.
|
|
*/
|
|
FSize = EBfEnd - (EBfBeg + SvEbSz + (GapEnd - GapBeg));
|
|
if (MakRom((SIZE_T)FSize) == FAILURE) {
|
|
Status = FAILURE;
|
|
goto exeeqdone;
|
|
}
|
|
|
|
/*
|
|
* Copy the text that we just read from the file into the q-register.
|
|
*/
|
|
MEMMOVE(QR->Start,
|
|
EBfBeg + SvEbSz + 1 + (GapEnd - GapBeg),
|
|
(SIZE_T)FSize);
|
|
QR->End_P1 = QR->Start + FSize;
|
|
|
|
Status = SUCCESS;
|
|
exeeqdone:
|
|
FFPage = SvFFPg; /* restore FFpage */
|
|
EBfEnd = EBfBeg + SvEbSz +
|
|
(GapEnd - GapBeg); /* restore EBfEnd */
|
|
CurInp = SvCrIn; /* restore CurInp */
|
|
|
|
ZIClos(EQFL); /* close the file */
|
|
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,(Status == SUCCESS) ? "SUCCESS" : "FAILURE");
|
|
return Status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeER()
|
|
|
|
This function executes an ER command.
|
|
|
|
ER Select primary input stream
|
|
ERfilespec$ Open input file
|
|
:ERfilespec$ ER, return status
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeER() /* execute an ER command */
|
|
{
|
|
BOOLEAN RepFNF; /* report "file not found" errors? */
|
|
DEFAULT status;
|
|
|
|
DBGFEN(1,"ExeER",NULL);
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FBfPtr == FBfBeg) { /* if it's ER$ */
|
|
CurInp = PINPFL; /* primary input stream */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
RepFNF = !(CmdMod & COLON); /* report file not found? */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
status = OpnInp(CurInp, FALSE, RepFNF); /* open input file */
|
|
if (status != SUCCESS) {
|
|
if (status == FILENF) {
|
|
if (!RepFNF) { /* if it's :ER */
|
|
DBGFEX(1,DbgFNm,"PushEx(0)");
|
|
return PushEx(0L,OPERAND);
|
|
}
|
|
}
|
|
DBGFEX(1,DbgFNm,"FAILURE, OpnInp() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (!RepFNF) { /* if it's :ER */
|
|
DBGFEX(1,DbgFNm,"PushEx(-1)");
|
|
return PushEx(-1L,OPERAND);
|
|
}
|
|
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeES()
|
|
|
|
This function executes an ES command.
|
|
|
|
ES Search verification flag
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeES() /* execute an ES command */
|
|
{
|
|
DBGFEN(1,"ExeES",NULL);
|
|
DBGFEX(1,DbgFNm,"DoFlag(&EsFlag)");
|
|
return DoFlag(&EsFlag);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeET()
|
|
|
|
This function executes an ET command.
|
|
|
|
ET Type out control flag
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeET() /* execute an ET command */
|
|
{
|
|
DEFAULT status;
|
|
WORD TmpET;
|
|
|
|
DBGFEN(1,"ExeET",NULL);
|
|
|
|
TmpET = EtFlag;
|
|
status = DoFlag(&EtFlag);
|
|
|
|
/*
|
|
* If DoFlag set or cleared the 8-bit flag, we have to tell the operating
|
|
* system.
|
|
*/
|
|
if (status != FAILURE) {
|
|
if ((TmpET & ET_EIGHTBIT) && /* eightbit flag cleared? */
|
|
!(EtFlag & ET_EIGHTBIT)) {
|
|
status = ZSetTT(TT8BIT, 0);
|
|
} else if (!(TmpET & ET_EIGHTBIT) && /* eightbit flag set? */
|
|
(EtFlag & ET_EIGHTBIT)) {
|
|
status = ZSetTT(TT8BIT, 1);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If one of the read-only flags was changed, set it back.
|
|
*/
|
|
if ((TmpET & ET_WAT_SCOPE) != (EtFlag & ET_WAT_SCOPE)) {
|
|
if (TmpET & ET_WAT_SCOPE) /* if it was cleared */
|
|
EtFlag |= ET_WAT_SCOPE; /* set it */
|
|
else
|
|
EtFlag &= ~ET_WAT_SCOPE; /* clear it */
|
|
}
|
|
if ((TmpET & ET_WAT_REFRESH) != (EtFlag & ET_WAT_REFRESH)) {
|
|
if (TmpET & ET_WAT_REFRESH) /* if it was cleared */
|
|
EtFlag |= ET_WAT_REFRESH; /* set it */
|
|
else
|
|
EtFlag &= ~ET_WAT_REFRESH; /* clear it */
|
|
}
|
|
|
|
DBGFEX(1,DbgFNm,(status==FAILURE) ? "FAILURE" : "SUCCESS");
|
|
return status;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEU()
|
|
|
|
This function executes an EU command.
|
|
|
|
EU Case flagging flag
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEU() /* execute an EU command */
|
|
{
|
|
DBGFEN(1,"ExeEU",NULL);
|
|
DBGFEX(1,DbgFNm,"DoFlag(&EuFlag)");
|
|
return DoFlag(&EuFlag);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEUn()
|
|
|
|
This function executes an E_ command.
|
|
|
|
nE_ Search without yank protection
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEUn() /* execute an E_ command */
|
|
{
|
|
DBGFEN(1,"ExeEUn",NULL);
|
|
|
|
/*
|
|
* The command m,nE_ is illegal: the user should use m,nFB
|
|
*/
|
|
|
|
if (CmdMod & MARGIS) { /* if it's m,nE_ */
|
|
ErrStr(ERR_ILL, "m,nE_"); /* illegal command "m,nE_" */
|
|
DBGFEX(1,DbgFNm,"FAILURE, m,nE is illegal");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (CmdMod & DCOLON) { /* if it's ::E_ */
|
|
ErrStr(ERR_ILL, "::E_"); /* illegal command "::E_" */
|
|
DBGFEX(1,DbgFNm,"FAILURE, ::E_ is illegal");
|
|
return FAILURE;
|
|
}
|
|
|
|
SrcTyp = E_SEARCH;
|
|
if (Search(FALSE) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, Search() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEV()
|
|
|
|
This function executes an EV command.
|
|
|
|
EV Edit verify flag
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEV() /* execute an EV command */
|
|
{
|
|
DBGFEN(1,"ExeEV",NULL);
|
|
DBGFEX(1,DbgFNm,"DoFlag()");
|
|
return DoFlag(&EvFlag);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEW()
|
|
|
|
This function executes an EW command.
|
|
|
|
EWfilespec$ Open output file
|
|
EW Select primary output stream
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEW() /* execute an EW command */
|
|
{
|
|
BOOLEAN RepErr; /* report errors? */
|
|
|
|
DBGFEN(1,"ExeEW",NULL);
|
|
|
|
if (BldStr(FBfBeg, FBfEnd, &FBfPtr) == FAILURE) {
|
|
DBGFEX(1,DbgFNm,"FAILURE, BldStr() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
if (FBfPtr == FBfBeg) { /* if it's EW$ */
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
CurOut = POUTFL; /* primary output stream */
|
|
EStTop = EStBot; /* clear expression stack */
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
RepErr = !(CmdMod & COLON);
|
|
CmdMod = '\0'; /* clear modifiers flags */
|
|
if (OpnOut(CurOut, RepErr, FALSE) == FAILURE) {
|
|
#if DEBUGGING
|
|
sprintf(DbgSBf,"%s, OpnOut() failed",
|
|
(RepErr) ? "FAILURE" : "PushEx(0)");
|
|
DbgFEx(1,DbgFNm,DbgSBf);
|
|
#endif
|
|
return ((RepErr) ? FAILURE : PushEx(0L,OPERAND));
|
|
}
|
|
|
|
if (!RepErr) {
|
|
DBGFEX(1,DbgFNm,"PushEx(-1)");
|
|
return PushEx(-1L,OPERAND);
|
|
}
|
|
|
|
EStTop = EStBot; /* clear expression stack */
|
|
|
|
DBGFEX(1,DbgFNm,"SUCCESS");
|
|
return SUCCESS;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEX()
|
|
|
|
This function executes an EX command.
|
|
|
|
EX Close out and exit
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEX() /* execute an EX command */
|
|
{
|
|
DBGFEN(1,"ExeEX",NULL);
|
|
|
|
if (ExeEC() != FAILURE) { /* execute an EC command */
|
|
DBGFEX(1,DbgFNm,"exiting successfully!");
|
|
TAbort(EXIT_SUCCESS); /* exit TECO-C */
|
|
}
|
|
|
|
DBGFEX(1,DbgFNm,"FAILURE, ExeEX() failed");
|
|
return FAILURE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeEZ()
|
|
|
|
This function executes an EZ command. EZ is a mode control flag
|
|
that contains bits specific to the operating system we're using.
|
|
|
|
*****************************************************************************/
|
|
|
|
static DEFAULT ExeEZ() /* execute an EZ command */
|
|
{
|
|
DBGFEN(1,"ExeEZ",NULL);
|
|
DBGFEX(1,DbgFNm,"DoFlag(&EZFlag)");
|
|
return DoFlag(&EzFlag);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
|
|
ExeE()
|
|
|
|
This function executes two-letter commands that start with "E".
|
|
It uses the character following the "E" to index into a table of functions.
|
|
|
|
*****************************************************************************/
|
|
|
|
DEFAULT ExeE() /* execute an E command */
|
|
{
|
|
unsigned char TmpChr;
|
|
static DEFAULT (*FEAray[])(VVOID) = {
|
|
/* A */ ExeEA, /* B */ ExeEB,
|
|
/* C */ ExeEC, /* D */ ExeED,
|
|
/* E */ ExeIll, /* F */ ExeEF,
|
|
/* G */ ExeEG, /* H */ ExeEH,
|
|
/* I */ ExeEI, /* J */ ZExeEJ,
|
|
/* K */ ExeEK, /* L */ ExeNYI,
|
|
/* M */ ExeNYI, /* N */ ExeEN,
|
|
/* O */ ExeEO, /* P */ ExeEP,
|
|
/* Q */ ExeEQ, /* R */ ExeER,
|
|
/* S */ ExeES, /* T */ ExeET,
|
|
/* U */ ExeEU, /* V */ ExeEV,
|
|
/* W */ ExeEW, /* X */ ExeEX,
|
|
/* Y */ ExeEY, /* Z */ ExeEZ
|
|
};
|
|
|
|
if (IncCBP() == FAILURE) {
|
|
return FAILURE;
|
|
}
|
|
|
|
TmpChr = To_Upper (*CBfPtr);
|
|
|
|
if (TmpChr == '%') { /* we have E%q */
|
|
return ExeEPr();
|
|
}
|
|
|
|
if (TmpChr == '_') { /* we have nE_ */
|
|
return ExeEUn();
|
|
}
|
|
|
|
if (!Is_Upper(TmpChr) || (TmpChr == 'E')) {
|
|
ErrChr(ERR_IEC, TmpChr);
|
|
return FAILURE;
|
|
}
|
|
|
|
return (*FEAray[TmpChr-'A'])();
|
|
}
|