![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / ex|
Return to ex_subr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / ex |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)ex_subr.c 7.10 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: #include "ex.h"
12: #include "ex_re.h"
13: #include "ex_tty.h"
14: #include "ex_vis.h"
15:
16: /*
17: * Random routines, in alphabetical order.
18: */
19:
20: any(c, s)
21: int c;
22: register char *s;
23: {
24: register int x;
25:
26: while (x = *s++)
27: if (x == c)
28: return (1);
29: return (0);
30: }
31:
32: backtab(i)
33: register int i;
34: {
35: register int j;
36:
37: j = i % value(SHIFTWIDTH);
38: if (j == 0)
39: j = value(SHIFTWIDTH);
40: i -= j;
41: if (i < 0)
42: i = 0;
43: return (i);
44: }
45:
46: change()
47: {
48:
49: tchng++;
50: chng = tchng;
51: }
52:
53: /*
54: * Column returns the number of
55: * columns occupied by printing the
56: * characters through position cp of the
57: * current line.
58: */
59: column(cp)
60: register char *cp;
61: {
62:
63: if (cp == 0)
64: cp = &linebuf[LBSIZE - 2];
65: return (qcolumn(cp, (char *) 0));
66: }
67:
68: /*
69: * Ignore a comment to the end of the line.
70: * This routine eats the trailing newline so don't call newline().
71: */
72: comment()
73: {
74: register int c;
75:
76: do {
77: c = getchar();
78: } while (c != '\n' && c != EOF);
79: if (c == EOF)
80: ungetchar(c);
81: }
82:
83: Copy(to, from, size)
84: register char *from, *to;
85: register int size;
86: {
87:
88: if (size > 0)
89: do
90: *to++ = *from++;
91: while (--size > 0);
92: }
93:
94: copyw(to, from, size)
95: register line *from, *to;
96: register int size;
97: {
98:
99: if (size > 0)
100: do
101: *to++ = *from++;
102: while (--size > 0);
103: }
104:
105: copywR(to, from, size)
106: register line *from, *to;
107: register int size;
108: {
109:
110: while (--size >= 0)
111: to[size] = from[size];
112: }
113:
114: ctlof(c)
115: int c;
116: {
117:
118: return (c == TRIM ? '?' : c | ('A' - 1));
119: }
120:
121: dingdong()
122: {
123:
124: if (VB)
125: putpad(VB);
126: else if (value(ERRORBELLS))
127: putch('\207');
128: }
129:
130: fixindent(indent)
131: int indent;
132: {
133: register int i;
134: register char *cp;
135:
136: i = whitecnt(genbuf);
137: cp = vpastwh(genbuf);
138: if (*cp == 0 && i == indent && linebuf[0] == 0) {
139: genbuf[0] = 0;
140: return (i);
141: }
142: CP(genindent(i), cp);
143: return (i);
144: }
145:
146: filioerr(cp)
147: char *cp;
148: {
149: register int oerrno = errno;
150:
151: lprintf("\"%s\"", cp);
152: errno = oerrno;
153: syserror();
154: }
155:
156: char *
157: genindent(indent)
158: register int indent;
159: {
160: register char *cp;
161:
162: for (cp = genbuf; indent >= value(TABSTOP); indent -= value(TABSTOP))
163: *cp++ = '\t';
164: for (; indent > 0; indent--)
165: *cp++ = ' ';
166: return (cp);
167: }
168:
169: getDOT()
170: {
171:
172: getline(*dot);
173: }
174:
175: line *
176: getmark(c)
177: register int c;
178: {
179: register line *addr;
180:
181: for (addr = one; addr <= dol; addr++)
182: if (names[c - 'a'] == (*addr &~ 01)) {
183: return (addr);
184: }
185: return (0);
186: }
187:
188: getn(cp)
189: register char *cp;
190: {
191: register int i = 0;
192:
193: while (isdigit(*cp))
194: i = i * 10 + *cp++ - '0';
195: if (*cp)
196: return (0);
197: return (i);
198: }
199:
200: ignnEOF()
201: {
202: register int c = getchar();
203:
204: if (c == EOF)
205: ungetchar(c);
206: else if (c=='"')
207: comment();
208: }
209:
210: iswhite(c)
211: int c;
212: {
213:
214: return (c == ' ' || c == '\t');
215: }
216:
217: junk(c)
218: register int c;
219: {
220:
221: if (c && !value(BEAUTIFY))
222: return (0);
223: if (c >= ' ' && c != TRIM)
224: return (0);
225: switch (c) {
226:
227: case '\t':
228: case '\n':
229: case '\f':
230: return (0);
231:
232: default:
233: return (1);
234: }
235: }
236:
237: killed()
238: {
239:
240: killcnt(addr2 - addr1 + 1);
241: }
242:
243: killcnt(cnt)
244: register int cnt;
245: {
246:
247: if (inopen) {
248: notecnt = cnt;
249: notenam = notesgn = "";
250: return;
251: }
252: if (!notable(cnt))
253: return;
254: printf("%d lines", cnt);
255: if (value(TERSE) == 0) {
256: printf(" %c%s", Command[0] | ' ', Command + 1);
257: if (Command[strlen(Command) - 1] != 'e')
258: putchar('e');
259: putchar('d');
260: }
261: putNFL();
262: }
263:
264: lineno(a)
265: line *a;
266: {
267:
268: return (a - zero);
269: }
270:
271: lineDOL()
272: {
273:
274: return (lineno(dol));
275: }
276:
277: lineDOT()
278: {
279:
280: return (lineno(dot));
281: }
282:
283: markDOT()
284: {
285:
286: markpr(dot);
287: }
288:
289: markpr(which)
290: line *which;
291: {
292:
293: if ((inglobal == 0 || inopen) && which <= endcore) {
294: names['z'-'a'+1] = *which & ~01;
295: if (inopen)
296: ncols['z'-'a'+1] = cursor;
297: }
298: }
299:
300: markreg(c)
301: register int c;
302: {
303:
304: if (c == '\'' || c == '`')
305: return ('z' + 1);
306: if (c >= 'a' && c <= 'z')
307: return (c);
308: return (0);
309: }
310:
311: /*
312: * Mesg decodes the terse/verbose strings. Thus
313: * 'xxx@yyy' -> 'xxx' if terse, else 'xxx yyy'
314: * 'xxx|yyy' -> 'xxx' if terse, else 'yyy'
315: * All others map to themselves.
316: */
317: char *
318: mesg(str)
319: register char *str;
320: {
321: register char *cp;
322:
323: str = strcpy(genbuf, str);
324: for (cp = str; *cp; cp++)
325: switch (*cp) {
326:
327: case '@':
328: if (value(TERSE))
329: *cp = 0;
330: else
331: *cp = ' ';
332: break;
333:
334: case '|':
335: if (value(TERSE) == 0)
336: return (cp + 1);
337: *cp = 0;
338: break;
339: }
340: return (str);
341: }
342:
343: /*VARARGS2*/
344: merror(seekpt, i)
345: #ifdef VMUNIX
346: char *seekpt;
347: #else
348: # ifdef lint
349: char *seekpt;
350: # else
351: int seekpt;
352: # endif
353: #endif
354: int i;
355: {
356: register char *cp = linebuf;
357:
358: if (seekpt == 0)
359: return;
360: merror1(seekpt);
361: if (*cp == '\n')
362: putnl(), cp++;
363: if (inopen > 0 && CE)
364: vclreol();
365: if (SO && SE)
366: putpad(SO);
367: printf(mesg(cp), i);
368: if (SO && SE)
369: putpad(SE);
370: }
371:
372: merror1(seekpt)
373: #ifdef VMUNIX
374: char *seekpt;
375: #else
376: # ifdef lint
377: char *seekpt;
378: # else
379: int seekpt;
380: # endif
381: #endif
382: {
383:
384: #ifdef VMUNIX
385: strcpy(linebuf, seekpt);
386: #else
387: lseek(erfile, (long) seekpt, 0);
388: if (read(erfile, linebuf, 128) < 2)
389: CP(linebuf, "ERROR");
390: #endif
391: }
392:
393: morelines()
394: {
395:
396: if ((int) sbrk(1024 * sizeof (line)) == -1)
397: return (-1);
398: endcore += 1024;
399: return (0);
400: }
401:
402: nonzero()
403: {
404:
405: if (addr1 == zero) {
406: notempty();
407: error("Nonzero address required@on this command");
408: }
409: }
410:
411: notable(i)
412: int i;
413: {
414:
415: return (hush == 0 && !inglobal && i > value(REPORT));
416: }
417:
418:
419: notempty()
420: {
421:
422: if (dol == zero)
423: error("No lines@in the buffer");
424: }
425:
426:
427: netchHAD(cnt)
428: int cnt;
429: {
430:
431: netchange(lineDOL() - cnt);
432: }
433:
434: netchange(i)
435: register int i;
436: {
437: register char *cp;
438:
439: if (i > 0)
440: notesgn = cp = "more ";
441: else
442: notesgn = cp = "fewer ", i = -i;
443: if (inopen) {
444: notecnt = i;
445: notenam = "";
446: return;
447: }
448: if (!notable(i))
449: return;
450: printf(mesg("%d %slines@in file after %s"), i, cp, Command);
451: putNFL();
452: }
453:
454: putmark(addr)
455: line *addr;
456: {
457:
458: putmk1(addr, putline());
459: }
460:
461: putmk1(addr, n)
462: register line *addr;
463: int n;
464: {
465: register line *markp;
466: register oldglobmk;
467:
468: oldglobmk = *addr & 1;
469: *addr &= ~1;
470: for (markp = (anymarks ? names : &names['z'-'a'+1]);
471: markp <= &names['z'-'a'+1]; markp++)
472: if (*markp == *addr)
473: *markp = n;
474: *addr = n | oldglobmk;
475: }
476:
477: char *
478: plural(i)
479: long i;
480: {
481:
482: return (i == 1 ? "" : "s");
483: }
484:
485: int qcount();
486: short vcntcol;
487:
488: qcolumn(lim, gp)
489: register char *lim, *gp;
490: {
491: register int x;
492: int (*OO)();
493:
494: OO = Outchar;
495: Outchar = qcount;
496: vcntcol = 0;
497: if (lim != NULL)
498: x = lim[1], lim[1] = 0;
499: pline(0);
500: if (lim != NULL)
501: lim[1] = x;
502: if (gp)
503: while (*gp)
504: putchar(*gp++);
505: Outchar = OO;
506: return (vcntcol);
507: }
508:
509: int
510: qcount(c)
511: int c;
512: {
513:
514: if (c == '\t') {
515: vcntcol += value(TABSTOP) - vcntcol % value(TABSTOP);
516: return;
517: }
518: vcntcol++;
519: }
520:
521: reverse(a1, a2)
522: register line *a1, *a2;
523: {
524: register line t;
525:
526: for (;;) {
527: t = *--a2;
528: if (a2 <= a1)
529: return;
530: *a2 = *a1;
531: *a1++ = t;
532: }
533: }
534:
535: save(a1, a2)
536: line *a1;
537: register line *a2;
538: {
539: register int more;
540:
541: if (!FIXUNDO)
542: return;
543: #ifdef TRACE
544: if (trace)
545: vudump("before save");
546: #endif
547: undkind = UNDNONE;
548: undadot = dot;
549: more = (a2 - a1 + 1) - (unddol - dol);
550: while (more > (endcore - truedol))
551: if (morelines() < 0)
552: error("Out of memory@saving lines for undo - try using ed");
553: if (more)
554: (*(more > 0 ? copywR : copyw))(unddol + more + 1, unddol + 1,
555: (truedol - unddol));
556: unddol += more;
557: truedol += more;
558: copyw(dol + 1, a1, a2 - a1 + 1);
559: undkind = UNDALL;
560: unddel = a1 - 1;
561: undap1 = a1;
562: undap2 = a2 + 1;
563: #ifdef TRACE
564: if (trace)
565: vudump("after save");
566: #endif
567: }
568:
569: save12()
570: {
571:
572: save(addr1, addr2);
573: }
574:
575: saveall()
576: {
577:
578: save(one, dol);
579: }
580:
581: span()
582: {
583:
584: return (addr2 - addr1 + 1);
585: }
586:
587: sync()
588: {
589:
590: chng = 0;
591: tchng = 0;
592: xchng = 0;
593: }
594:
595:
596: skipwh()
597: {
598: register int wh;
599:
600: wh = 0;
601: while (iswhite(peekchar())) {
602: wh++;
603: ignchar();
604: }
605: return (wh);
606: }
607:
608: /*VARARGS2*/
609: smerror(seekpt, cp)
610: #ifdef lint
611: char *seekpt;
612: #else
613: int seekpt;
614: #endif
615: char *cp;
616: {
617:
618: if (seekpt == 0)
619: return;
620: merror1(seekpt);
621: if (inopen && CE)
622: vclreol();
623: if (SO && SE)
624: putpad(SO);
625: lprintf(mesg(linebuf), cp);
626: if (SO && SE)
627: putpad(SE);
628: }
629:
630: char *
631: strend(cp)
632: register char *cp;
633: {
634:
635: while (*cp)
636: cp++;
637: return (cp);
638: }
639:
640: strcLIN(dp)
641: char *dp;
642: {
643:
644: CP(linebuf, dp);
645: }
646:
647: syserror()
648: {
649: register int e = errno;
650: extern int sys_nerr;
651: extern char *sys_errlist[];
652:
653: dirtcnt = 0;
654: putchar(' ');
655: if (e >= 0 && e <= sys_nerr)
656: error(sys_errlist[e]);
657: else
658: error("System error %d", e);
659: }
660:
661: /*
662: * Return the column number that results from being in column col and
663: * hitting a tab, where tabs are set every ts columns. Work right for
664: * the case where col > COLUMNS, even if ts does not divide COLUMNS.
665: */
666: tabcol(col, ts)
667: int col, ts;
668: {
669: int offset, result;
670:
671: if (col >= COLUMNS) {
672: offset = COLUMNS * (col/COLUMNS);
673: col -= offset;
674: } else
675: offset = 0;
676: result = col + ts - (col % ts) + offset;
677: return (result);
678: }
679:
680: char *
681: vfindcol(i)
682: int i;
683: {
684: register char *cp;
685: register int (*OO)() = Outchar;
686:
687: Outchar = qcount;
688: ignore(qcolumn(linebuf - 1, NOSTR));
689: for (cp = linebuf; *cp && vcntcol < i; cp++)
690: putchar(*cp);
691: if (cp != linebuf)
692: cp--;
693: Outchar = OO;
694: return (cp);
695: }
696:
697: char *
698: vskipwh(cp)
699: register char *cp;
700: {
701:
702: while (iswhite(*cp) && cp[1])
703: cp++;
704: return (cp);
705: }
706:
707:
708: char *
709: vpastwh(cp)
710: register char *cp;
711: {
712:
713: while (iswhite(*cp))
714: cp++;
715: return (cp);
716: }
717:
718: whitecnt(cp)
719: register char *cp;
720: {
721: register int i;
722:
723: i = 0;
724: for (;;)
725: switch (*cp++) {
726:
727: case '\t':
728: i += value(TABSTOP) - i % value(TABSTOP);
729: break;
730:
731: case ' ':
732: i++;
733: break;
734:
735: default:
736: return (i);
737: }
738: }
739:
740: #ifdef lint
741: Ignore(a)
742: char *a;
743: {
744:
745: a = a;
746: }
747:
748: Ignorf(a)
749: int (*a)();
750: {
751:
752: a = a;
753: }
754: #endif
755:
756: markit(addr)
757: line *addr;
758: {
759:
760: if (addr != dot && addr >= one && addr <= dol)
761: markDOT();
762: }
763:
764: /*
765: * The following code is defensive programming against a bug in the
766: * pdp-11 overlay implementation. Sometimes it goes nuts and asks
767: * for an overlay with some garbage number, which generates an emt
768: * trap. This is a less than elegant solution, but it is somewhat
769: * better than core dumping and losing your work, leaving your tty
770: * in a weird state, etc.
771: */
772: int _ovno;
773: onemt()
774: {
775: int oovno;
776:
777: signal(SIGEMT, onemt);
778: oovno = _ovno;
779: /* 2 and 3 are valid on 11/40 type vi, so */
780: if (_ovno < 0 || _ovno > 3)
781: _ovno = 0;
782: error("emt trap, _ovno is %d @ - try again");
783: }
784:
785: /*
786: * When a hangup occurs our actions are similar to a preserve
787: * command. If the buffer has not been [Modified], then we do
788: * nothing but remove the temporary files and exit.
789: * Otherwise, we sync the temp file and then attempt a preserve.
790: * If the preserve succeeds, we unlink our temp files.
791: * If the preserve fails, we leave the temp files as they are
792: * as they are a backup even without preservation if they
793: * are not removed.
794: */
795: onhup()
796: {
797:
798: /*
799: * USG tty driver can send multiple HUP's!!
800: */
801: signal(SIGINT, SIG_IGN);
802: signal(SIGHUP, SIG_IGN);
803: if (chng == 0) {
804: cleanup(1);
805: exit(0);
806: }
807: if (setexit() == 0) {
808: if (preserve()) {
809: cleanup(1);
810: exit(0);
811: }
812: }
813: exit(1);
814: }
815:
816: /*
817: * An interrupt occurred. Drain any output which
818: * is still in the output buffering pipeline.
819: * Catch interrupts again. Unless we are in visual
820: * reset the output state (out of -nl mode, e.g).
821: * Then like a normal error (with the \n before Interrupt
822: * suppressed in visual mode).
823: */
824: onintr()
825: {
826:
827: #ifndef CBREAK
828: signal(SIGINT, onintr);
829: #else
830: signal(SIGINT, inopen ? vintr : onintr);
831: #endif
832: alarm(0); /* in case we were called from map */
833: draino();
834: if (!inopen) {
835: pstop();
836: setlastchar('\n');
837: #ifdef CBREAK
838: }
839: #else
840: } else
841: vraw();
842: #endif
843: error("\nInterrupt" + inopen);
844: }
845:
846: /*
847: * If we are interruptible, enable interrupts again.
848: * In some critical sections we turn interrupts off,
849: * but not very often.
850: */
851: setrupt()
852: {
853:
854: if (ruptible) {
855: #ifndef CBREAK
856: signal(SIGINT, onintr);
857: #else
858: signal(SIGINT, inopen ? vintr : onintr);
859: #endif
860: #ifdef SIGTSTP
861: if (dosusp)
862: signal(SIGTSTP, onsusp);
863: #endif
864: }
865: }
866:
867: preserve()
868: {
869:
870: #ifdef VMUNIX
871: tflush();
872: #endif
873: synctmp();
874: pid = fork();
875: if (pid < 0)
876: return (0);
877: if (pid == 0) {
878: close(0);
879: dup(tfile);
880: execl(EXPRESERVE, "expreserve", (char *) 0);
881: exit(1);
882: }
883: waitfor();
884: if (rpid == pid && status == 0)
885: return (1);
886: return (0);
887: }
888:
889: #ifndef V6
890: exit(i)
891: int i;
892: {
893:
894: # ifdef TRACE
895: if (trace)
896: fclose(trace);
897: # endif
898: _exit(i);
899: }
900: #endif
901:
902: #ifdef SIGTSTP
903: /*
904: * We have just gotten a susp. Suspend and prepare to resume.
905: */
906: onsusp()
907: {
908: ttymode f;
909: int omask;
910: struct winsize win;
911:
912: f = setty(normf);
913: vnfl();
914: putpad(TE);
915: flush();
916:
917: (void) sigsetmask(0);
918: signal(SIGTSTP, SIG_DFL);
919: kill(0, SIGTSTP);
920:
921: /* the pc stops here */
922:
923: signal(SIGTSTP, onsusp);
924: vcontin(0);
925: setty(f);
926: if (!inopen)
927: error(0);
928: else {
929: if (ioctl(0, TIOCGWINSZ, &win) >= 0)
930: if (win.ws_row != winsz.ws_row ||
931: win.ws_col != winsz.ws_col)
932: winch();
933: if (vcnt < 0) {
934: vcnt = -vcnt;
935: if (state == VISUAL)
936: vclear();
937: else if (state == CRTOPEN)
938: vcnt = 0;
939: }
940: vdirty(0, LINES);
941: vrepaint(cursor);
942: }
943: }
944: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.