static DEFAULT SkpOne() /* skip one command character */
{
#if DEBUGGING
static char *DbgFNm = "SkpOne";
sprintf(DbgSBf,"*CBfPtr = '%c'", *CBfPtr);
DbgFEn(3,DbgFNm,DbgSBf);
#endif
if (CBfPtr == CStEnd) {
if (MStTop < 0) { /* if not in a macro */
ErrUTC(); /* unterminated command */
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
} else {
DBGFEX(3,DbgFNm,"SUCCESS");
return SUCCESS;
}
}
++CBfPtr;
#if DEBUGGING
sprintf(DbgSBf,"*CBfPtr = '%c'", *CBfPtr);
DbgFEx(3,DbgFNm,DbgSBf);
#endif
return SUCCESS;
}
integer
DoCJR(long HowFar) /* do C, J or R stuff */
/* long HowFar; positive or negative displacement */
{
long InRange;
bool ColonMod;
#if DEBUGGING
static char *DbgFNm = "DoCJR";
sprintf(DbgSBf,"HowFar = %ld", HowFar);
DbgFEn(2,DbgFNm,DbgSBf);
#endif
ColonMod = (CmdMod & COLON); /* is it :C, :J, or :R? */
CmdMod &= ~COLON; /* clear : flag */
InRange = -1; /* -1 means SUCCESS in TECO */
if (HowFar > 0)
{
if ((GapEnd + HowFar) > EBfEnd)
InRange = 0; /* 0 means FAILURE in TECO */
else
{
MEMMOVE(GapBeg, GapEnd + 1, HowFar);
GapBeg += HowFar;
GapEnd += HowFar;
}
}
else
{
if ((GapBeg + HowFar) < EBfBeg)
InRange = 0; /* 0 means FAILURE in TECO */
else
{
GapBeg += HowFar;
GapEnd += HowFar;
MEMMOVE(GapEnd+1, GapBeg, -(HowFar));
}
}
if (ColonMod) /* if colon modifier */
{
DBGFEX(2,DbgFNm,"PushEx");
return PushEx(InRange, OPERAND);
}
else if (InRange == 0) /* if out-of-bounds */
{
ErrChr(ERR_POP, *CBfPtr);
DBGFEX(2, DbgFNm, "FAILURE");
return FAILURE;
}
CmdMod = '\0'; /* clear modifiers flags */
EStTop = EStBot; /* clear expression stack */
DBGFEX(2,DbgFNm,"SUCCESS");
return SUCCESS;
}
DEFAULT GetAra() /* get m,n addresses */
{
LONG TmpLng;
#if DEBUGGING
static char *DbgFNm = "GetAra";
sprintf(DbgSBf,"MArgmt = %ld, NArgmt = %ld", MArgmt, NArgmt);
DbgFEn(4,DbgFNm,DbgSBf);
#endif
if (MArgmt < 0) { /* if negative m */
ErrMsg(ERR_NCA); /* negative argument to , */
DBGFEX(4,DbgFNm,"FAILURE, negative m");
return FAILURE;
}
if (NArgmt < 0) { /* if negative n */
ErrStr(ERR_POP, ErrTxt); /* POP = pointer off page */
DBGFEX(4,DbgFNm,"FAILURE, negative n");
return FAILURE;
}
if (MArgmt > NArgmt) { /* if wrong order */
TmpLng = NArgmt;
NArgmt = MArgmt;
MArgmt = TmpLng;
}
AraBeg = EBfBeg + MArgmt; /* compute area beginning */
if (AraBeg > GapBeg-1) { /* if past start of gap */
AraBeg += (GapEnd-GapBeg) + 1; /* correct for gap */
}
AraEnd = (EBfBeg + NArgmt) - 1; /* compute area end */
if (AraEnd > GapBeg-1) { /* if before end of gap */
AraEnd += (GapEnd-GapBeg) + 1; /* correct for gap */
}
if ((AraBeg > EBfEnd) || /* if m or n too large */
(AraEnd > EBfEnd)) {
ErrStr(ERR_POP, ErrTxt); /* POP = pointer off page */
DBGFEX(4,DbgFNm,"FAILURE");
return FAILURE;
}
#if DEBUGGING
sprintf(DbgSBf,"SUCCESS, AraBeg = %ld, AraEnd = %ld",
Zcp2ul(AraBeg), Zcp2ul(AraEnd));
DbgFEx(4,DbgFNm,DbgSBf);
#endif
return SUCCESS;
}
/*****************************************************************************
SkpCmd()
This function "skips" TECO commands. It is used when TECO needs to
skip forward under one of these conditions:
1. flow to the end of a conditional
2. flow to the else clause of a conditional
3. flow to the end of a loop
4. flow while searching for a tag
When this function is called, CBfPtr points to a command. When this
function returns, CBfPtr is left pointing to the last character of the
command. In the case of a command like T, CBfPtr is not changed. In the
case of a command like Stext<ESC>, CBfPtr is left pointing to the <ESC>.
*****************************************************************************/
DEFAULT SkpCmd() /* skip a "command" */
{
static DEFAULT (*FSAray[])(VVOID) = {
/*NUL*/ ExeNul, /* ^A*/ SkpCtA, /* ^B*/ SkpSkp, /* ^C*/ SkpSkp,
/* ^D*/ SkpSkp, /* ^E*/ SkpSkp, /* ^F*/ SkpSkp, /* ^G*/ SkpSkp,
/* BS*/ SkpSkp, /*TAB*/ SkpArg, /* LF*/ ExeNul, /* VT*/ SkpSkp,
/* FF*/ SkpSkp, /* CR*/ ExeNul, /* ^N*/ SkpSkp, /* ^O*/ SkpSkp,
/* ^P*/ SkpSkp, /* ^Q*/ SkpSkp, /* ^R*/ SkpSkp, /* ^S*/ SkpSkp,
/* ^T*/ SkpSkp, /* ^U*/ SkpCtU, /* ^V*/ SkpSkp, /* ^W*/ SkpSkp,
/* ^X*/ SkpSkp, /* ^Y*/ SkpSkp, /* ^Z*/ SkpSkp, /*ESC*/ SkpSkp,
/* ^\*/ SkpSkp, /* ^]*/ SkpSkp, /* ^^*/ SkpOne, /* ^_*/ SkpSkp,
/* SP*/ ExeNul, /* ! */ SkpExc, /* " */ SkpDqu, /* # */ SkpSkp,
/* $ */ SkpSkp, /* % */ SkpOne, /* & */ SkpSkp, /* ' */ SkpSkp,
/* ( */ SkpSkp, /* ) */ SkpSkp, /* * */ SkpSkp, /* + */ SkpSkp,
/* , */ SkpSkp, /* - */ SkpSkp, /* . */ SkpSkp, /* / */ SkpSkp,
/* 0 */ SkpSkp, /* 1 */ SkpSkp, /* 2 */ SkpSkp, /* 3 */ SkpSkp,
/* 4 */ SkpSkp, /* 5 */ SkpSkp, /* 6 */ SkpSkp, /* 7 */ SkpSkp,
/* 8 */ SkpSkp, /* 9 */ SkpSkp, /* : */ SkpSkp, /* ; */ SkpSkp,
/* < */ SkpSkp, /* = */ SkpSkp, /* > */ SkpSkp, /* ? */ SkpSkp,
/* @ */ ExeAtS, /* A */ SkpSkp, /* B */ SkpSkp, /* C */ SkpSkp,
/* D */ SkpSkp, /* E */ SkpE, /* F */ SkpF, /* G */ SkpOne,
/* H */ SkpSkp, /* I */ SkpArg, /* J */ SkpSkp, /* K */ SkpSkp,
/* L */ SkpSkp, /* M */ SkpOne, /* N */ SkpArg, /* O */ SkpArg,
/* P */ SkpSkp, /* Q */ SkpOne, /* R */ SkpSkp, /* S */ SkpArg,
/* T */ SkpSkp, /* U */ SkpOne, /* V */ SkpSkp, /* W */ SkpSkp,
/* X */ SkpOne, /* Y */ SkpSkp, /* Z */ SkpSkp, /* [ */ SkpOne,
/* \ */ SkpSkp, /* ] */ SkpOne, /* ^ */ SkpCrt, /* _ */ SkpArg,
/* ` */ SkpSkp, /* a */ SkpSkp, /* b */ SkpSkp, /* c */ SkpSkp,
/* d */ SkpSkp, /* e */ SkpE, /* f */ SkpF, /* g */ SkpOne,
/* h */ SkpSkp, /* i */ SkpArg, /* j */ SkpSkp, /* k */ SkpSkp,
/* l */ SkpSkp, /* m */ SkpOne, /* n */ SkpArg, /* o */ SkpArg,
/* p */ SkpSkp, /* q */ SkpOne, /* r */ SkpSkp, /* s */ SkpArg,
/* t */ SkpSkp, /* u */ SkpOne, /* v */ SkpSkp, /* w */ SkpSkp,
/* x */ SkpOne, /* y */ SkpSkp, /* z */ SkpSkp, /* { */ SkpSkp,
/* | */ SkpSkp, /* } */ SkpSkp, /* ~ */ SkpSkp, /*DEL*/ SkpSkp,
/*129*/ SkpSkp, /*130*/ SkpSkp, /*131*/ SkpSkp, /*132*/ SkpSkp,
/*133*/ SkpSkp, /*134*/ SkpSkp, /*135*/ SkpSkp, /*136*/ SkpSkp,
/*137*/ SkpSkp, /*138*/ SkpSkp, /*139*/ SkpSkp, /*140*/ SkpSkp,
/*141*/ SkpSkp, /*142*/ SkpSkp, /*143*/ SkpSkp, /*144*/ SkpSkp,
/*145*/ SkpSkp, /*146*/ SkpSkp, /*147*/ SkpSkp, /*148*/ SkpSkp,
/*149*/ SkpSkp, /*150*/ SkpSkp, /*151*/ SkpSkp, /*152*/ SkpSkp,
/*153*/ SkpSkp, /*154*/ SkpSkp, /*155*/ SkpSkp, /*156*/ SkpSkp,
/*157*/ SkpSkp, /*158*/ SkpSkp, /*159*/ SkpSkp, /*160*/ SkpSkp,
/*161*/ SkpSkp, /*162*/ SkpSkp, /*163*/ SkpSkp, /*164*/ SkpSkp,
/*165*/ SkpSkp, /*166*/ SkpSkp, /*167*/ SkpSkp, /*168*/ SkpSkp,
/*169*/ SkpSkp, /*170*/ SkpSkp, /*171*/ SkpSkp, /*172*/ SkpSkp,
/*173*/ SkpSkp, /*174*/ SkpSkp, /*175*/ SkpSkp, /*176*/ SkpSkp,
/*177*/ SkpSkp, /*178*/ SkpSkp, /*179*/ SkpSkp, /*180*/ SkpSkp,
/*181*/ SkpSkp, /*182*/ SkpSkp, /*183*/ SkpSkp, /*184*/ SkpSkp,
/*185*/ SkpSkp, /*186*/ SkpSkp, /*187*/ SkpSkp, /*188*/ SkpSkp,
/*189*/ SkpSkp, /*190*/ SkpSkp, /*191*/ SkpSkp, /*192*/ SkpSkp,
/*193*/ SkpSkp, /*194*/ SkpSkp, /*195*/ SkpSkp, /*196*/ SkpSkp,
/*197*/ SkpSkp, /*198*/ SkpSkp, /*199*/ SkpSkp, /*200*/ SkpSkp,
/*201*/ SkpSkp, /*202*/ SkpSkp, /*203*/ SkpSkp, /*204*/ SkpSkp,
/*205*/ SkpSkp, /*206*/ SkpSkp, /*207*/ SkpSkp, /*208*/ SkpSkp,
/*209*/ SkpSkp, /*210*/ SkpSkp, /*211*/ SkpSkp, /*212*/ SkpSkp,
/*213*/ SkpSkp, /*214*/ SkpSkp, /*215*/ SkpSkp, /*216*/ SkpSkp,
/*217*/ SkpSkp, /*218*/ SkpSkp, /*219*/ SkpSkp, /*220*/ SkpSkp,
/*221*/ SkpSkp, /*222*/ SkpSkp, /*223*/ SkpSkp, /*224*/ SkpSkp,
/*225*/ SkpSkp, /*226*/ SkpSkp, /*227*/ SkpSkp, /*228*/ SkpSkp,
/*229*/ SkpSkp, /*230*/ SkpSkp, /*231*/ SkpSkp, /*232*/ SkpSkp,
/*233*/ SkpSkp, /*234*/ SkpSkp, /*235*/ SkpSkp, /*236*/ SkpSkp,
/*237*/ SkpSkp, /*238*/ SkpSkp, /*239*/ SkpSkp, /*240*/ SkpSkp,
/*241*/ SkpSkp, /*242*/ SkpSkp, /*243*/ SkpSkp, /*244*/ SkpSkp,
/*245*/ SkpSkp, /*246*/ SkpSkp, /*247*/ SkpSkp, /*248*/ SkpSkp,
/*249*/ SkpSkp, /*250*/ SkpSkp, /*251*/ SkpSkp, /*252*/ SkpSkp,
/*253*/ SkpSkp, /*254*/ SkpSkp, /*255*/ SkpSkp, /*256*/ SkpSkp
};
DEFAULT Status;
#if DEBUGGING
static char *DbgFNm = "SkpCmd";
sprintf(DbgSBf,"*CBfPtr = '%c', at_sign is %s",
*CBfPtr, (CmdMod & ATSIGN) ? "TRUE" : "FALSE");
DbgFEn(3,DbgFNm,DbgSBf);
#endif
Status = (*FSAray[*CBfPtr])();
#if DEBUGGING
sprintf(DbgSBf,"*CBfPtr = '%c'", *CBfPtr);
DbgFEx(3,DbgFNm,DbgSBf);
#endif
return Status;
}
integer ExeRBr() /* execute ] command */
{
QRptr TmpQRp;
ptrdiff_t TmpSiz;
bool ColonMod;
#if DEBUGGING
static char *DbgFNm = "ExeRBr";
sprintf(DbgSBf, "QStTop = %d", QStTop);
DbgFEn(1,DbgFNm,DbgSBf);
#endif
ColonMod = (CmdMod & COLON); /* is it :] ? */
CmdMod &= ~COLON; /* clear colon flag */
if (IncCBP() == FAILURE) {
return FAILURE;
}
if (FindQR() == FAILURE) {
DBGFEX(1,DbgFNm,"FAILURE");
return FAILURE;
}
if (QStTop < 0) { /* if q-reg stack is empty */
if (ColonMod) { /* if it's :] */
DBGFEX(1,DbgFNm,"PushEx(0)");
return PushEx(0L, OPERAND);
} else {
ErrMsg(ERR_PES); /* can't pop empty stack */
DBGFEX(1,DbgFNm,"FAILURE");
return FAILURE;
}
}
/*
* Copy QStack Q-register to QR
*/
TmpQRp = &QStack[QStTop];
TmpSiz = TmpQRp->End_P1 - TmpQRp->Start;
if (TmpSiz == 0) { /* if it should be empty */
if (QR->Start != NULL) { /* but it isn't empty */
ZFree((voidptr)QR->Start); /* then empty it */
QR->Start = QR->End_P1 = NULL;
}
} else {
if (MakRom((size_t)TmpSiz) == FAILURE) { /* adjust QR space */
DBGFEX(1,DbgFNm,"FAILURE");
return FAILURE;
}
MEMMOVE(QR->Start, TmpQRp->Start, (size_t)TmpSiz);
QR->End_P1 = QR->Start + TmpSiz;
}
QR->Number = TmpQRp->Number;
/*
* clear QStack Q-register
*/
if (TmpQRp->Start != NULL) {
ZFree((voidptr)TmpQRp->Start);
TmpQRp->Start = TmpQRp->End_P1 = NULL;
}
TmpQRp->Number = 0;
--QStTop;
DBGFEX(1,DbgFNm,(ColonMod) ? "PushEx(-1)" : "SUCCESS");
return (ColonMod) ? PushEx(-1L, OPERAND) : SUCCESS;
}
/*****************************************************************************
BakSrc()
This recursive function does a backward search in the edit buffer,
looking for a string which will match the first match construct in the search
buffer. Basically, it is the high-speed part of the search algorithm: it
scans the edit buffer looking for the first character in the search string.
On entry, SStPtr points to the first match construct in the search
buffer. On exit, SStPtr points to the last character of the first match
construct in the search buffer.
SBfPtr points to the character following the last character in
the search string. This function does not modify SBfPtr.
On entry, EBPtr1 points to the place in the edit buffer where
the search starts. On exit, if the search was successful, EBPtr1 will
point to the found character. If the search was unsuccessful, EBPtr1 will
be less than EndSAr.
On entry, EBPtr2 is undefined. On exit, if the search was
successful, EBPtr2 points to the last character of the found string. If
the search was unsuccessful, EBPtr2 is undefined.
EndSAr points to the end of the search area (where the search ends).
Note that for backwards searches, EndSAr is less than EBPtr1. This function
does not modify EndSAr.
Match constructs are:
^X match any character
^S match a separator character (not letter or digit)
^N match anything but following match construct
^EA match any alphabetic
^EB match a separator character (not letter or digit)
^EC match symbol constituent
^ED match any digit
^EGq match any character in q-register q
^EL match any line terminator (LF, VT, FF)
^EM match non-null string of following match construct
^ER match any alphanumeric
^ES match non-null string of spaces and/or tabs
^EV match lowercase alphabetic
^EW match uppercase alphabetic
^EX match any character
^E<nnn> match character with ASCII code nnn (octal)
^E[x1,x2,...xn] match any of the match constructs x1, x2, etc.
else match the character itself
*****************************************************************************/
#include "zport.h" /* define portability identifiers */
#include "tecoc.h" /* define general identifiers */
#include "defext.h" /* define external global variables */
#include "dchars.h" /* define identifiers for characters */
#include "chmacs.h" /* define character processing macros */
#include "deferr.h" /* define identifiers for error messages */
DEFAULT BakSrc() /* forward search for 1st search char */
{
unsigned char Charac; /* holds a character */
charptr LstBeg; /* beginning of ^E[x1,x2,...] list */
char OtCase; /* "other" case character */
charptr QRPtr; /* pointer into q-register text */
BOOLEAN SamChr; /* same character indicator */
charptr SavEP2; /* temporary holder of EBPtr2 */
charptr SavSSP; /* temporary holder of SStPtr */
DEFAULT Status; /* FindQR() status for ^EGq */
charptr TCBfPt; /* temporary holder of CBfPtr */
charptr TCStEn; /* temporary holder of CStEnd */
LONG TmpLng; /* holds octal number for ^E<nnn> */
#if DEBUGGING
static char *DbgFNm = "BakSrc";
sprintf(DbgSBf,"*SStPtr = '%c', *EBPtr1 = '%c'", *SStPtr, *EBPtr1);
DbgFEn(3,DbgFNm,DbgSBf);
#endif
switch (*SStPtr) {
case CTRL_X: /* ^X match any char */
break;
case CTRL_S: /* ^S match separator char */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (!Is_Alnum(*EBPtr1)) {
break;
}
}
break;
case CTRL_N: /* ^Nx match any BUT next match construct */
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ISS); /* illegal search string */
DBGFEX(3,DbgFNm,"FAILURE, no ^N arg");
return FAILURE;
}
SavSSP = SStPtr;
for (;EBPtr1>=EndSAr;--EBPtr1) {
EBPtr2 = EBPtr1;
SStPtr = SavSSP;
if (CMatch(&SamChr) == FAILURE) {
DBGFEX(3,DbgFNm,"FAILURE, CMatch failed");
return FAILURE;
}
if (!SamChr) {
break;
}
}
break;
case CTRL_E: /* ^E match construct */
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE); /* ICE = illegal ^E */
DBGFEX(3,DbgFNm,"FAILURE, no ^E arg");
return FAILURE;
}
switch (To_Upper(*SStPtr)) {
case 'A': /* ^EA match any alphabetic */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (Is_Alpha(*EBPtr1)) {
break;
}
}
break;
case 'B': /* ^EB match any separator (==^S) */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (!Is_Alnum(*EBPtr1)) {
break;
}
}
break;
case 'C': /* ^EC match symbol constitient */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (Is_SyCon(*EBPtr1)) {
break;
}
}
break;
case 'D': /* ^ED match any digit */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (Is_Digit(*EBPtr1)) {
break;
}
}
break;
case 'G': /* ^EGq match any char in Q-reg q */
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE, no ^EG arg");
return FAILURE;
}
TCBfPt = CBfPtr; /* save CBfPtr */
TCStEn = CStEnd; /* save CStEnd */
CBfPtr = SStPtr;
CStEnd = SBfPtr;
Status = FindQR();
SStPtr = CBfPtr;
SBfPtr = CStEnd;
CBfPtr = TCBfPt; /* restore CBfPtr */
CStEnd = TCStEn; /* restore CStEnd */
if (Status == FAILURE) {
DBGFEX(3,DbgFNm,"FAILURE, ^EG FindQR failed");
return FAILURE;
}
for (; EBPtr1 >= EndSAr; --EBPtr1) {
QRPtr = QR->Start;
while (QRPtr < QR->End_P1) {
if (*QRPtr++ == *EBPtr1) {
goto kludge;
}
}
}
kludge: break;
case 'L': /* ^EL match line terminator */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (IsEOL(*EBPtr1)) {
break;
}
}
break;
case 'M': /* ^EM match multiple next constructs */
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE, no ^EM arg");
return FAILURE;
}
SavSSP = SStPtr;
if (BakSrc() == FAILURE) {
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
if (EBPtr1 < EndSAr) { /* if not found */
break;
}
SavEP2 = EBPtr2;
while (EBPtr1 > EndSAr) {
EBPtr1--;
EBPtr2 = EBPtr1;
SStPtr = SavSSP;
if (CMatch(&SamChr) == FAILURE) {
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
if (!SamChr) {
EBPtr1++;
EBPtr2 = SavEP2;
break;
}
}
DBGFEX(3,DbgFNm,"SUCCESS");
return SUCCESS;
case 'R': /* ^ER match any alphanumeric */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (Is_Alnum(*EBPtr1)) {
break;
}
}
break;
case 'S': /* ^ES match any spaces/tabs */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if ((*EBPtr1 == SPACE) || (*EBPtr1 == TABCHR)) {
EBPtr2 = EBPtr1;
while (EBPtr1 > EndSAr) {
EBPtr1--;
if ((*EBPtr1 != SPACE) &&
(*EBPtr1 != TABCHR)) {
EBPtr1++;
break;
}
}
DBGFEX(3,DbgFNm,"SUCCESS");
return SUCCESS;
}
}
break;
case 'V': /* ^EV match any lowercase char */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (Is_Lower(*EBPtr1)) {
break;
}
}
break;
case 'W': /* ^EW match any uppercase character */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (Is_Upper(*EBPtr1)) {
break;
}
}
break;
case 'X': /* ^EX match any char (==^X) */
break;
case '<': /* ^E<n> match char w/ASCII octal code n */
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE, no ^E<> arg");
return FAILURE;
}
TmpLng = 0;
while (Is_Digit(*SStPtr)) {
TmpLng = (TmpLng * 8) + (*SStPtr - '0');
if (TmpLng > 127) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
}
if (*SStPtr != '>') {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
Charac = (unsigned char)TmpLng;
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (*EBPtr1 == Charac) {
break;
}
}
break;
case '[': /* ^E[x1,x2,...] match any one of x1,x2,... */
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE, no ^E[] arg");
return FAILURE;
}
LstBeg = SStPtr;
for (; EBPtr1 >= EndSAr; --EBPtr1) {
while (*SStPtr != ']') {
if (*SStPtr == ',') {
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
} else {
EBPtr2 = EBPtr1;
if (CMatch(&SamChr) == FAILURE) {
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
if (SamChr) {
while (*SStPtr != ']') {
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
}
EBPtr2 = EBPtr1;
DBGFEX(3,DbgFNm,"SUCCESS");
return SUCCESS;
}
if (++SStPtr == SBfPtr) {
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE");
return FAILURE;
}
}
}
SStPtr = LstBeg;
}
break;
default:
ErrMsg(ERR_ICE);
DBGFEX(3,DbgFNm,"FAILURE, bad ^E arg");
return FAILURE;
} /* end of ^E switch */
break;
default: /* edit buffer char must match search string char */
if (SMFlag) { /* if case dependence */
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if (*EBPtr1 == *SStPtr) {
break;
}
}
} else { /* else case independence */
OtCase = Is_Upper(*SStPtr)
? To_Lower(*SStPtr)
: To_Upper(*SStPtr);
for (; EBPtr1 >= EndSAr; --EBPtr1) {
if ((*EBPtr1 == *SStPtr) || (*EBPtr1 == OtCase)) {
break;
}
}
}
} /* end of switch */
EBPtr2 = EBPtr1;
DBGFEX(3,DbgFNm,"SUCCESS");
return SUCCESS;
}
