![[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] / 3BSD / cmd / ex|
Return to ex_subr.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / ex |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include "ex.h"
3: #include "ex_re.h"
4: #include "ex_tty.h"
5: #include "ex_vis.h"
6:
7: /*
8: * Random routines, in alphabetical order.
9: */
10:
11: any(c, s)
12: int c;
13: register char *s;
14: {
15: register int x;
16:
17: while (x = *s++)
18: if (x == c)
19: return (1);
20: return (0);
21: }
22:
23: backtab(i)
24: register int i;
25: {
26: register int j;
27:
28: j = i % value(SHIFTWIDTH);
29: if (j == 0)
30: j = value(SHIFTWIDTH);
31: i -= j;
32: if (i < 0)
33: i = 0;
34: return (i);
35: }
36:
37: change()
38: {
39:
40: tchng++;
41: chng = tchng;
42: }
43:
44: /*
45: * Column returns the number of
46: * columns occupied by printing the
47: * characters through position cp of the
48: * current line.
49: */
50: column(cp)
51: register char *cp;
52: {
53:
54: if (cp == 0)
55: cp = &linebuf[LBSIZE - 2];
56: return (qcolumn(cp, (char *) 0));
57: }
58:
59: Copy(to, from, size)
60: register char *from, *to;
61: register int size;
62: {
63:
64: if (size > 0)
65: do
66: *to++ = *from++;
67: while (--size > 0);
68: }
69:
70: copyw(to, from, size)
71: register line *from, *to;
72: register int size;
73: {
74:
75: if (size > 0)
76: do
77: *to++ = *from++;
78: while (--size > 0);
79: }
80:
81: copywR(to, from, size)
82: register line *from, *to;
83: register int size;
84: {
85:
86: while (--size >= 0)
87: to[size] = from[size];
88: }
89:
90: ctlof(c)
91: int c;
92: {
93:
94: return (c == TRIM ? '?' : c | ('A' - 1));
95: }
96:
97: dingdong()
98: {
99:
100: if (VB)
101: putpad(VB);
102: else if (value(ERRORBELLS))
103: putch('\207');
104: }
105:
106: fixindent(indent)
107: int indent;
108: {
109: register int i;
110: register char *cp;
111:
112: i = whitecnt(genbuf);
113: cp = vpastwh(genbuf);
114: if (*cp == 0 && i == indent && linebuf[0] == 0) {
115: genbuf[0] = 0;
116: return (i);
117: }
118: CP(genindent(i), cp);
119: return (i);
120: }
121:
122: filioerr(cp)
123: char *cp;
124: {
125: register int oerrno = errno;
126:
127: lprintf("\"%s\"", cp);
128: errno = oerrno;
129: syserror();
130: }
131:
132: char *
133: genindent(indent)
134: register int indent;
135: {
136: register char *cp;
137:
138: for (cp = genbuf; indent >= value(TABSTOP); indent -= value(TABSTOP))
139: *cp++ = '\t';
140: for (; indent > 0; indent--)
141: *cp++ = ' ';
142: return (cp);
143: }
144:
145: getDOT()
146: {
147:
148: getline(*dot);
149: }
150:
151: line *
152: getmark(c)
153: register int c;
154: {
155: register line *addr;
156:
157: for (addr = one; addr <= dol; addr++)
158: if (names[c - 'a'] == (*addr &~ 01)) {
159: return (addr);
160: }
161: return (0);
162: }
163:
164: getn(cp)
165: register char *cp;
166: {
167: register int i = 0;
168:
169: while (isdigit(*cp))
170: i = i * 10 + *cp++ - '0';
171: if (*cp)
172: return (0);
173: return (i);
174: }
175:
176: ignnEOF()
177: {
178: register int c = getchar();
179:
180: if (c == EOF)
181: ungetchar(c);
182: }
183:
184: iswhite(c)
185: int c;
186: {
187:
188: return (c == ' ' || c == '\t');
189: }
190:
191: junk(c)
192: register int c;
193: {
194:
195: if (c && !value(BEAUTIFY))
196: return (0);
197: if (c >= ' ' && c != TRIM)
198: return (0);
199: switch (c) {
200:
201: case '\t':
202: case '\n':
203: case '\f':
204: return (0);
205:
206: default:
207: return (1);
208: }
209: }
210:
211: killed()
212: {
213:
214: killcnt(addr2 - addr1 + 1);
215: }
216:
217: killcnt(cnt)
218: register int cnt;
219: {
220:
221: if (inopen) {
222: notecnt = cnt;
223: notenam = notesgn = "";
224: return;
225: }
226: if (!notable(cnt))
227: return;
228: printf("%d lines", cnt);
229: if (value(TERSE) == 0) {
230: printf(" %c%s", Command[0] | ' ', Command + 1);
231: if (Command[strlen(Command) - 1] != 'e')
232: putchar('e');
233: putchar('d');
234: }
235: putNFL();
236: }
237:
238: lineno(a)
239: line *a;
240: {
241:
242: return (a - zero);
243: }
244:
245: lineDOL()
246: {
247:
248: return (lineno(dol));
249: }
250:
251: lineDOT()
252: {
253:
254: return (lineno(dot));
255: }
256:
257: markDOT()
258: {
259:
260: markpr(dot);
261: }
262:
263: markpr(which)
264: line *which;
265: {
266:
267: if ((inglobal == 0 || inopen) && which <= endcore) {
268: names['z'-'a'+1] = *which & ~01;
269: if (inopen)
270: ncols['z'-'a'+1] = cursor;
271: }
272: }
273:
274: markreg(c)
275: register int c;
276: {
277:
278: if (c == '\'' || c == '`')
279: return ('z' + 1);
280: if (c >= 'a' && c <= 'z')
281: return (c);
282: return (0);
283: }
284:
285: /*
286: * Mesg decodes the terse/verbose strings. Thus
287: * 'xxx@yyy' -> 'xxx' if terse, else 'xxx yyy'
288: * 'xxx|yyy' -> 'xxx' if terse, else 'yyy'
289: * All others map to themselves.
290: */
291: char *
292: mesg(str)
293: register char *str;
294: {
295: register char *cp;
296:
297: str = strcpy(genbuf, str);
298: for (cp = str; *cp; cp++)
299: switch (*cp) {
300:
301: case '@':
302: if (value(TERSE))
303: *cp = 0;
304: else
305: *cp = ' ';
306: break;
307:
308: case '|':
309: if (value(TERSE) == 0)
310: return (cp + 1);
311: *cp = 0;
312: break;
313: }
314: return (str);
315: }
316:
317: /*VARARGS2*/
318: merror(seekpt, i)
319: #ifdef VMUNIX
320: char *seekpt;
321: #else
322: # ifdef lint
323: char *seekpt;
324: # else
325: int seekpt;
326: # endif
327: #endif
328: int i;
329: {
330: register char *cp = linebuf;
331:
332: if (seekpt == 0)
333: return;
334: merror1(seekpt);
335: if (*cp == '\n')
336: putnl(), cp++;
337: if (inopen && CE)
338: vclreol();
339: if (SO && SE)
340: putpad(SO);
341: printf(mesg(cp), i);
342: if (SO && SE)
343: putpad(SE);
344: }
345:
346: merror1(seekpt)
347: #ifdef VMUNIX
348: char *seekpt;
349: #else
350: # ifdef lint
351: char *seekpt;
352: # else
353: int seekpt;
354: # endif
355: #endif
356: {
357:
358: #ifdef VMUNIX
359: strcpy(linebuf, seekpt);
360: #else
361: lseek(erfile, (long) seekpt, 0);
362: if (read(erfile, linebuf, 128) < 2)
363: CP(linebuf, "ERROR");
364: #endif
365: }
366:
367: morelines()
368: {
369:
370: if ((int) sbrk(1024 * sizeof (line)) == -1)
371: return (-1);
372: endcore += 1024;
373: return (0);
374: }
375:
376: nonzero()
377: {
378:
379: if (addr1 == zero) {
380: notempty();
381: error("Nonzero address required@on this command");
382: }
383: }
384:
385: notable(i)
386: int i;
387: {
388:
389: return (hush == 0 && !inglobal && i > value(REPORT));
390: }
391:
392:
393: notempty()
394: {
395:
396: if (dol == zero)
397: error("No lines@in the buffer");
398: }
399:
400:
401: netchHAD(cnt)
402: int cnt;
403: {
404:
405: netchange(lineDOL() - cnt);
406: }
407:
408: netchange(i)
409: register int i;
410: {
411: register char *cp;
412:
413: if (i > 0)
414: notesgn = cp = "more ";
415: else
416: notesgn = cp = "fewer ", i = -i;
417: if (inopen) {
418: notecnt = i;
419: notenam = "";
420: return;
421: }
422: if (!notable(i))
423: return;
424: printf(mesg("%d %slines@in file after %s"), i, cp, Command);
425: putNFL();
426: }
427:
428: putmark(addr)
429: line *addr;
430: {
431:
432: putmk1(addr, putline());
433: }
434:
435: putmk1(addr, n)
436: register line *addr;
437: int n;
438: {
439: register line *markp;
440:
441: *addr &= ~1;
442: for (markp = (anymarks ? names : &names['z'-'a'+1]);
443: markp <= &names['z'-'a'+1]; markp++)
444: if (*markp == *addr)
445: *markp = n;
446: *addr = n;
447: }
448:
449: char *
450: plural(i)
451: long i;
452: {
453:
454: return (i == 1 ? "" : "s");
455: }
456:
457: int qcount();
458: short vcntcol;
459:
460: qcolumn(lim, gp)
461: register char *lim, *gp;
462: {
463: register int x;
464: int (*OO)();
465:
466: OO = Outchar;
467: Outchar = qcount;
468: vcntcol = 0;
469: if (lim != NULL)
470: x = lim[1], lim[1] = 0;
471: pline(0);
472: if (lim != NULL)
473: lim[1] = x;
474: if (gp)
475: while (*gp)
476: putchar(*gp++);
477: Outchar = OO;
478: return (vcntcol);
479: }
480:
481: int
482: qcount(c)
483: int c;
484: {
485:
486: if (c == '\t') {
487: vcntcol += value(TABSTOP) - vcntcol % value(TABSTOP);
488: return;
489: }
490: vcntcol++;
491: }
492:
493: reverse(a1, a2)
494: register line *a1, *a2;
495: {
496: register line t;
497:
498: for (;;) {
499: t = *--a2;
500: if (a2 <= a1)
501: return;
502: *a2 = *a1;
503: *a1++ = t;
504: }
505: }
506:
507: save(a1, a2)
508: line *a1;
509: register line *a2;
510: {
511: register int more;
512:
513: undkind = UNDNONE;
514: undadot = dot;
515: more = (a2 - a1 + 1) - (unddol - dol);
516: while (more > (endcore - truedol))
517: if (morelines() < 0)
518: error("Out of memory@saving lines for undo - try using ed or re");
519: if (more)
520: (*(more > 0 ? copywR : copyw))(unddol + more + 1, unddol + 1,
521: (truedol - unddol));
522: unddol += more;
523: truedol += more;
524: copyw(dol + 1, a1, a2 - a1 + 1);
525: undkind = UNDALL;
526: unddel = a1 - 1;
527: undap1 = a1;
528: undap2 = a2 + 1;
529: }
530:
531: save12()
532: {
533:
534: save(addr1, addr2);
535: }
536:
537: saveall()
538: {
539:
540: save(one, dol);
541: }
542:
543: span()
544: {
545:
546: return (addr2 - addr1 + 1);
547: }
548:
549: sync()
550: {
551:
552: chng = 0;
553: tchng = 0;
554: xchng = 0;
555: }
556:
557:
558: skipwh()
559: {
560: register int wh;
561:
562: wh = 0;
563: while (iswhite(peekchar())) {
564: wh++;
565: ignchar();
566: }
567: return (wh);
568: }
569:
570: /*VARARGS2*/
571: smerror(seekpt, cp)
572: #ifdef lint
573: char *seekpt;
574: #else
575: int seekpt;
576: #endif
577: char *cp;
578: {
579:
580: if (seekpt == 0)
581: return;
582: merror1(seekpt);
583: if (inopen && CE)
584: vclreol();
585: if (SO && SE)
586: putpad(SO);
587: lprintf(mesg(linebuf), cp);
588: if (SO && SE)
589: putpad(SE);
590: }
591:
592: #define std_nerrs (sizeof std_errlist / sizeof std_errlist[0])
593:
594: #define error(i) i
595:
596: #ifdef lint
597: char *std_errlist[] = {
598: #else
599: #ifdef VMUNIX
600: char *std_errlist[] = {
601: #else
602: short std_errlist[] = {
603: #endif
604: #endif
605: error("Error 0"),
606: error("Not super-user"),
607: error("No such file or directory"),
608: error("No such process"),
609: error("Interrupted system call"),
610: error("Physical I/O error"),
611: error("No such device or address"),
612: error("Argument list too long"),
613: error("Exec format error"),
614: error("Bad file number"),
615: error("No children"),
616: error("No more processes"),
617: error("Not enough core"),
618: error("Permission denied"),
619: error("Bad address"),
620: error("Block device required"),
621: error("Mount device busy"),
622: error("File exists"),
623: error("Cross-device link"),
624: error("No such device"),
625: error("Not a directory"),
626: error("Is a directory"),
627: error("Invalid argument"),
628: error("File table overflow"),
629: error("Too many open files"),
630: error("Not a typewriter"),
631: error("Text file busy"),
632: error("File too large"),
633: error("No space left on device"),
634: error("Illegal seek"),
635: error("Read-only file system"),
636: error("Too many links"),
637: error("Broken pipe")
638: #ifndef QUOTA
639: , error("Math argument")
640: , error("Result too large")
641: #else
642: , error("Quota exceeded")
643: #endif
644: };
645:
646: #undef error
647:
648: char *
649: strend(cp)
650: register char *cp;
651: {
652:
653: while (*cp)
654: cp++;
655: return (cp);
656: }
657:
658: strcLIN(dp)
659: char *dp;
660: {
661:
662: CP(linebuf, dp);
663: }
664:
665: syserror()
666: {
667: register int e = errno;
668:
669: dirtcnt = 0;
670: putchar(' ');
671: if (e >= 0 && errno <= std_nerrs)
672: error(std_errlist[e]);
673: else
674: error("System error %d", e);
675: }
676:
677: char *
678: vfindcol(i)
679: int i;
680: {
681: register char *cp;
682: register int (*OO)() = Outchar;
683:
684: Outchar = qcount;
685: ignore(qcolumn(linebuf - 1, NOSTR));
686: for (cp = linebuf; *cp && vcntcol < i; cp++)
687: putchar(*cp);
688: if (cp != linebuf)
689: cp--;
690: Outchar = OO;
691: return (cp);
692: }
693:
694: char *
695: vskipwh(cp)
696: register char *cp;
697: {
698:
699: while (iswhite(*cp) && cp[1])
700: cp++;
701: return (cp);
702: }
703:
704:
705: char *
706: vpastwh(cp)
707: register char *cp;
708: {
709:
710: while (iswhite(*cp))
711: cp++;
712: return (cp);
713: }
714:
715: whitecnt(cp)
716: register char *cp;
717: {
718: register int i;
719:
720: i = 0;
721: for (;;)
722: switch (*cp++) {
723:
724: case '\t':
725: i += value(TABSTOP) - i % value(TABSTOP);
726: break;
727:
728: case ' ':
729: i++;
730: break;
731:
732: default:
733: return (i);
734: }
735: }
736:
737: #ifdef lint
738: Ignore(a)
739: char *a;
740: {
741:
742: a = a;
743: }
744:
745: Ignorf(a)
746: int (*a)();
747: {
748:
749: a = a;
750: }
751: #endif
752:
753: markit(addr)
754: line *addr;
755: {
756:
757: if (addr != dot && addr >= one && addr <= dol)
758: markDOT();
759: }
760:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.