![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vis.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / ex|
Return to ex_vis.h CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / ex |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: /*
3: * Ex version 2
4: * Mark Horton, UCB
5: * Bill Joy UCB
6: *
7: * Open and visual mode definitions.
8: *
9: * There are actually 4 major states in open/visual modes. These
10: * are visual, crt open (where the cursor can move about the screen and
11: * the screen can scroll and be erased), one line open (on dumb glass-crt's
12: * like the adm3), and hardcopy open (for everything else).
13: *
14: * The basic state is given by bastate, and the current state by state,
15: * since we can be in pseudo-hardcopy mode if we are on an adm3 and the
16: * line is longer than 80.
17: */
18:
19: short bastate;
20: short state;
21:
22: #define VISUAL 0
23: #define CRTOPEN 1
24: #define ONEOPEN 2
25: #define HARDOPEN 3
26:
27: /*
28: * The screen in visual and crtopen is of varying size; the basic
29: * window has top basWTOP and basWLINES lines are thereby implied.
30: * The current window (which may have grown from the basic size)
31: * has top WTOP and WLINES lines. The top line of the window is WTOP,
32: * and the bottom line WBOT. The line WECHO is used for messages,
33: * search strings and the like. If WBOT==WECHO then we are in ONEOPEN
34: * or HARDOPEN and there is no way back to the line we were on if we
35: * go to WECHO (i.e. we will have to scroll before we go there, and
36: * we can't get back). There are WCOLS columns per line.
37: * If WBOT!=WECHO then WECHO will be the last line on the screen
38: * and WBOT is the line before it.
39: */
40: short basWTOP;
41: short basWLINES;
42: short WTOP;
43: short WBOT;
44: short WLINES;
45: short WCOLS;
46: short WECHO;
47:
48: /*
49: * When we are dealing with the echo area we consider the window
50: * to be "split" and set the variable splitw. Otherwise, moving
51: * off the bottom of the screen into WECHO causes a screen rollup.
52: */
53: bool splitw;
54:
55: /*
56: * Information about each line currently on the screen includes
57: * the y coordinate associated with the line, the printing depth
58: * of the line (0 indicates unknown), and a mask which indicates
59: * whether the line is "unclean", i.e. whether we should check
60: * to make sure the line is displayed correctly at the next
61: * appropriate juncture.
62: */
63: struct vlinfo {
64: char vliny; /* Y coordinate */
65: char vdepth; /* Depth of displayed line */
66: short vflags; /* Is line potentially dirty ? */
67: } vlinfo[TUBELINES + 2];
68:
69: #define DEPTH(c) (vlinfo[c].vdepth)
70: #define LINE(c) (vlinfo[c].vliny)
71: #define FLAGS(c) (vlinfo[c].vflags)
72:
73: #define VDIRT 1
74:
75: /*
76: * Hacks to copy vlinfo structures around
77: */
78: #ifdef V6
79: /* Kludge to make up for no structure assignment */
80: struct {
81: long longi;
82: };
83: # define vlcopy(i, j) i.longi = j.longi
84: #else
85: # define vlcopy(i, j) i = j;
86: #endif
87:
88: /*
89: * The current line on the screen is represented by vcline.
90: * There are vcnt lines on the screen, the last being "vcnt - 1".
91: * Vcline is intimately tied to the current value of dot,
92: * and when command mode is used as a subroutine fancy footwork occurs.
93: */
94: short vcline;
95: short vcnt;
96:
97: /*
98: * To allow many optimizations on output, an exact image of the terminal
99: * screen is maintained in the space addressed by vtube0. The vtube
100: * array indexes this space as lines, and is shuffled on scrolls, insert+delete
101: * lines and the like rather than (more expensively) shuffling the screen
102: * data itself. It is also rearranged during insert mode across line
103: * boundaries to make incore work easier.
104: */
105: char *vtube[TUBELINES];
106: char *vtube0;
107:
108: /*
109: * The current cursor position within the current line is kept in
110: * cursor. The current line is kept in linebuf. During insertions
111: * we use the auxiliary array genbuf as scratch area.
112: * The cursor wcursor and wdot are used in operations within/spanning
113: * lines to mark the other end of the affected area, or the target
114: * for a motion.
115: */
116: char *cursor;
117: char *wcursor;
118: line *wdot;
119:
120: /*
121: * Undo information is saved in a LBSIZE buffer at "vutmp" for changes
122: * within the current line, or as for command mode for multi-line changes
123: * or changes on lines no longer the current line.
124: * The change kind "VCAPU" is used immediately after a U undo to prevent
125: * two successive U undo's from destroying the previous state.
126: */
127: #define VNONE 0
128: #define VCHNG 1
129: #define VMANY 2
130: #define VCAPU 3
131: #define VMCHNG 4
132: #define VMANYINS 5
133:
134: short vundkind; /* Which kind of undo - from above */
135: char *vutmp; /* Prev line image when "VCHNG" */
136:
137: /*
138: * For U undo's the line is grabbed by "vmove" after it first appears
139: * on that line. The "vUNDdot" which specifies which line has been
140: * saved is selectively cleared when changes involving other lines
141: * are made, i.e. after a 'J' join. This is because a 'JU' would
142: * lose completely the text of the line just joined on.
143: */
144: char *vUNDcurs; /* Cursor just before 'U' */
145: line *vUNDdot; /* The line address of line saved in vUNDsav */
146: line vUNDsav; /* Grabbed initial "*dot" */
147:
148: #define killU() vUNDdot = NOLINE
149:
150: /*
151: * There are a number of cases where special behaviour is needed
152: * from deeply nested routines. This is accomplished by setting
153: * the bits of hold, which acts to change the state of the general
154: * visual editing behaviour in specific ways.
155: *
156: * HOLDAT prevents the clreol (clear to end of line) routines from
157: * putting out @'s or ~'s on empty lines.
158: *
159: * HOLDDOL prevents the reopen routine from putting a '$' at the
160: * end of a reopened line in list mode (for hardcopy mode, e.g.).
161: *
162: * HOLDROL prevents spurious blank lines when scrolling in hardcopy
163: * open mode.
164: *
165: * HOLDQIK prevents the fake insert mode during repeated commands.
166: *
167: * HOLDPUPD prevents updating of the physical screen image when
168: * mucking around while in insert mode.
169: *
170: * HOLDECH prevents clearing of the echo area while rolling the screen
171: * backwards (e.g.) in deference to the clearing of the area at the
172: * end of the scroll (1 time instead of n times). The fact that this
173: * is actually needed is recorded in heldech, which says that a clear
174: * of the echo area was actually held off.
175: */
176: short hold;
177: short holdupd; /* Hold off update when echo line is too long */
178:
179: #define HOLDAT 1
180: #define HOLDDOL 2
181: #define HOLDROL 4
182: #define HOLDQIK 8
183: #define HOLDPUPD 16
184: #define HOLDECH 32
185: #define HOLDWIG 64
186:
187: /*
188: * Miscellaneous variables
189: */
190: short CDCNT; /* Count of ^D's in insert on this line */
191: char DEL[VBSIZE]; /* Last deleted text */
192: bool HADUP; /* This insert line started with ^ then ^D */
193: bool HADZERO; /* This insert line started with 0 then ^D */
194: char INS[VBSIZE]; /* Last inserted text */
195: int Vlines; /* Number of file lines "before" vi command */
196: int Xcnt; /* External variable holding last cmd's count */
197: bool Xhadcnt; /* Last command had explicit count? */
198: short ZERO;
199: short dir; /* Direction for search (+1 or -1) */
200: short doomed; /* Disply chars right of cursor to be killed */
201: bool gobblebl; /* Wrapmargin space generated nl, eat a space */
202: bool hadcnt; /* (Almost) internal to vmain() */
203: bool heldech; /* We owe a clear of echo area */
204: bool insmode; /* Are in character insert mode */
205: char lastcmd[5]; /* Chars in last command */
206: int lastcnt; /* Count for last command */
207: char *lastcp; /* Save current command here to repeat */
208: bool lasthad; /* Last command had a count? */
209: short lastvgk; /* Previous input key, if not from keyboard */
210: short lastreg; /* Register with last command */
211: char *ncols['z'-'a'+2]; /* Cursor positions of marks */
212: char *notenam; /* Name to be noted with change count */
213: char *notesgn; /* Change count from last command */
214: char op; /* Operation of current command */
215: short Peekkey; /* Peek ahead key */
216: bool rubble; /* Line is filthy (in hardcopy open), redraw! */
217: int vSCROLL; /* Number lines to scroll on ^D/^U */
218: char *vglobp; /* Untyped input (e.g. repeat insert text) */
219: char vmacbuf[VBSIZE]; /* Text of visual macro, hence nonnestable */
220: char *vmacp; /* Like vglobp but for visual macros */
221: char *vmcurs; /* Cursor for restore after undo d), e.g. */
222: short vmovcol; /* Column to try to keep on arrow keys */
223: bool vmoving; /* Are trying to keep vmovcol */
224: char vreg; /* Register for this command */
225: short wdkind; /* Liberal/conservative words? */
226: char workcmd[5]; /* Temporary for lastcmd */
227:
228:
229: /*
230: * Macros
231: */
232: #define INF 30000
233: #define LASTLINE LINE(vcnt)
234: #define OVERBUF QUOTE
235: #define beep obeep
236: #define cindent() ((outline - vlinfo[vcline].vliny) * WCOLS + outcol)
237: #define vputp(cp, cnt) tputs(cp, cnt, vputch)
238: #define vputc(c) putch(c)
239:
240: /*
241: * Function types
242: */
243: int beep();
244: int qcount();
245: int vchange();
246: int vdelete();
247: int vgrabit();
248: int vinschar();
249: int vmove();
250: int vputchar();
251: int vshift();
252: int vyankit();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.