Print this page
5088 it's probably ok for vi to stop working around pdp-11 bugs now
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/vi/port/ex.h
+++ new/usr/src/cmd/vi/port/ex.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 24 */
25 25
26 26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 27 /* All Rights Reserved */
28 28
29 29 /* Copyright (c) 1981 Regents of the University of California */
30 30
31 31 #ifndef _EX_H
32 32 #define _EX_H
33 33
34 34 #ifdef __cplusplus
35 35 extern "C" {
36 36 #endif
37 37
38 38 /*
39 39 * This file contains most of the declarations common to a large number
40 40 * of routines. The file ex_vis.h contains declarations
41 41 * which are used only inside the screen editor.
42 42 * The file ex_tune.h contains parameters which can be diddled per installation.
43 43 *
44 44 * The declarations relating to the argument list, regular expressions,
45 45 * the temporary file data structure used by the editor
46 46 * and the data describing terminals are each fairly substantial and
47 47 * are kept in the files ex_{argv,re,temp,tty}.h which
48 48 * we #include separately.
49 49 *
50 50 * If you are going to dig into ex, you should look at the outline of the
51 51 * distribution of the code into files at the beginning of ex.c and ex_v.c.
52 52 * Code which is similar to that of ed is lightly or undocumented in spots
53 53 * (e.g. the regular expression code). Newer code (e.g. open and visual)
54 54 * is much more carefully documented, and still rough in spots.
55 55 *
56 56 */
57 57 #ifdef UCBV7
58 58 #include <whoami.h>
59 59 #endif
60 60 #include <sys/types.h>
61 61 #include <ctype.h>
62 62 #include <errno.h>
63 63 #include <signal.h>
64 64 #include <setjmp.h>
65 65 #include <sys/stat.h>
66 66 #include <stdlib.h>
67 67 #include <limits.h>
68 68 #include <libintl.h>
69 69
70 70 #define MULTI_BYTE_MAX MB_LEN_MAX
71 71 #define FTYPE(A) (A.st_mode)
72 72 #define FMODE(A) (A.st_mode)
73 73 #define IDENTICAL(A,B) (A.st_dev==B.st_dev && A.st_ino==B.st_ino)
74 74 #define ISBLK(A) ((A.st_mode & S_IFMT) == S_IFBLK)
75 75 #define ISCHR(A) ((A.st_mode & S_IFMT) == S_IFCHR)
76 76 #define ISDIR(A) ((A.st_mode & S_IFMT) == S_IFDIR)
77 77 #define ISFIFO(A) ((A.st_mode & S_IFMT) == S_IFIFO)
78 78 #define ISREG(A) ((A.st_mode & S_IFMT) == S_IFREG)
79 79
80 80 #ifdef USG
81 81 #include <termio.h>
82 82 typedef struct termios SGTTY;
83 83 #else
84 84 #include <sgtty.h>
85 85 typedef struct sgttyb SGTTY;
86 86 #endif
87 87
88 88 #ifdef PAVEL
89 89 #define SGTTY struct sgttyb /* trick Pavel curses to not include <curses.h> */
90 90 #endif
91 91 typedef char bool;
92 92 typedef unsigned long chtype;
93 93 #include <term.h>
94 94 #define bool vi_bool
95 95 #ifdef PAVEL
96 96 #undef SGTTY
97 97 #endif
98 98 #ifndef var
99 99 #define var extern
100 100 #endif
101 101 var char *exit_bold; /* string to exit standout mode */
102 102
103 103 /*
104 104 * The following little dance copes with the new USG tty handling.
105 105 * This stuff has the advantage of considerable flexibility, and
106 106 * the disadvantage of being incompatible with anything else.
107 107 * The presence of the symbol USG will indicate the new code:
108 108 * in this case, we define CBREAK (because we can simulate it exactly),
109 109 * but we won't actually use it, so we set it to a value that will
110 110 * probably blow the compilation if we goof up.
111 111 */
112 112 #ifdef USG
113 113 #define CBREAK xxxxx
114 114 #endif
115 115
116 116 #ifndef VMUNIX
117 117 typedef short line;
118 118 #else
119 119 typedef int line;
120 120 #endif
121 121 typedef short bool;
122 122
123 123 #include "ex_tune.h"
124 124 #include "ex_vars.h"
125 125 /*
126 126 * Options in the editor are referred to usually by "value(vi_name)" where
127 127 * name is all uppercase, i.e. "value(vi_PROMPT)". This is actually a macro
128 128 * which expands to a fixed field in a static structure and so generates
129 129 * very little code. The offsets for the option names in the structure
130 130 * are generated automagically from the structure initializing them in
131 131 * ex_data.c... see the shell script "makeoptions".
132 132 */
133 133 struct option {
134 134 unsigned char *oname;
135 135 unsigned char *oabbrev;
136 136 short otype; /* Types -- see below */
137 137 short odefault; /* Default value */
138 138 short ovalue; /* Current value */
139 139 unsigned char *osvalue;
140 140 };
141 141
142 142 #define ONOFF 0
143 143 #define NUMERIC 1
144 144 #define STRING 2 /* SHELL or DIRECTORY */
145 145 #define OTERM 3
146 146
147 147 #define value(a) options[a].ovalue
148 148 #define svalue(a) options[a].osvalue
149 149
150 150 extern struct option options[vi_NOPTS + 1];
151 151
152 152
153 153 /*
154 154 * The editor does not normally use the standard i/o library. Because
155 155 * we expect the editor to be a heavily used program and because it
156 156 * does a substantial amount of input/output processing it is appropriate
157 157 * for it to call low level read/write primitives directly. In fact,
158 158 * when debugging the editor we use the standard i/o library. In any
159 159 * case the editor needs a printf which prints through "putchar" ala the
160 160 * old version 6 printf. Thus we normally steal a copy of the "printf.c"
161 161 * and "strout" code from the standard i/o library and mung it for our
162 162 * purposes to avoid dragging in the stdio library headers, etc if we
163 163 * are not debugging. Such a modified printf exists in "printf.c" here.
164 164 */
165 165 #ifdef TRACE
166 166 #include <stdio.h>
167 167 var FILE *trace;
168 168 var bool trubble;
169 169 var bool techoin;
170 170 var unsigned char tracbuf[BUFSIZ];
171 171 #undef putchar
172 172 #undef getchar
173 173 #else
174 174 /*
175 175 * Warning: do not change BUFSIZ without also changing LBSIZE in ex_tune.h
176 176 * Running with BUFSIZ set to anything besides what is in <stdio.h> is
177 177 * not recommended, if you use stdio.
178 178 */
179 179 #ifdef u370
180 180 #define BUFSIZE 4096
181 181 #else
182 182 #define BUFSIZE (LINE_MAX*2)
183 183 #endif
184 184 #undef NULL
185 185 #define NULL 0
186 186 #undef EOF
187 187 #define EOF -1
188 188 #endif
189 189
190 190 /*
191 191 * Character constants and bits
192 192 *
193 193 * The editor uses the QUOTE bit as a flag to pass on with characters
194 194 * e.g. to the putchar routine. The editor never uses a simple char variable.
195 195 * Only arrays of and pointers to characters are used and parameters and
196 196 * registers are never declared character.
197 197 */
198 198 #define QUOTE 020000000000
199 199 #define TRIM 017777777777
200 200 #define NL '\n'
201 201 #define CR '\r'
202 202 #define DELETE 0177 /* See also ATTN, QUIT in ex_tune.h */
203 203 #define ESCAPE 033
204 204 #undef CTRL
205 205 #define CTRL(c) (c & 037)
206 206
207 207 /*
208 208 * Miscellaneous random variables used in more than one place
209 209 */
210 210 var bool multibyte;
211 211 var bool aiflag; /* Append/change/insert with autoindent */
212 212 var bool tagflg; /* set for -t option and :tag command */
213 213 var bool anymarks; /* We have used '[a-z] */
214 214 var int chng; /* Warn "No write" */
215 215 var unsigned char *Command;
216 216 var short defwind; /* -w# change default window size */
217 217 var int dirtcnt; /* When >= MAXDIRT, should sync temporary */
218 218 #ifdef SIGTSTP
219 219 var bool dosusp; /* Do SIGTSTP in visual when ^Z typed */
220 220 #endif
221 221 var bool edited; /* Current file is [Edited] */
222 222 var line *endcore; /* Last available core location */
223 223 extern bool endline; /* Last cmd mode command ended with \n */
224 224 var line *fendcore; /* First address in line pointer space */
225 225 var unsigned char file[FNSIZE]; /* Working file name */
226 226 var unsigned char genbuf[LBSIZE]; /* Working buffer when manipulating linebuf */
227 227 var bool hush; /* Command line option - was given, hush up! */
228 228 var unsigned char *globp; /* (Untyped) input string to command mode */
229 229 var bool holdcm; /* Don't cursor address */
230 230 var bool inappend; /* in ex command append mode */
231 231 var bool inglobal; /* Inside g//... or v//... */
232 232 var unsigned char *initev; /* Initial : escape for visual */
233 233 var bool inopen; /* Inside open or visual */
234 234 var unsigned char *input; /* Current position in cmd line input buffer */
235 235 var bool intty; /* Input is a tty */
236 236 var short io; /* General i/o unit (auto-closed on error!) */
237 237 extern short lastc; /* Last character ret'd from cmd input */
238 238 var bool laste; /* Last command was an "e" (or "rec") */
239 239 var unsigned char lastmac; /* Last macro called for ** */
240 240 var unsigned char lasttag[TAGSIZE]; /* Last argument to a tag command */
241 241 var unsigned char *linebp; /* Used in substituting in \n */
242 242 var unsigned char linebuf[LBSIZE]; /* The primary line buffer */
243 243 var bool listf; /* Command should run in list mode */
244 244 var line names['z'-'a'+2]; /* Mark registers a-z,' */
245 245 var int notecnt; /* Count for notify (to visual from cmd) */
246 246 var bool numberf; /* Command should run in number mode */
247 247 var unsigned char obuf[BUFSIZE]; /* Buffer for tty output */
248 248 var short oprompt; /* Saved during source */
249 249 var short ospeed; /* Output speed (from gtty) */
250 250 var int otchng; /* Backup tchng to find changes in macros */
251 251 var int peekc; /* Peek ahead character (cmd mode input) */
252 252 var unsigned char *pkill[2]; /* Trim for put with ragged (LISP) delete */
253 253 var bool pfast; /* Have stty -nl'ed to go faster */
254 254 var pid_t pid; /* Process id of child */
255 255 var pid_t ppid; /* Process id of parent (e.g. main ex proc) */
256 256 var jmp_buf resetlab; /* For error throws to top level (cmd mode) */
257 257 var pid_t rpid; /* Pid returned from wait() */
258 258 var bool ruptible; /* Interruptible is normal state */
259 259 var bool seenprompt; /* 1 if have gotten user input */
260 260 var bool shudclob; /* Have a prompt to clobber (e.g. on ^D) */
261 261 var int status; /* Status returned from wait() */
262 262 var int tchng; /* If nonzero, then [Modified] */
263 263 extern short tfile; /* Temporary file unit */
264 264 var bool vcatch; /* Want to catch an error (open/visual) */
265 265 var jmp_buf vreslab; /* For error throws to a visual catch */
266 266 var bool writing; /* 1 if in middle of a file write */
267 267 var int xchng; /* Suppresses multiple "No writes" in !cmd */
268 268 #ifndef PRESUNEUC
269 269 var char mc_filler; /* Right margin filler for multicolumn char */
270 270 var bool mc_wrap; /* Multicolumn character wrap at right margin */
271 271 #endif /* PRESUNEUC */
272 272 var int inexrc; /* boolean: in .exrc initialization */
273 273
274 274 extern int termiosflag; /* flag for using termios */
275 275
276 276 /*
277 277 * Macros
278 278 */
279 279 #define CP(a, b) ((void)strcpy(a, b))
280 280 /*
281 281 * FIXUNDO: do we want to mung undo vars?
282 282 * Usually yes unless in a macro or global.
283 283 */
284 284 #define FIXUNDO (inopen >= 0 && (inopen || !inglobal))
285 285 #define ckaw() {if (chng && value(vi_AUTOWRITE) && !value(vi_READONLY)) \
286 286 wop(0);\
287 287 }
288 288 #define copy(a,b,c) Copy((char *) (a), (char *) (b), (c))
289 289 #define eq(a, b) ((a) && (b) && strcmp(a, b) == 0)
290 290 #define getexit(a) copy(a, resetlab, sizeof (jmp_buf))
291 291 #define lastchar() lastc
292 292 #define outchar(c) (*Outchar)(c)
293 293 #define pastwh() ((void)skipwh())
294 294 #define pline(no) (*Pline)(no)
295 295 #define reset() longjmp(resetlab,1)
296 296 #define resexit(a) copy(resetlab, a, sizeof (jmp_buf))
297 297 #define setexit() setjmp(resetlab)
298 298 #define setlastchar(c) lastc = c
299 299 #define ungetchar(c) peekc = c
300 300
301 301 #define CATCH vcatch = 1; if (setjmp(vreslab) == 0) {
302 302 #define ONERR } else { vcatch = 0;
303 303 #define ENDCATCH } vcatch = 0;
304 304
305 305 /*
306 306 * Environment like memory
307 307 */
308 308 var unsigned char altfile[FNSIZE]; /* Alternate file name */
309 309 extern unsigned char direct[ONMSZ]; /* Temp file goes here */
310 310 extern unsigned char shell[ONMSZ]; /* Copied to be settable */
311 311 var unsigned char uxb[UXBSIZE + 2]; /* Last !command for !! */
312 312
313 313 /*
314 314 * The editor data structure for accessing the current file consists
315 315 * of an incore array of pointers into the temporary file tfile.
316 316 * Each pointer is 15 bits (the low bit is used by global) and is
317 317 * padded with zeroes to make an index into the temp file where the
318 318 * actual text of the line is stored.
319 319 *
320 320 * To effect undo, copies of affected lines are saved after the last
321 321 * line considered to be in the buffer, between dol and unddol.
322 322 * During an open or visual, which uses the command mode undo between
323 323 * dol and unddol, a copy of the entire, pre-command buffer state
324 324 * is saved between unddol and truedol.
325 325 */
326 326 var line *addr1; /* First addressed line in a command */
327 327 var line *addr2; /* Second addressed line */
328 328 var line *dol; /* Last line in buffer */
329 329 var line *dot; /* Current line */
330 330 var line *one; /* First line */
331 331 var line *truedol; /* End of all lines, including saves */
332 332 var line *unddol; /* End of undo saved lines */
333 333 var line *zero; /* Points to empty slot before one */
334 334
335 335 /*
336 336 * Undo information
337 337 *
338 338 * For most commands we save lines changed by salting them away between
339 339 * dol and unddol before they are changed (i.e. we save the descriptors
340 340 * into the temp file tfile which is never garbage collected). The
341 341 * lines put here go back after unddel, and to complete the undo
342 342 * we delete the lines [undap1,undap2).
343 343 *
344 344 * Undoing a move is much easier and we treat this as a special case.
345 345 * Similarly undoing a "put" is a special case for although there
346 346 * are lines saved between dol and unddol we don't stick these back
347 347 * into the buffer.
348 348 */
349 349 var short undkind;
350 350
351 351 var line *unddel; /* Saved deleted lines go after here */
352 352 var line *undap1; /* Beginning of new lines */
353 353 var line *undap2; /* New lines end before undap2 */
354 354 var line *undadot; /* If we saved all lines, dot reverts here */
355 355
356 356 #define UNDCHANGE 0
357 357 #define UNDMOVE 1
358 358 #define UNDALL 2
|
↓ open down ↓ |
358 lines elided |
↑ open up ↑ |
359 359 #define UNDNONE 3
360 360 #define UNDPUT 4
361 361
362 362 /*
363 363 * Various miscellaneous flags and buffers needed by the encryption routines.
364 364 */
365 365 #define KSIZE 9 /* key size for encryption */
366 366 var int xflag; /* True if we are in encryption mode */
367 367 var int xtflag; /* True if the temp file is being encrypted */
368 368 var int kflag; /* True if the key has been accepted */
369 -var int crflag; /* True if the key has been accepted and the file
370 - being read is ciphertext
369 +var int crflag; /* True if the key has been accepted and the file
370 + being read is ciphertext
371 371 */
372 372 var int perm[2]; /* pipe connection to crypt for file being edited */
373 373 var int tperm[2]; /* pipe connection to crypt for temporary file */
374 374 var int permflag;
375 375 var int tpermflag;
376 376 var unsigned char *key;
377 377 var unsigned char crbuf[CRSIZE];
378 378 char *getpass();
379 379
380 380 var bool write_quit; /* True if executing a 'wq' command */
381 381 var int errcnt; /* number of error/warning messages in */
382 - /* editing session (global flag) */
382 + /* editing session (global flag) */
383 383 /*
384 384 * Function type definitions
385 385 */
386 386 #define NOSTR (char *) 0
387 387 #define NOLINE (line *) 0
388 388
389 389 #define setterm visetterm
390 390 #define draino vidraino
391 391 #define gettmode vigettmode
392 392
393 393 extern int (*Outchar)();
394 394 extern int (*Pline)();
395 395 extern int (*Putchar)();
396 396 var void (*oldhup)();
397 397 int (*setlist())();
398 398 int (*setnorm())();
399 399 int (*setnorm())();
400 400 int (*setnumb())();
401 401 #ifndef PRESUNEUC
402 402 int (*wdwc)(wchar_t); /* tells kind of word character */
403 403 int (*wdbdg)(wchar_t, wchar_t, int); /* tells word binding force */
404 404 wchar_t *(*wddlm)(wchar_t, wchar_t, int); /* tells desired delimiter */
405 405 wchar_t (*mcfllr)(void); /* tells multicolumn filler character */
406 406 #endif /* PRESUNEUC */
407 407 line *address();
408 408 unsigned char *cgoto();
409 409 unsigned char *genindent();
410 410 unsigned char *getblock();
411 411 char *getenv();
412 412 line *getmark();
413 413 unsigned char *mesg();
414 414 unsigned char *place();
415 415 unsigned char *plural();
416 416 line *scanfor();
417 417 void setin(line *);
418 418 unsigned char *strend();
419 419 unsigned char *tailpath();
420 420 char *tgetstr();
421 421 char *tgoto();
422 422 char *ttyname();
423 423 line *vback();
424 424 unsigned char *vfindcol();
425 425 unsigned char *vgetline();
426 426 unsigned char *vinit();
427 427 unsigned char *vpastwh();
428 428 unsigned char *vskipwh();
429 429 int put(void);
430 430 int putreg(unsigned char);
431 431 int YANKreg(int);
432 432 int delete(bool);
|
↓ open down ↓ |
40 lines elided |
↑ open up ↑ |
433 433 int vi_filter();
434 434 int getfile();
435 435 int getsub();
436 436 int gettty();
437 437 int join(int);
438 438 int listchar(wchar_t);
439 439 int normchar(wchar_t);
440 440 int normline(void);
441 441 int numbline(int);
442 442 var void (*oldquit)();
443 -#ifdef __STDC__
443 +
444 444 void onhup(int);
445 445 void onintr(int);
446 -void onemt(int);
447 446 void oncore(int);
448 447 #ifdef CBREAK
449 448 void vintr(int);
450 449 #endif
451 450 void onsusp(int);
452 451 int putch(char);
453 452 int plodput(char);
454 453 int vputch(char);
455 -#else
456 -void onhup();
457 -void onintr();
458 -void onemt();
459 -void oncore();
460 -#ifdef CBREAK
461 -void vintr();
462 -#endif
463 -void onsusp();
464 -int putch();
465 -int plodput();
466 -int vputch();
467 -#endif /* __STDC__ */
468 454
469 455 void shift(int, int);
470 456 int termchar(wchar_t);
471 457 int vfilter();
472 458 int vshftop();
473 459 int yank(void);
474 460 unsigned char *lastchr();
475 461 unsigned char *nextchr();
476 462 bool putoctal;
477 463
478 464 void error();
479 465 void error0(void);
480 466 void error1(unsigned char *);
481 467 void fixol(void);
482 468 void resetflav(void);
483 469 void serror(unsigned char *, unsigned char *);
484 470 void setflav(void);
485 471 void tailprim(unsigned char *, int, bool);
486 472 void vcontin(bool);
487 473 void squish(void);
488 474 void move1(int, line *);
489 475 void pragged(bool);
490 476 void zop2(int, int);
491 477 void plines(line *, line *, bool);
492 478 void pofix(void);
493 479 void undo(bool);
494 480 void somechange(void);
495 481 void savetag(char *);
496 482 void unsavetag(void);
497 483 void checkjunk(unsigned char);
498 484 void getone(void);
499 485 void rop3(int);
500 486 void rop2(void);
501 487 void putfile(int);
502 488 void wrerror(void);
503 489 void clrstats(void);
504 490 void slobber(int);
505 491 void flush(void);
506 492 void flush1(void);
507 493 void flush2(void);
508 494 void fgoto(void);
509 495 void flusho(void);
510 496 void comprhs(int);
511 497 int dosubcon(bool, line *);
512 498 void ugo(int, int);
513 499 void dosub(void);
514 500 void snote(int, int);
515 501 void cerror(unsigned char *);
516 502 void unterm(void);
517 503 int setend(void);
518 504 void prall(void);
519 505 void propts(void);
520 506 void propt(struct option *);
521 507 void killcnt(int);
522 508 void markpr(line *);
523 509 void merror1(unsigned char *);
524 510 void notempty(void);
525 511 int qcolumn(unsigned char *, unsigned char *);
526 512 void netchange(int);
527 513 void putmk1(line *, int);
528 514 int nqcolumn(unsigned char *, unsigned char *);
529 515 void syserror(int);
530 516 void cleanup(bool);
531 517 void blkio(short, unsigned char *, int (*)());
532 518 void tflush(void);
533 519 short partreg(unsigned char);
534 520 void kshift(void);
535 521 void YANKline(void);
536 522 void rbflush(void);
537 523 void waitfor(void);
538 524 void ovbeg(void);
539 525 void fixzero(void);
540 526 void savevis(void);
541 527 void undvis(void);
542 528 void setwind(void);
543 529 void vok(wchar_t *, int);
544 530 void vsetsiz(int);
545 531 void vinslin(int, int, int);
546 532 void vopenup(int, bool, int);
547 533 void vadjAL(int, int);
548 534 void vup1(void);
549 535 void vmoveitup(int, bool);
550 536 void vscroll(int);
551 537 void vscrap(void);
552 538 void vredraw(int);
553 539 void vdellin(int, int, int);
554 540 void vadjDL(int, int);
555 541 void vsyncCL(void);
556 542 void vsync(int);
557 543 void vsync1(int);
558 544 void vcloseup(int, int);
559 545 void sethard(void);
560 546 void vdirty(int, int);
561 547 void setBUF(unsigned char *);
562 548 void addto(unsigned char *, unsigned char *);
563 549 void macpush();
564 550 void setalarm(void);
565 551 void cancelalarm(void);
566 552 void grabtag(void);
567 553 void prepapp(void);
568 554 void vremote();
569 555 void vsave(void);
570 556 void vzop(bool, int, int);
571 557 void warnf();
572 558 int wordof(unsigned char, unsigned char *);
573 559 void setpk(void);
574 560 void back1(void);
575 561 void vdoappend(unsigned char *);
576 562 void vclrbyte(wchar_t *, int);
577 563 void vclreol(void);
578 564 void vsetcurs(unsigned char *);
579 565 void vigoto(int, int);
580 566 void vcsync(void);
581 567 void vgotoCL(int);
582 568 void vgoto(int, int);
583 569 void vmaktop(int, wchar_t *);
584 570 void vrigid(void);
585 571 void vneedpos(int);
586 572 void vnpins(int);
587 573 void vishft(void);
588 574 void viin(wchar_t);
589 575 void godm(void);
590 576 void enddm(void);
591 577 void goim(void);
592 578 void endim(void);
593 579 void vjumpto(line *, unsigned char *, unsigned char);
594 580 void vup(int, int, bool);
595 581 void vdown(int, int, bool);
596 582 void vcontext(line *, unsigned char);
597 583 void vclean(void);
598 584 void vshow(line *, line*);
599 585 void vreset(bool);
600 586 void vroll(int);
601 587 void vrollR(int);
602 588 void vnline(unsigned char *);
603 589 void noerror();
604 590 void getaline(line);
605 591 void viprintf();
606 592 void gettmode(void);
607 593 void setterm(unsigned char *);
608 594 void draino(void);
609 595 int lfind();
610 596 void source();
611 597 void commands();
612 598 void addmac();
613 599 void vmoveto();
614 600 void vrepaint();
615 601 void getDOT(void);
616 602 void vclear(void);
617 603
618 604 unsigned char *lastchr();
619 605 unsigned char *nextchr();
620 606 bool putoctal;
621 607
622 608 void setdot1(void);
623 609
624 610 #ifdef __cplusplus
625 611 }
626 612 #endif
627 613
628 614 #endif /* _EX_H */
|
↓ open down ↓ |
151 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX