add LCC - a better C-Compiler for WEGA
This commit is contained in:
Oliver Lehmann
parent
ebb9f4f95f
commit
0bf22a0c2b
|
|
@ -0,0 +1,390 @@
|
|||
/*
|
||||
* Copyright (c) 1980 Regents of the University of California.
|
||||
* All rights reserved. The Berkeley software License Agreement
|
||||
* specifies the terms and conditions for redistribution.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static char sccsid[] = "@(#)cr_put.c 5.1 (Berkeley) 6/7/85";
|
||||
#endif not lint
|
||||
|
||||
# include "curses.ext"
|
||||
|
||||
# define HARDTABS 8
|
||||
|
||||
extern char *tgoto();
|
||||
int plodput();
|
||||
|
||||
/*
|
||||
* Terminal driving and line formatting routines.
|
||||
* Basic motion optimizations are done here as well
|
||||
* as formatting of lines (printing of control characters,
|
||||
* line numbering and the like).
|
||||
*/
|
||||
|
||||
/*
|
||||
* Sync the position of the output cursor.
|
||||
* Most work here is rounding for terminal boundaries getting the
|
||||
* column position implied by wraparound or the lack thereof and
|
||||
* rolling up the screen to get destline on the screen.
|
||||
*/
|
||||
|
||||
static int outcol, outline, destcol, destline;
|
||||
|
||||
WINDOW *_win;
|
||||
|
||||
mvcur(ly, lx, y, x)
|
||||
int ly, lx, y, x; {
|
||||
|
||||
#ifdef DEBUG
|
||||
fprintf(outf, "MVCUR: moving cursor from (%d,%d) to (%d,%d)\n", ly, lx, y, x);
|
||||
#endif
|
||||
destcol = x;
|
||||
destline = y;
|
||||
outcol = lx;
|
||||
outline = ly;
|
||||
fgoto();
|
||||
}
|
||||
|
||||
fgoto()
|
||||
{
|
||||
reg char *cgp;
|
||||
reg int l, c;
|
||||
|
||||
if (destcol >= COLS) {
|
||||
destline += destcol / COLS;
|
||||
destcol %= COLS;
|
||||
}
|
||||
if (outcol >= COLS) {
|
||||
l = (outcol + 1) / COLS;
|
||||
outline += l;
|
||||
outcol %= COLS;
|
||||
if (AM == 0) {
|
||||
while (l > 0) {
|
||||
if (_pfast)
|
||||
if (CR)
|
||||
_puts(CR);
|
||||
else
|
||||
_putchar('\r');
|
||||
if (NL)
|
||||
_puts(NL);
|
||||
else
|
||||
_putchar('\n');
|
||||
l--;
|
||||
}
|
||||
outcol = 0;
|
||||
}
|
||||
if (outline > LINES - 1) {
|
||||
destline -= outline - (LINES - 1);
|
||||
outline = LINES - 1;
|
||||
}
|
||||
}
|
||||
if (destline >= LINES) {
|
||||
l = destline;
|
||||
destline = LINES - 1;
|
||||
if (outline < LINES - 1) {
|
||||
c = destcol;
|
||||
if (_pfast == 0 && !CA)
|
||||
destcol = 0;
|
||||
fgoto();
|
||||
destcol = c;
|
||||
}
|
||||
while (l >= LINES) {
|
||||
/*
|
||||
* The following linefeed (or simulation thereof)
|
||||
* is supposed to scroll up the screen, since we
|
||||
* are on the bottom line. We make the assumption
|
||||
* that linefeed will scroll. If ns is in the
|
||||
* capability list this won't work. We should
|
||||
* probably have an sc capability but sf will
|
||||
* generally take the place if it works.
|
||||
*
|
||||
* Superbee glitch: in the middle of the screen we
|
||||
* have to use esc B (down) because linefeed screws up
|
||||
* in "Efficient Paging" (what a joke) mode (which is
|
||||
* essential in some SB's because CRLF mode puts garbage
|
||||
* in at end of memory), but you must use linefeed to
|
||||
* scroll since down arrow won't go past memory end.
|
||||
* I turned this off after recieving Paul Eggert's
|
||||
* Superbee description which wins better.
|
||||
*/
|
||||
if (NL /* && !XB */ && _pfast)
|
||||
_puts(NL);
|
||||
else
|
||||
_putchar('\n');
|
||||
l--;
|
||||
if (_pfast == 0)
|
||||
outcol = 0;
|
||||
}
|
||||
}
|
||||
if (destline < outline && !(CA || UP))
|
||||
destline = outline;
|
||||
if (CA) {
|
||||
cgp = tgoto(CM, destcol, destline);
|
||||
if (plod(strlen(cgp)) > 0)
|
||||
plod(0);
|
||||
else
|
||||
tputs(cgp, 0, _putchar);
|
||||
}
|
||||
else
|
||||
plod(0);
|
||||
outline = destline;
|
||||
outcol = destcol;
|
||||
}
|
||||
|
||||
/*
|
||||
* Move (slowly) to destination.
|
||||
* Hard thing here is using home cursor on really deficient terminals.
|
||||
* Otherwise just use cursor motions, hacking use of tabs and overtabbing
|
||||
* and backspace.
|
||||
*/
|
||||
|
||||
static int plodcnt, plodflg;
|
||||
|
||||
plodput(c)
|
||||
{
|
||||
if (plodflg)
|
||||
plodcnt--;
|
||||
else
|
||||
_putchar(c);
|
||||
}
|
||||
|
||||
plod(cnt)
|
||||
{
|
||||
register int i, j, k;
|
||||
register int soutcol, soutline;
|
||||
|
||||
plodcnt = plodflg = cnt;
|
||||
soutcol = outcol;
|
||||
soutline = outline;
|
||||
/*
|
||||
* Consider homing and moving down/right from there, vs moving
|
||||
* directly with local motions to the right spot.
|
||||
*/
|
||||
if (HO) {
|
||||
/*
|
||||
* i is the cost to home and tab/space to the right to
|
||||
* get to the proper column. This assumes ND space costs
|
||||
* 1 char. So i+destcol is cost of motion with home.
|
||||
*/
|
||||
if (GT)
|
||||
i = (destcol / HARDTABS) + (destcol % HARDTABS);
|
||||
else
|
||||
i = destcol;
|
||||
/*
|
||||
* j is cost to move locally without homing
|
||||
*/
|
||||
if (destcol >= outcol) { /* if motion is to the right */
|
||||
j = destcol / HARDTABS - outcol / HARDTABS;
|
||||
if (GT && j)
|
||||
j += destcol % HARDTABS;
|
||||
else
|
||||
j = destcol - outcol;
|
||||
}
|
||||
else
|
||||
/* leftward motion only works if we can backspace. */
|
||||
if (outcol - destcol <= i && (BS || BC))
|
||||
i = j = outcol - destcol; /* cheaper to backspace */
|
||||
else
|
||||
j = i + 1; /* impossibly expensive */
|
||||
|
||||
/* k is the absolute value of vertical distance */
|
||||
k = outline - destline;
|
||||
if (k < 0)
|
||||
k = -k;
|
||||
j += k;
|
||||
|
||||
/*
|
||||
* Decision. We may not have a choice if no UP.
|
||||
*/
|
||||
if (i + destline < j || (!UP && destline < outline)) {
|
||||
/*
|
||||
* Cheaper to home. Do it now and pretend it's a
|
||||
* regular local motion.
|
||||
*/
|
||||
tputs(HO, 0, plodput);
|
||||
outcol = outline = 0;
|
||||
}
|
||||
else if (LL) {
|
||||
/*
|
||||
* Quickly consider homing down and moving from there.
|
||||
* Assume cost of LL is 2.
|
||||
*/
|
||||
k = (LINES - 1) - destline;
|
||||
if (i + k + 2 < j && (k<=0 || UP)) {
|
||||
tputs(LL, 0, plodput);
|
||||
outcol = 0;
|
||||
outline = LINES - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
/*
|
||||
* No home and no up means it's impossible.
|
||||
*/
|
||||
if (!UP && destline < outline)
|
||||
return -1;
|
||||
if (GT)
|
||||
i = destcol % HARDTABS + destcol / HARDTABS;
|
||||
else
|
||||
i = destcol;
|
||||
/*
|
||||
if (BT && outcol > destcol && (j = (((outcol+7) & ~7) - destcol - 1) >> 3)) {
|
||||
j *= (k = strlen(BT));
|
||||
if ((k += (destcol&7)) > 4)
|
||||
j += 8 - (destcol&7);
|
||||
else
|
||||
j += k;
|
||||
}
|
||||
else
|
||||
*/
|
||||
j = outcol - destcol;
|
||||
/*
|
||||
* If we will later need a \n which will turn into a \r\n by
|
||||
* the system or the terminal, then don't bother to try to \r.
|
||||
*/
|
||||
if ((NONL || !_pfast) && outline < destline)
|
||||
goto dontcr;
|
||||
/*
|
||||
* If the terminal will do a \r\n and there isn't room for it,
|
||||
* then we can't afford a \r.
|
||||
*/
|
||||
if (NC && outline >= destline)
|
||||
goto dontcr;
|
||||
/*
|
||||
* If it will be cheaper, or if we can't back up, then send
|
||||
* a return preliminarily.
|
||||
*/
|
||||
if (j > i + 1 || outcol > destcol && !BS && !BC) {
|
||||
/*
|
||||
* BUG: this doesn't take the (possibly long) length
|
||||
* of CR into account.
|
||||
*/
|
||||
if (CR)
|
||||
tputs(CR, 0, plodput);
|
||||
else
|
||||
plodput('\r');
|
||||
if (NC) {
|
||||
if (NL)
|
||||
tputs(NL, 0, plodput);
|
||||
else
|
||||
plodput('\n');
|
||||
outline++;
|
||||
}
|
||||
outcol = 0;
|
||||
}
|
||||
dontcr:
|
||||
while (outline < destline) {
|
||||
outline++;
|
||||
if (NL)
|
||||
tputs(NL, 0, plodput);
|
||||
else
|
||||
plodput('\n');
|
||||
if (plodcnt < 0)
|
||||
goto out;
|
||||
if (NONL || _pfast == 0)
|
||||
outcol = 0;
|
||||
}
|
||||
if (BT)
|
||||
k = strlen(BT);
|
||||
while (outcol > destcol) {
|
||||
if (plodcnt < 0)
|
||||
goto out;
|
||||
/*
|
||||
if (BT && outcol - destcol > k + 4) {
|
||||
tputs(BT, 0, plodput);
|
||||
outcol--;
|
||||
outcol &= ~7;
|
||||
continue;
|
||||
}
|
||||
*/
|
||||
outcol--;
|
||||
if (BC)
|
||||
tputs(BC, 0, plodput);
|
||||
else
|
||||
plodput('\b');
|
||||
}
|
||||
while (outline > destline) {
|
||||
outline--;
|
||||
tputs(UP, 0, plodput);
|
||||
if (plodcnt < 0)
|
||||
goto out;
|
||||
}
|
||||
if (GT && destcol - outcol > 1) {
|
||||
for (;;) {
|
||||
i = tabcol(outcol, HARDTABS);
|
||||
if (i > destcol)
|
||||
break;
|
||||
if (TA)
|
||||
tputs(TA, 0, plodput);
|
||||
else
|
||||
plodput('\t');
|
||||
outcol = i;
|
||||
}
|
||||
if (destcol - outcol > 4 && i < COLS && (BC || BS)) {
|
||||
if (TA)
|
||||
tputs(TA, 0, plodput);
|
||||
else
|
||||
plodput('\t');
|
||||
outcol = i;
|
||||
while (outcol > destcol) {
|
||||
outcol--;
|
||||
if (BC)
|
||||
tputs(BC, 0, plodput);
|
||||
else
|
||||
plodput('\b');
|
||||
}
|
||||
}
|
||||
}
|
||||
while (outcol < destcol) {
|
||||
/*
|
||||
* move one char to the right. We don't use ND space
|
||||
* because it's better to just print the char we are
|
||||
* moving over.
|
||||
*/
|
||||
if (_win != NULL)
|
||||
if (plodflg) /* avoid a complex calculation */
|
||||
plodcnt--;
|
||||
else {
|
||||
i = curscr->_y[outline][outcol];
|
||||
if ((i&_STANDOUT) == (curscr->_flags&_STANDOUT))
|
||||
_putchar(i);
|
||||
else
|
||||
goto nondes;
|
||||
}
|
||||
else
|
||||
nondes:
|
||||
if (ND)
|
||||
tputs(ND, 0, plodput);
|
||||
else
|
||||
plodput(' ');
|
||||
outcol++;
|
||||
if (plodcnt < 0)
|
||||
goto out;
|
||||
}
|
||||
out:
|
||||
if (plodflg) {
|
||||
outcol = soutcol;
|
||||
outline = soutline;
|
||||
}
|
||||
return(plodcnt);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the column number that results from being in column col and
|
||||
* hitting a tab, where tabs are set every ts columns. Work right for
|
||||
* the case where col > COLS, even if ts does not divide COLS.
|
||||
*/
|
||||
tabcol(col, ts)
|
||||
int col, ts;
|
||||
{
|
||||
int offset, result;
|
||||
|
||||
if (col >= COLS) {
|
||||
offset = COLS * (col / COLS);
|
||||
col -= offset;
|
||||
}
|
||||
else
|
||||
offset = 0;
|
||||
return col + ts - (col % ts) + offset;
|
||||
}
|
||||
|
|
@ -0,0 +1,308 @@
|
|||
/*
|
||||
* Copyright (c) 1980 Regents of the University of California.
|
||||
* All rights reserved. The Berkeley software License Agreement
|
||||
* specifies the terms and conditions for redistribution.
|
||||
*/
|
||||
|
||||
#ifndef lint
|
||||
static char sccsid[] = "@(#)refresh.c 5.1 (Berkeley) 6/7/85";
|
||||
#endif not lint
|
||||
|
||||
/*
|
||||
* make the current screen look like "win" over the area coverd by
|
||||
* win.
|
||||
*/
|
||||
|
||||
# include "curses.ext"
|
||||
|
||||
# ifdef DEBUG
|
||||
# define STATIC
|
||||
# else
|
||||
# define STATIC static
|
||||
# endif
|
||||
|
||||
STATIC short ly, lx;
|
||||
|
||||
STATIC bool curwin;
|
||||
|
||||
WINDOW *_win = NULL;
|
||||
|
||||
wrefresh(win)
|
||||
reg WINDOW *win;
|
||||
{
|
||||
reg short wy;
|
||||
reg int retval;
|
||||
reg WINDOW *orig;
|
||||
|
||||
/*
|
||||
* make sure were in visual state
|
||||
*/
|
||||
if (_endwin) {
|
||||
_puts(VS);
|
||||
_puts(TI);
|
||||
_endwin = FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* initialize loop parameters
|
||||
*/
|
||||
|
||||
ly = curscr->_cury;
|
||||
lx = curscr->_curx;
|
||||
wy = 0;
|
||||
_win = win;
|
||||
curwin = (win == curscr);
|
||||
|
||||
if (win->_clear || curscr->_clear || curwin) {
|
||||
if ((win->_flags & _FULLWIN) || curscr->_clear) {
|
||||
_puts(CL);
|
||||
ly = 0;
|
||||
lx = 0;
|
||||
if (!curwin) {
|
||||
curscr->_clear = FALSE;
|
||||
curscr->_cury = 0;
|
||||
curscr->_curx = 0;
|
||||
werase(curscr);
|
||||
}
|
||||
touchwin(win);
|
||||
}
|
||||
win->_clear = FALSE;
|
||||
}
|
||||
if (!CA) {
|
||||
if (win->_curx != 0)
|
||||
_putchar('\n');
|
||||
if (!curwin)
|
||||
werase(curscr);
|
||||
}
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "REFRESH(%0.2o): curwin = %d\n", win, curwin);
|
||||
fprintf(outf, "REFRESH:\n\tfirstch\tlastch\n");
|
||||
# endif
|
||||
for (wy = 0; wy < win->_maxy; wy++) {
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "%d\t%d\t%d\n", wy, win->_firstch[wy],
|
||||
win->_lastch[wy]);
|
||||
# endif
|
||||
if (win->_firstch[wy] != _NOCHANGE)
|
||||
if (makech(win, wy) == ERR)
|
||||
return ERR;
|
||||
else {
|
||||
if (win->_firstch[wy] >= win->_ch_off)
|
||||
win->_firstch[wy] = win->_maxx +
|
||||
win->_ch_off;
|
||||
if (win->_lastch[wy] < win->_maxx +
|
||||
win->_ch_off)
|
||||
win->_lastch[wy] = win->_ch_off;
|
||||
if (win->_lastch[wy] < win->_firstch[wy])
|
||||
win->_firstch[wy] = _NOCHANGE;
|
||||
}
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "\t%d\t%d\n", win->_firstch[wy],
|
||||
win->_lastch[wy]);
|
||||
# endif
|
||||
}
|
||||
|
||||
if (win == curscr)
|
||||
domvcur(ly, lx, win->_cury, win->_curx);
|
||||
else {
|
||||
if (win->_leave) {
|
||||
curscr->_cury = ly;
|
||||
curscr->_curx = lx;
|
||||
ly -= win->_begy;
|
||||
lx -= win->_begx;
|
||||
if (ly >= 0 && ly < win->_maxy && lx >= 0 &&
|
||||
lx < win->_maxx) {
|
||||
win->_cury = ly;
|
||||
win->_curx = lx;
|
||||
}
|
||||
else
|
||||
win->_cury = win->_curx = 0;
|
||||
}
|
||||
else {
|
||||
domvcur(ly, lx, win->_cury + win->_begy,
|
||||
win->_curx + win->_begx);
|
||||
curscr->_cury = win->_cury + win->_begy;
|
||||
curscr->_curx = win->_curx + win->_begx;
|
||||
}
|
||||
}
|
||||
retval = OK;
|
||||
ret:
|
||||
_win = NULL;
|
||||
fflush(stdout);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/*
|
||||
* make a change on the screen
|
||||
*/
|
||||
STATIC
|
||||
makech(win, wy)
|
||||
reg WINDOW *win;
|
||||
short wy;
|
||||
{
|
||||
reg char *nsp, *csp, *ce;
|
||||
reg short wx, lch, y;
|
||||
reg int nlsp, clsp; /* last space in lines */
|
||||
|
||||
wx = win->_firstch[wy] - win->_ch_off;
|
||||
if (wx >= win->_maxx)
|
||||
return OK;
|
||||
else if (wx < 0)
|
||||
wx = 0;
|
||||
lch = win->_lastch[wy] - win->_ch_off;
|
||||
if (lch < 0)
|
||||
return OK;
|
||||
else if (lch >= win->_maxx)
|
||||
lch = win->_maxx - 1;;
|
||||
y = wy + win->_begy;
|
||||
|
||||
if (curwin)
|
||||
csp = " ";
|
||||
else
|
||||
csp = &curscr->_y[wy + win->_begy][wx + win->_begx];
|
||||
|
||||
nsp = &win->_y[wy][wx];
|
||||
if (CE && !curwin) {
|
||||
for (ce = &win->_y[wy][win->_maxx - 1]; *ce == ' '; ce--)
|
||||
if (ce <= win->_y[wy])
|
||||
break;
|
||||
nlsp = ce - win->_y[wy];
|
||||
}
|
||||
|
||||
if (!curwin)
|
||||
ce = CE;
|
||||
else
|
||||
ce = NULL;
|
||||
|
||||
while (wx <= lch) {
|
||||
if (*nsp != *csp) {
|
||||
domvcur(ly, lx, y, wx + win->_begx);
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "MAKECH: 1: wx = %d, lx = %d\n", wx, lx);
|
||||
# endif
|
||||
ly = y;
|
||||
lx = wx + win->_begx;
|
||||
while (*nsp != *csp && wx <= lch) {
|
||||
if (ce != NULL && wx >= nlsp && *nsp == ' ') {
|
||||
/*
|
||||
* check for clear to end-of-line
|
||||
*/
|
||||
ce = &curscr->_y[ly][COLS - 1];
|
||||
while (*ce == ' ')
|
||||
if (ce-- <= csp)
|
||||
break;
|
||||
clsp = ce - curscr->_y[ly] - win->_begx;
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "MAKECH: clsp = %d, nlsp = %d\n", clsp, nlsp);
|
||||
# endif
|
||||
if (clsp - nlsp >= strlen(CE)
|
||||
&& clsp < win->_maxx) {
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "MAKECH: using CE\n");
|
||||
# endif
|
||||
_puts(CE);
|
||||
lx = wx + win->_begx;
|
||||
while (wx++ <= clsp)
|
||||
*csp++ = ' ';
|
||||
return OK;
|
||||
}
|
||||
ce = NULL;
|
||||
}
|
||||
/*
|
||||
* enter/exit standout mode as appropriate
|
||||
*/
|
||||
if (SO && (*nsp&_STANDOUT) != (curscr->_flags&_STANDOUT)) {
|
||||
if (*nsp & _STANDOUT) {
|
||||
_puts(SO);
|
||||
curscr->_flags |= _STANDOUT;
|
||||
}
|
||||
else {
|
||||
_puts(SE);
|
||||
curscr->_flags &= ~_STANDOUT;
|
||||
}
|
||||
}
|
||||
wx++;
|
||||
if (wx >= win->_maxx && wy == win->_maxy - 1)
|
||||
if (win->_scroll) {
|
||||
if ((curscr->_flags&_STANDOUT) &&
|
||||
(win->_flags & _ENDLINE))
|
||||
if (!MS) {
|
||||
_puts(SE);
|
||||
curscr->_flags &= ~_STANDOUT;
|
||||
}
|
||||
if (!curwin)
|
||||
_putchar((*csp = *nsp) & 0177);
|
||||
else
|
||||
_putchar(*nsp & 0177);
|
||||
if (win->_flags&_FULLWIN && !curwin)
|
||||
scroll(curscr);
|
||||
ly = win->_begy+win->_cury;
|
||||
lx = win->_begx+win->_curx;
|
||||
return OK;
|
||||
}
|
||||
else if (win->_flags&_SCROLLWIN) {
|
||||
lx = --wx;
|
||||
return ERR;
|
||||
}
|
||||
if (!curwin)
|
||||
_putchar((*csp++ = *nsp) & 0177);
|
||||
else
|
||||
_putchar(*nsp & 0177);
|
||||
# ifdef FULLDEBUG
|
||||
fprintf(outf,
|
||||
"MAKECH:putchar(%c)\n", *nsp & 0177);
|
||||
# endif
|
||||
if (UC && (*nsp & _STANDOUT)) {
|
||||
_putchar('\b');
|
||||
_puts(UC);
|
||||
}
|
||||
nsp++;
|
||||
}
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "MAKECH: 2: wx = %d, lx = %d\n", wx, lx);
|
||||
# endif
|
||||
if (lx == wx + win->_begx) /* if no change */
|
||||
break;
|
||||
lx = wx + win->_begx;
|
||||
if (lx >= COLS && AM) {
|
||||
lx = 0;
|
||||
ly++;
|
||||
/*
|
||||
* xn glitch: chomps a newline after auto-wrap.
|
||||
* we just feed it now and forget about it.
|
||||
*/
|
||||
if (XN) {
|
||||
_putchar('\n');
|
||||
_putchar('\r');
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (wx <= lch)
|
||||
while (*nsp == *csp && wx <= lch) {
|
||||
nsp++;
|
||||
if (!curwin)
|
||||
csp++;
|
||||
++wx;
|
||||
}
|
||||
else
|
||||
break;
|
||||
# ifdef DEBUG
|
||||
fprintf(outf, "MAKECH: 3: wx = %d, lx = %d\n", wx, lx);
|
||||
# endif
|
||||
}
|
||||
return OK;
|
||||
}
|
||||
|
||||
/*
|
||||
* perform a mvcur, leaving standout mode if necessary
|
||||
*/
|
||||
STATIC
|
||||
domvcur(oy, ox, ny, nx)
|
||||
int oy, ox, ny, nx; {
|
||||
|
||||
if (curscr->_flags & _STANDOUT && !MS) {
|
||||
_puts(SE);
|
||||
curscr->_flags &= ~_STANDOUT;
|
||||
}
|
||||
mvcur(oy, ox, ny, nx);
|
||||
}
|
||||
Loading…
Reference in New Issue