Beispiel #1
0
static DEFAULT SkpCtU()		/* skip control-U command */
{
	BOOLEAN	TTrace;		/* temp: holds trace flag */

	if (CBfPtr == CStEnd)
		if (MStTop < 0)			/* if not in a macro */
			{
			ErrUTC();		/* unterminated command */
			return FAILURE;
			}
		else
			return SUCCESS;
	++CBfPtr;
	TTrace = TraceM;			/* save trace mode flag */
	TraceM = FALSE;				/* keep FindES from tracing */
	if (FindES(ESCAPE) == FAILURE)		/* find end of string */
		{
		TraceM = TTrace;		/* restore trace mode flag */
		return FAILURE;
		}

	TraceM = TTrace;			/* restore trace mode flag */
	CmdMod = '\0';				/* clear modifiers flags */
	return SUCCESS;
}
Beispiel #2
0
/*****************************************************************************
	SkpDAr()
*****************************************************************************/
static DEFAULT SkpDAr()		/* skip "double text argument" command */
{
	BOOLEAN TTrace;		/* saves TraceM temporarily */
	TTrace = TraceM;			/* save trace mode flag */
	TraceM = FALSE;				/* keep FindES from tracing */
	if (FindES(ESCAPE) == FAILURE)
		{
		TraceM = TTrace;		/* restore trace mode flag */
		return FAILURE;
		}
	if (CmdMod & ATSIGN)			/* if at-sign modified */
		--CBfPtr;
	if (FindES(ESCAPE) == FAILURE)
		{
		TraceM = TTrace;		/* restore trace mode flag */
		return FAILURE;
		}
	TraceM = TTrace;			/* restore trace mode flag */
	return SUCCESS;
}
Beispiel #3
0
/*****************************************************************************
	SkpCtA()
*****************************************************************************/
static DEFAULT SkpCtA()		/* skip control-A command */
{
	BOOLEAN	TTrace;		/* temp: holds trace flag */
	TTrace = TraceM;			/* save trace mode flag */
	TraceM = FALSE;				/* keep FindES from tracing */
	if (FindES(CTRL_A) == FAILURE)		/* find end of string */
		{
		TraceM = TTrace;		/* restore trace mode flag */
		return FAILURE;
		}
	TraceM = TTrace;			/* restore trace mode flag */
	CmdMod = '\0';				/* clear modifiers flags */
	return SUCCESS;
}
Beispiel #4
0
/*****************************************************************************
	SkpArg()
*****************************************************************************/
static DEFAULT SkpArg()		/* skip command with text argument */
{
	BOOLEAN TTrace;		/* temp: holds trace flag */
	TTrace = TraceM;			/* save trace mode flag */
	TraceM = FALSE;				/* keep FindES from tracing */
	if (FindES(ESCAPE) == FAILURE)		/* find end of string */
		{
		TraceM = TTrace;		/* restore trace mode flag */
		return FAILURE;
		}
	TraceM = TTrace;			/* restore trace mode flag */
	CmdMod = '\0';				/* clear modifiers flags */
	return SUCCESS;
}
Beispiel #5
0
integer ExeExc()		/* execute a ! (exclamation mark) command */
{
	DBGFEN(1,"ExeExc",NULL);
	if (FindES('!') == FAILURE) {		/* simply skip to next '!' */
		DBGFEX(1,DbgFNm,"FAILURE");
		return FAILURE;
	}

	CmdMod = '\0';				/* clear modifiers flags */
	EStTop = EStBot;			/* clear expression stack */

	DBGFEX(1,DbgFNm,"SUCCESS");
	return SUCCESS;
}
Beispiel #6
0
integer ExeCtU()		/* execute a ^U (control-U) command */
{
    ptrdiff_t TmpSiz;

    DBGFEN(1,"ExeCtU",NULL);

    /*
     * increment CBfPtr past ^U
     */
    if (IncCBP() == FAILURE) {
        DBGFEX(1,DbgFNm,"FAILURE, IncCBP() failed");
        return FAILURE;
    }

    /*
     * try to find Q-register name after ^U
     */
    if (FindQR() == FAILURE) {
        DBGFEX(1,DbgFNm,"FAILURE, FindQR() failed");
        return FAILURE;
    }

    /*
     * If there is a colon modifier, we are appending to the Q-register text.
     * If there isn't a colon modifier, we are replacing the text currently
     * in the Q-register.  If there is any text currently in the Q-register,
     * we have to zap it first.
     */
    if (!(CmdMod & COLON)) {		/* if no colon modifier */
        if (QR->Start != NULL) {	/* if not empty */
            ZFree((voidptr)QR->Start);	/* free the memory */
            QR->Start = QR->End_P1 = NULL;
        }
    }


    /*
     * If there is a numeric argument n, we are dealing with a character to
     * place into or append to the Q-register.
     */
    if (EStTop > EStBot) {			/* if numeric argument */
        if (GetNmA() == FAILURE) {	/* get numeric argument */
            DBGFEX(1,DbgFNm,"FAILURE, GetNmA() failed");
            return FAILURE;
        }
        if (CmdMod & ATSIGN) {		/* it's @^U// */

            /*
             * increment CBfPtr to 1st delimiter
             */
            if (IncCBP() == FAILURE) {
                DBGFEX(1,DbgFNm,"FAILURE, IncCBP() failed");
                return FAILURE;
            }

            /*
             * increment CBfPtr to 2nd delimiter
             */
            if (IncCBP() == FAILURE) {
                DBGFEX(1,DbgFNm,"FAILURE, IncCBP() failed");
                return FAILURE;
            }

            /*
             * the two delimiters should be the same
             */
            if (*CBfPtr != *(CBfPtr-1)) {
                ErrMsg(ERR_IIA);
                DBGFEX(1,DbgFNm,"FAILURE, ERR_IIA");
                return FAILURE;
            }
        }

        /*
         * Increase the size of the text area by 1 character
         */
        if (MakRom((size_t) 1) == FAILURE) {
            DBGFEX(1,DbgFNm,"FAILURE, MakRom() failed");
            return FAILURE;
        }

        /*
         * Append the character to the Q-register
         */
        *(QR->End_P1) = (char) NArgmt;
        QR->End_P1++;
    } else {				/* else no numeric argument */
        /*
         * We must be dealing with a string, find the end of the string.
         */
        if (FindES(ESCAPE) == FAILURE) {
            DBGFEX(1,DbgFNm,"FAILURE, FindES() failed");
            return FAILURE;
        }

        TmpSiz = CBfPtr - ArgPtr;
        if (TmpSiz > 0) {

            /*
             * make room for the string
             */
            if (MakRom((size_t)TmpSiz) == FAILURE) {
                DBGFEX(1,DbgFNm,"FAILURE, MakRom() failed");
                return FAILURE;
            }

            /*
             * Append the string to the Q-register text
             */
            MEMMOVE(QR->End_P1, ArgPtr, (size_t)TmpSiz);
            QR->End_P1 += TmpSiz;
        }
    }

    CmdMod = '\0';				/* clear modifiers flags */

    DBGFEX(1,DbgFNm,"SUCCESS");
    return SUCCESS;
}
Beispiel #7
0
integer ExeS()			/* execute an S command */
{
	DBGFEN(1, "ExeS", NULL);

/*
 * The command m,nS is illegal: the user should use m,nFB
 */
	if (CmdMod & MARGIS) {			/* if it's m,nS */
		ErrStr(ERR_ILL, "m,nS");	/* illegal command "m,nS" */
		DBGFEX(1,DbgFNm,"FAILURE");
		return FAILURE;
	}

/*
 * If it's ::Stext$,  it's a compare,  not a search.  The text argument is
 * compared to the characters immediately following the character pointer.
 * It returns -1 if the strings match, else 0.  A ::Stext$ command is
 * equivalent to a .,.+1:FBtext$ command,  so that's the way it's implemented.
 */

	if (CmdMod & DCOLON) {			/* if it's ::S */
		if (CmdMod & MARGIS) {		/* if it's m,n::S */
			ErrStr(ERR_ILL, "m,n::S");
			DBGFEX(1,DbgFNm,"FAILURE");
			return FAILURE;
		}
		if (EStTop > EStBot) {		/* if it's n::S */
			ErrStr(ERR_ILL, "n::S");
			DBGFEX(1,DbgFNm,"FAILURE");
			return FAILURE;
		}
		if (GapEnd == EBfEnd) {		/* if nothing to search */
			if (FindES(ESCAPE) == FAILURE) {
				DBGFEX(1,DbgFNm,"FAILURE");
				return FAILURE;
			}
			DBGFEX(1,DbgFNm,"PushEx(0)");
			return PushEx(0L,OPERAND);
		}
		CmdMod &= ~DCOLON;		/* clear double-colon bit */
		CmdMod |= COLON;		/* set colon bit */
		CmdMod |= MARGIS;		/* set m defined bit */
		MArgmt = GapBeg - EBfBeg;	/* set m */
		if (PushEx((long)((GapBeg-EBfBeg)+1),OPERAND) == FAILURE) {
			DBGFEX(1,DbgFNm,"FAILURE");
			return FAILURE;
		}
		DBGFEX(1,DbgFNm,"ExeFB()");
		return ExeFB();			/* execute FB command */
	}

	SrcTyp = S_SEARCH;

	if (Search(false) == FAILURE) {
		DBGFEX(1,DbgFNm,"FAILURE");
		return FAILURE;
	}

	CmdMod = '\0';				/* clear modifiers flags */

	DBGFEX(1,DbgFNm,"SUCCESS");
	return SUCCESS;
}
Beispiel #8
0
int
BldStr(charptr XBfBeg, charptr XBfEnd, charptr* XBfPtr)                /* build a string */
/* charptr XBfBeg;                 beginning of build-string buffer */
/* charptr XBfEnd;                 end of build-string buffer */
/* charptr (*XBfPtr);                 pointer into build-string buffer */
{
    charptr       EndArg;                /* end of input string, plus 1 */
    unsigned char TmpChr;        /* temporary character */

    DBGFEN(2,"BldStr",NULL);

    if (FindES(ESCAPE) == FAILURE)         /* move CBfPtr to end of argument */
    {
        DBGFEX(2,DbgFNm,"FAILURE, FindES(ESCAPE) failed");
        return FAILURE;
    }

    CaseCv = IniSrM;                /* initialize internal search mode */
    BBfPtr = XBfBeg;                /* initialize ptr into build-string buffer */
    EndArg = CBfPtr;                /* save pointer to end of argument */
    CBfPtr = ArgPtr;                /* reset to beginning of argument */

    while (CBfPtr < EndArg)
    {
        if ((*CBfPtr == '^') && ((EdFlag & ED_CARET_OK) == 0))
        {
            if (++CBfPtr == EndArg)
            {
                ErrMsg(ERR_ISS);
                DBGFEX(2,DbgFNm,"FAILURE, no char after ^");
                return FAILURE;
            }
            TmpChr = To_Upper(*CBfPtr);
            if ((TmpChr < '@') || (TmpChr > '_'))
            {
                ErrChr(ERR_IUC, *CBfPtr);
                DBGFEX(2,DbgFNm,"FAILURE, bad char after ^");
                return FAILURE;
            }
            TmpChr &= '\077';
        }
        else
            TmpChr = *CBfPtr;

        switch (TmpChr)
        {
            case CTRL_R:
            case CTRL_Q:
                if (++CBfPtr == EndArg)
                {
                    ErrMsg(ERR_ISS);
                    DBGFEX(2, DbgFNm, "FAILURE");
                    return FAILURE;
                }
                *BBfPtr++ = *CBfPtr;
                break;

            case CTRL_V:
            case CTRL_W:
                if (DoCtVW(EndArg, TmpChr) == FAILURE)
                {
                    DBGFEX(2, DbgFNm, "FAILURE, DoCtVW failed");
                    return FAILURE;
                }
                break;

            case CTRL_E:
                if (DoCtE(EndArg, XBfEnd) == FAILURE)
                {
                    DBGFEX(2, DbgFNm, "FAILURE, DoCtE failed");
                    return FAILURE;
                }
                break;

            default:
                if (CaseCv == LOWER)
                    TmpChr = To_Lower(TmpChr);
                else if (CaseCv == UPPER)
                    TmpChr = To_Upper(TmpChr);
                *BBfPtr++ = TmpChr;
        } /* switch(TmpChr) */

        if (BBfPtr > XBfEnd)
        {
            ErrMsg(ERR_STL);        /* string too long */
            DBGFEX(2, DbgFNm, "FAILURE, string too long");
            return FAILURE;
        }
        ++CBfPtr;
    }
    *XBfPtr = BBfPtr;

#if DEBUGGING
    sprintf(DbgSBf, "string = \"%.*s\"", (int)(BBfPtr-XBfBeg), XBfBeg);
    DbgFEx(2, DbgFNm, DbgSBf);
#endif

    return SUCCESS;
}
Beispiel #9
0
integer ExeI()			/* execute an I command */
{
	unsigned char InChar;

	DBGFEN(1,"ExeI",NULL);
	if (EStTop > EStBot) {			/* if numeric argument */
		if (GetNmA() == FAILURE) {	/* get numeric argument */
			DBGFEX(1,DbgFNm,"FAILURE, GetNmA() failed");
			return FAILURE;
		}

		if (CmdMod & ATSIGN) {		/* if it's n@I// */
			if (IncCBP() == FAILURE) {
				DBGFEX(1,DbgFNm,"FAILURE, 1st IncCBP() failed");
				return FAILURE;
			}
			if (IncCBP() == FAILURE) {
				DBGFEX(1,DbgFNm,"FAILURE, 2nd IncCBP() failed");
				return FAILURE;
			}
			if (*CBfPtr != *(CBfPtr-1)) {
				ErrMsg(ERR_IIA);     /* illegal insert arg */
				DBGFEX(1,DbgFNm,"FAILURE, illegal insert arg");
				return FAILURE;
			}
		} else {				/* else must be nI$ */
			if ((CBfPtr+1) == CStEnd) {
				if (MStTop < 0) {
					ErrUTC();
					DBGFEX(1,DbgFNm,"FAILURE, unterminated command");
					return FAILURE;
				} else {
					DBGFEX(1,DbgFNm,"SUCCESS");
					return SUCCESS;
				}
			}
			if (*(CBfPtr+1) != ESCAPE) {
				ErrMsg(ERR_IIA);     /* illegal insert arg */
				DBGFEX(1,DbgFNm,"FAILURE, illegal insert arg");
				return FAILURE;
			}
		}
		InChar = (char)NArgmt;
		if (InsStr(&InChar, (ptrdiff_t)1) == FAILURE) {
			DBGFEX(1,DbgFNm,"FAILURE, InsStr() failed");
			return FAILURE;
		}
	} else {				/* else no numeric argument */
		if (FindES(ESCAPE) == FAILURE) {
			DBGFEX(1,DbgFNm,"FAILURE, FindES() failed");
			return FAILURE;
		}
		if (InsStr(ArgPtr, CBfPtr-ArgPtr) == FAILURE) {
			DBGFEX(1,DbgFNm,"FAILURE, InsStr() failed");
			return FAILURE;
		}
	}

	CmdMod = '\0';				/* clear modifiers flags */

	DBGFEX(1,DbgFNm,"SUCCESS");
	return SUCCESS;
}