![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xed.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src|
Return to xed.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / apl / src |
1.1 root 1: static char Sccsid[] = "xed.c @(#)xed.c 1.1 10/1/82 Berkeley ";
2: #
3:
4: /*
5: * V7.15 81/09/16 14:22 Fixed bug causing bus errors occasionally
6: * V7.14 81/09/10 21:50 -B dynamically allocated line buffer
7: * V7.13 81/07/25 22:51 added -O and "long" pointers
8: *
9: * Editor
10: *
11: * Major additions beginning 77/04
12: * Conversion to version 7 79/12
13: * Conversion to VAX 80/11
14: *
15: * Purdue University, Engineering Computer Network
16: *
17: * Tgi -- Room 337A
18: * Electrical Engineering Dept
19: * Purdue University
20: * West Lafayette, Indiana
21: * 47907
22: * 317/49-41592
23: */
24:
25: #define XED /* enable powerful stuff */
26: #define V7 /* enable environment stuff for protocol */
27:
28: /*
29: * At the entry to a function (PDP-11) the following sequence
30: * of instructions is executed:
31: * func: jsr r5,csv
32: * csv: mov r5,r0
33: * csv+2: mov sp,r5
34: * If a signal occurs between the first and second, or between the
35: * second and third instructions, r5 will NOT contain a valid
36: * stack address. Hence, when longjmp() attempts to validate
37: * the environment pointer (r5) links, an instruction will be
38: * fetched instead of a valid pointer, and will generally cause
39: * one of "memory fault", "bus error", or "illegal instruction"
40: * resulting in the loss of the editing session.
41: *
42: * Due to this wonderful feature of version 7 ingenuity, I have
43: * reverted to using setexit/reset, since they are simpler and
44: * do not assume that I do not know what I am doing.
45: *
46: * 80/11/10 V7.01 Tgi
47: */
48:
49: #ifndef pdp11
50: #include <setjmp.h>
51: jmp_buf _env_rst;
52: #define setexit() setjmp(_env_rst)
53: #define reset() longjmp(_env_rst,1)
54: #endif
55:
56: #include <sys/types.h>
57: #include <sys/stat.h>
58:
59: /*
60: * Machine-dependent definitions
61: */
62:
63: #ifdef pdp11
64: # define BPB 8 /* bits per byte */
65: # define BPW (BPB*sizeof(int))/* bits per word */
66: # define BPWC 4 /* log2(BPW) */
67: # define BPWM 017 /* mask of BPWC bits */
68: typedef short block;
69: typedef short charac;
70: typedef short filedes;
71: typedef short flag;
72: typedef int (*func)();
73: typedef short linep;
74: #endif
75:
76: #ifdef vax
77: # define BPB 8 /* bits per byte */
78: # define BPW (BPB*sizeof(int))/* bits per word */
79: # define BPWC 5 /* log2(BPW) */
80: # define BPWM 037 /* mask of BPWC bits */
81: typedef long block;
82: typedef int charac;
83: typedef short filedes;
84: typedef char flag;
85: typedef int (*func)();
86: typedef long linep; /* NEW */
87: #endif
88:
89: /*
90: * conditional compilation
91: */
92:
93: #ifdef XED
94: # define AGAIN /* enable "o" "again" command */
95: # define ALLOC 1024 /* line buffer size */
96: # define APLMAP /* enable Apl character mapping */
97: # define DEBUG /* enable "du" command */
98: # define DUMB 0 /* enable command to disable spcl chars */
99: # define EOL /* enable special eol stuff */
100: # define EXTMARK /* extended "k" capability */
101: # define G_VFY /* enable verifying on "g" command */
102: # define HELP "/etc/xed.doc"
103: # ifdef pdp11 /* only needed on 16-bit machines */
104: # define HUGE /* enable "huge" file stuff */
105: # endif
106: # define PAGE /* enable proper line counting on ":" */
107: # define PARENS /* enable "b" suffix to count parentheses */
108: # define PIPE /* enable | command to pipe to process */
109: # define PROMPT ">"
110: # define STRLEN /* enable string-length counting code */
111: # define TABS ((LBSIZE+sizeof(int)-1)/sizeof(int)) /* words for tab stops */
112: # define TTL "XED\tV7.15"
113: /* #define TTL_NL 9 /* location of newline in TTL */
114: # define UNDO /* enable "u"ndo command */
115: # define USE /* enable "@" command */
116: # define XDEL /* enable undelete stuff */
117: # define YINT /* enable special interrupt processing */
118: #endif
119:
120: /*
121: * stuff for EED, instead of XED
122: */
123:
124: #ifndef XED
125: # define HELP "/etc/eed.doc"
126: # define PROMPT "*"
127: # define TTL "EED"
128: #else
129: # define EEDHELP "/etc/eed.doc"
130: # define EEDPROMPT "*"
131: # define EEDTTL "EED"
132: #endif
133:
134: /*
135: * stuff normally enabled
136: */
137:
138: #define CLEAR "\33:\33H\33J\32\14" /* HP-2640A, Lear ADM-3A */
139: #define CMDS "edsav" /* all commands written if exists */
140: #ifndef DUMB
141: # define DUMB 1 /* enable command to disable spcl chars */
142: #endif
143:
144: /*
145: * special stuff, occasionally enabled
146: */
147:
148: #define LOG "/a/tgi/etc/xed.log" /* feature use logging */
149:
150: /*
151: * data #defines
152: */
153:
154: #define BAK 4 /* file.bak - backup() */
155: #define BLKSIZE 512 /* disk block size (bytes) */
156: #define BS1 0100000 /* stty() */
157: #define CBACK 14 /* back-reference: \(blah\)more\1 */
158: #define CBRA 1 /* \( */
159: #define CCHR 2 /* literal character */
160: #define CCL 6 /* character class [x...y] */
161: #define CCOUNT (80-1) /* terminal width */
162: #define CDOL 10 /* ...$ */
163: #define CDOT 4 /* . */
164: #define CEOF 11 /* end of pattern */
165: #define CKET 12 /* \) */
166: #define EOF -1 /* end of file */
167: #define ESIZE 128 /* regular expression size */
168: #define FILE 0 /* no extension - backup() */
169: #define FNSIZE 64 /* max size of pathname to file */
170: #define GBSIZE 256 /* max global command length */
171: #define HUP 3 /* file.hup - backup() */
172: #define INT 2 /* file.int - backup() */
173: #define LBSIZE 512 /* max line length */
174: #define LMASK 077 /* mask for "locked" file */
175: #define LMODE (MODE&~LMASK) /* mode for "locked" file */
176: #define MODCNT 35 /* default mod count before auto-write */
177: #define MODE 0666 /* mode for normal files */
178: #define NBRA 9 /* number of \( \) pairs */
179: #define NCCL 8 /* not in character class: [^x...y] */
180: #define PAGSIZ 22 /* page size for ":" command */
181: #define READ 0 /* getblock: read function */
182: #define SIGBUS 10 /* Bus error */
183: #define SIGEMT 7 /* EMT trap */
184: #define SIGFPE 8 /* Floating Point Exception */
185: #define SIGHUP 1 /* Hangup signal */
186: #define SIGILL 4 /* Illegal instruction */
187: #define SIGINT 2 /* Interrupt signal */
188: #define SIGIOT 6 /* IOT trap */
189: #define SIGPIP 13 /* Broken pipe for ! stuff */
190: #define SIGQIT 3 /* Quit signal */
191: #define SIGSEGV 11 /* Memory fault */
192: #define SIGSYS 12 /* Bad system call */
193: #define SIGTRC 5 /* Trace/BPT for mail stuff */
194: #define SIGTRM 15 /* Termination */
195: #define STAR 1 /* * */
196: #define TABFILL '\t' /* fill character for tab expansion */
197: #define TMP 1 /* file.edt - backup() */
198: #define TRM 5 /* file.trm - backup() */
199: #define TTSIZE (512+4) /* terminal output buffer size */
200: #define WRITE 1 /* getblock: write function */
201: #define ever (;;)
202:
203: #define error errfunc
204: #define ctrl(x) ((x)&037)
205:
206: #ifdef AGAIN
207: char agbuf[GBSIZE], /* save area for "again" command */
208: *agp = 0; /* "again" command pointer */
209: flag agf = 0; /* "again" flag (executing the command) */
210: #endif
211:
212: #ifdef ALLOC
213: int lbsize = LBSIZE;/* line buffer size */
214: #endif
215:
216: #ifdef APLMAP
217: flag aplmap = 0; /* Apl character mapping */
218: #include "aplmap.h" /* apl ADM-3A char set mapping tables */
219: #endif
220:
221: #ifdef CKPT
222: char *cfname = "/tmp/ce00000";/* filename for checkpoint */
223: int recovry = 0, /* non-zero to recover checkpointed session */
224: tfnum; /* index into tfname for "00000" string */
225: #endif
226:
227: #ifdef CLEAR
228: char *clears = CLEAR;/* screen-clear sequence */
229: flag zflg = 0; /* if "stty bs1" not set */
230: /* bs1 displays ctrl-z as ^Z on tty */
231: #endif
232:
233: #ifdef CMDS
234: filedes cmd = 0; /* file des for command-save file */
235: char cmdfil[] = CMDS;/* command-save file */
236: #endif
237:
238: #ifdef DEBUG
239: flag tflg = 0; /* tracing flag */
240: #endif
241:
242: #ifdef DUMB
243: flag dumbf = DUMB; /* 1 = disable special chars in patterns */
244: #endif
245:
246: #ifdef EOL
247: charac eol = 0; /* "end-of-line" char for multiple commands */
248: /* per line */
249: flag prompt3 = 1; /* disable prompts for "eol" stuff */
250: #endif
251:
252: #ifdef G_VFY
253: flag gaskf = 0; /* verify mode on global command */
254: #endif
255:
256: #ifdef HELP
257: filedes doc = 0; /* "help" file descriptor */
258: char *help = HELP; /* "help" file name */
259: #endif
260:
261: #ifdef LOG
262: char logfile[]= LOG; /* logging use of features */
263: filedes lfile = 0; /* logging file descriptor */
264: short logamp; /* since s/x/&/ may be done many times */
265: struct logstat {
266: short l_uid; /* user id of caller */
267: char l_xed, /* 1 if xed, 0 if eed, 2 if apled */
268: l_inter; /* 1 if interactive */
269: /* command features */
270: short lc_shell, /* ! */
271: lc_pipe, /* | */
272: lc_piplus, /* |+ */
273: lc_piminus, /* |- */
274: lc_dpipe, /* || */
275: lc_pfrom, /* |< */
276: lc_pto, /* |> */
277: lc_at, /* @ */
278: lc_colon, /* : */
279: lc_star, /* * */
280: lc_clnminus, /* :- */
281: lc_comment, /* : stuff or * stuff */
282: lc_append, /* a */
283: lc_abort, /* abort */
284: lc_aspace, /* a line */
285: lc_aslash, /* a/string/ */
286: lc_browse, /* bN */
287: lc_change, /* c */
288: lc_cslash, /* c/s1/s2/ */
289: lc_copy, /* coNN */
290: lc_delete, /* d */
291: lc_depth, /* d=NN */
292: lc_directory, /* d path */
293: lc_edit, /* e file */
294: lc_eol, /* e=C */
295: lc_errmsg, /* eNN */
296: lc_exp, /* exp */
297: lc_eplus, /* e+ */
298: lc_eminus, /* e- */
299: lc_fshow, /* f */
300: lc_fset, /* f file */
301: lc_fillset, /* f=C */
302: lc_global, /* g/str/cmd */
303: lc_gvfy, /* g/str/vcmd */
304: lc_header, /* h */
305: lc_help, /* help */
306: lc_insert, /* i */
307: lc_islash, /* i/string/ */
308: lc_join, /* j */
309: lc_jglue, /* j/glue/ */
310: lc_klist, /* k */
311: lc_kset, /* kC */
312: lc_list, /* l */
313: lc_move, /* mNN */
314: lc_moove, /* moNN */
315: lc_magic, /* m */
316: lc_numbers, /* n */
317: lc_numinus, /* n- */
318: lc_numplus, /* n+ */
319: lc_o, /* o ^Q */
320: lc_print, /* p */
321: lc_pprint, /* pp */
322: lc_quit, /* q */
323: lc_qimm, /* qi */
324: lc_quote, /* q=C */
325: lc_read, /* r */
326: lc_substitute, /* s/s1/s2/ */
327: lc_stop, /* s */
328: lc_savecount, /* saNN */
329: lc_tablist, /* t */
330: lc_tabset, /* t,NN */
331: lc_tabchar, /* t=C */
332: lc_transfer, /* tNN */
333: lc_undo, /* u */
334: lc_vglobal, /* v/str/cmd */
335: lc_write, /* w */
336: lc_wonto, /* w> */
337: lc_wimm, /* wi */
338: lc_width, /* w=NN */
339: lc_xundelete, /* x */
340: lc_yintr, /* y */
341: lc_yminus, /* y- */
342: lc_yplus, /* y+ */
343: /* address features */
344: la_dot, /* . */
345: la_dotdot, /* .. */
346: la_dol, /* $ */
347: la_num, /* NN */
348: la_plus, /* + */
349: la_minus, /* - */
350: la_caret, /* ^ */
351: la_quote, /* 'a */
352: la_letter, /* A */
353: la_slash, /* /str/ */
354: la_query, /* ?str? */
355: la_equal, /* = */
356: /* pattern features */
357: lp_caret, /* ^ */
358: lp_dol, /* $ */
359: lp_dot, /* . */
360: lp_star, /* * */
361: lp_ccl, /* [ ] */
362: lp_nccl, /* [^ ] */
363: lp_paren, /* \( \) */
364: lp_digit, /* \1 \2 \3 ... */
365: /* substitution features */
366: lp_amp, /* & */
367: /* miscellaneous features */
368: lm_quote, /* ...q */
369: lm_bracket, /* ...b */
370: lm_overwrite; /* -O,wi */
371: /* resources */
372: long lt_start, /* starting time */
373: lt_end, /* elapsed time */
374: lt_usercpu, /* user cpu time */
375: lt_syscpu, /* system cpu time */
376: lt_kidscpu, /* total ! kids time */
377: lt_rlines, /* total lines read */
378: lt_wlines; /* total lines written */
379: } logstats;
380: #endif
381:
382: #ifdef PAGE
383: int ccount = CCOUNT;/* terminal width */
384: #endif
385:
386: #ifdef PARENS
387: int parenc[3] = {0, 0, 0};/* parentheses counts */
388: flag parenf = 0; /* count parentheses and brackets */
389: #endif
390:
391: #ifdef PIPE
392: filedes pfile = 0; /* "pipe" file descriptor */
393: char *pfname = "/tmp/ep00000";/* for "double-piping" */
394: flag piperr = 0, /* pipe error flag - shell() */
395: pno = -1, /* piping line numbering flag (default n-) */
396: strict = 1; /* strict exit status checking for | */
397: #endif
398:
399: #ifdef STRLEN
400: charac quotec = '\0', /* quote character other than " or ' */
401: quotec2 = '\0'; /* closing quote */
402: int quotef = 0; /* length of strings within " or ' chars */
403: #endif
404:
405: #ifdef TABS
406: charac tabfill = TABFILL,/* fill character */
407: tabc = 0; /* tab character - if 0 no tab processing */
408: int maxtab = -1, /* last column number with tab stop */
409: tabs[TABS]; /* each bit on = tab stop */
410: #endif
411:
412: #ifdef UNDO
413: linep undo_oldp, /* original line pointer */
414: undo_newp; /* replacement line */
415: #endif
416:
417: #ifdef USE
418: filedes alt = 0; /* alternate command input file */
419: char altfile[FNSIZE];
420: flag eflg2 = 0; /* another kludge */
421: #endif
422:
423: #ifdef XDEL
424: linep deleted = 0; /* pointer to deleted line pointers */
425: int ndeleted = 0; /* number of lines */
426: #endif
427:
428: #ifdef YINT
429: flag yflg = 0; /* page upon interrupt */
430: linep *yplus = 0; /* page from this line - if zero, from dot */
431: #endif
432:
433: /*
434: * globals
435: */
436:
437: block iblock = -1, /* block number of input buffer */
438: oblock = -1; /* output buffer block number */
439:
440: char *braelist[NBRA], /* bracket \( \) end list */
441: *braslist[NBRA], /* bracket \( \) start list */
442: dotbak[] = ".bak",
443: dotedt[] = ".edt", /* "file saved" file */
444: dothup[] = ".hup",
445: dotint[] = ".int",
446: dottrm[] = ".trm",
447: *dots[] = { dothup, dottrm, dotedt, dotint, 0 },
448: expbuf[ESIZE + 4], /* expression buffer */
449: file[FNSIZE], /* filename buffer */
450: #ifndef ALLOC
451: genbuf[LBSIZE], /* generated line buffer */
452: #else
453: *genbuf, /* generated line buffer pointer */
454: #endif
455: ibuff[BLKSIZE], /* input tmpfile buffer */
456: line[TTSIZE + 4], /* terminal output buffer */
457: #ifndef ALLOC
458: linebuf[LBSIZE], /* line buffer for getline()/putline() */
459: #else
460: *linebuf, /* line buffer for getline()/putline() */
461: #endif
462: no[] = "no ",
463: null[] = "", /* "" */
464: obuff[BLKSIZE], /* output tmpfile buffer */
465: off[] = "off",
466: on[] = "on",
467: prcntu[] = "%u\n", /* %u */
468: quote_s[] = "s", /* "s" */
469: rhsbuf[LBSIZE / 2], /* right-hand-side expression buffer */
470: savedfile[FNSIZE], /* saved filename */
471: tempfile[FNSIZE], /* scratch area for filename */
472:
473: *editor, /* argv[0] */
474: *e_prompt = PROMPT,/* editor command prompt */
475: *fmtlno = "%7u=",/* format for line-number output */
476: *globp, /* global command pointer */
477: *linp = line, /* line pointer */
478: *linebp,
479: *loc1, /* start pointer of & string */
480: *loc2, /* end pointer of & string */
481: *locs,
482: *nextip,
483: *overfile, /* filename mode was changed on */
484: *tfname = "/tmp/e00000",/* "buffer" name */
485: *ver = TTL; /* ID message */
486:
487: charac lastc = 0, /* peekc set to lastc on interrupt */
488: peekc = 0; /* one character pushback */
489:
490: int brcount = 1, /* number of lines to output on "newline" */
491: col = 0, /* column counter for calculating line wraps */
492: line_num, /* integer for line number on output */
493: modcount = MODCNT,/* number of mods before auto-write */
494: overmode, /* mode of overridden file */
495: mods = 0, /* number of mods */
496: nbra = 0, /* count of currently defined \( \) pairs */
497: ninbuf, /* bytes in tmpfile input buffer */
498: nleft, /* bytes remaining in tmpfile output buffer */
499: num_reads = 0, /* indicator to aid text_modified-- */
500: /* first read isn't really a modify */
501: pcount = PAGSIZ-1,/* number of lines to display on ":" command */
502: s_cnt = 0, /* counter for "s/str1/str2/nn" */
503: s_tmp = 0, /* scratch var for same */
504: savf, /* counter for auto-write stuff */
505: text_modified = 0;/* flag--on if text was modified */
506:
507: filedes fout = 1, /* putchar() writes on this fildes */
508: io = 0, /* file descriptor for "r", "w", "e" */
509: tfile = -1; /* file des for "buffer" */
510:
511: flag aflg = 0, /* "apl mode" flag */
512: appflg = 0, /* append flag (if "w>file") */
513: badf = 0, /* bad read on temp file */
514: bflg = 0, /* "back-up" flag -- Generate back-up file */
515: bflg2 = 0, /* Secondary "back-up" flag */
516: circfl, /* reg expr started with ^ */
517: curt = 0, /* short error messages -- ie: '?' */
518: deltflg = 0, /* don't delete .edt file upon exit */
519: eflg = 0, /* echo input flag */
520: eof = 0, /* eof was last char typed */
521: fflg = 0, /* "create" flag */
522: globf2 = 0, /* kludge for -f */
523: #ifdef HUGE
524: hugef = 0, /* -h is process huge file */
525: hugef2 = 0, /* getblock() conversion to huge */
526: #endif
527: hupflag = 0, /* hangup signal has been caught */
528: ichanged, /* ibuf has been changed */
529: iflg = 0, /* file.int and exit on interrupt */
530: immflg = 0, /* immediate flag -- q and e */
531: io_w = 0, /* writing in progress */
532: listf = 0, /* list control chars explicitly */
533: noshell = 0, /* true if no ! command allowed */
534: over = 0, /* override permissions on write if possible */
535: pflag, /* print line after doing command */
536: pipef = 0, /* for talking to pipes */
537: prompt1 = 1, /* flag--enable or disable line-num prompts */
538: prompt2 = 1, /* flag--enable or disable ALL prompting */
539: reading = 0, /* waiting on tty read */
540: seekf = 0, /* no seek to EOF on error on fd 0 */
541: termflg = 0; /* if termination signal (15) occurred */
542:
543: linep *addr1, /* lower line bound */
544: *addr2, /* upper line bound */
545: *dol, /* last line in file */
546: *dot, /* "current" line */
547: *dotdot, /* last different "dot" */
548: *endcore, /* current end of memory */
549: *fendcore, /* start of dynamic area */
550: *lastdot, /* last "dot" */
551: names['z' - 'a' + 1], /* "k" command markers */
552: #ifdef EXTMARK
553: names2['z' - 'a' + 1], /* "k" command markers */
554: #endif
555: *old_a1, /* previous address bounds */
556: *old_a2,
557: tline, /* pointer to next available pos in tmpfile */
558: *zero; /* anchor line for all other lines */
559:
560: /*
561: * magic constants used in many places
562: */
563:
564: #ifdef pdp11
565: # define _1a ~0377
566: # define _2a 0400
567: # define _3a 0377
568: # define _4a 0774
569: # define _5a 255
570: # define _6a 077776
571: # define _1b ~0177
572: # define _2b 0200
573: # define _3b 0777
574: # define _4b 0774
575: # define _5b 511
576: # define _6b 077777
577: #endif
578:
579: #ifdef vax
580: # define _1a ~0377
581: # define _2a 0400
582: # define _3a 077777777
583: # define _4a 0774
584: # define _5a 65535
585: # define _6a 077777776
586: #endif
587:
588: #ifdef HUGE
589: int _1[] = { _1a, _1b }, /* tl &= _1; getline() */
590: _2[] = { _2a, _2b }, /* tl += _2; getline()... */
591: _3[] = { _3a, _3b }, /* bno = ... & _3; getblock() */
592: _4[] = { _4a, _4b }, /* off = ... & _4; getblock() */
593: _5[] = { _5a, _5b }, /* if (bno >= _5)... getblock() */
594: _6[] = { _6a, _6b }; /* tline += ... & _6; */
595: #else
596: # define _1 _1a
597: # define _2 _2a
598: # define _3 _3a
599: # define _4 _4a
600: # define _5 _5a
601: # define _6 _6a
602: #endif
603:
604: /*
605: * error messages
606: *
607: * (there are more than these)
608: */
609:
610: char *errtext[] = {
611: /* 0 */ "syntax is k[a-z]",
612: /* 1 */ "illegal command format",
613: /* 2 */ "no command",
614: /* 3 */ "no tab character",
615: /* 4 */ "can't change filename",
616: /* 5 */ "file name syntax",
617: /* 6 */ "recursive \"@\" command",
618: /* 7 */ "null file name illegal",
619: /* 8 */ "unrecognized command",
620: /* 9 */ "no tabs set",
621: /* 10 */ "global command not allowed with huge file",
622: /* 11 */ "file name too long",
623: /* 12 */ "expanded line too long",
624: /* 13 */ "no such line",
625: /* 14 */ "can't fork",
626: /* 15 */ "can't write to process",
627: /* 16 */ "no lines",
628: /* 17 */ "backup(FILE) error (?)",
629: /* 18 */ "string not found",
630: /* 19 */ " ' must be followed by [a-z]",
631: /* 20 */ "address syntax error",
632: /* 21 */ "lower address bound > upper one",
633: /* 22 */ "address illegal here",
634: /* 23 */ "non-existent line number",
635: /* 24 */ "bottom of file reached",
636: /* 25 */ "command syntax error",
637: /* 26 */ "\"advance\" error (?)",
638: /* 27 */ "null string illegal",
639: /* 28 */ "destination not found",
640: /* 29 */ "INTERRUPT!",
641: /* 30 */ "line too long",
642: /* 31 */ "missing destination address",
643: /* 32 */ "I/O error--file not saved!",
644: /* 33 */ "file overflows available memory",
645: /* 34 */ "file too large (TMPERR)",
646: /* 35 */ "I/O error on temp file (TMPERR)",
647: /* 36 */ "open error on temp file (TMPERR)",
648: /* 37 */ "recursive global command",
649: /* 38 */ "global command list too long",
650: /* 39 */ "substitute pattern not found",
651: /* 40 */ "missing substring",
652: /* 41 */ "string2 too long",
653: /* 42 */ "substring too long",
654: /* 43 */ "substituted string too long",
655: /* 44 */ "too many \\(",
656: /* 45 */ "unbalanced \\( \\)",
657: /* 46 */ "\\n illegal",
658: /* 47 */ "unimplemented feature",
659: /* 48 */ "[nothing written]",
660: /* 49 */ "pattern too complicated",
661: /* 50 */ "can't create temp file (TMPERR)",
662: /* 51 */ "bad directory",
663: /* 52 */ "no ! allowed",
664: /* 53 */ "can't read ",
665: /* 54 */ "can't create ",
666: /* 55 */ "%u line%s\n",
667: /* 56 */ "[file saved]",
668: /* 57 */ "\nHangup!\n",
669: /* 58 */ "\nTerminated...\n",
670: /* 59 */ "EOF illegal here",
671: /* 60 */ "can't join to line 0",
672: /* 61 */ "! not allowed with global command",
673: /* 62 */ "no filename specified",
674: /* 63 */ "not enough \\( \\) pairs",
675: /* 64 */ "can't create pipe file (PIPERR)",
676: /* 65 */ "open error on pipe file (PIPERR)",
677: /* 66 */ "can't checkpoint",
678: /* 67 */ "can't recover",
679: };
680: #define NERR (sizeof errtext / sizeof errtext[0])
681:
682: /*
683: * ! error strings
684: */
685:
686: char *status[] = {
687: /* 0 */ 0,
688: /* 1 */ "hangup",
689: /* 2 */ "interrupt",
690: /* 3 */ "quit",
691: /* 4 */ "illegal instruction",
692: /* 5 */ "bpt",
693: /* 6 */ "iot",
694: /* 7 */ "emt",
695: /* 8 */ "fpp",
696: /* 9 */ "killed",
697: /* 10 */ "bus error",
698: /* 11 */ "memory fault",
699: /* 12 */ "bad sys call",
700: /* 13 */ "broken pipe",
701: /* 14 */ "alarm",
702: /* 15 */ "terminated",
703: #ifdef pdp11
704: /* 16 */ "time limit",
705: #else
706: /* 16 */ 0,
707: /* 17 */ "stopped",
708: /* 18 */ "terminal stop",
709: /* 19 */ "continue",
710: /* 20 */ "child status changed",
711: /* 21 */ "terminal input",
712: /* 22 */ "terminal output",
713: /* 23 */ "terminal input ready",
714: /* 24 */ "cpu timelimit exceeded",
715: /* 25 */ "filesize limit exceeded",
716: #endif
717: };
718: #define NSTR (sizeof status / sizeof status[0])
719:
720: #define putsn(x) (puts2((x)),putchar('\n'))
721: #define min(x,y) ((x)<(y)?(x):(y))
722: #define max(x,y) ((x)>(y)?(x):(y))
723:
724: /*
725: * function declarations
726: */
727:
728: linep *findmark();
729: char *getblock();
730: long lseek();
731: func signal();
732: #ifndef CKPT
733: int badsig(),
734: #else
735: int checkpoint(),
736: #endif
737: hangup(),
738: mail(),
739: onintr(),
740: term();
741:
742: /*
743: * signals
744: */
745:
746: struct sigtab {
747: int s_sig,
748: s_func;
749: } sigtab1[] = {
750: #ifdef CKPT
751: SIGILL, checkpoint,
752: SIGIOT, checkpoint,
753: SIGEMT, checkpoint,
754: SIGFPE, checkpoint,
755: SIGBUS, checkpoint,
756: SIGSEGV, checkpoint,
757: SIGSYS, checkpoint,
758: #else
759: SIGILL, badsig,
760: SIGIOT, badsig,
761: SIGEMT, badsig,
762: SIGFPE, badsig,
763: SIGBUS, badsig,
764: SIGSEGV, badsig,
765: SIGSYS, badsig,
766: #endif
767: 0, 0,
768: }, sigtab2[] = {
769: SIGTRC, mail,
770: SIGHUP, hangup,
771: SIGTRM, term,
772: SIGINT, onintr,
773: 0, 0,
774: };
775:
776: main(argc, argv)
777: char **argv;
778: {
779: #ifdef CKPT
780: extern checkpoint();
781: #else
782: extern badsig();
783: #endif
784: extern onintr(), hangup(), mail(), term();
785: #ifdef DEBUG
786: #ifdef EXPDMP
787: extern expdmp();
788: #endif
789: #endif
790: register n;
791: register char *p1, *p2, *ep;
792: func savint;
793:
794: signal(SIGQIT, 1);
795: savint = signal(SIGINT, 1);
796: ep = *argv;
797: #ifdef XED
798: p1 = ep;
799: p2 = p1;
800: while (*p1)
801: if (*p1++ == '/' && *p1 && *p1 != '/')
802: p2 = p1;
803: p1 = p2;
804: *argv = p2;
805: n = 0;
806: while (*p1)
807: if (*p1++ == 'x') { /* xed .vs. eed */
808: ++n;
809: break;
810: }
811: if (n == 0) {
812: e_prompt = EEDPROMPT;
813: ver = EEDTTL;
814: help = EEDHELP;
815: dumbf = 1;
816: }
817: #ifdef LOG
818: logstats.l_xed = n;
819: #endif
820: #endif
821: prompt2 = istty(0);
822: #ifdef V7
823: if (getenv("_OVERWRITE_"))
824: ++over;
825: #endif
826: while (--argc)
827: if (**++argv == '-') {
828: while (*++*argv) {
829: switch (**argv) {
830: case '!': /* no ! allowed */
831: noshell = 1;
832: break;
833: #ifdef APLMAP
834: case 'A': /* apl char mapping */
835: aplmap = 1;
836: errtext[29] = "G interrupt G";
837: p1 = ver;
838: while (*p1) {
839: if ('A' <= *p1 && *p1 <= 'Z')
840: *p1 |= 040;
841: ++p1;
842: }
843: #endif
844: case 'a': /* apl mode */
845: aflg = 1;
846: fmtlno = "[ %u ]\t";
847: #ifdef DUMB
848: dumbf = 1;
849: #endif
850: #ifdef XED
851: #ifdef TTL_NL
852: ver[TTL_NL] = 0;
853: #endif
854: #endif
855: break;
856: case 'b': /* file.bak on entry */
857: bflg = 1;
858: bflg2 = 1;
859: break;
860: #ifdef PAGE
861: case 'c': /* crt depth in lines */
862: ++*argv;
863: n = argnum(argv);
864: if (n >= 0)
865: pcount = n;
866: break;
867: #endif
868: case 'd': /* don't delete .edt file */
869: deltflg = 1;
870: break;
871: case 'e': /* echo input commands */
872: eflg = 1;
873: break;
874: case 'f': /* create mode */
875: fflg = 1;
876: break;
877: #ifdef HUGE
878: case 'h': /* edit "huge" file */
879: hugef = 1;
880: break;
881: #endif
882: case 'i': /* file.int on interrupt */
883: iflg = 1;
884: break;
885: case 'k': /* kill verbose messages */
886: curt = 1;
887: break;
888: #ifdef EOL
889: case 'l': /* set eol char to "x" */
890: if (*++*argv)
891: eol = **argv;
892: else
893: --*argv;
894: break;
895: #endif
896: case 'm': /* mod cnt for autosave */
897: ++*argv;
898: n = argnum(argv);
899: if (n >= 0)
900: modcount = n;
901: break;
902: case 'n': /* no line num */
903: prompt1 = 0;
904: break;
905: case 'o': /* no seek to EOF on error */
906: seekf = 1;
907: break;
908: case 'p': /* force prompts for pipe */
909: pipef = 1;
910: prompt2 = 1;
911: break;
912: case 'q': /* don't inhibit quits */
913: signal(SIGQIT, 0);
914: break;
915: #ifdef DUMB
916: case 'r': /* spcl char meaning */
917: dumbf ^= 01;
918: break;
919: #endif
920: case 's': /* silent mode */
921: prompt2 = 0;
922: break;
923: #ifdef TABS
924: case 't': /* tab char */
925: if (*++*argv)
926: tabc = **argv;
927: else
928: --*argv;
929: break;
930: #endif
931: #ifdef TABS
932: case 'v': /* tab fill char */
933: if (*++*argv)
934: tabfill = **argv;
935: else
936: --*argv;
937: break;
938: #endif
939: #ifdef PAGE
940: case 'w': /* crt width */
941: ++*argv;
942: n = argnum(argv);
943: if (--n >= 2)
944: ccount = n;
945: break;
946: #endif
947: #ifdef YINT
948: case 'y': /* page on interrupt */
949: yflg = 1;
950: break;
951: #endif
952: #ifdef USE
953: case '@': /* set "@" filename */
954: p2 = altfile;
955: p1 = ++*argv;
956: while (*p1 && p2 < &altfile[FNSIZE - 2])
957: *p2++ = *p1++;
958: if (*p1) {
959: p2 = altfile;
960: putsn(errtext[11]);
961: }
962: *p2 = '\0';
963: *argv = &p1[-1];
964: break;
965: #endif
966: #ifdef ALLOC
967: case 'B': /* line buffer size */
968: ++*argv;
969: n = argnum(argv);
970: if (n >= LBSIZE)
971: lbsize = n;
972: break;
973: #endif
974: #ifdef DEBUG
975: case 'D': /* trace mode -- debug */
976: tflg = 1;
977: break;
978: #ifdef EXPDMP
979: case 'Q': /* show pattern on quit */
980: signal(SIGQIT, expdmp);
981: break;
982: #endif
983: #endif
984: #ifdef XED
985: case 'I': /* suppress ID message */
986: ver = 0;
987: break;
988: case 'P': /* prompt */
989: p1 = *argv;
990: e_prompt = ++p1;
991: while (*p1++);
992: *argv = &p1[-2];
993: break;
994: case 'L': /* line number prompt */
995: p1 = *argv;
996: fmtlno = ++p1;
997: while (*p1++);
998: *argv = &p1[-2];
999: break;
1000: case 'C': /* screen-clear */
1001: p1 = *argv;
1002: clears = ++p1;
1003: while (*p1++);
1004: *argv = &p1[-2];
1005: break;
1006: #ifdef CKPT
1007: case 'R': /* recover */
1008: ++*argv;
1009: if ((recovry = argnum(argv)) == 0)
1010: recovry = 1;
1011: break;
1012: #endif
1013: case 'O': /* over-ride write perm */
1014: over ^= 01;
1015: break;
1016: case 'T': /* temp filename */
1017: p1 = *argv;
1018: tfname = ++p1;
1019: #ifdef PIPE
1020: while (*p1)
1021: if (*p1++ == ':') {
1022: p1[-1] = '\0';
1023: pfname = p1;
1024: #ifdef CKPT
1025: break;
1026: #endif
1027: }
1028: #endif
1029: #ifdef CKPT
1030: while (*p1)
1031: if (*p1++ == ':') {
1032: p1[-1] = '\0';
1033: cfname = p1;
1034: }
1035: #endif
1036: *argv = &p1[-1];
1037: break;
1038: #endif
1039: default: /* tabs stops/illegals */
1040: if (!**argv || **argv == '-'
1041: #ifdef TABS
1042: || **argv == ','
1043: #endif
1044: )
1045: break;
1046: #ifdef TABS
1047: if (**argv < '0' ||
1048: **argv > '9') {
1049: #endif
1050: printf("bad flag: -%c\n",
1051: **argv);
1052: exit(1);
1053: #ifdef TABS
1054: }
1055: n = argnum(argv);
1056: settab(n);
1057: #endif
1058: }
1059: }
1060: } else {
1061: p1 = *argv;
1062: p2 = savedfile;
1063: while (*p2++ = *p1++)
1064: if (p2 >= &savedfile[FNSIZE - 2]) {
1065: putsn(errtext[11]);
1066: exit(1);
1067: }
1068: globf2 = 1;
1069: if (fflg)
1070: globp = "a\n";
1071: else
1072: globp = "r\n";
1073: }
1074:
1075:
1076: #ifdef YINT
1077: if (iflg)
1078: yflg = 0;
1079: #endif
1080: #ifdef ALLOC
1081: linebuf = sbrk(lbsize);
1082: genbuf = sbrk(lbsize);
1083: #endif
1084: fendcore = sbrk(0);
1085: #ifdef CKPT
1086: if ((n = recovry) == 0)
1087: #endif
1088: n = getpid();
1089: #ifdef PIPE
1090: tmpname(pfname, n);
1091: #endif
1092: #ifdef CKPT
1093: tmpname(cfname, n);
1094: #endif
1095: tmpname(tfname, n); /* MUST be last call to tmpname */
1096: #ifdef LOG
1097: logstats.l_uid = getuid();
1098: time(&logstats.lt_start);
1099: if (prompt2)
1100: ++logstats.l_inter;
1101: if (aflg)
1102: logstats.l_xed = 2; /* magic num for apled */
1103: #endif
1104: #ifdef CKPT
1105: if (recovry)
1106: recover();
1107: #endif
1108: editor = ep;
1109: if (prompt2) {
1110: #ifdef CMDS
1111: if ((cmd = open(cmdfil, 1)) > 0)
1112: lseek(cmd, 0L, 2);
1113: else
1114: cmd = 0;
1115: #endif
1116: if (ver)
1117: putsn(ver); /* XED V0.00 ... */
1118: flush_buf();
1119: } else
1120: modcount = 0;
1121: #ifdef CMDS
1122: if (cmd && *savedfile) {
1123: write(cmd, "e,", 2);
1124: p1 = savedfile;
1125: while (*p1++);
1126: write(cmd, savedfile, --p1 - savedfile);
1127: write(cmd, "\n", 1);
1128: }
1129: #endif
1130: signals(sigtab1);
1131: setexit();
1132: if (((int)savint & 01) == 0)
1133: signals(sigtab2);
1134: #ifdef YINT
1135: else
1136: yflg = 0;
1137: #endif
1138: #ifdef CKPT
1139: if (!recovry)
1140: #endif
1141: init();
1142: setexit();
1143: cant: do {
1144: commands(0);
1145: } while (are_you_sure());
1146: if (immflg == 0) {
1147: if (fflg)
1148: if (backup(FILE))
1149: text_modified = 0;
1150: else
1151: goto cant;
1152: if (text_modified == 0)
1153: backup(-TMP);
1154: else if (modcount && eof)
1155: if (backup(TMP) && prompt2)
1156: if (!curt)
1157: putsn(errtext[56]);
1158: }
1159: delexit(0);
1160: }
1161:
1162: abort() {
1163: register char *p;
1164: register charac c;
1165:
1166: setnoaddr();
1167: peekc = 0;
1168: p = "ort\n";
1169: while (*p)
1170: if ((c = getchar()) != *p++) {
1171: peekc = c;
1172: errmsg(25);
1173: }
1174: #ifdef LOG
1175: ++logstats.lc_abort;
1176: #endif
1177: delexit(1);
1178: }
1179:
1180: linep *
1181: address() {
1182: register minus;
1183: register charac c;
1184: register linep *a1, *start;
1185: register n, relerr;
1186:
1187: minus = 0;
1188: a1 = 0;
1189: for ever {
1190: c = getchar();
1191: if ('0' <= c && c <= '9') {
1192: peekc = c;
1193: n = getnum();
1194: if (a1 == 0) {
1195: a1 = zero;
1196: n += aflg;
1197: #ifdef LOG
1198: if (!globp)
1199: ++logstats.la_num;
1200: #endif
1201: }
1202: if (minus < 0)
1203: n = -n;
1204: a1 += n;
1205: minus = 0;
1206: continue;
1207: }
1208: relerr = 0;
1209: if (a1 || minus)
1210: relerr++;
1211: switch (c) {
1212: case ' ':
1213: case '\t':
1214: continue;
1215:
1216: case '+':
1217: minus += brcount;
1218: if (a1 == 0)
1219: a1 = dot;
1220: #ifdef LOG
1221: if (!globp)
1222: ++logstats.la_plus;
1223: #endif
1224: continue;
1225:
1226: case '-':
1227: case '^': /* for upwards compatibility */
1228: minus -= brcount;
1229: if (a1 == 0)
1230: a1 = dot;
1231: #ifdef LOG
1232: if (!globp)
1233: if (c == '^')
1234: ++logstats.la_caret;
1235: else
1236: ++logstats.la_minus;
1237: #endif
1238: continue;
1239:
1240: /* search: */
1241: case '?':
1242: minus++;
1243: case '/':
1244: compile(c);
1245: if (a1 == 0)
1246: a1 = dot;
1247: if (a1 < zero)
1248: a1 = zero;
1249: if (a1 > dol)
1250: a1 = dol;
1251: start = a1;
1252: #ifdef LOG
1253: if (!globp)
1254: if (minus)
1255: ++logstats.la_query;
1256: else
1257: ++logstats.la_slash;
1258: #endif
1259: for ever {
1260: if (minus == 0) {
1261: if (++a1 > dol)
1262: a1 = zero;
1263: } else {
1264: if (--a1 < zero)
1265: a1 = dol;
1266: }
1267: if (execute(0, a1)) {
1268: minus = 0;
1269: relerr = 0;
1270: break;
1271: }
1272: if (a1 == start)
1273: errmsg(18);
1274: }
1275: break;
1276:
1277: case '$':
1278: a1 = dol;
1279: #ifdef LOG
1280: if (!globp)
1281: ++logstats.la_dol;
1282: #endif
1283: break;
1284:
1285: case '.':
1286: if ((peekc = getchar()) == '.') {
1287: peekc = 0;
1288: a1 = dotdot;
1289: #ifdef LOG
1290: if (!globp)
1291: ++logstats.la_dotdot;
1292: #endif
1293: } else {
1294: a1 = dot;
1295: #ifdef LOG
1296: if (!globp)
1297: ++logstats.la_dot;
1298: #endif
1299: }
1300: break;
1301:
1302: case '\'':
1303: if (((c = getchar()) | 040) < 'a' ||
1304: (c | 040) > 'z') {
1305: peekc = c;
1306: errmsg(19);
1307: }
1308: c |= 040;
1309: #ifdef LOG
1310: if (!globp)
1311: ++logstats.la_quote;
1312: #endif
1313: casemark:
1314: #ifdef EXTMARK
1315: n = 3;
1316: if ((peekc = getchar()) == '^') {
1317: n = 1;
1318: peekc = 0;
1319: } else if (peekc == '$') {
1320: n = 2;
1321: if (names2[c - 'a'] == 0)
1322: n = 1;
1323: peekc = 0;
1324: }
1325: if (n & 01)
1326: if ((a1=findmark(names[c-'a'],0))==0) {
1327: a1 = dol;
1328: n = 0;
1329: }
1330: if (n > 1 && names2[c - 'a']) {
1331: if (n == 3) {
1332: if (addr1 || addr2)
1333: errmsg(20);
1334: addr1 = a1;
1335: }
1336: a1 = findmark(names2[c - 'a'], dol);
1337: if (n == 2)
1338: break;
1339: addr2 = a1;
1340: return(0);
1341: }
1342: #else
1343: a1 = findmark(names[c - 'a'], dol);
1344: #endif
1345: break;
1346:
1347: case '=':
1348: #ifdef LOG
1349: if (!globp)
1350: ++logstats.la_equal;
1351: #endif
1352: if ((peekc = getchar()) == '^')
1353: a1 = old_a1;
1354: else if (peekc == '$')
1355: a1 = old_a2;
1356: else {
1357: if (addr1 || addr2 || a1)
1358: errmsg(20);
1359: addr1 = old_a1;
1360: addr2 = old_a2;
1361: return(0);
1362: }
1363: peekc = 0;
1364: break;
1365:
1366: default:
1367: if ('A' <= c && c <= 'Z') {
1368: c |= 040;
1369: #ifdef LOG
1370: if (!globp)
1371: ++logstats.la_letter;
1372: #endif
1373: goto casemark;
1374: }
1375: peekc = c;
1376: if (a1 == 0)
1377: if (c == ',' || c == ';')
1378: if (dot + 1 > dol)
1379: return(dol);
1380: else
1381: return(dot + 1);
1382: else
1383: return(0);
1384: a1 += minus;
1385: if (a1 < zero)
1386: a1 = zero + (zero != dol);
1387: else if (a1 > dol)
1388: a1 = dol;
1389: return(a1);
1390: }
1391: if (relerr)
1392: errmsg(20);
1393: }
1394: }
1395:
1396: advance(alp, aep) {
1397: register char *lp, *ep, *curlp;
1398: register s_sav, i;
1399:
1400: lp = alp;
1401: ep = aep;
1402: for ever switch (*ep++) {
1403:
1404: case CCHR:
1405: if (*ep++ == *lp++)
1406: continue;
1407: return(0);
1408:
1409: case CDOT:
1410: if (*lp++)
1411: continue;
1412: return(0);
1413:
1414: case CDOL:
1415: if (*lp == 0)
1416: continue;
1417: return(0);
1418:
1419: case CEOF:
1420: loc2 = lp;
1421: if (--s_tmp > 0)
1422: return(0);
1423: return(1);
1424:
1425: case CCL:
1426: case NCCL:
1427: if (cclass(ep, *lp++, ep[-1] == CCL)) {
1428: ep += *ep;
1429: continue;
1430: }
1431: return(0);
1432:
1433: case CBRA:
1434: braslist[*ep++] = lp;
1435: continue;
1436:
1437: case CKET:
1438: braelist[*ep++] = lp;
1439: continue;
1440:
1441: case CBACK:
1442: if (braelist[i = *ep++] == 0)
1443: errmsg(63);
1444: if (backref(i, lp)) {
1445: lp += braelist[i] - braslist[i];
1446: continue;
1447: }
1448: return(0);
1449:
1450: case CBACK | STAR:
1451: if (braelist[i = *ep++] == 0)
1452: errmsg(63);
1453: curlp = lp;
1454: while (backref(i, lp))
1455: lp += braelist[i] - braslist[i];
1456: while (lp >= curlp) {
1457: if (advance(lp, ep))
1458: return(1);
1459: lp -= braelist[i] - braslist[i];
1460: }
1461: continue;
1462:
1463: case CDOT | STAR:
1464: curlp = lp;
1465: while (*lp++);
1466: goto star;
1467:
1468: case CCHR | STAR:
1469: curlp = lp;
1470: while (*lp++ == *ep);
1471: ep++;
1472: goto star;
1473:
1474: case CCL | STAR:
1475: case NCCL | STAR:
1476: curlp = lp;
1477: while (cclass(ep, *lp++, ep[-1] == (CCL | STAR)));
1478: ep += *ep;
1479: /* goto star; */
1480:
1481: star:
1482: s_sav = s_tmp;
1483: do {
1484: if (--lp == locs)
1485: break;
1486: if (advance(lp, ep))
1487: return(1);
1488: s_tmp = s_sav;
1489: } while (lp > curlp);
1490: --s_tmp;
1491: return(0);
1492:
1493: default:
1494: errmsg(-26);
1495: }
1496: }
1497:
1498: linep *
1499: append(f, a, single, bkpf)
1500: func f;
1501: linep *a;
1502: {
1503: register linep *a1, *a2, *rdot;
1504: register nline, tl;
1505:
1506: nline = 0;
1507: dot = a;
1508: while ((*f)(single) == 0) {
1509: if (dol >= endcore) {
1510: if (sbrk(1024) == -1)
1511: errmsg(33);
1512: endcore = (int)endcore + 1024;
1513: }
1514: tl = putline();
1515: nline++;
1516: a1 = ++dol;
1517: a2 = a1 + 1;
1518: rdot = ++dot;
1519: while (a1 > rdot)
1520: *--a2 = *--a1;
1521: *rdot = tl;
1522: if (bkpf) {
1523: mods++;
1524: backchk();
1525: }
1526: if (single)
1527: break;
1528: }
1529: return(nline);
1530: }
1531:
1532: are_you_sure() {
1533: #ifdef USE
1534: if (alt)
1535: return(1);
1536: #endif
1537: if (!text_modified || fflg || immflg || zero == dol)
1538: return(0);
1539: return(yes_no(curt? "?forget" :
1540: "did you forget to save your text", 1, 1, 0));
1541: }
1542:
1543: argnum(ap)
1544: char **ap;
1545: {
1546: register n;
1547: register char *p;
1548:
1549: p = *ap;
1550: n = 0;
1551: while ('0' <= *p && *p <= '9')
1552: n = n * 10 + *p++ - '0';
1553: *ap = --p;
1554: return(n);
1555: }
1556:
1557: backchk() {
1558: if (modcount == 0)
1559: return;
1560: if (mods >= modcount) {
1561: mods = 0;
1562: #ifdef EOL
1563: if (backup(TMP) && prompt2 && prompt3)
1564: #endif
1565: #ifndef EOL
1566: if (backup(TMP) && prompt2)
1567: #endif
1568: if (!curt)
1569: putsn(errtext[56]);
1570: }
1571: }
1572:
1573: backref(an, alp)
1574: char *alp;
1575: {
1576: register n;
1577: register char *bp, *lp;
1578:
1579: n = an;
1580: bp = braslist[n];
1581: lp = alp;
1582: while (*bp++ == *lp++)
1583: if (bp >= braelist[n])
1584: return(1);
1585: return(0);
1586: }
1587:
1588: backup(af) {
1589: register char *p1, *p2, *t2;
1590: register linep *a1, *a2;
1591: register func savint, savhup;
1592:
1593: if (io) {
1594: putsn("******** backup: I/O in progress");
1595: return(0);
1596: }
1597: flush_buf();
1598: p1 = savedfile;
1599: t2 = p2 = file;
1600: while (*p2 = *p1++)
1601: if (*p2++ == '/')
1602: t2 = p2;
1603: if (p2 > t2 + 10)
1604: p2 = t2 + 10;
1605: if (af != FILE && p2 >= &file[FNSIZE - 6])
1606: errmsg(11);
1607: switch (af < 0? -af : af) {
1608: case FILE: p1 = 0; break;
1609: case TMP: p1 = dotedt; break;
1610: case INT: p1 = dotint; break;
1611: case HUP: p1 = dothup; break;
1612: case BAK: p1 = dotbak; break;
1613: case TRM: p1 = dottrm; break;
1614: default: errmsg(-17);
1615: }
1616: if (p1)
1617: while (*p2++ = *p1++);
1618: if (af < 0) {
1619: if (deltflg)
1620: return(1);
1621: return(!unlink(file));
1622: }
1623: if (dol == zero && !fflg) {
1624: if (af == FILE)
1625: if (curt)
1626: putsn("?48");
1627: else
1628: putsn(errtext[48]);
1629: return(1);
1630: }
1631: if (dol == zero)
1632: return(1);
1633: if (!iflg) {
1634: savhup = signal(SIGHUP, 1);
1635: savint = signal(SIGINT, 1);
1636: }
1637: if (over && af == FILE)
1638: override();
1639: io = create(file, (af == FILE? MODE : LMODE));
1640: if (overfile) {
1641: chmod(overfile, overmode);
1642: overfile = 0;
1643: }
1644: if (io < 0) {
1645: io = 0;
1646: if (af != TMP) {
1647: if (curt)
1648: putsn("?54");
1649: else {
1650: puts2(errtext[54]);
1651: putsn(file);
1652: }
1653: }
1654: if (!iflg) {
1655: signal(SIGHUP, savhup);
1656: signal(SIGINT, savint);
1657: }
1658: return(0);
1659: }
1660: io_w++;
1661: a1 = addr1;
1662: a2 = addr2;
1663: addr1 = zero + 1;
1664: addr2 = dol;
1665: putfile();
1666: close(io);
1667: io = 0;
1668: io_w = 0;
1669: addr1 = a1;
1670: addr2 = a2;
1671: if (!iflg) {
1672: signal(SIGHUP, savhup);
1673: signal(SIGINT, savint);
1674: }
1675: return(1);
1676: }
1677:
1678: #ifndef CKPT
1679: badsig(an) {
1680: register n;
1681:
1682: if (n = backup(TMP))
1683: putsn(errtext[56]);
1684: puts(" Fatal Signal: ");
1685: if (0 < an && an < NSTR && status[an])
1686: putsn(status[an]);
1687: else
1688: printf("%d\n", an);
1689: flush_buf();
1690: if (n)
1691: exit(1);
1692: error();
1693: }
1694: #endif
1695:
1696: blkio(b, buf, iofcn)
1697: func iofcn;
1698: {
1699: lseek(tfile, 512L * b, 0);
1700: if ((*iofcn)(tfile, buf, BLKSIZE) != BLKSIZE) {
1701: badf++;
1702: errmsg(-35);
1703: }
1704: }
1705:
1706: cclass(aset, ac, af)
1707: char *aset;
1708: charac ac;
1709: {
1710: register char *set;
1711: register n;
1712: register charac c, m;
1713:
1714: set = aset;
1715: if ((c = ac) == 0)
1716: return(0);
1717: n = *set++;
1718: while (--n)
1719: if (set[1] == '-' && n > 2) {
1720: c = min(set[0], set[2]);
1721: m = max(set[0], set[2]);
1722: do {
1723: if (c == ac)
1724: return(af);
1725: } while (++c != m);
1726: set += 2;
1727: c = ac;
1728: } else
1729: if (*set++ == c)
1730: return(af);
1731: return(!af);
1732: }
1733:
1734: #ifdef CKPT
1735: checkpoint(asig) {
1736: extern etext;
1737: register filedes f;
1738: register char *p;
1739: register func savint, savqit;
1740: int n;
1741:
1742: savint = signal(SIGINT, 1);
1743: savqit = signal(SIGQIT, 1);
1744: p = &etext; /* won't work for -n, -i, or -z */
1745: n = (char *)dol - p;
1746: n += sizeof (int);
1747: if ((f = create(cfname, LMODE)) < 0 ||
1748: write(f, &n, sizeof n) != sizeof n) {
1749: n = 66;
1750: goto cerror;
1751: }
1752: #ifdef pdp11 /* 16 bit byte count only */
1753: if (n < 0) {
1754: if (write(f, etext, 32256) != 32256) {
1755: n = 66;
1756: goto cerror;
1757: }
1758: n -= 32256; /* 63 blocks, since 64 is < 0 */
1759: p += 32256;
1760: }
1761: #endif
1762: if (write(f, p, n) != n)
1763: n = 66;
1764: else
1765: n = 0;
1766: cerror:
1767: close(f);
1768: if (n) {
1769: signal(SIGINT, savint);
1770: signal(SIGQIT, savqit);
1771: recovry = 0;
1772: errmsg(n);
1773: }
1774: if (asig) {
1775: puts2(status[asig]);
1776: if (!curt)
1777: puts(": Fatal error");
1778: }
1779: if (curt)
1780: puts2("?CKPT ");
1781: else {
1782: puts2("Editing session checkpointed to \"");
1783: puts2(cfname);
1784: puts("\".\nTo recover your work, type:");
1785: if (editor && *editor)
1786: puts2(editor);
1787: else
1788: puts2("edit");
1789: puts2(" -R");
1790: }
1791: puts(&tfname[tfnum]);
1792: exit(1);
1793: }
1794: #endif
1795:
1796: chk() {
1797: register charac c;
1798: register char *p2, *p1, *t2, **p;
1799: register charac oldc;
1800: long t;
1801: struct stat s;
1802:
1803: if (*savedfile == '\0')
1804: return(0);
1805: t2 = p2 = file;
1806: p1 = savedfile;
1807: if (stat(p1, &s) >= 0)
1808: t = s.st_mtime;
1809: else
1810: t = 0L;
1811: while (*p2 = *p1++)
1812: if (*p2++ == '/')
1813: t2 = p2;
1814: if (p2 > t2 + 10)
1815: p2 = t2 + 10;
1816: if (p2 >= &file[FNSIZE - 6])
1817: return(0);
1818: t2 = p2;
1819: p = dots;
1820: while (p1 = *p++) {
1821: p2 = t2;
1822: while (*p2++ = *p1++);
1823: if (stat(file, &s) >= 0 && s.st_mtime >= t) {
1824: if (curt) {
1825: puts2("?\"");
1826: puts2(file);
1827: puts2("\" ");
1828: } else {
1829: putsn("When you were last editing this file");
1830: putsn("you did not exit the editor normally,");
1831: puts2("leaving the file: \"");
1832: puts2(file);
1833: if (p1 == dotedt) {
1834: putsn("\".\nIt contains your file up to the last \"[file saved]\"");
1835: putsn("message. This file will be deleted if you do");
1836: putsn("not read it into the editor now. If you read");
1837: putsn("it, then decide not to use it, exit the editor");
1838: putsn("with \"qi\".");
1839: } else
1840: putsn("\".");
1841: }
1842: return(yes_no(curt? "read" : "Do you wish to read it",
1843: 1, -1, 0));
1844: }
1845: }
1846: return(0);
1847: }
1848:
1849: _cleanup() {
1850: flush_buf();
1851: }
1852:
1853: #ifdef CLEAR
1854: clear() {
1855: register l, i;
1856:
1857: l = listf;
1858: listf = 0;
1859: puts2(clears); /* clear sequence */
1860: flush_buf();
1861: i = 5;
1862: while (--i >= 0)
1863: putchar(0); /* ADM-3A's need padding at 19.2 */
1864: putchar('\n');
1865: listf = l;
1866: }
1867: #endif
1868:
1869: commands(baseflg) {
1870: extern getfile(), gettty();
1871: register linep *a1;
1872: register charac c;
1873: register char *p;
1874: register r, num;
1875:
1876: for ever {
1877: #ifdef AGAIN
1878: if (agp) {
1879: *agp++ = '\n';
1880: *agp = '\0';
1881: }
1882: agf = 0;
1883: agp = 0;
1884: #endif
1885: immflg = 0;
1886: #ifdef LOG
1887: if (logamp) {
1888: ++logstats.lp_amp;
1889: logamp = 0;
1890: }
1891: #endif
1892: if (!globp && (hupflag || termflg)) {
1893: if (hupflag) {
1894: backup(HUP);
1895: puts2(errtext[57]);
1896: } else {
1897: backup(TRM);
1898: puts2(errtext[58]);
1899: }
1900: delexit(1);
1901: }
1902: if (pflag) {
1903: pflag = 0;
1904: addr1 = addr2 = dot;
1905: goto print;
1906: }
1907: if (!globp) {
1908: #ifdef USE
1909: if (!alt) {
1910: #endif
1911: if (modcount) {
1912: if (text_modified > savf)
1913: mods++;
1914: savf = text_modified;
1915: backchk();
1916: }
1917: #ifdef EOL
1918: #ifdef USE
1919: if (prompt2 && prompt3 && !eflg2)
1920: #endif
1921: #ifndef USE
1922: if (prompt2 && prompt3)
1923: #endif
1924: #endif
1925: #ifndef EOL
1926: #ifdef USE
1927: if (prompt2 && !eflg2)
1928: #endif
1929: #ifndef USE
1930: if (prompt2)
1931: #endif
1932: #endif
1933: {
1934: puts2(e_prompt);
1935: flush_buf();
1936: }
1937: #ifdef USE
1938: }
1939: #endif
1940: }
1941: if (!globp) {
1942: if (dotdot > dol)
1943: dotdot = dol;
1944: if (dotdot < zero)
1945: dotdot = zero;
1946: if (dot != lastdot) {
1947: dotdot = lastdot;
1948: lastdot = dot;
1949: }
1950: }
1951: addr1 = 0;
1952: addr2 = 0;
1953: s_tmp = 0;
1954: s_cnt = 0;
1955: r = 1;
1956: do {
1957: addr1 = addr2;
1958: if ((a1 = address()) == 0) {
1959: c = getchar();
1960: break;
1961: }
1962: addr2 = a1;
1963: if ((c = getchar()) == ';') {
1964: c = ',';
1965: dot = a1;
1966: }
1967: } while (c == ',' && --r >= 0);
1968: if (addr1 == 0)
1969: addr1 = addr2;
1970: if (!globp && !baseflg) {
1971: if (addr1) {
1972: old_a1 = addr1;
1973: old_a2 = addr2;
1974: }
1975: }
1976: line_num = (addr1? addr1 : dot) - zero;
1977: #ifdef AGAIN
1978: if (c == 'o' || c == ctrl('Q')) { /* again command "o" */
1979: if (c != ctrl('Q') && (peekc = getchar()) != '\n')
1980: errmsg(1);
1981: if (c == ctrl('Q'))
1982: putchar(lastc = '\n');
1983: if (*agbuf == 0)
1984: errmsg(2);
1985: agf++;
1986: agp = agbuf;
1987: c = *agp++;
1988: peekc = 0;
1989: #ifdef LOG
1990: ++logstats.lc_o;
1991: #endif
1992: } else if (baseflg == 0 && globp == 0)
1993: if (c != '\n') {
1994: agp = agbuf;
1995: *agp++ = c; /* first char not yet saved */
1996: }
1997: #endif
1998:
1999: switch (c) {
2000: case 'a':
2001: if ((peekc = getchar()) == 'b')
2002: abort();
2003: setdot();
2004: #ifdef XED
2005: if (peekc != ' ' && peekc != '\n') {
2006: c = peekc;
2007: peekc = 0;
2008: if (tack(c, 1))
2009: text_modified++;
2010: #ifdef LOG
2011: ++logstats.lc_aslash;
2012: #endif
2013: continue;
2014: }
2015: #endif
2016: line_num++;
2017: num = addr2;
2018: #ifdef LOG
2019: ++logstats.lc_append;
2020: #endif
2021: caseadd:
2022: if ((c = getchar()) == ' ') {
2023: r = 1;
2024: #ifdef LOG
2025: ++logstats.lc_aspace;
2026: #endif
2027: } else {
2028: #ifndef XED
2029: if (c != '\n') {
2030: peekc = c;
2031: newline();
2032: }
2033: #endif
2034: r = 0;
2035: }
2036: if (append(gettty, num, r, 1))
2037: text_modified++;
2038: continue;
2039:
2040: case 'b':
2041: setnoaddr();
2042: white_space();
2043: if ((brcount = setnum(1)) <= 0)
2044: brcount = 1;
2045: #ifdef LOG
2046: ++logstats.lc_browse;
2047: #endif
2048: continue;
2049:
2050: case 'c':
2051: if ((peekc = getchar()) == 'o') { /* co == t */
2052: peekc = 0;
2053: #ifdef LOG
2054: ++logstats.lc_copy;
2055: #endif
2056: goto casecopy;
2057: }
2058: if (peekc != '\n')
2059: goto casesub;
2060: newline();
2061: setdot();
2062: nonzero();
2063: delete();
2064: text_modified++;
2065: #ifdef LOG
2066: ++logstats.lc_change;
2067: #endif
2068: append(gettty, addr1 - 1, 0, 0);
2069: continue;
2070:
2071: case 'd':
2072: #ifdef DEBUG
2073: /* *du Dump command (testing only) */
2074: if ((peekc = getchar()) == 'u') {
2075: peekc = 0;
2076: dump();
2077: continue;
2078: }
2079: #endif
2080: if ((peekc = getchar()) == ' ' || peekc == ',') {
2081: peekc = 0;
2082: white_space();
2083: p = linebuf;
2084: if ((c = getchar()) == '\n')
2085: errmsg(51);
2086: do {
2087: *p++ = c;
2088: #ifndef ALLOC
2089: if (p >= &linebuf[LBSIZE - 2])
2090: #else
2091: if (p >= &linebuf[lbsize - 2])
2092: #endif
2093: errmsg(11);
2094: } while ((c = getchar()) >= 0 && c != '\n');
2095: *p = 0;
2096: #ifdef LOG
2097: ++logstats.lc_directory;
2098: #endif
2099: if (chdir(linebuf) < 0)
2100: errmsg(51);
2101: continue;
2102: }
2103: #ifdef PAGE
2104: if (peekc == '=') { /* d=<depth> */
2105: peekc = 0;
2106: setnoaddr();
2107: pcount = setnum(PAGSIZ);
2108: #ifdef LOG
2109: ++logstats.lc_depth;
2110: #endif
2111: continue;
2112: }
2113: #endif
2114: newline();
2115: setdot();
2116: nonzero();
2117: delete();
2118: text_modified++;
2119: #ifdef LOG
2120: ++logstats.lc_delete;
2121: #endif
2122: continue;
2123:
2124: case 'e':
2125: eagain:
2126: if ((peekc = getchar()) != '\n') {
2127: #ifdef EOL
2128: if (peekc == '=') { /* e=c - set eol to 'c' */
2129: peekc = 0;
2130: if (immflg)
2131: errmsg(8);
2132: setnoaddr();
2133: eol = setchar(0);
2134: #ifdef LOG
2135: ++logstats.lc_eol;
2136: #endif
2137: continue;
2138: }
2139: #endif
2140: #ifdef TABS
2141: if (peekc == 'x') {
2142: peekc = 0;
2143: if (immflg)
2144: errmsg(8);
2145: if ((c = getchar()) != 'p')
2146: errmsg(8);
2147: newline();
2148: if (!tabc)
2149: errmsg(3);
2150: if (maxtab < 0)
2151: errmsg(9);
2152: if (exp())
2153: text_modified++;
2154: #ifdef LOG
2155: ++logstats.lc_exp;
2156: #endif
2157: continue;
2158: }
2159: #endif
2160: if ('0' <= peekc && peekc <= '9') {
2161: c = getnum();
2162: newline();
2163: if (0 <= c && c < NERR)
2164: printf("%3d: %s\n",
2165: c, errtext[c]);
2166: #ifdef LOG
2167: ++logstats.lc_errmsg;
2168: #endif
2169: continue;
2170: }
2171: if (peekc == '+' || peekc == '-') {
2172: c = peekc;
2173: peekc = 0;
2174: newline();
2175: curt = c == '-';
2176: #ifdef LOG
2177: if (curt)
2178: ++logstats.lc_eminus;
2179: else
2180: ++logstats.lc_eplus;
2181: #endif
2182: continue;
2183: }
2184: if (peekc == 'i') {
2185: peekc = 0;
2186: if (immflg)
2187: errmsg(8);
2188: immflg++;
2189: goto eagain;
2190: }
2191: setnoaddr();
2192: if (fflg)
2193: errmsg(4);
2194: if (peekc != ' ' && peekc != ',')
2195: illfnm: errmsg(5);
2196: scopy(savedfile, tempfile);
2197: if (zero == dol || text_modified == 0)
2198: backup(-TMP);
2199: savedfile[0] = 0;
2200: filename();
2201: if (text_modified && are_you_sure()) {
2202: scopy(tempfile, savedfile);
2203: error();
2204: }
2205: peekc = '\n';
2206: } else {
2207: setnoaddr();
2208: if (text_modified) {
2209: r = peekc;
2210: peekc = 0;
2211: if (are_you_sure()) {
2212: peekc = r;
2213: error();
2214: }
2215: peekc = r;
2216: }
2217: if (zero == dol || text_modified == 0)
2218: backup(-TMP);
2219: }
2220: if (init())
2221: continue;
2222: #ifdef LOG
2223: ++logstats.lc_edit;
2224: #endif
2225: goto caseread;
2226:
2227: case 'f':
2228: setnoaddr();
2229: #ifdef TABS
2230: if ((peekc = getchar()) == '=') { /* f=c fill char */
2231: peekc = 0;
2232: tabfill = setchar(TABFILL);
2233: #ifdef LOG
2234: ++logstats.lc_fillset;
2235: #endif
2236: continue;
2237: }
2238: #endif
2239: if ((c = getchar()) != '\n') {
2240: if (fflg)
2241: errmsg(4);
2242: peekc = c;
2243: filename();
2244: scopy(file, savedfile);
2245: #ifdef LOG
2246: ++logstats.lc_fset;
2247: #endif
2248: if (prompt2 == 0)
2249: continue;
2250: }
2251: #ifdef LOG
2252: else
2253: ++logstats.lc_fshow;
2254: #endif
2255: putsn(savedfile);
2256: continue;
2257:
2258: case 'g':
2259: global(1);
2260: continue;
2261:
2262: case 'h':
2263: #ifdef HELP
2264: if ((peekc = getchar()) == 'e') { /* he[lp] */
2265: peekc = 0;
2266: setnoaddr();
2267: skip_rest();
2268: #ifdef LOG
2269: ++logstats.lc_help;
2270: #endif
2271: if ((doc = open(help, 0)) > 0) {
2272: while ((c = read(doc, linebuf,
2273: #ifndef ALLOC
2274: LBSIZE)) > 0)
2275: #else
2276: lbsize)) > 0)
2277: #endif
2278: write(1, linebuf, c);
2279: close(doc);
2280: }
2281: doc = 0;
2282: continue;
2283: }
2284: #endif
2285: if (zero != dol) {
2286: setdot();
2287: nonzero();
2288: }
2289: #ifdef LOG
2290: ++logstats.lc_header;
2291: #endif
2292: header();
2293: continue;
2294:
2295: case 'i':
2296: setdot();
2297: #ifdef XED
2298: if ((peekc = getchar()) != ' ' && peekc != '\n') {
2299: c = peekc;
2300: peekc = 0;
2301: if (tack(c, 0))
2302: text_modified++;
2303: #ifdef LOG
2304: ++logstats.lc_islash;
2305: #endif
2306: continue;
2307: }
2308: #endif
2309: nonzero();
2310: num = addr2 - 1;
2311: #ifdef LOG
2312: ++logstats.lc_insert;
2313: #endif
2314: goto caseadd;
2315:
2316: #ifdef XED
2317: case 'j':
2318: setdot();
2319: nonzero();
2320: join();
2321: text_modified++;
2322: continue;
2323: #endif
2324:
2325: case 'k':
2326: if ((c = getchar()) == '\n') {
2327: setnoaddr();
2328: #ifdef LOG
2329: ++logstats.lc_klist;
2330: #endif
2331: printmarks();
2332: continue;
2333: }
2334: if ('A' <= c && c <= 'Z')
2335: c |= 040;
2336: if (c < 'a' || c > 'z')
2337: errmsg(0);
2338: newline();
2339: setdot();
2340: nonzero();
2341: #ifdef HUGE
2342: r = hugef ^ 01;
2343: #else
2344: #define r 1
2345: #endif
2346: #ifdef EXTMARK
2347: if (addr1 != addr2) {
2348: names[c - 'a'] = *addr1 | r;
2349: names2[c - 'a'] = *addr2 | r;
2350: } else {
2351: names[c - 'a'] = *addr2 | r;
2352: names2[c - 'a'] = 0;
2353: }
2354: #else
2355: names[c - 'a'] = *addr2 | r;
2356: #endif
2357: #ifdef LOG
2358: ++logstats.lc_kset;
2359: #endif
2360: continue;
2361: #ifndef HUGE
2362: #undef r
2363: #endif
2364:
2365: case 'm':
2366: #ifdef DUMB
2367: if ((peekc = getchar()) == '\n') {
2368: setnoaddr();
2369: peekc = 0;
2370: dumbf ^= 01;
2371: #ifdef LOG
2372: ++logstats.lc_magic;
2373: #endif
2374: if (curt)
2375: putsn(dumbf? off : on);
2376: else {
2377: puts2("\"$&[^.*\\(\\)\" have ");
2378: if (dumbf)
2379: puts2(no);
2380: putsn("special meaning");
2381: }
2382: continue;
2383: }
2384: #endif
2385: if ((peekc = getchar()) == 'o') { /* mo == m */
2386: peekc = 0;
2387: #ifdef LOG
2388: ++logstats.lc_moove;
2389: #endif
2390: }
2391: #ifdef LOG
2392: else
2393: ++logstats.lc_move;
2394: #endif
2395: move(0);
2396: text_modified++;
2397: continue;
2398:
2399: case 'n':
2400: setnoaddr();
2401: #ifdef PIPE
2402: if ((peekc = getchar()) == '+') {
2403: peekc = 0;
2404: newline();
2405: pno = 1;
2406: #ifdef LOG
2407: ++logstats.lc_numplus;
2408: #endif
2409: continue;
2410: }
2411: if (peekc == '-') {
2412: peekc = 0;
2413: newline();
2414: pno = -1;
2415: #ifdef LOG
2416: ++logstats.lc_numinus;
2417: #endif
2418: continue;
2419: }
2420: #endif
2421: newline();
2422: prompt1 ^= 01;
2423: #ifdef LOG
2424: ++logstats.lc_numbers;
2425: #endif
2426: if (curt)
2427: putsn(prompt1? on : off);
2428: else {
2429: if (prompt1 == 0)
2430: puts2(no);
2431: putsn("line numbers");
2432: }
2433: continue;
2434:
2435: case '\n':
2436: if (globp || addr2 > dol)
2437: continue;
2438: if (addr2 == 0) {
2439: addr1 = addr2 = dot + 1;
2440: if (addr2 <= dol)
2441: line_num++;
2442: if (brcount != 1) {
2443: addr2 = dot + brcount;
2444: if (addr1 > dol)
2445: continue;
2446: if (addr2 > dol)
2447: addr2 = dol;
2448: if (addr2 < zero)
2449: addr2 = zero;
2450: #ifdef CLEAR
2451: if (zflg && addr2 - addr1 > pcount / 2)
2452: clear();
2453: #endif
2454: }
2455: }
2456: if (addr2 <= dol) {
2457: pflag = 0;
2458: goto print;
2459: }
2460: continue;
2461:
2462: case 'l':
2463: listf++;
2464: #ifdef LOG
2465: ++logstats.lc_list;
2466: #endif
2467: case 'p':
2468: if ((peekc = getchar()) == 'a') {
2469: peekc = 0;
2470: case ':':
2471: case '*':
2472: num = 0;
2473: if (c == ':' || c == '*') {
2474: if ((peekc = getchar()) == ' ' ||
2475: peekc == '\t') {
2476: skip_rest(); /* comments */
2477: #ifdef LOG
2478: ++logstats.lc_comment;
2479: #endif
2480: continue;
2481: }
2482: r = peekc;
2483: peekc = 0;
2484: #ifdef LOG
2485: if (r == '-' || r == '+')
2486: ++logstats.lc_clnminus;
2487: else if (c == '*')
2488: ++logstats.lc_star;
2489: else
2490: ++logstats.lc_colon;
2491: #endif
2492: while (r == '-' || r == '^' || r == '+') {
2493: if (r == '+')
2494: ++num;
2495: else
2496: --num;
2497: r = getchar();
2498: }
2499: peekc = r;
2500: }
2501: #ifdef LOG
2502: else
2503: if (c != 'p')
2504: ++logstats.lc_print;
2505: #endif
2506: newline();
2507: pflag = 0;
2508: if (addr1 == addr2) {
2509: if (num == -1 && c == ':') {
2510: if (addr2 == 0)
2511: addr2 = dot;
2512: addr1 = addr2 - pcount;
2513: if (addr1 <= zero)
2514: addr1 = zero + 1;
2515: #ifdef CLEAR
2516: if (zflg)
2517: clear();
2518: #endif
2519: goto print;
2520: }
2521: num *= pcount;
2522: if (c == '*')
2523: num -= (pcount + 1) / 2;
2524: if (addr1 == 0)
2525: a1 = dot + (num? num : 1);
2526: else
2527: a1 = addr1 + num;
2528: if (a1 <= zero)
2529: a1 = zero + 1;
2530: addr1 = addr2 = a1;
2531: }
2532: nonzero();
2533: if (addr1 == addr2 || addr2 > dol ||
2534: addr2 <= zero)
2535: addr2 = dol;
2536: setdot();
2537: #ifdef CLEAR
2538: if (zflg && addr2 - addr1 > pcount / 2)
2539: clear();
2540: #endif
2541: #ifndef PAGE
2542: if (addr2 > addr1 + pcount)
2543: addr2 = addr1 + pcount;
2544: goto print;
2545: #else
2546: page();
2547: listf = 0;
2548: #ifdef PARENS
2549: parenf = 0;
2550: #endif
2551: #ifdef STRLEN
2552: quotef = 0;
2553: #endif
2554: continue;
2555: #endif
2556: } else if (peekc == 'p' || peekc == 'l') {
2557: peekc = 0;
2558: addr1 = zero + 1;
2559: addr2 = dol;
2560: #ifdef LOG
2561: ++logstats.lc_pprint;
2562: #endif
2563: }
2564: newline();
2565: pflag = 0;
2566: print:
2567: setdot();
2568: nonzero();
2569: a1 = addr1;
2570: #ifdef PARENS
2571: parenc[0] = 0;
2572: parenc[1] = 0;
2573: parenc[2] = 0;
2574: #endif
2575: do {
2576: col = 0;
2577: printlno(line_num = a1 - zero);
2578: puts(getline(*a1++));
2579: } while (a1 <= addr2);
2580: dot = addr2;
2581: listf = 0;
2582: #ifdef PARENS
2583: parenf = 0;
2584: #endif
2585: #ifdef STRLEN
2586: quotef = 0;
2587: #endif
2588: continue;
2589:
2590: case 'q':
2591: if ((peekc = getchar()) == 'i') { /* qi - immediate */
2592: peekc = 0;
2593: newline();
2594: immflg++;
2595: #ifdef LOG
2596: ++logstats.lc_qimm;
2597: #endif
2598: return;
2599: }
2600: #ifdef STRLEN
2601: if (peekc == '=') { /* q=cc set quote chars */
2602: peekc = 0;
2603: if ((c = getchar()) == '\\')
2604: c = getchar();
2605: quotec = quotec2 = c;
2606: #ifdef LOG
2607: ++logstats.lc_quote;
2608: #endif
2609: if (c != '\n') {
2610: if ((c = getchar()) == '\\')
2611: c = getchar();
2612: if (c == '\n')
2613: continue;
2614: quotec2 = c;
2615: } else {
2616: quotec = 0;
2617: quotec2 = 0;
2618: continue;
2619: }
2620: if (c != '\n')
2621: newline();
2622: continue;
2623: }
2624: #endif
2625: setnoaddr();
2626: if ((peekc = getchar()) != '\n')
2627: errmsg(25);
2628: peekc = 0;
2629: #ifdef LOG
2630: ++logstats.lc_quit;
2631: #endif
2632: return;
2633:
2634: case 'r':
2635: #ifdef LOG
2636: ++logstats.lc_read;
2637: #endif
2638: caseread:
2639: filename();
2640: if ((io = open(file, 0)) < 0) {
2641: io = 0;
2642: lastc = '\n';
2643: if (curt)
2644: errmsg(53);
2645: puts2(errtext[53]);
2646: putsn(file);
2647: error();
2648: }
2649: setall();
2650: ninbuf = 0;
2651: r = append(getfile, addr2, 0, 0);
2652: if (prompt2)
2653: printf((curt? prcntu : errtext[55]),
2654: r, (r == 1? null : quote_s));
2655: close(io);
2656: io = 0;
2657: #ifdef LOG
2658: logstats.lt_rlines += r;
2659: #endif
2660: if (num_reads++ || fflg) {
2661: if (r)
2662: text_modified++;
2663: } /* else
2664: text_modified = 0; */
2665: if ((c == 'e' && bflg == 1) || bflg2 == 1) {
2666: bflg2 = 0;
2667: backup(BAK);
2668: }
2669: continue;
2670:
2671: case 's':
2672: if (!globp && (peekc = getchar()) == '\n') { /* w;q */
2673: setnoaddr();
2674: #ifdef LOG
2675: ++logstats.lc_stop;
2676: #endif
2677: if (text_modified && !fflg)
2678: if (backup(FILE) == 0)
2679: error(); /* errmsg(10) */
2680: peekc = text_modified = 0;
2681: #ifdef LOG
2682: logstats.lt_wlines += dol - zero;
2683: #endif
2684: return;
2685: }
2686: if (peekc == 'a') { /* sa - count before auto-save */
2687: setnoaddr();
2688: peekc = 0;
2689: modcount = setnum(MODCNT);
2690: mods = 0;
2691: #ifdef LOG
2692: ++logstats.lc_savecount;
2693: #endif
2694: continue;
2695: }
2696: casesub:
2697: setdot();
2698: nonzero();
2699: substitute(globp);
2700: text_modified++;
2701: #ifdef LOG
2702: if (c == 's')
2703: ++logstats.lc_substitute;
2704: else
2705: ++logstats.lc_cslash;
2706: #endif
2707: continue;
2708:
2709: case 't':
2710: #ifdef TABS
2711: if ((peekc = getchar()) == '=') { /* t=c tab char */
2712: setnoaddr();
2713: peekc = 0;
2714: tabc = setchar(0);
2715: #ifdef LOG
2716: ++logstats.lc_tabchar;
2717: #endif
2718: continue;
2719: } else if (peekc == ',') { /* t,nn set tabs */
2720: setnoaddr();
2721: #ifdef LOG
2722: ++logstats.lc_tabset;
2723: #endif
2724: while ((c = getchar()) == ',') {
2725: while ((c = getchar()) == ',');
2726: if ((c < '0' || c > '9') && c != '-')
2727: break;
2728: peekc = c;
2729: settab(getsnum());
2730: }
2731: peekc = c;
2732: newline();
2733: continue;
2734: } else if (peekc == '\n') { /* list tabs */
2735: setnoaddr();
2736: peekc = 0;
2737: #ifdef LOG
2738: ++logstats.lc_tablist;
2739: #endif
2740: listabs();
2741: continue;
2742: }
2743: #endif
2744: #ifdef LOG
2745: ++logstats.lc_transfer;
2746: #endif
2747: casecopy:
2748: move(1);
2749: text_modified++;
2750: continue;
2751:
2752: #ifdef UNDO
2753: case 'u':
2754: setnoaddr();
2755: newline();
2756: undo();
2757: #ifdef LOG
2758: ++logstats.lc_undo;
2759: #endif
2760: continue;
2761: #endif
2762:
2763: case 'v':
2764: global(0);
2765: continue;
2766:
2767: case 'w':
2768: #ifdef PAGE
2769: if ((peekc = getchar()) == '=') { /* w=<width> */
2770: peekc = 0;
2771: ccount = setnum(CCOUNT);
2772: #ifdef LOG
2773: ++logstats.lc_width;
2774: #endif
2775: continue;
2776: }
2777: #endif
2778: if ((peekc = getchar()) == 'i') { /* wi over-ride */
2779: ++immflg;
2780: peekc = 0;
2781: #ifdef LOG
2782: ++logstats.lc_wimm;
2783: #endif
2784: }
2785: #ifdef LOG
2786: else
2787: ++logstats.lc_write;
2788: #endif
2789: filename();
2790: #ifdef LOG
2791: if (appflg) {
2792: --logstats.lc_write;
2793: ++logstats.lc_wonto;
2794: }
2795: #endif
2796: if (globp) {
2797: setdot();
2798: appflg++;
2799: } else
2800: setall();
2801: if (dol == zero) {
2802: if (curt)
2803: putsn("?48");
2804: else
2805: putsn(errtext[48]);
2806: if (!fflg || appflg)
2807: continue;
2808: }
2809: if (over || immflg)
2810: override();
2811: if (appflg)
2812: io = open(file, 1);
2813: if (!appflg || io < 0)
2814: io = creat(file, MODE);
2815: if (overfile) {
2816: chmod(overfile, overmode);
2817: overfile = 0;
2818: }
2819: if (io < 0) {
2820: io = 0;
2821: if (curt)
2822: errmsg(54);
2823: puts2(errtext[54]);
2824: putsn(file);
2825: error();
2826: }
2827: io_w++;
2828: if (appflg)
2829: lseek(io, 0L, 2); /* append onto file */
2830: putfile();
2831: close(io);
2832: io = 0;
2833: io_w = 0;
2834: if (addr1 == zero + 1 && addr2 == dol)
2835: text_modified = 0;
2836: #ifdef LOG
2837: logstats.lt_wlines += dol - zero;
2838: #endif
2839: continue;
2840:
2841: #ifdef USE
2842: case '@':
2843: setnoaddr();
2844: if (alt)
2845: errmsg(6);
2846: if ((peekc = getchar()) == 'p')
2847: peekc = 0;
2848: else
2849: eflg2++;
2850: if ((peekc = getchar()) == '\n' && altfile[0]) {
2851: peekc = 0;
2852: goto altname;
2853: }
2854: if ((c = getchar()) != ' ' && c != '\t' && c != ',')
2855: errmsg(5);
2856: white_space();
2857: if ((c = getchar()) == '\n')
2858: errmsg(7);
2859: p = altfile;
2860: *p++ = c;
2861: while ((c = getchar()) != '\n') {
2862: if (c < 0)
2863: errmsg(59);
2864: *p++ = c;
2865: }
2866: *p = '\0';
2867: altname:
2868: #ifdef LOG
2869: ++logstats.lc_at;
2870: #endif
2871: if ((alt = open(altfile, 0)) < 0) {
2872: alt = 0; /* this MUST be 0 */
2873: lastc = '\n';
2874: if (curt)
2875: errmsg(53);
2876: puts2(errtext[53]);
2877: putsn(altfile);
2878: error();
2879: }
2880: continue;
2881: #endif
2882:
2883: #ifdef DEBUG
2884: case '#': /* toggle debug flag */
2885: if (addr1 != addr2 || addr1 != zero)
2886: goto illcmd;
2887: newline();
2888: tflg ^= 01;
2889: continue;
2890:
2891: #ifdef XDEL
2892: case '`':
2893: setnoaddr();
2894: newline();
2895: if (ndeleted == 0)
2896: errmsg(16);
2897: printf("deleted = %o ndeleted = %d\n", deleted, ndeleted);
2898: { register n, *bp, nl;
2899: int tl;
2900:
2901: tl = deleted;
2902: bp = getblock(tl, READ);
2903: #ifdef HUGE
2904: tl &= _1[hugef];
2905: #else
2906: tl &= _1;
2907: #endif
2908: nl = nleft / sizeof(linep);
2909: for (n = 0; n < ndeleted; n++) {
2910: printf("%7d: %6o\n", n + 1, *bp++);
2911: if (--nl <= 0) {
2912: #ifdef HUGE
2913: bp = getblock(tl += _2[hugef], READ);
2914: #else
2915: bp = getblock(tl += _2, READ);
2916: #endif
2917: nl = nleft / sizeof(linep);
2918: }
2919: }
2920: }
2921: continue;
2922: #endif
2923: #endif
2924:
2925: #ifdef XDEL
2926: case 'x':
2927: newline();
2928: r = undelete();
2929: #ifdef LOG
2930: ++logstats.lc_xundelete;
2931: #endif
2932: if (prompt2)
2933: printf((curt? prcntu : errtext[55]),
2934: r, (r == 1? null : quote_s));
2935: text_modified++;
2936: continue;
2937: #endif
2938:
2939: #ifdef YINT
2940: case 'y':
2941: if ((c = getchar()) == '+') {
2942: setdot();
2943: nonzero();
2944: newline();
2945: if (zero == dol)
2946: yplus = 0;
2947: else
2948: yplus = *addr2 | 01;
2949: yflg = 1;
2950: #ifdef LOG
2951: ++logstats.lc_yplus;
2952: #endif
2953: } else if (c == '-') {
2954: setnoaddr();
2955: newline();
2956: yflg = 0;
2957: #ifdef LOG
2958: ++logstats.lc_yminus;
2959: #endif
2960: } else {
2961: setnoaddr();
2962: peekc = c;
2963: newline();
2964: yflg = 1;
2965: yplus = 0;
2966: #ifdef LOG
2967: ++logstats.lc_yintr;
2968: #endif
2969: }
2970: continue;
2971: #endif
2972:
2973: #ifdef PIPE
2974: case '|':
2975: #ifndef XED
2976: if (globp) /* turkeys will be turkeys */
2977: errmsg(61);
2978: #endif
2979: if (noshell)
2980: errmsg(52);
2981: if ((peekc = getchar()) == '+') {
2982: peekc = 0;
2983: newline();
2984: setnoaddr();
2985: strict++;
2986: #ifdef LOG
2987: ++logstats.lc_piplus;
2988: #endif
2989: continue;
2990: } else if (peekc == '-') {
2991: peekc = 0;
2992: newline();
2993: setnoaddr();
2994: strict = 0;
2995: #ifdef LOG
2996: ++logstats.lc_piminus;
2997: #endif
2998: continue;
2999: }
3000: setdot();
3001: shell();
3002: continue;
3003: #endif
3004:
3005: case '!':
3006: #ifndef XED
3007: if (globp)
3008: errmsg(61);
3009: #endif
3010: if (noshell)
3011: errmsg(52);
3012: setnoaddr();
3013: shell();
3014: continue;
3015:
3016: #ifdef CKPT
3017: case 'z':
3018: newline();
3019: setnoaddr();
3020: checkpoint(0); /* doesn't return */
3021: #endif
3022:
3023: case EOF:
3024: #ifdef USE
3025: if (!baseflg && alt) {
3026: close(alt);
3027: alt = 0;
3028: eflg2 = 0;
3029: continue;
3030: }
3031: #endif
3032: return;
3033:
3034: }
3035: illcmd:
3036: errmsg(8);
3037: } /* nothing lasts "for ever" */
3038: }
3039:
3040: compile(aeof)
3041: charac aeof;
3042: {
3043: register charac eof, c;
3044: register char *ep, *lastep, *bracketp;
3045: register cclcnt;
3046: char bracket[NBRA];
3047:
3048: ep = expbuf;
3049: lastep = 0;
3050: eof = aeof;
3051: bracketp = bracket;
3052: if ((c = getchar()) == eof || c == '\n') {
3053: if (*ep == 0)
3054: errmsg(27);
3055: if (c == '\n')
3056: peekc = c;
3057: return;
3058: }
3059: circfl = 0;
3060: nbra = 0;
3061: if (
3062: #ifdef DUMB
3063: !dumbf &&
3064: #endif
3065: c == '^') {
3066: c = getchar();
3067: circfl++;
3068: #ifdef LOG
3069: ++logstats.lp_caret;
3070: #endif
3071: }
3072: /* if (c == '*') { /* if first = *, then quote it */
3073: /* *ep++ = CCHR; */
3074: /* *ep++ = c; */
3075: /* c = 0; */
3076: /* } */
3077: peekc = c;
3078: for ever {
3079: if (ep >= &expbuf[ESIZE - 2 - (bracketp - bracket) * 2])
3080: break;
3081: c = getchar();
3082: if (c == eof || c == '\n') {
3083: while (bracketp > bracket) {
3084: *ep++ = CKET;
3085: *ep++ = *--bracketp;
3086: }
3087: *ep++ = CEOF;
3088: if (c == '\n') {
3089: if (prompt2)
3090: pflag++;
3091: peekc = c;
3092: }
3093: return;
3094: }
3095: if (c != '*')
3096: lastep = ep;
3097: #ifdef DUMB
3098: if (dumbf && c >= 0)
3099: goto defchar;
3100: #endif
3101: switch (c) {
3102: case '\\':
3103: if ((c = getchar()) == '(') {
3104: if (nbra >= NBRA) {
3105: c = 44;
3106: goto cerror;
3107: }
3108: *bracketp++ = nbra;
3109: *ep++ = CBRA;
3110: *ep++ = nbra++;
3111: #ifdef LOG
3112: ++logstats.lp_paren;
3113: #endif
3114: continue;
3115: }
3116: if (c == ')') {
3117: if (bracketp <= bracket) {
3118: c = 45;
3119: goto cerror;
3120: }
3121: *ep++ = CKET;
3122: *ep++ = *--bracketp;
3123: continue;
3124: }
3125: if ('1' <= c && c < '1' + nbra) {
3126: *ep++ = CBACK;
3127: *ep++ = c - '1';
3128: #ifdef LOG
3129: ++logstats.lp_digit;
3130: #endif
3131: continue;
3132: }
3133: if (c == '\n') {
3134: c = 46;
3135: goto cerror;
3136: }
3137: defchar:
3138: default:
3139: *ep++ = CCHR;
3140: *ep++ = c;
3141: continue;
3142:
3143: case '.':
3144: *ep++ = CDOT;
3145: #ifdef LOG
3146: ++logstats.lp_dot;
3147: #endif
3148: continue;
3149:
3150: case '*':
3151: if (lastep == 0 ||
3152: *lastep == CBRA || *lastep == CKET)
3153: goto defchar;
3154: *lastep |= STAR;
3155: #ifdef LOG
3156: ++logstats.lp_star;
3157: #endif
3158: continue;
3159:
3160: case '$':
3161: if ((peekc = getchar()) != eof && peekc != '\n')
3162: goto defchar;
3163: *ep++ = CDOL;
3164: #ifdef LOG
3165: ++logstats.lp_dol;
3166: #endif
3167: continue;
3168:
3169: case '[':
3170: *ep++ = CCL;
3171: *ep++ = 0;
3172: cclcnt = 1;
3173: if ((c = getchar()) == '^') {
3174: c = getchar();
3175: ep[-2] = NCCL;
3176: #ifdef LOG
3177: ++logstats.lp_nccl;
3178: #endif
3179: }
3180: #ifdef LOG
3181: else
3182: ++logstats.lp_ccl;
3183: #endif
3184: do {
3185: if (c == '\\')
3186: c = getchar();
3187: if (c == '\n') {
3188: peekc = c;
3189: break;
3190: }
3191: if (c < 0) {
3192: c = 59;
3193: goto cerror;
3194: }
3195: *ep++ = c;
3196: cclcnt++;
3197: if (ep >= &expbuf[ESIZE - 2]) {
3198: c = 49;
3199: goto cerror;
3200: }
3201: } while ((c = getchar()) != ']');
3202: lastep[1] = cclcnt;
3203: continue;
3204:
3205: case EOF:
3206: c = 59;
3207: goto cerror;
3208: }
3209: }
3210: c = 42;
3211: cerror:
3212: expbuf[0] = '\0';
3213: nbra = 0;
3214: errmsg(c);
3215: }
3216:
3217: compsub() {
3218: register charac seof, c;
3219: register char *p;
3220:
3221: if ((seof = getchar()) == '\n')
3222: errmsg(40);
3223: compile(seof);
3224: p = rhsbuf;
3225: for ever {
3226: c = getchar();
3227: if (c < 0)
3228: errmsg(59);
3229: if (c == '\\')
3230: c = getchar() | 0200;
3231: if (c == '\n') {
3232: *p = 0;
3233: peekc = 0;
3234: if (prompt2)
3235: pflag++;
3236: return(0);
3237: }
3238: if (c == seof)
3239: break;
3240: *p++ = c;
3241: if (p >= &rhsbuf[LBSIZE / 2 - 2])
3242: errmsg(41);
3243: }
3244: *p = '\0';
3245: p = 0;
3246: if ((peekc = getchar()) == 'g') { /* if in 'glob' */
3247: peekc = 0;
3248: p = 1;
3249: } else if ('0' <= peekc && peekc <= '9')
3250: if ((s_cnt = getnum()) < 0)
3251: s_cnt = 0;
3252: newline();
3253: return(p);
3254: }
3255:
3256: create(as, am)
3257: char *as;
3258: {
3259: register savmask;
3260: register func savint, savqit;
3261: register ret;
3262:
3263: if (am == LMODE) {
3264: savint = signal(SIGINT, 1);
3265: savqit = signal(SIGQIT, 1);
3266: savmask = umask(LMASK);
3267: }
3268: ret = creat(as, am);
3269: if (am == LMODE) {
3270: umask(savmask);
3271: signal(SIGINT, savint);
3272: signal(SIGQIT, savqit);
3273: }
3274: return(ret);
3275: }
3276:
3277: delete() {
3278: register linep *a1, *a2, *a3;
3279:
3280: a1 = addr1;
3281: a2 = addr2 + 1;
3282: #ifdef XDEL
3283: if (!globp)
3284: saveline();
3285: #endif
3286: a3 = dol;
3287: dol -= a2 - a1;
3288: do {
3289: *a1++ = *a2++;
3290: } while (a2 <= a3);
3291: a1 = addr1;
3292: if (a1 > dol)
3293: a1 = dol;
3294: dot = a1;
3295: }
3296:
3297: delexit(aretcode) {
3298: #ifdef LOG
3299: #include <sys/times.h>
3300: struct tms t;
3301: #endif
3302:
3303: unlink(tfname);
3304: #ifdef LOG
3305: if ((io = open(LOG, 1)) >= 0) {
3306: time(&logstats.lt_end);
3307: times(&t);
3308: logstats.lt_usercpu = t.tms_utime;
3309: logstats.lt_syscpu = t.tms_stime;
3310: logstats.lt_kidscpu = t.tms_cutime + t.tms_cstime;
3311: lseek(io, 0L, 2);
3312: write(io, &logstats, sizeof logstats);
3313: }
3314: #endif
3315: exit(aretcode);
3316: }
3317:
3318: dosub() {
3319: register char *lp, *sp, *rp;
3320: register charac c;
3321:
3322: lp = linebuf;
3323: sp = genbuf;
3324: rp = rhsbuf;
3325: while (lp < loc1)
3326: *sp++ = *lp++;
3327: while (c = *rp++) {
3328: #ifdef DUMB
3329: if (!dumbf)
3330: #endif
3331: if (c == '&') {
3332: #ifdef LOG
3333: ++logamp;
3334: #endif
3335: sp = place(sp, loc1, loc2);
3336: continue;
3337: } else if (c < 0 && (c &= 0177) >= '1' &&
3338: c < nbra + '1') {
3339: c -= '1';
3340: sp = place(sp,braslist[c],braelist[c]);
3341: continue;
3342: }
3343: *sp++ = c & 0177;
3344: #ifndef ALLOC
3345: if (sp >= &genbuf[LBSIZE - 2])
3346: #else
3347: if (sp >= &genbuf[lbsize - 2])
3348: #endif
3349: errmsg(42);
3350: }
3351: lp = loc2;
3352: loc2 = sp + (linebuf - genbuf);
3353: while (*sp++ = *lp++)
3354: #ifndef ALLOC
3355: if (sp >= &genbuf[LBSIZE - 2])
3356: #else
3357: if (sp >= &genbuf[lbsize - 2])
3358: #endif
3359: errmsg(43);
3360: lp = linebuf;
3361: sp = genbuf;
3362: while (*lp++ = *sp++);
3363: }
3364:
3365: #ifdef DEBUG
3366: dump() {
3367: register linep *i;
3368: register b, o;
3369:
3370: setdot();
3371: nonzero();
3372: newline();
3373: line_num = addr1 - zero;
3374: for (i = addr1; i <= addr2; i++) {
3375: #ifdef HUGE
3376: b = (*i >> (8 - hugef)) & _3[hugef];
3377: o = (*i << (1 + hugef)) & _4[hugef];
3378: #else
3379: b = (*i >> 8) & _3;
3380: o = (*i << 1) & _4;
3381: #endif
3382: printlno(line_num++);
3383: #ifdef pdp11
3384: printf("%6o:%7o%6d/%d\n", i, *i, b, o);
3385: #else
3386: printf("%6o:%7o%6d/%d\n", i, *i&(unsigned)(unsigned short)-1, b, o);
3387: #endif
3388: }
3389: dot = addr2;
3390: }
3391: #endif
3392:
3393: echo(ch)
3394: charac ch;
3395: {
3396: #ifdef AGAIN
3397: static charac lastchar;
3398: #endif
3399: #ifdef USE
3400: if (eflg || alt && !eflg2)
3401: #endif
3402: #ifndef USE
3403: if (eflg)
3404: #endif
3405: write(2, &ch, 1);
3406: #ifdef AGAIN
3407: if (!agf && agp) { /* save current command for "again" */
3408: if (agp >= &agbuf[GBSIZE - 2])
3409: agp = agbuf[0] = 0;
3410: else
3411: *agp++ = ch;
3412: if (ch == '\n' && lastchar != '\\')
3413: agp = *agp = 0;
3414: }
3415: lastchar = ch;
3416: #endif
3417: return(ch);
3418: }
3419:
3420: errfunc() {
3421: if (io) {
3422: close(io);
3423: io = 0;
3424: io_w = 0;
3425: }
3426: if (overfile) {
3427: chmod(overfile, overmode);
3428: overfile = 0;
3429: }
3430: #ifdef HELP
3431: if (doc) {
3432: close(doc);
3433: doc = 0;
3434: }
3435: #endif
3436: #ifdef PIPE
3437: if (pfile) {
3438: close(pfile);
3439: unlink(pfname);
3440: pfile = 0;
3441: }
3442: #endif
3443: /* puts("?"); */
3444: if (!seekf)
3445: lseek(0, 0L, 2);
3446: pflag = 0;
3447: listf = 0;
3448: #ifdef PARENS
3449: parenf = 0;
3450: #endif
3451: #ifdef STRLEN
3452: quotef = 0;
3453: #endif
3454: if (globp) {
3455: lastc = '\n';
3456: globp = 0;
3457: }
3458: peekc = lastc;
3459: skip_rest();
3460: eflg2 = 0;
3461: reset();
3462: }
3463:
3464: errmsg(n) {
3465: extern errno;
3466:
3467: listf = 0;
3468: #ifdef PARENS
3469: parenf = 0;
3470: #endif
3471: #ifdef STRLEN
3472: quotef = 0;
3473: #endif
3474: col = 0;
3475: if (n < 0) {
3476: puts2("\7******** ");
3477: printf("%d ", errno);
3478: n = -n;
3479: }
3480: if (curt)
3481: printf("?%d\n", n);
3482: else
3483: if (0 <= n && n < NERR)
3484: putsn(errtext[n]);
3485: else
3486: printf("bad error number: %d\n", n);
3487: error();
3488: }
3489:
3490: execute(gf, addr)
3491: linep *addr;
3492: {
3493: register char *p1, *p2;
3494: register charac c;
3495:
3496: if (gf) {
3497: if (circfl)
3498: return(0);
3499: p1 = linebuf;
3500: p2 = genbuf;
3501: while (*p1++ = *p2++);
3502: locs = p1 = loc2;
3503: } else {
3504: if (addr == zero)
3505: return(0);
3506: p1 = getline(*addr);
3507: locs = 0;
3508: }
3509: p2 = expbuf;
3510: c = NBRA;
3511: while (--c >= 0) {
3512: braslist[c] = 0;
3513: braelist[c] = 0;
3514: }
3515: if (circfl) {
3516: loc1 = p1;
3517: return(advance(p1, p2));
3518: }
3519: /* fast check for first character */
3520: if (*p2 == CCHR) {
3521: c = p2[1];
3522: do {
3523: if (*p1 != c)
3524: continue;
3525: if (advance(p1, p2)) {
3526: loc1 = p1;
3527: return(1);
3528: }
3529: } while (*p1++);
3530: return(0);
3531: }
3532: /* regular algorithm */
3533: do {
3534: if (advance(p1, p2)) {
3535: loc1 = p1;
3536: return(1);
3537: }
3538: } while (*p1++);
3539: return(0);
3540: }
3541:
3542: #ifdef TABS
3543: exp() {
3544: register n;
3545: register linep p, *a1;
3546:
3547: setdot();
3548: nonzero();
3549: n = 0;
3550: for (a1 = addr1; a1 <= addr2; a1++) {
3551: getline(*a1);
3552: if (expand()) {
3553: n++;
3554: p = *a1;
3555: *a1 = putline();
3556: savemark(p, *a1);
3557: }
3558: }
3559: dot = addr2;
3560: return(n);
3561: }
3562:
3563: expand() {
3564: register char *p2;
3565: register charac c;
3566: register n;
3567: register char *p1;
3568: register cnt, i;
3569: register flag tabflg;
3570:
3571: p1 = linebuf;
3572: p2 = genbuf;
3573: while (*p2++ = *p1++);
3574: p2 = linebuf;
3575: p1 = genbuf;
3576: cnt = col = n = 0;
3577: while (c = *p1++) {
3578: if (c == tabc && col < maxtab) {
3579: n = col;
3580: c = tabfill;
3581: if (c == '\t') {
3582: n = col;
3583: tabflg = 0;
3584: while (n < maxtab) {
3585: if ((++n & 07) == 0) {
3586: *p2++ = c;
3587: tabflg++;
3588: if (p2 >=
3589: #ifndef ALLOC
3590: &linebuf[LBSIZE - 2]
3591: #else
3592: &linebuf[lbsize - 2]
3593: #endif
3594: || n >= TABS * BPW)
3595: goto experr;
3596: }
3597: if (tabs[n >> BPWC] >> (n & BPWM) & 01)
3598: if (*p1 == tabc &&
3599: n < maxtab) {
3600: p1++;
3601: cnt++;
3602: } else
3603: break;
3604: }
3605: i = n;
3606: if (tabflg)
3607: n &= 07;
3608: else
3609: n -= col;
3610: col = i;
3611: while (n--) {
3612: *p2++ = ' ';
3613: #ifndef ALLOC
3614: if (p2 >= &linebuf[LBSIZE - 2])
3615: #else
3616: if (p2 >= &linebuf[lbsize - 2])
3617: #endif
3618: goto experr;
3619: }
3620: cnt++;
3621: continue;
3622: }
3623: do {
3624: *p2++ = c;
3625: #ifndef ALLOC
3626: if (p2 >= &linebuf[LBSIZE - 2]
3627: #else
3628: if (p2 >= &linebuf[lbsize - 2]
3629: #endif
3630: || n >= TABS * BPW)
3631: goto experr;
3632: n++;
3633: } while (!(tabs[n >> BPWC] >> (n & BPWM) & 01));
3634: col = n;
3635: cnt++;
3636: continue;
3637: } else if ('\0' < c && c < ' ') {
3638: switch (c) {
3639: case '\b':
3640: col -= 2;
3641: break;
3642: case '\t':
3643: col += 7 - (col & 07);
3644: break;
3645: case '\r':
3646: col = -1;
3647: break;
3648: default:
3649: col--;
3650: }
3651: }
3652: if (c) {
3653: *p2++ = c;
3654: col++;
3655: #ifndef ALLOC
3656: if (p2 >= &linebuf[LBSIZE - 2] ||
3657: #else
3658: if (p2 >= &linebuf[lbsize - 2] ||
3659: #endif
3660: col >= TABS * BPW)
3661: experr: errmsg(12);
3662: }
3663: }
3664: *p2++ = 0;
3665: return(cnt);
3666: }
3667: #endif
3668:
3669: #ifdef DEBUG
3670: #ifdef EXPDMP
3671: expdmp() {
3672: register n;
3673: register char *ep, **p;
3674: register flag star;
3675:
3676: signal(SIGQIT, expdmp);
3677: ep = expbuf;
3678: putchar('"');
3679: if (circfl)
3680: putchar('^');
3681: while (*ep) {
3682: n = 0;
3683: star = 0;
3684: switch (*ep++) {
3685: case CCHR | STAR:
3686: star++;
3687: case CCHR:
3688: putchar(*ep++);
3689: break;
3690: case CDOT | STAR:
3691: star++;
3692: case CDOT:
3693: putchar('.');
3694: break;
3695: case CDOL:
3696: putchar('$');
3697: break;
3698: case CEOF:
3699: putchar('"');
3700: goto done;
3701: case NCCL | STAR:
3702: star++;
3703: case NCCL:
3704: n++;
3705: goto ccl;
3706: case CCL | STAR:
3707: star++;
3708: case CCL: ccl:
3709: putchar('[');
3710: if (n)
3711: putchar('^');
3712: n = *ep++;
3713: while (--n)
3714: putchar(*ep++);
3715: putchar(']');
3716: break;
3717: case CBRA:
3718: putchar('\\');
3719: putchar('(');
3720: ep++;
3721: break;
3722: case CKET:
3723: putchar('\\');
3724: putchar(')');
3725: ep++;
3726: break;
3727: case CBACK | STAR:
3728: star++;
3729: case CBACK:
3730: putchar('\\');
3731: putchar(*ep++ + '1');
3732: break;
3733: default:
3734: putchar('?');
3735: break;
3736: }
3737: if (star)
3738: putchar('*');
3739: }
3740: done: putchar('\n');
3741: if (reading)
3742: reset();
3743: }
3744: #endif
3745: #endif
3746:
3747: filename() {
3748: register char *p1, *p2;
3749: register charac c;
3750:
3751: appflg = 0;
3752: c = getchar();
3753: if (c < 0)
3754: errmsg(59);
3755: if (c == '\n') {
3756: noname:
3757: if (savedfile[0] == 0)
3758: errmsg(62);
3759: scopy(savedfile, file);
3760: return;
3761: }
3762: if (c != ' ' && c != '\t' && c != ',' && c != '>')
3763: errmsg(5);
3764: if (c != ',')
3765: peekc = c;
3766: white_space();
3767: if ((c = getchar()) == '>') {
3768: while ((c = getchar()) == '>');
3769: appflg++;
3770: if (c == '\n')
3771: goto noname;
3772: peekc = c;
3773: white_space();
3774: c = getchar();
3775: }
3776: if (c == '\n')
3777: errmsg(7);
3778: p1 = file;
3779: do {
3780: *p1++ = c;
3781: if (p1 >= &file[FNSIZE - 2])
3782: errmsg(11);
3783: } while ((c = getchar()) != '\n');
3784: *p1++ = 0;
3785: if (savedfile[0] == 0)
3786: scopy(file, savedfile);
3787: }
3788:
3789: linep *
3790: findmark(alp, adflt)
3791: linep alp, *adflt;
3792: {
3793: register linep *a, v;
3794: #ifdef HUGE
3795: register i;
3796:
3797: i = hugef ^ 01;
3798: #endif
3799: v = alp;
3800: for (a = zero + 1; a <= dol; a++)
3801: if (v == (*a |
3802: #ifdef HUGE
3803: i
3804: #else
3805: 1
3806: #endif
3807: ))
3808: return(a);
3809: return(adflt);
3810: }
3811:
3812: flush_buf() {
3813: register n;
3814:
3815: if (n = linp - line) {
3816: linp = line;
3817: write(fout, line, n);
3818: }
3819: }
3820:
3821: #ifdef G_VFY
3822: gask(a1)
3823: linep *a1;
3824: {
3825: register charac c;
3826:
3827: col = 0;
3828: printlno(line_num = a1 - zero);
3829: puts(linebuf);
3830: puts2("Ok? ");
3831: flush_buf();
3832: if ((c = getchar()) < 0) {
3833: putchar('\n');
3834: return(-1);
3835: }
3836: if (c == '\n')
3837: return(1);
3838: skip_rest();
3839: return(c != 'n');
3840: }
3841: #endif
3842:
3843: char *
3844: getblock(atl, iof) {
3845: extern read(), write();
3846: register bno, off;
3847: register linep *a;
3848: #ifdef HUGE
3849: register flag c;
3850: register func savint;
3851:
3852: bno = (atl >> (8 - hugef)) & _3[hugef];
3853: off = (atl << (1 + hugef)) & _4[hugef];
3854: #else
3855: bno = (atl >> 8) & _3;
3856: off = (atl << 1) & _4;
3857: #endif
3858: if (bno >=
3859: #ifdef HUGE
3860: _5[hugef]
3861: #else
3862: _5
3863: #endif
3864: ) {
3865: #ifdef HUGE
3866: if (!hugef && !globp) { /* let's try converting to huge */
3867: if (!curt) {
3868: putsn("File too large for normal editing.");
3869: puts2("Conversion to \"huge\" mode disallows ");
3870: puts2("use of the global command.");
3871: }
3872: c = yes_no(curt? "?huge" : "Do you wish to convert",
3873: 1, 0, 0);
3874: if (c) {
3875: savint = signal(SIGINT, 1);
3876: for (a = zero + 1; a <= dol; a++)
3877: *a = ((unsigned)*a) >> 1;
3878: hugef++;
3879: hugef2++; /* conversion occurred */
3880: atl = (atl >> 1) & _6[hugef];
3881: #ifdef XDEL
3882: ndeleted = 0; /* useless pointers */
3883: deleted = 0;
3884: #endif
3885: signal(SIGINT, savint);
3886: goto huger;
3887: }
3888: }
3889: #endif
3890: errmsg(34);
3891: }
3892: #ifdef HUGE
3893: huger:
3894: #endif
3895: nleft = BLKSIZE - off;
3896: if (bno == iblock && !badf) {
3897: ichanged |= iof;
3898: return(ibuff + off);
3899: }
3900: if (bno == oblock)
3901: return(obuff + off);
3902: if (iof == READ) {
3903: if (ichanged) {
3904: blkio(iblock, ibuff, write);
3905: ichanged = 0;
3906: }
3907: iblock = bno;
3908: blkio(bno, ibuff, read);
3909: return(ibuff + off);
3910: }
3911: if (oblock >= 0)
3912: blkio(oblock, obuff, write);
3913: oblock = bno;
3914: return(obuff + off);
3915: }
3916:
3917: charac
3918: getchar() {
3919: flush_buf();
3920: eof = 0;
3921: if (lastc = peekc) {
3922: peekc = 0;
3923: return(lastc);
3924: }
3925: if (globp) {
3926: if (lastc = *globp++) {
3927: if (globf2 && *globp == 0)
3928: globp = globf2 = 0;
3929: return(lastc);
3930: }
3931: globp = 0;
3932: return(EOF);
3933: }
3934: #ifdef AGAIN
3935: if (agf
3936: #ifdef USE
3937: && !alt
3938: #endif
3939: ) { /* "again" stuff */
3940: if (lastc = *agp++)
3941: return(lastc);
3942: agf = agp = 0;
3943: }
3944: #endif
3945: reading++;
3946: #ifdef USE
3947: if (read(alt, &lastc, 1) <= 0) {
3948: #endif
3949: #ifndef USE
3950: if (read(0, &lastc, 1) <= 0) {
3951: #endif
3952: reading = 0;
3953: eof++;
3954: return(lastc = EOF);
3955: }
3956: reading = 0;
3957: lastc &= 0177;
3958: #ifdef APLMAP
3959: if (aplmap && lastc > ' ')
3960: lastc = map_ascii[lastc - (' ' + 1)];
3961: #endif
3962: #ifdef EOL
3963: if (lastc == '\n')
3964: prompt3 = 1;
3965: else if (eol && lastc == eol) {
3966: lastc = '\n';
3967: prompt3 = 0;
3968: }
3969: #endif
3970: #ifdef CMDS
3971: if (cmd)
3972: write(cmd, &lastc, 1);
3973: #endif
3974: eof = 0;
3975: return(echo(lastc));
3976: }
3977:
3978: getcopy() {
3979: if (addr1 > addr2)
3980: return(EOF);
3981: getline(*addr1++);
3982: return(0);
3983: }
3984:
3985: getfile() {
3986: register charac c;
3987: register char *lp, *fp;
3988:
3989: lp = linebuf;
3990: fp = nextip;
3991: do {
3992: if (--ninbuf < 0) {
3993: #ifndef ALLOC
3994: if ((ninbuf = read(io, genbuf, LBSIZE) - 1) < 0)
3995: #else
3996: if ((ninbuf = read(io, genbuf, lbsize) - 1) < 0)
3997: #endif
3998: if (lp == linebuf)
3999: return(EOF);
4000: else {
4001: lp++;
4002: break;
4003: }
4004: fp = genbuf;
4005: }
4006: #ifndef ALLOC
4007: if (lp >= &linebuf[LBSIZE - 2] && (*fp & 0177) != '\n') {
4008: #else
4009: if (lp >= &linebuf[lbsize - 2] && (*fp & 0177) != '\n') {
4010: #endif
4011: printf((curt? "?long%u\n" : "line %u in file too long\n"),
4012: dot - zero + 1);
4013: flush_buf();
4014: lp++;
4015: ninbuf++;
4016: break;
4017: }
4018: if ((*lp++ = c = *fp++ & 0177) == 0) {
4019: lp--;
4020: continue;
4021: }
4022: } while (c != '\n');
4023: *--lp = 0;
4024: nextip = fp;
4025: return(0);
4026: }
4027:
4028: getline(tl) {
4029: register char *bp, *lp;
4030: register nl;
4031:
4032: #ifdef DEBUG
4033: if (tflg)
4034: printf("getline:\t%o\n", tl);
4035: #endif
4036: lp = linebuf;
4037: bp = getblock(tl, READ);
4038: #ifdef HUGE
4039: if (hugef2) {
4040: hugef2 = 0;
4041: tl = (tl >> 1) & _6[hugef];
4042: }
4043: tl &= _1[hugef];
4044: #else
4045: tl &= _1;
4046: #endif
4047: nl = nleft;
4048: while (*lp++ = *bp++)
4049: if (--nl <= 0) {
4050: #ifdef HUGE
4051: bp = getblock(tl += _2[hugef], READ);
4052: #else
4053: bp = getblock(tl += _2, READ);
4054: #endif
4055: nl = nleft;
4056: }
4057: return(linebuf);
4058: }
4059:
4060: getnum() {
4061: register n;
4062: register charac c;
4063:
4064: n = 0;
4065: while ('0' <= (c = getchar()) && c <= '9')
4066: n = n * 10 + c - '0';
4067: peekc = c;
4068: return(n);
4069: }
4070:
4071: getsnum() {
4072: register sign;
4073:
4074: if (sign = (peekc = getchar()) == '-')
4075: peekc = 0;
4076: return(sign? -getnum() : getnum());
4077: }
4078:
4079: getsub() {
4080: register char *p1, *p2;
4081:
4082: p1 = linebuf;
4083: if ((p2 = linebp) == 0)
4084: return(EOF);
4085: while (*p1++ = *p2++);
4086: linebp = 0;
4087: return(0);
4088: }
4089:
4090: gettty(single) {
4091: register charac c;
4092: register char *p, *gf;
4093: #ifdef TABS
4094: int tabf;
4095:
4096: tabf = 0;
4097: #endif
4098: p = linebuf;
4099: gf = globp;
4100: #ifdef EOL
4101: if (prompt2 && prompt3 && !single) {
4102: #endif
4103: #ifndef EOL
4104: if (prompt2 && !single) {
4105: #endif
4106: printlno(line_num);
4107: flush_buf();
4108: }
4109: line_num++;
4110: while ((c = getchar()) != '\n') {
4111: if (c < 0) {
4112: if (gf)
4113: peekc = c;
4114: else if (prompt2 && (prompt1 || !zflg))
4115: putchar('\n');
4116: if (p > linebuf)
4117: break;
4118: return(c);
4119: }
4120: if ((c &= 0177) == 0)
4121: continue;
4122: #ifdef TABS
4123: if (tabc && c == tabc)
4124: tabf++;
4125: #endif
4126: *p++ = c;
4127: #ifndef ALLOC
4128: if (p >= &linebuf[LBSIZE - 2])
4129: #else
4130: if (p >= &linebuf[lbsize - 2])
4131: #endif
4132: errmsg(30);
4133: }
4134: *p++ = 0;
4135: #ifdef TABS
4136: if (tabf)
4137: expand();
4138: #endif
4139: if (!single && linebuf[0] == '.' && linebuf[1] == 0)
4140: return(EOF);
4141: return(0);
4142: }
4143:
4144: global(k) {
4145: register char *gp;
4146: register charac c;
4147: register linep *a1;
4148: register flag globpf;
4149: char globuf[GBSIZE];
4150:
4151: #ifdef HUGE
4152: if (hugef)
4153: errmsg(10);
4154: #endif
4155: if (globp)
4156: errmsg(37);
4157: setall();
4158: nonzero();
4159: if ((c = getchar()) == '\n')
4160: peekc = c;
4161: compile(c);
4162: #ifdef G_VFY
4163: gaskf = 0;
4164: if ((peekc = getchar()) == 'v') {
4165: gaskf++;
4166: peekc = 0;
4167: }
4168: #endif
4169: globpf = pflag;
4170: if (peekc == '\n')
4171: globpf = 0;
4172: pflag = 0;
4173: gp = globuf;
4174: if ((peekc = getchar()) < 0)
4175: errmsg(59);
4176: if (peekc == '\n') {
4177: *gp++ = 'p';
4178: peekc = 0;
4179: } else
4180: while ((c = getchar()) != '\n') {
4181: if (c == '\\') {
4182: c = getchar();
4183: if (c != '\n')
4184: *gp++ = '\\';
4185: }
4186: if (c < 0)
4187: errmsg(59);
4188: *gp++ = c;
4189: if (gp >= &globuf[GBSIZE - 2])
4190: errmsg(38);
4191: }
4192: *gp++ = '\n';
4193: *gp = 0;
4194: c = 0;
4195: #ifdef LOG
4196: #ifdef G_VFY
4197: if (gaskf)
4198: ++logstats.lc_gvfy;
4199: #endif
4200: if (k)
4201: ++logstats.lc_global;
4202: else
4203: ++logstats.lc_vglobal;
4204: #endif
4205: for (a1 = zero + 1; a1 <= dol; a1++) {
4206: *a1 &= ~01;
4207: s_tmp = 0;
4208: if (a1 >= addr1 && a1 <= addr2 && execute(0, a1) == k)
4209: #ifdef G_VFY
4210: if (!gaskf || (c = gask(a1)))
4211: if (c < 0)
4212: addr2 = a1;
4213: else
4214: #endif
4215: *a1 |= 01;
4216: }
4217: for (a1 = zero + 1; a1 <= dol; a1++)
4218: if (*a1 & 01) {
4219: *a1 &= ~01;
4220: dot = a1;
4221: globp = globuf;
4222: pflag = globpf;
4223: commands(1);
4224: a1 = zero;
4225: }
4226: }
4227:
4228: hangup() {
4229: signal(SIGHUP, 1);
4230: if (reading) {
4231: backup(HUP);
4232: if (fout != 1) {
4233: flush_buf();
4234: fout = 1;
4235: }
4236: puts2(errtext[57]);
4237: delexit(1);
4238: }
4239: hupflag++;
4240: }
4241:
4242: header() {
4243: register colnum, number;
4244: register flag lf;
4245:
4246: number = 0;
4247: if ((peekc = getchar()) != '\n') {
4248: white_space();
4249: number = getnum();
4250: }
4251: if (!number)
4252: number = ccount - (prompt1? 8 : 0);
4253: newline();
4254: if (zero != dol)
4255: dot = addr2;
4256: lf = listf;
4257: listf = 0;
4258: if (prompt1)
4259: putchar('\t');
4260: for (colnum = 0; colnum < number / 10; colnum++)
4261: printf("%10d", colnum + 1);
4262: putchar('\n');
4263: if (prompt1)
4264: putchar('\t');
4265: for (colnum = 1; colnum <= number; colnum++)
4266: #ifdef TABS
4267: if (colnum < (TABS << BPWC) &&
4268: (tabs[(colnum - 1) >> BPWC] >>
4269: ((colnum - 1) & BPWM) & 01))
4270: putchar('-');
4271: else
4272: #endif
4273: putchar(colnum % 10 + '0');
4274: putchar('\n');
4275: listf = lf;
4276: }
4277:
4278: init() {
4279: register n;
4280: register char *p;
4281:
4282: if (tfile > 0)
4283: close(tfile);
4284: if (io) {
4285: close(io);
4286: io = 0;
4287: io_w = 0;
4288: }
4289: #ifdef HELP
4290: if (doc) {
4291: close(doc);
4292: doc = 0;
4293: }
4294: #endif
4295: #ifdef USE
4296: if (alt) {
4297: close(alt);
4298: alt = 0;
4299: eflg2 = 0;
4300: }
4301: #endif
4302: #ifdef PIPE
4303: if (pfile) {
4304: close(pfile);
4305: unlink(pfname);
4306: pfile = 0;
4307: }
4308: #endif
4309: tline = 0;
4310: #ifdef XDEL
4311: deleted = 0;
4312: ndeleted = 0;
4313: #endif
4314: num_reads = 0;
4315: text_modified = 0;
4316: #ifdef YINT
4317: yplus = 0;
4318: #endif
4319: #ifdef UNDO
4320: undo_oldp = 0;
4321: undo_newp = 0;
4322: #endif
4323: #ifdef V7
4324: if (overfile) {
4325: chmod(overfile, overmode);
4326: overfile = 0;
4327: }
4328: #endif
4329: iblock = oblock = -1;
4330: badf = 0;
4331: ichanged = 0;
4332: if ((n = create(tfname, LMODE)) < 0) {
4333: putsn(errtext[50]);
4334: exit(1);
4335: }
4336: close(n);
4337: if ((tfile = open(tfname, 2)) < 0) {
4338: putsn(errtext[36]);
4339: exit(1);
4340: }
4341: addr1 = addr2 = dot = dotdot = lastdot = zero = dol = fendcore;
4342: endcore = fendcore - 2;
4343: brk(fendcore);
4344: n = 26;
4345: while (--n >= 0) { /* kill marks */
4346: names[n] = 0;
4347: #ifdef EXTMARK
4348: names2[n] = 0;
4349: #endif
4350: }
4351: p = globp;
4352: globp = 0;
4353: if (chk()) {
4354: if ((io = open(file, 0)) < 0) {
4355: io = 0;
4356: lastc = '\n';
4357: if (curt)
4358: putsn("?53");
4359: else {
4360: puts2(errtext[53]);
4361: putsn(file);
4362: }
4363: flush_buf();
4364: } else {
4365: n = append(getfile, addr1, 0, 0);
4366: if (prompt2)
4367: printf((curt? prcntu : errtext[55]),
4368: n, (n == 1? null : quote_s));
4369: if (n) {
4370: num_reads++;
4371: text_modified++;
4372: }
4373: if (io) {
4374: close(io);
4375: io = 0;
4376: io_w = 0;
4377: }
4378: }
4379: return(1);
4380: }
4381: globp = p;
4382: return(0);
4383: }
4384:
4385: istty(fd) {
4386: register r;
4387: short buf[3]; /* naughty int's */
4388:
4389: buf[2] = BS1;
4390: r = 0;
4391: if (gtty(fd, buf) >= 0)
4392: ++r;
4393: #ifdef CLEAR
4394: zflg = (buf[2] & BS1) == 0;
4395: #endif
4396: if (pipef
4397: #ifdef V7
4398: || getenv("_NO_STDIO_BUF")
4399: #endif
4400: )
4401: ++r;
4402: return(r);
4403: }
4404:
4405: #ifdef XED
4406: join() {
4407: register linep *a1;
4408: register char *p1, *p2;
4409: register charac c, ceof;
4410:
4411: setdot();
4412: nonzero();
4413: if (addr1 == addr2)
4414: --addr1;
4415: if (addr1 <= zero)
4416: errmsg(60);
4417:
4418: p2 = rhsbuf;
4419: if ((c = peekc = getchar()) < 0)
4420: errmsg(59);
4421: ceof = 0;
4422: if (peekc != '\n' && peekc != 'p' && peekc != 'l'
4423: #ifdef PARENS
4424: && peekc != 'b'
4425: #endif
4426: #ifdef STRLEN
4427: && peekc != 'q'
4428: #endif
4429: ) {
4430: ceof = peekc;
4431: peekc = 0;
4432: while ((c = getchar()) != ceof && c != '\n') {
4433: if (c < 0)
4434: errmsg(59);
4435: if (c == '\\')
4436: if ((c = getchar()) == '\n')
4437: errmsg(46);
4438: *p2++ = c;
4439: if (p2 >= &rhsbuf[LBSIZE / 2 - 2])
4440: errmsg(42);
4441: }
4442: if (c != '\n')
4443: c = '\0';
4444: else
4445: if (prompt2)
4446: pflag++;
4447: if (p2 != rhsbuf)
4448: *p2 = '\0';
4449: if (*rhsbuf == 0)
4450: errmsg(27);
4451: #ifdef LOG
4452: ++logstats.lc_jglue;
4453: #endif
4454: }
4455: #ifdef LOG
4456: else
4457: ++logstats.lc_join;
4458: #endif
4459: peekc = c;
4460: newline();
4461:
4462: p1 = rhsbuf;
4463: while (*p1)
4464: if (*p1++ == '\n')
4465: errmsg(46);
4466:
4467: p2 = genbuf;
4468: a1 = addr1;
4469:
4470: while (a1 <= addr2) {
4471: p1 = getline(*a1++);
4472: while (*p2++ = *p1++)
4473: #ifndef ALLOC
4474: if (p2 >= &genbuf[LBSIZE - 2])
4475: #else
4476: if (p2 >= &genbuf[lbsize - 2])
4477: #endif
4478: errmsg(12);
4479: --p2;
4480: if (ceof && a1 <= addr2) {
4481: p1 = rhsbuf;
4482: while (*p2++ = *p1++)
4483: #ifndef ALLOC
4484: if (p2 >= &genbuf[LBSIZE - 2])
4485: #else
4486: if (p2 >= &genbuf[lbsize - 2])
4487: #endif
4488: errmsg(12);
4489: --p2;
4490: }
4491: }
4492: *p2 = '\0';
4493:
4494: p1 = genbuf;
4495: p2 = linebuf;
4496: while (*p2++ = *p1++);
4497:
4498: a1 = putline();
4499: savemark(*addr1, a1);
4500: *addr1++ = a1;
4501: delete();
4502: dot = --addr1;
4503: if (dot > dol)
4504: dot = dol;
4505: }
4506: #endif
4507:
4508: #ifdef TABS
4509: listabs() {
4510: register n;
4511:
4512: if (maxtab < 0)
4513: errmsg(9);
4514: n = next_tab(-1);
4515: printf("tabs: %d", n + 1);
4516: while ((n = next_tab(n)) >= 0)
4517: printf(",%d", n + 1);
4518: putchar('\n');
4519: }
4520: #endif
4521:
4522: mail() {
4523: delexit(1);
4524: }
4525:
4526: move(cflag) {
4527: extern getcopy();
4528: register linep *adt, *ad1, *ad2;
4529:
4530: setdot();
4531: nonzero();
4532: if ((adt = address()) == 0)
4533: errmsg(31);
4534: ad1 = addr1;
4535: ad2 = addr2;
4536: newline();
4537: if (cflag) {
4538: ad1 = dol;
4539: append(getcopy, ad1++, 0, 0);
4540: ad2 = dol;
4541: }
4542: ad2++;
4543: if (adt < ad1) {
4544: dot = adt + (ad2 - ad1);
4545: if (++adt == ad1)
4546: return;
4547: reverse(adt, ad1);
4548: reverse(ad1, ad2);
4549: reverse(adt, ad2);
4550: } else if (adt >= ad2) {
4551: dot = adt++;
4552: reverse(ad1, ad2);
4553: reverse(ad2, adt);
4554: reverse(ad1, adt);
4555: } else
4556: errmsg(28);
4557: }
4558:
4559: newline() {
4560: register charac c;
4561:
4562: if ((c = getchar()) == '\n')
4563: return;
4564: if (c == 'p' || c == 'l'
4565: #ifdef PARENS
4566: || c == 'b'
4567: #endif
4568: #ifdef STRLEN
4569: || c == 'q'
4570: #endif
4571: ) {
4572: pflag++;
4573: if (c == 'l')
4574: listf++;
4575: #ifdef PARENS
4576: else if (c == 'b')
4577: parenf++;
4578: #endif
4579: #ifdef STRLEN
4580: else if (c == 'q')
4581: quotef++;
4582: #endif
4583: if (getchar() == '\n')
4584: return;
4585: }
4586: errmsg(25);
4587: }
4588:
4589: #ifdef TABS
4590: next_tab(acol) {
4591: register n;
4592:
4593: if ((n = acol) < maxtab) {
4594: do {
4595: n++;
4596: } while (!(tabs[n >> BPWC] >> (n & BPWM) & 01));
4597: return(n);
4598: }
4599: return(-1);
4600: }
4601: #endif
4602:
4603: nonzero() {
4604: if (addr1 <= zero)
4605: errmsg(23);
4606: if (addr2 > dol)
4607: errmsg(24);
4608: }
4609:
4610: #ifdef PIPE
4611: oil_spilled() {
4612: if (!iflg) {
4613: signal(SIGINT, 1);
4614: signal(SIGQIT, 1);
4615: }
4616: signal(SIGPIP, 1);
4617: piperr++;
4618: }
4619: #endif
4620:
4621: onintr() {
4622: register char *p1, *p2;
4623:
4624: signal(SIGINT, onintr);
4625: #ifdef USE
4626: if (alt) {
4627: close(alt);
4628: alt = 0;
4629: eflg2 = 0;
4630: }
4631: #endif
4632: if (io) {
4633: if (curt)
4634: putsn("?intI/O");
4635: else {
4636: puts2("\7Interrupted I/O!!!\7\nWarning: \"");
4637: puts2(file);
4638: if (io_w) {
4639: putsn("\" is probably truncated.");
4640: puts2("You should probably re-write it.");
4641: } else {
4642: putsn("\" was not read entirely.");
4643: puts2("If you write the buffer, ");
4644: puts2("part of the file may be lost.");
4645: }
4646: }
4647: flush_buf();
4648: }
4649: #ifdef EOL
4650: prompt3 = 1;
4651: #endif
4652: if (fout != 1) {
4653: close(fout);
4654: fout = 1;
4655: }
4656: #ifdef YINT
4657: if (!globp && reading && yflg) {
4658: globp = ".:\n";
4659: if (yplus) {
4660: dot = findmark(yplus, 0);
4661: } else
4662: globp++;
4663: peekc = 0;
4664: putchar('\n');
4665: commands(1);
4666: reset();
4667: }
4668: #endif
4669: if (iflg) {
4670: signal(SIGINT, 1);
4671: backup(INT);
4672: delexit(1);
4673: }
4674: putchar(lastc = '\n');
4675: errmsg(29);
4676: }
4677:
4678: override() {
4679: struct stat s;
4680:
4681: if (access(file, 02) < 0) {
4682: if (stat(file, &s) >= 0 && (s.st_mode & S_IFMT) == S_IFREG) {
4683: overmode = s.st_mode & 07777;
4684: if (chmod(file, overmode) < 0)
4685: return;
4686: if (immflg == 0) {
4687: if (curt) {
4688: puts2("?\"");
4689: puts2(file);
4690: puts2("\" ");
4691: } else {
4692: puts2("The file \"");
4693: puts2(file);
4694: puts2("\" is write-protected.");
4695: }
4696: if (yes_no(curt? "override" :
4697: "Do you wish to over-ride the permission",
4698: 0, 1, 1))
4699: return;
4700: }
4701: overfile = file;
4702: if (chmod(overfile, overmode | 0200) < 0)
4703: overfile = 0;
4704: else {
4705: putsn("[over-riding]");
4706: #ifdef LOG
4707: ++logstats.lm_overwrite;
4708: #endif
4709: }
4710: }
4711: }
4712: }
4713:
4714: #ifdef PAGE
4715: page() {
4716: register cl, n;
4717: register char *p, *pp;
4718: register linep *a, *b;
4719: register l;
4720:
4721: a = addr1;
4722: if (addr2 != addr1)
4723: b = addr2;
4724: else
4725: b = dol;
4726: #ifdef PARENS
4727: parenc[0] = 0;
4728: parenc[1] = 0;
4729: parenc[2] = 0;
4730: #endif
4731: for (n = pcount; n >= 0 && a <= b; n--) {
4732: pp = p = getline(*a);
4733: cl = prompt1? 8 : 0;
4734: l = 0;
4735: while (*p) {
4736: if (*p < ' ' || *p > '~')
4737: switch (*p) {
4738: case '\b':
4739: if (listf)
4740: cl++;
4741: else {
4742: cl--;
4743: if (aflg
4744: #ifdef PARENS
4745: && !parenf
4746: #endif
4747: #ifdef STRLEN
4748: && !quotef
4749: #endif
4750: )
4751: l++;
4752: }
4753: break;
4754: case '\t':
4755: if (listf)
4756: cl++;
4757: else
4758: cl += 8 - cl % 8;
4759: break;
4760: case '\r':
4761: if (listf)
4762: cl += 2;
4763: else
4764: cl = 0;
4765: break;
4766: case ctrl('L'): /* ADM-3A's */
4767: if (listf)
4768: cl++;
4769: cl++;
4770: break;
4771: default:
4772: if (listf || zflg)
4773: cl += 2;
4774: }
4775: else
4776: cl++;
4777: #ifdef PARENS
4778: if (parenf && paren(*p))
4779: l++;
4780: #endif
4781: #ifdef STRLEN
4782: /* if (quotef && (*p == '"' || *p == '\'')) */
4783: if (quotef && (quotec? *p == quotec :
4784: *p == '"' || *p == '\''))
4785: l++;
4786: #endif
4787: if (cl < 0)
4788: cl = 0;
4789: else if (cl > ccount) {
4790: cl = 0;
4791: if (--n < 0)
4792: goto done;
4793: }
4794: p++;
4795: }
4796: if (l)
4797: if (--n < 0)
4798: goto done;
4799: col = 0;
4800: printlno(line_num = a - zero);
4801: puts(pp);
4802: a++;
4803: }
4804: done:
4805: dot = a - 1;
4806: }
4807: #endif
4808:
4809: #ifdef PARENS
4810: paren(ac) {
4811: switch (ac) {
4812: case '(': return(1);
4813: case '[': return(2);
4814: case '{': return(3);
4815: case ')': return(-1);
4816: case ']': return(-2);
4817: case '}': return(-3);
4818: }
4819: return(0);
4820: }
4821: #endif
4822:
4823: place(asp, al1, al2) {
4824: register char *sp, *l1, *l2;
4825:
4826: sp = asp;
4827: l1 = al1;
4828: l2 = al2;
4829: while (l1 < l2) {
4830: *sp++ = *l1++;
4831: #ifndef ALLOC
4832: if (sp >= &genbuf[LBSIZE - 2])
4833: #else
4834: if (sp >= &genbuf[lbsize - 2])
4835: #endif
4836: errmsg(42);
4837: }
4838: return(sp);
4839: }
4840:
4841: /*VARARGS*/
4842: printf(as, aarglist)
4843: char *as;
4844: {
4845: register *args, w;
4846: register char *q;
4847: register flag f;
4848:
4849: args = &aarglist;
4850: while (*as) {
4851: if (*as != '%') {
4852: putchar(*as++);
4853: continue;
4854: }
4855: if (*++as == '\0')
4856: return;
4857: w = 0; /* no default width */
4858: f = 0; /* unsigned default */
4859: while ('0' <= *as && *as <= '9')
4860: w = w * 10 + *as++ - '0';
4861: if (*as == '\0')
4862: return;
4863: switch (*as++) {
4864: case 'c': /* char */
4865: putchar(*args++);
4866: continue;
4867: case 'd': /* signed decimal */
4868: f = 1; /* signed */
4869: case 'u': /* unsigned decimal */
4870: printfn(*args++, 10, f, w);
4871: continue;
4872: case 'o': /* unsigned octal */
4873: printfn(*args++, 8, 0, w);
4874: continue;
4875: case 's': /* string */
4876: q = *args++;
4877: while (*q) {
4878: putchar(*q++);
4879: --w;
4880: }
4881: while (--w > 0)
4882: putchar(' ');
4883: continue;
4884: default:
4885: putchar(as[-1]);
4886: continue;
4887: }
4888: }
4889: }
4890:
4891: printfn(an, ab, af, aw) {
4892: register w;
4893: register unsigned n;
4894: register char *p;
4895: char buf[(sizeof(int) != 2? 10 : 6) + 2];
4896:
4897: w = aw;
4898: p = &buf[sizeof buf];
4899: *--p = '\0';
4900: n = an;
4901: if (af)
4902: if (an < 0)
4903: n = -an;
4904: else
4905: af = 0;
4906: do {
4907: *--p = n % ab + '0';
4908: --w;
4909: } while (n /= ab);
4910: if (af) {
4911: *--p = '-';
4912: --w;
4913: }
4914: while (--w >= 0)
4915: putchar(' ');
4916: while (*p)
4917: putchar(*p++);
4918: }
4919:
4920: printlno(an) {
4921: register flag l;
4922:
4923: if (prompt1) {
4924: l = listf;
4925: listf = 0;
4926: printf(fmtlno, an - aflg);
4927: col = 8;
4928: listf = l;
4929: }
4930: }
4931:
4932: printmarks() {
4933: register linep *a1;
4934: register charac c;
4935: register n, i;
4936:
4937: #ifdef HUGE
4938: i = hugef ^ 01;
4939: #endif
4940: for (c = 'a' - 'a'; c <= 'z' - 'a'; c++) {
4941: if (names[c] == 0) /* zap marks to deleted lines */
4942: continue;
4943: n = 0;
4944: for (a1 = zero + 1; a1 <= dol; a1++)
4945: if (names[c] == (*a1 |
4946: #ifdef HUGE
4947: i
4948: #else
4949: 01
4950: #endif
4951: )) {
4952: n++;
4953: printf("%c=%u", c + 'a', a1 - zero);
4954: #ifdef EXTMARK
4955: if (names2[c]) {
4956: for (a1++; a1 <= dol; a1++)
4957: if (names2[c] == (*a1 | 01)) {
4958: printf(",%u", a1 - zero);
4959: break;
4960: }
4961: }
4962: #endif
4963: putchar(' ');
4964: break;
4965: }
4966: if (n == 0)
4967: names[c] = 0; /* clear unknown marks */
4968: }
4969: putchar('\n');
4970: }
4971:
4972: putchar(ac)
4973: charac ac;
4974: {
4975: register char *lp;
4976: register charac c;
4977:
4978: lp = linp;
4979: c = ac;
4980: #ifdef APLMAP
4981: if (aplmap && fout == 1 && c > ' ')
4982: c = map_apl[c - (' ' + 1)];
4983: #endif
4984: if (listf) {
4985: if (++col >= ccount - 1) {
4986: col = 1;
4987: if (c != '\n') {
4988: *lp++ = '\\';
4989: *lp++ = '\n';
4990: }
4991: }
4992: if (c == '\t') {
4993: c = '>';
4994: goto esc;
4995: }
4996: if (c == '\b') {
4997: c = '<';
4998: esc:
4999: *lp++ = '-';
5000: *lp++ = '\b';
5001: *lp++ = c;
5002: goto out;
5003: }
5004: if (c < ' ' && c != '\n' || c == 0177) {
5005: *lp++ = '^';
5006: *lp++ = c ^ 0100;
5007: col++;
5008: goto out;
5009: }
5010: }
5011: *lp++ = c;
5012: out:
5013: if (lp >= &line[TTSIZE]) {
5014: linp = line;
5015: write(fout, line, lp - line);
5016: return;
5017: }
5018: linp = lp;
5019: }
5020:
5021: putfile() {
5022: register char *fp, *lp;
5023: register nib;
5024: register linep *a1;
5025:
5026: nib = BLKSIZE;
5027: fp = genbuf;
5028: a1 = addr1;
5029: do {
5030: lp = getline(*a1++);
5031: for ever {
5032: if (--nib < 0) {
5033: wte(io, genbuf, fp - genbuf);
5034: nib = BLKSIZE - 1;
5035: fp = genbuf;
5036: }
5037: if ((*fp++ = *lp++) == 0) {
5038: fp[-1] = '\n';
5039: break;
5040: }
5041: }
5042: } while (a1 <= addr2);
5043: wte(io, genbuf, fp - genbuf);
5044: }
5045:
5046: putline() {
5047: register char *bp, *lp;
5048: register nl, tl;
5049:
5050: lp = linebuf;
5051: tl = tline;
5052: #ifdef DEBUG
5053: if (tflg)
5054: printf("putline:\t%o\n", tl);
5055: #endif
5056: bp = getblock(tl, WRITE);
5057: #ifdef HUGE
5058: if (hugef2) {
5059: hugef2 = 0;
5060: tl = tline = (tline >> 1) & _6[hugef];
5061: }
5062: tl &= _1[hugef];
5063: #else
5064: tl &= _1;
5065: #endif
5066: nl = nleft;
5067: while (*bp = *lp++) {
5068: if (*bp++ == '\n') {
5069: *--bp = 0;
5070: linebp = lp;
5071: break;
5072: }
5073: if (--nl <= 0) {
5074: #ifdef HUGE
5075: bp = getblock(tl += _2[hugef], WRITE);
5076: #else
5077: bp = getblock(tl += _2, WRITE);
5078: #endif
5079: nl = nleft;
5080: }
5081: }
5082: nl = tline;
5083: #ifdef HUGE
5084: tline += (((lp - linebuf) + 03) >> (1 + hugef)) & _6[hugef];
5085: #else
5086: tline += (((lp - linebuf) + 03) >> 1) & _6;
5087: #endif
5088: return(nl);
5089: }
5090:
5091: #ifdef PARENS
5092: putparen(an) {
5093: register c;
5094:
5095: an %= 10 + 26 + 26;
5096: if (an < 0)
5097: an += 10 + 26 + 26;
5098: c = '0';
5099: if (an > 9 + 26)
5100: c = 'a' - (10 + 26);
5101: else if (an > 9)
5102: c = 'A' - 10;
5103: putchar(c + an);
5104: }
5105: #endif
5106:
5107: puts(as) {
5108: register n;
5109: register flag ovp;
5110: register char *sp, *s;
5111:
5112: sp = as;
5113: ovp = 0;
5114: while (*sp) {
5115: if (aflg &&
5116: #ifdef PARENS
5117: !parenf &&
5118: #endif
5119: #ifdef STRLEN
5120: !quotef &&
5121: #endif
5122: !listf && *sp == '\b') {
5123: ovp = 1;
5124: sp += 2;
5125: continue;
5126: }
5127: #ifdef PARENS
5128: if (!ovp && parenf && !listf && paren(*sp))
5129: ovp = 1;
5130: #endif
5131: #ifdef STRLEN
5132: /* if (!ovp && quotef && !listf && (*sp == '"' || *sp == '\'')) */
5133: if (!ovp && quotef && !listf && (
5134: quotec? *sp == quotec : *sp == '"' || *sp == '\''))
5135: ovp = 1;
5136: #endif
5137: putchar(*sp++);
5138: }
5139: sp = as;
5140: if (aflg && ovp &&
5141: #ifdef PARENS
5142: !parenf &&
5143: #endif
5144: #ifdef STRLEN
5145: !quotef &&
5146: #endif
5147: !listf) {
5148: putchar('\n');
5149: if (prompt1)
5150: putchar('\t');
5151: for (; *sp; sp++)
5152: if (sp[1] == '\b' && sp[2]) {
5153: putchar(sp[2]);
5154: sp += 2;
5155: } else if (*sp == '\t')
5156: putchar('\t');
5157: else if (*sp >= ' ')
5158: putchar(' ');
5159: ovp = 0;
5160: }
5161: #ifdef PARENS
5162: if (parenf && ovp && !listf) {
5163: putchar('\n');
5164: if (prompt1)
5165: putchar('\t');
5166: for (; *sp; sp++)
5167: if (n = paren(*sp)) {
5168: if (n < 0) {
5169: n = -n - 1;
5170: putparen(parenc[n]--);
5171: } else
5172: putparen(++parenc[--n]);
5173: } else if (*sp == '\t' || *sp >= ' ')
5174: putchar(*sp == '\t'? '\t' : ' ');
5175: ovp = 0;
5176: }
5177: #endif
5178: #ifdef STRLEN
5179: if (quotef && ovp && !listf) {
5180: s = null;
5181: n = 0;
5182: ovp = 0;
5183: putchar('\n');
5184: if (prompt1)
5185: putchar('\t');
5186: for (; *sp; sp++) {
5187: /* if (n == 0 && (*sp == '"' || *sp == '\'') || */
5188: if (n == 0 && (quotec? *sp == (ovp?
5189: quotec : quotec2) : *sp == '"' || *sp == '\'') ||
5190: *sp == n) {
5191: if (ovp) {
5192: ovp = 0;
5193: goto not;
5194: }
5195: if (n)
5196: n = 0;
5197: else {
5198: s = sp++;
5199: n = 0;
5200: while (*sp && *sp != *s) {
5201: if (*sp == '\\') {
5202: if ('0' <= *++sp && *sp <= '7') {
5203: if ('0' <= *++sp && *sp <= '7')
5204: if ('0' <= *++sp && *sp <= '7')
5205: sp++;
5206: } else
5207: sp++;
5208: } else
5209: sp++;
5210: n++;
5211: }
5212: sp = s;
5213: s = &"00000"[5];
5214: do {
5215: *--s = n % 10 + '0';
5216: } while (n /= 10);
5217: n = *sp;
5218: }
5219: }
5220: not: if (*s)
5221: putchar(*s++);
5222: else
5223: putchar(*sp == '\t'? '\t' : ' ');
5224: if (*sp == '\\')
5225: ovp ^= 01;
5226: }
5227: ovp = 0;
5228: }
5229: #endif
5230: putchar('\n');
5231: }
5232:
5233: puts2(as) {
5234: register char *sp;
5235:
5236: sp = as;
5237: while (*sp)
5238: putchar(*sp++);
5239: }
5240:
5241: #ifdef CKPT
5242: recover() {
5243: extern etext;
5244: register filedes f;
5245: register char *p;
5246: register func savint, savqit;
5247: int n;
5248:
5249: savint = signal(SIGINT, 1);
5250: savqit = signal(SIGQIT, 1);
5251: if ((f = open(cfname, 0)) < 0 ||
5252: read(f, &n, sizeof n) != sizeof n) {
5253: n = 67;
5254: goto cerror;
5255: }
5256: p = &etext;
5257: if (brk(p + n) == -1) {
5258: n = 67;
5259: goto cerror;
5260: }
5261: #ifdef pdp11 /* 16 bit byte count only */
5262: if (n < 0) {
5263: if (read(f, p, 32256) != 32256) {
5264: n = 67;
5265: goto cerror;
5266: }
5267: n -= 32256; /* 63 blocks, since 64 is < 0 */
5268: p += 32256;
5269: }
5270: #endif
5271: if (read(f, p, n) != n ||
5272: (tfile = open(tfname, 2)) < 0)
5273: n = 67;
5274: else
5275: n = 0;
5276: recovry = 1; /* overwritten by reading data space */
5277: cerror:
5278: if (n) {
5279: puts(errtext[n]);
5280: exit(1);
5281: }
5282: if (f > 0)
5283: close(f);
5284:
5285: /*
5286: * "initialize" special stuff to restore order
5287: */
5288:
5289: globp = 0;
5290: io = 0;
5291: io_w = 0;
5292: #ifdef HELP
5293: doc = 0;
5294: #endif
5295: #ifdef USE
5296: alt = 0;
5297: #endif
5298: #ifdef AGAIN
5299: agf = 0;
5300: agp = 0;
5301: #endif
5302: #ifdef EOL
5303: prompt3 = 1;
5304: #endif
5305: #ifdef PIPE
5306: if (pfile) {
5307: unlink(pfname);
5308: pfile = 0;
5309: }
5310: #endif
5311:
5312: signal(SIGINT, savint);
5313: signal(SIGQIT, savqit);
5314: }
5315: #endif
5316:
5317: reverse(aa1, aa2) {
5318: register linep *a1, *a2, t;
5319:
5320: a1 = aa1;
5321: a2 = aa2;
5322: for ever {
5323: t = *--a2;
5324: if (a2 <= a1)
5325: return;
5326: *a2 = *a1;
5327: *a1++ = t;
5328: }
5329: }
5330:
5331: #ifdef XDEL
5332: saveline() {
5333: register linep *a1, *a2, *bp;
5334: register nl, tl;
5335:
5336: a1 = addr1;
5337: a2 = addr2;
5338: ndeleted = a2 - a1 + 1;
5339: tl = tline;
5340: #ifdef DEBUG
5341: if (tflg)
5342: printf("saveline:\t%o\n", tl);
5343: #endif
5344: bp = getblock(tl, WRITE);
5345: #ifdef HUGE
5346: if (hugef2) {
5347: hugef2 = 0;
5348: tl = (tl >> 1) & _6[hugef];
5349: }
5350: tl &= _1[hugef];
5351: #else
5352: tl &= _1;
5353: #endif
5354: nl = nleft / sizeof(linep);
5355: while (a1 <= a2) {
5356: *bp++ = *a1++;
5357: if (--nl <= 0) {
5358: #ifdef HUGE
5359: bp = getblock(tl += _2[hugef], WRITE);
5360: if (hugef2) {
5361: hugef2 = 0;
5362: tl = (tl >> 1) & _6[hugef];
5363: }
5364: #else
5365: bp = getblock(tl += _2, WRITE);
5366: #endif
5367: nl = nleft / sizeof(linep);
5368: }
5369: }
5370: deleted = tline;
5371: #ifdef HUGE
5372: tline += ((a2 - addr1 + 1) << (1 - hugef)) & _6[hugef];
5373: #else
5374: tline += ((a2 - addr1 + 1) << 1) & _6;
5375: #endif
5376: }
5377: #endif
5378:
5379: savemark(p1, p2)
5380: linep p1, p2;
5381: {
5382: register n;
5383: #ifdef HUGE
5384: register i;
5385:
5386: i = hugef ^ 01;
5387: p1 |= i;
5388: p2 |= i;
5389: #else
5390: p1 |= 01;
5391: p2 |= 01;
5392: #endif
5393: /* save "marks" on lines so marked */
5394: for (n = 0; n <= 'z' - 'a'; n++) {
5395: if (names[n] == 0) /* zap marks to deleted lines */
5396: continue;
5397: if (names[n] == p1)
5398: names[n] = p2;
5399: #ifdef EXTMARK
5400: if (names2[n] && names2[n] == p1)
5401: names2[n] = p2;
5402: #endif
5403: }
5404: #ifdef YINT
5405: /* don't lose "y+" line either */
5406: if (yplus == p1)
5407: yplus = p2;
5408: #endif
5409: #ifdef UNDO
5410: /* and remember the line for "undo" */
5411: undo_oldp = p1;
5412: undo_newp = p2;
5413: #endif
5414: }
5415:
5416: scopy(ass, ads)
5417: char *ass, *ads;
5418: {
5419: register char *p, *q;
5420:
5421: p = ass;
5422: q = ads;
5423: while (*q++ = *p++)
5424: ;
5425: return(ads);
5426: }
5427:
5428: setall() {
5429: if (addr2 == 0) {
5430: addr1 = zero + (zero != dol);
5431: addr2 = dol;
5432: }
5433: setdot();
5434: }
5435:
5436: setchar(adflt) {
5437: register charac c;
5438:
5439: if ((c = getchar()) == '\\')
5440: c = getchar();
5441: if (c < 0)
5442: errmsg(59);
5443: if (c == '\n')
5444: return(adflt);
5445: newline();
5446: return(c);
5447: }
5448:
5449: setdot() {
5450: if (addr2 == 0)
5451: addr1 = addr2 = dot;
5452: if (addr1 > addr2)
5453: errmsg(21);
5454: }
5455:
5456: setnoaddr() {
5457: if (addr2)
5458: errmsg(22);
5459: }
5460:
5461: setnum(adflt) {
5462: register n;
5463:
5464: white_space();
5465: n = adflt;
5466: if ('0' <= (peekc = getchar()) && peekc <= '9')
5467: n = getnum();
5468: newline();
5469: return(n);
5470: }
5471:
5472: #ifdef TABS
5473: settab(acs) {
5474: register *p, i, n;
5475:
5476: if (acs == 0) {
5477: maxtab = -1;
5478: n = TABS;
5479: p = tabs;
5480: while (--n >= 0)
5481: *p++ = 0;
5482: return;
5483: }
5484: i = 0;
5485: if (acs < 0) {
5486: acs = -acs;
5487: i++;
5488: }
5489: if (--acs < TABS * BPW) {
5490: p = &tabs[acs >> BPWC];
5491: *p |= 01 << (n = acs & BPWM);
5492: if (i) {
5493: *p ^= 01 << n;
5494: if (acs == maxtab) { /* find new maxtab */
5495: for (n = TABS - 1; n >= 0; --n)
5496: if (tabs[n >> BPWC] >> (n & BPWM) & 01)
5497: break;
5498: maxtab = n;
5499: }
5500: } else if (acs > maxtab)
5501: maxtab = acs;
5502: }
5503: }
5504: #endif
5505:
5506: shell() {
5507: #ifdef PIPE
5508: extern oil_spilled();
5509: #endif
5510: register pid, wpid;
5511: register linep *a;
5512: register dp, df, nopipe, c, e, savint, savqit;
5513: register linep *dest;
5514: int retcode, p[2];
5515:
5516: #ifdef PIPE
5517: dp = 0;
5518: df = 0;
5519: if (addr2) {
5520: #ifdef LOG
5521: ++logstats.lc_pipe;
5522: #endif
5523: dest = 0;
5524: nopipe = 0;
5525: if ((peekc = getchar()) == '|') {
5526: nonzero();
5527: peekc = 0;
5528: dp++;
5529: df++;
5530: #ifdef LOG
5531: --logstats.lc_pipe;
5532: ++logstats.lc_dpipe;
5533: #endif
5534: }
5535: if ((peekc = getchar()) == '>') {
5536: nonzero();
5537: #ifdef LOG
5538: --logstats.lc_pipe;
5539: ++logstats.lc_pto;
5540: #endif
5541: goto pi;
5542: } else if ((peekc = getchar()) == '<') {
5543: nopipe++;
5544: #ifdef LOG
5545: --logstats.lc_pipe;
5546: ++logstats.lc_pfrom;
5547: #endif
5548: pi: peekc = 0;
5549: dp++;
5550: dest = addr2;
5551: }
5552: if (dp && '0' <= (peekc = getchar()) && peekc <= '9') {
5553: c = getnum();
5554: dest = zero + c;
5555: if (dest < zero)
5556: dest = zero + 1;
5557: if (dest > dol)
5558: dest = dol;
5559: }
5560: }
5561: #ifdef LOG
5562: else
5563: ++logstats.lc_shell;
5564: #endif
5565: piperr = 0;
5566: if (!iflg)
5567: if (addr2) {
5568: savint = signal(SIGINT, oil_spilled);
5569: savqit = signal(SIGQIT, oil_spilled);
5570: } else {
5571: #endif
5572: savint = signal(SIGINT, 1);
5573: savqit = signal(SIGQIT, 1);
5574: #ifdef PIPE
5575: }
5576: if (addr2 && pipe(p) < 0) {
5577: c = 15;
5578: errm: if (!iflg) {
5579: signal(SIGINT, savint);
5580: signal(SIGQIT, savqit);
5581: }
5582: if (c)
5583: errmsg(c);
5584: error();
5585: }
5586: if (dp) {
5587: if ((pfile = create(pfname, LMODE)) < 0) {
5588: pfile = 0;
5589: c = 64;
5590: goto errm;
5591: }
5592: if ((io = open(pfname, 0)) < 0) {
5593: io = 0;
5594: c = 65;
5595: goto errm;
5596: }
5597: }
5598: #endif
5599: if ((pid = fork()) < 0) {
5600: #ifdef PIPE
5601: if (addr2) {
5602: close(p[0]);
5603: close(p[1]);
5604: }
5605: #endif
5606: c = 14;
5607: goto errm;
5608: }
5609: if (pid == 0) {
5610: /* kid */ if (!iflg) {
5611: /* kid */ signal(SIGHUP, 0);
5612: /* kid */ signal(SIGINT, 0);
5613: /* kid */ signal(SIGQIT, 0);
5614: /* kid */ }
5615: #ifdef PIPE
5616: /* kid */ if (addr2) {
5617: /* kid */ close(0);
5618: /* kid */ dup(p[0]);
5619: /* kid */ close(p[0]);
5620: /* kid */ close(p[1]);
5621: /* kid */ if (dp) {
5622: /* kid */ close(1);
5623: /* kid */ dup(pfile);
5624: /* kid */ close(pfile);
5625: /* kid */ }
5626: /* kid */ }
5627: #endif
5628: /* kid */ execl("/bin/sh", "!sh", "-t", 0);
5629: /* kid */ write(2, "No shell!\n", 10);
5630: /* kid */ exit(0177);
5631: }
5632: #ifdef CMDS
5633: if (cmd && !addr2)
5634: write(cmd, "<UNIX>\n", 7);
5635: #endif
5636: #ifdef PIPE
5637: if (addr2) {
5638: signal(SIGPIP, oil_spilled);
5639: close(p[0]);
5640: e = eflg2;
5641: eflg2++;
5642: fout = p[1];
5643: while ((c = getchar()) >= 0 && c != '\n')
5644: putchar(c);
5645: putchar('\n');
5646: if (!nopipe) {
5647: line_num = (a = addr1) - zero - aflg;
5648: do {
5649: if (pno >= 0)
5650: printlno(line_num++);
5651: puts(getline(*a++));
5652: } while (a <= addr2 && !piperr);
5653: }
5654: flush_buf();
5655: fout = 1;
5656: eflg2 = e;
5657: close(p[1]);
5658: if (!iflg) {
5659: signal(SIGINT, 1);
5660: signal(SIGQIT, 1);
5661: }
5662: }
5663: #endif
5664: while ((wpid = wait(&retcode)) != pid && wpid >= 0);
5665: #ifdef CMDS
5666: if (cmd)
5667: lseek(cmd, 0L, 2);
5668: #endif
5669: #ifdef PIPE
5670: if (addr2)
5671: signal(SIGPIP, 0);
5672: #endif
5673: if (c = retcode & 0177) {
5674: if (0 < c && c < NSTR && status[c])
5675: puts2(status[c]);
5676: else
5677: printf("signal %d", c);
5678: if (retcode & 0200)
5679: puts2(" -- core dumped");
5680: putchar(lastc = '\n');
5681: c = 0;
5682: goto errm;
5683: } else if (df && strict && retcode >> 8) {
5684: printf("exit status %d\n", retcode >> 8);
5685: c = 0;
5686: goto errm;
5687: }
5688: #ifdef PIPE
5689: else if (addr2) {
5690: if (piperr) {
5691: putsn(status[SIGPIP]);
5692: c = 0;
5693: goto errm;
5694: }
5695: if (dp) {
5696: if (df) {
5697: c = addr2 != dol;
5698: delete();
5699: if (dest == 0)
5700: dest = dot - c;
5701: } else if (dest == 0)
5702: dest = addr2;
5703: if (dest < zero)
5704: dest = zero;
5705: if (c = append(getfile, dest, 0, 0))
5706: text_modified++;
5707: if (prompt2)
5708: printf((curt? prcntu : errtext[55]),
5709: c, (c == 1? null : quote_s));
5710: close(io);
5711: io = 0;
5712: unlink(pfname);
5713: close(pfile);
5714: pfile = 0;
5715: }
5716: }
5717: #endif
5718: if (!iflg) {
5719: signal(SIGINT, savint);
5720: signal(SIGQIT, savqit);
5721: }
5722: if (!addr2)
5723: putsn("!");
5724: #ifdef CLEAR
5725: istty(1); /* in case bs1 changed */
5726: #endif
5727: }
5728:
5729: signals(ast)
5730: struct sigtab *ast;
5731: {
5732: register n;
5733: register struct sigtab *s;
5734:
5735: s = ast - 1;
5736: while (n = (++s)->s_sig)
5737: signal(n, s->s_func);
5738: }
5739:
5740: skip_rest() {
5741: register charac c;
5742:
5743: while ((c = getchar()) >= 0 && c != '\n');
5744: }
5745:
5746: substitute(inglob) {
5747: extern getsub();
5748: register linep *a1, p;
5749: register nl;
5750: register flag gsubf;
5751:
5752: gsubf = compsub(); /* 0 or 1 depending on 'g' */
5753: for (a1 = addr1; a1 <= addr2; a1++) {
5754: s_tmp = s_cnt;
5755: if (execute(0, a1) == 0)
5756: continue;
5757: inglob |= 01;
5758: dosub();
5759: if (gsubf)
5760: while (*loc2) {
5761: if (execute(1) == 0)
5762: break;
5763: dosub();
5764: }
5765: p = *a1;
5766: *a1 = putline();
5767: savemark(p, *a1);
5768: nl = append(getsub, a1, 0, 0);
5769: a1 += nl;
5770: addr2 += nl;
5771: }
5772: if (inglob == 0)
5773: errmsg(39);
5774: }
5775:
5776: #ifdef XED
5777: tack(aeof, aflag)
5778: char aeof;
5779: {
5780: register n;
5781: register char *p1, *p2;
5782: register linep *a;
5783: register charac c;
5784:
5785: nonzero();
5786: setdot();
5787: p1 = rhsbuf; /* i/TEXT screwed for long lines */
5788: while ((c = getchar()) != aeof && c != '\n') {
5789: if (c == '\\')
5790: if ((c = getchar()) == '\n')
5791: break;
5792: if (c < 0)
5793: errmsg(59);
5794: *p1++ = c;
5795: if (p1 >= &rhsbuf[LBSIZE / 2 - 2])
5796: errmsg(42);
5797: }
5798: if (*rhsbuf == 0)
5799: errmsg(27);
5800: if (c == '\n') {
5801: if (prompt2)
5802: pflag++;
5803: } else
5804: newline();
5805: if (p1 != rhsbuf)
5806: *p1 = 0;
5807: else
5808: while (*p1)
5809: p1++;
5810: n = p1 - rhsbuf;
5811: for (a = addr1; a <= addr2; a++) {
5812: getline(*a);
5813: for (p2 = linebuf; *p2; p2++);
5814: #ifndef ALLOC
5815: if (p2 + n >= &linebuf[LBSIZE / 2 - 2])
5816: #else
5817: if (p2 + n >= &linebuf[lbsize / 2 - 2])
5818: #endif
5819: errmsg(30);
5820: if (aflag) { /* $ */
5821: p1 = rhsbuf;
5822: while (*p2++ = *p1++);
5823: } else { /* ^ */
5824: p1 = p2 + n;
5825: *p1 = *p2;
5826: while (p2 > linebuf)
5827: *--p1 = *--p2;
5828: p1 = linebuf;
5829: p2 = rhsbuf;
5830: while (*p2)
5831: *p1++ = *p2++;
5832: }
5833: p2 = *a;
5834: *a = putline();
5835: savemark(p2, *a);
5836: }
5837: dot = addr2;
5838: return(addr2 - addr1 + 1);
5839: }
5840: #endif
5841:
5842: term() {
5843: signal(SIGTRM, 1);
5844: if (reading) {
5845: backup(TRM);
5846: if (fout != 1) {
5847: flush_buf();
5848: fout = 1;
5849: }
5850: puts2(errtext[58]);
5851: delexit(1);
5852: }
5853: termflg++;
5854: }
5855:
5856: tmpname(as, an)
5857: char *as;
5858: {
5859: register unsigned n;
5860: register char *p, c;
5861:
5862: p = as;
5863: n = an;
5864: while (*p)
5865: p++;
5866: while (--p >= as)
5867: if ((c = *p) == '0' || (c | 040) == 'x') {
5868: *p = n % 10 + '0';
5869: n /= 10;
5870: #ifdef CKPT
5871: tfnum = p - as;
5872: #endif
5873: }
5874: return(as);
5875: }
5876:
5877: #ifdef XDEL
5878: undelete() {
5879: register linep *a1, *a2, *bp;
5880: register tl, nl, num;
5881:
5882: if ((tl = deleted) == 0)
5883: errmsg(16);
5884: #ifdef DEBUG
5885: if (tflg)
5886: printf("undelete:\t%o\n", tl);
5887: #endif
5888: setdot();
5889: a1 = dol + 1;
5890: a2 = a1 + ndeleted;
5891: bp = addr2 + 1;
5892: if (dol + ndeleted > endcore) {
5893: num = ((ndeleted * 2) + 1023) & ~01777;
5894: if (sbrk(num) == -1)
5895: errmsg(33);
5896: endcore = (int)endcore + num;
5897: }
5898: while (a1 > bp)
5899: *--a2 = *--a1;
5900: dol += ndeleted;
5901: a1 = addr2 + 1;
5902: a2 = a1 + ndeleted;
5903: bp = getblock(tl, READ);
5904: #ifdef HUGE
5905: tl &= _1[hugef];
5906: #else
5907: tl &= _1;
5908: #endif
5909: nl = nleft / sizeof(linep);
5910: while (a1 < a2) {
5911: *a1++ = *bp++;
5912: if (--nl <= 0) {
5913: #ifdef HUGE
5914: bp = getblock(tl += _2[hugef], READ);
5915: #else
5916: bp = getblock(tl += _2, READ);
5917: #endif
5918: nl = nleft / sizeof(linep);
5919: }
5920: }
5921: dot = a2 - 1;
5922: return(ndeleted);
5923: }
5924: #endif
5925:
5926: #ifdef UNDO
5927: undo() {
5928: register linep *a, t, o;
5929:
5930: if (undo_newp == 0 || (a = findmark(undo_newp, 0)) == 0)
5931: errmsg(13);
5932: t = *a |
5933: #ifdef HUGE
5934: hugef ^
5935: #endif
5936: 01;
5937: o = undo_oldp;
5938: savemark(*a, o);
5939: *a = o;
5940: undo_newp = o;
5941: undo_oldp = t;
5942: dot = a;
5943: if (text_modified == 0)
5944: text_modified++;
5945: }
5946: #endif
5947:
5948: white_space() {
5949: register charac c;
5950:
5951: while ((c = getchar()) == ' ' || c == '\t');
5952: peekc = c;
5953: }
5954:
5955: wte(fd, buf, len)
5956: char buf[];
5957: {
5958: if (write(fd, buf, len) != len)
5959: errmsg(-32);
5960: }
5961:
5962: /*
5963: * as a prompt string
5964: * ay yes response, !no response
5965: * ad default (\n) response, <0 means no default allowed
5966: * aef end-of-file response
5967: */
5968: yes_no(as, ay, ad, aef)
5969: char *as;
5970: {
5971: register charac c, p;
5972: register n;
5973: register flag l;
5974:
5975: l = listf;
5976: listf = 0;
5977: p = peekc;
5978: peekc = 0;
5979: for ever {
5980: putchar('\n');
5981: puts2(as);
5982: puts2("? ");
5983: for (n = 0; n < 5; n++) {
5984: flush_buf();
5985: if ((c = getchar()) < 0) {
5986: putchar('\n');
5987: n = aef;
5988: goto ret;
5989: }
5990: if (c != '\n')
5991: skip_rest();
5992: else if (ad >= 0) {
5993: n = ad;
5994: goto ret;
5995: }
5996: if (c == 'y' || c == 'n') {
5997: n = ay;
5998: if (c != 'y')
5999: n ^= 01;
6000: goto ret;
6001: }
6002: puts2("yes or no? ");
6003: }
6004: }
6005: ret:
6006: listf = l;
6007: peekc = p;
6008: return(n);
6009: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.