home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
minnie.tuhs.org
/
unixen.tar
/
unixen
/
PDP-11
/
Distributions
/
ucb
/
spencer_2bsd.tar.gz
/
2bsd.tar
/
src
/
ex
/
ex_v.c
< prev
next >
Wrap
C/C++ Source or Header
|
1980-02-17
|
8KB
|
375 lines
/* Copyright (c) 1979 Regents of the University of California */
#include "ex.h"
#include "ex_re.h"
#include "ex_tty.h"
#include "ex_vis.h"
/*
* Entry points to open and visual from command mode processor.
* The open/visual code breaks down roughly as follows:
*
* ex_v.c entry points, checking of terminal characteristics
*
* ex_vadj.c logical screen control, use of intelligent operations
* insert/delete line and coordination with screen image;
* updating of screen after changes.
*
* ex_vget.c input of single keys and reading of input lines
* from the echo area, handling of \ escapes on input for
* uppercase only terminals, handling of memory for repeated
* commands and small saved texts from inserts and partline
* deletes, notification of multi line changes in the echo
* area.
*
* ex_vmain.c main command decoding, some command processing.
*
* ex_voperate.c decoding of operator/operand sequences and
* contextual scans, implementation of word motions.
*
* ex_vops.c major operator interfaces, undos, motions, deletes,
* changes, opening new lines, shifts, replacements and yanks
* coordinating logical and physical changes.
*
* ex_vops2.c subroutines for operator interfaces in ex_vops.c,
* insert mode, read input line processing at lowest level.
*
* ex_vops3.c structured motion definitions of ( ) { } and [ ] operators,
* indent for lisp routines, () and {} balancing.
*
* ex_vput.c output routines, clearing, physical mapping of logical cursor
* positioning, cursor motions, handling of insert character
* and delete character functions of intelligent and unintelligent
* terminals, visual mode tracing routines (for debugging),
* control of screen image and its updating.
*
* ex_vwind.c window level control of display, forward and backward rolls,
* absolute motions, contextual displays, line depth determination
*/
/*
* Enter open mode
*/
oop()
{
register char *ic;
char atube[TUBESIZE + LBSIZE];
register int f;
ovbeg();
if (peekchar() == '/') {
ignore(compile(getchar(), 1));
savere(scanre);
if (execute(0, dot) == 0)
error("Fail|Pattern not found on addressed line");
ic = loc1;
if (ic > linebuf && *ic == 0)
ic--;
} else {
getDOT();
ic = vskipwh(linebuf);
}
newline();
/*
* If overstrike then have to HARDOPEN
* else if can move cursor up off current line can use CRTOPEN (~~vi1)
* otherwise (ugh) have to use ONEOPEN (like adm3)
*/
if (OS && !EO)
bastate = HARDOPEN;
else if (CA || UP)
bastate = CRTOPEN;
else
bastate = ONEOPEN;
setwind();
/*
* To avoid bombing on glass-crt's when the line is too long
* pretend that such terminals are 160 columns wide.
* If a line is too wide for display, we will dynamically
* switch to hardcopy open mode.
*/
if (state != CRTOPEN)
WCOLS = TUBECOLS;
if (!inglobal)
savevis();
vok(atube);
if (state != CRTOPEN)
COLUMNS = WCOLS;
Outchar = vputchar;
f = ostart();
if (state == CRTOPEN) {
if (outcol == UKCOL)
outcol = 0;
vmoveitup(1);
} else
outline = destline = WBOT;
vshow(dot, NOLINE);
vnline(ic);
vmain();
if (state != CRTOPEN)
vclean();
Command = "open";
ovend(f);
}
ovbeg()
{
if (!value(OPEN))
error("Can't use open/visual unless open option is set");
if (inopen)
error("Recursive open/visual not allowed");
Vlines = lineDOL();
fixzero();
setdot();
pastwh();
dot = addr2;
}
ovend(f)
int f;
{
splitw++;
vgoto(WECHO, 0);
vclreol();
vgoto(WECHO, 0);
holdcm = 0;
splitw = 0;
ostop(f);
setoutt();
undvis();
COLUMNS = OCOLUMNS;
inopen = 0;
flusho();
netchHAD(Vlines);
}
/*
* Enter visual mode
*/
vop()
{
register int c;
char atube[TUBESIZE + LBSIZE];
register int f;
if (!CA && UP == NOSTR) {
if (initev) {
toopen:
merror("[Using open mode]");
putNFL();
oop();
return;
}
error("Visual needs addressible cursor or upline capability");
}
if (OS && !EO) {
if (initev)
goto toopen;
error("Can't use visual on a terminal which overstrikes");
}
if (!CL) {
if (initev)
goto toopen;
error("Visual requires clear screen capability");
}
ovbeg();
bastate = VISUAL;
c = 0;
if (any(peekchar(), "+-^."))
c = getchar();
pastwh();
vsetsiz(isdigit(peekchar()) ? getnum() : value(WINDOW));
setwind();
newline();
vok(atube);
if (!inglobal)
savevis();
Outchar = vputchar;
vmoving = 0;
f = ostart();
if (initev == 0) {
vcontext(dot, c);
vnline(NOSTR);
}
vmain();
Command = "visual";
ovend(f);
}
/*
* Hack to allow entry to visual with
* empty buffer since routines internally
* demand at least one line.
*/
fixzero()
{
if (dol == zero) {
register bool ochng = chng;
vdoappend("");
if (!ochng)
sync();
addr1 = addr2 = one;
} else if (addr2 == zero)
addr2 = one;
}
/*
* Save lines before visual between unddol and truedol.
* Accomplish this by throwing away current [unddol,truedol]
* and then saving all the lines in the buffer and moving
* unddol back to dol. Don't do this if in a global.
*
* If you do
* g/xxx/vi.
* and then do a
* :e xxxx
* at some point, and then quit from the visual and undo
* you get the old file back. Somewhat weird.
*/
savevis()
{
if (inglobal)
return;
truedol = unddol;
saveall();
unddol = dol;
undkind = UNDNONE;
}
/*
* Restore a sensible state after a visual/open, moving the saved
* stuff back to [unddol,dol], and killing the partial line kill indicators.
*/
undvis()
{
if (ruptible)
signal(SIGINT, onintr);
squish();
pkill[0] = pkill[1] = 0;
unddol = truedol;
unddel = zero;
undap1 = one;
undap2 = dol + 1;
undkind = UNDALL;
}
/*
* Set the window parameters based on the base state bastate
* and the available buffer space.
*/
setwind()
{
WCOLS = COLUMNS;
switch (bastate) {
case ONEOPEN:
if (AM)
WCOLS--;
/* fall into ... */
case HARDOPEN:
basWTOP = WTOP = WBOT = WECHO = 0;
ZERO = 0;
holdcm++;
break;
case CRTOPEN:
basWTOP = LINES - 2;
/* fall into */
case VISUAL:
ZERO = LINES - TUBESIZE / WCOLS;
if (ZERO < 0)
ZERO = 0;
if (ZERO > basWTOP)
error("Screen too large for internal buffer");
WTOP = basWTOP; WBOT = LINES - 2; WECHO = LINES - 1;
break;
}
state = bastate;
basWLINES = WLINES = WBOT - WTOP + 1;
}
/*
* Can we hack an open/visual on this terminal?
* If so, then divide the screen buffer up into lines,
* and initialize a bunch of state variables before we start.
*/
vok(atube)
register char *atube;
{
register int i;
if (WCOLS == 1000)
serror("Don't know enough about your terminal to use %s", Command);
if (WCOLS > TUBECOLS)
error("Terminal too wide");
if (WLINES >= TUBELINES || WCOLS * (WECHO - ZERO + 1) > TUBESIZE)
error("Screen too large");
vtube0 = atube;
vclrbyte(atube, WCOLS * (WECHO - ZERO + 1));
for (i = 0; i < ZERO; i++)
vtube[i] = (char *) -20000;
for (; i <= WECHO; i++)
vtube[i] = atube, atube += WCOLS;
for (; i < TUBELINES; i++)
vtube[i] = (char *) -20000;
vutmp = atube;
vundkind = VNONE;
vUNDdot = 0;
OCOLUMNS = COLUMNS;
inopen = 1;
#ifndef V6
signal(SIGINT, vintr);
#endif
vmoving = 0;
splitw = 0;
doomed = 0;
holdupd = 0;
Peekkey = 0;
vcnt = vcline = 0;
if (vSCROLL == 0)
vSCROLL = value(SCROLL);
}
#ifndef V6
vintr()
{
signal(SIGINT, vintr);
if (vcatch)
onintr();
ungetkey(ATTN);
draino();
}
#endif
/*
* Set the size of the screen to size lines, to take effect the
* next time the screen is redrawn.
*/
vsetsiz(size)
int size;
{
register int b;
if (bastate != VISUAL)
return;
b = LINES - 1 - size;
if (b >= LINES - 1)
b = LINES - 2;
if (b < 0)
b = 0;
basWTOP = b;
basWLINES = WBOT - b + 1;
}