![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to col.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin|
Return to col.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * Col(1). Virtual typewriter, performs motions physical typewriters cannot,
3: * like reverse line feeds. Also filters control characters.
4: * Two global variables, LineNo and ColNo, have the current line and column
5: * numbers. Both start at zero.
6: */
7: #include <stdio.h>
8:
9: #define Unfetch(c) Unfetched = (c)
10:
11: #define PAGESIZE 256 /* Default Page size. */
12: #define IBUFSIZE 800 /* Number of possible columns. */
13: #define EBUFSIZ 4 /* Increment size for buf in EXTRA struct. */
14:
15: /*
16: * Fetch returns the control characters \n, \b, \t, \r, HVT, VT, HLF, LF.
17: * We choose HVT and HLF to make a switch statement more compact in Main().
18: */
19: #define OSTRK 037 /* Flag for overstruck chars. */
20: #define ESC 033 /* Escape character. */
21: #define SO 017 /* Shift out to alternate char set. */
22: #define SI 016 /* Shift in from alternate char set. */
23: #define HVT 014 /* Half vertical tab. */
24: #define VT 013 /* Vertical tab, or Rev. Line Feed. */
25: #define HLF 007 /* Half line feed. */
26: #define LF 006 /* Line feed (but not return!). */
27: #define EOT 004 /* End of line signal to InsChar. */
28: #define BOT 003 /* Start of line signal to InsChar. */
29:
30: #define not !
31: #define or ||
32: #define and &&
33: #define TRUE (0==0)
34: #define FALSE (not TRUE)
35: #define NOTREACHED return
36:
37: typedef unsigned int uint;
38: typedef unsigned char uchar;
39: typedef uchar bool;
40:
41: typedef struct extra {
42: struct extra *Next;
43: int Posn;
44: uchar Howmany;
45: char Ebuf[EBUFSIZ];
46: } EXTRA;
47:
48: typedef struct {
49: int Len; /* Number of valid columns in Line. */
50: char *Line;
51: struct extra *Extra;
52: } LINE;
53:
54:
55: /*
56: * Error Messages.
57: */
58: char Usage[] = "Usage: col [-bdfx] [-pnum]";
59: char BackScroll[] = "Scrolling backwards over top of page window.";
60: char Confused[] = "Seem to have lost Overstruck characters.";
61:
62: /*
63: * Flags.
64: */
65: bool Bflag = FALSE; /* Command line option 'b'. */
66: bool Dflag = FALSE; /* Command line option 'd'. */
67: bool Fflag = FALSE; /* Command line option 'f'. */
68: bool Pflag = FALSE; /* Command line option 'p'. */
69: bool Xflag = FALSE; /* Command line option 'x'. */
70:
71: /*
72: * External Variables.
73: */
74: char Ibuf[BUFSIZ]; /* Buffer for input lines. */
75:
76: LINE *Page; /* Page window. */
77: LINE *CurLine; /* Ptr to *(Page[LineNo % PageSize]). */
78:
79: int PageSize = PAGESIZE; /* Actual size of Page. */
80: int Ibuflen; /* Current length of line in Ibuf. */
81: int Unfetched; /* storage for unfetched char */
82: int Top; /* Line number of top of Page window. */
83: int Bottom; /* Line number of bottom of Page window. */
84: int Wmark; /* High-water-mark of Lineno. */
85: int LineNo; /* Current line number in Page. */
86: int ColNo; /* Current column number. */
87:
88:
89: /*
90: * Functions returning non-int.
91: */
92: bool Ostrikeout();
93: char *realloc();
94:
95:
96: main(ac, av)
97: int ac;
98: char *av[];
99: {
100: register int c;
101:
102: Aarghh(ac, av);
103: Init();
104: InsChar(BOT);
105: while ((c = Fetch()) != EOF)
106: switch (c) {
107: case '\b':
108: if (ColNo > 0)
109: --ColNo;
110: break;
111: case '\r':
112: ColNo = 0;
113: break;
114: case '\t':
115: ColNo = (ColNo & ~07) + 8;
116: break;
117: case '\n':
118: ColNo = 0;
119: case VT:
120: case LF:
121: case HVT:
122: case HLF:
123: InsChar(EOT); /* Close current line. */
124: VertMove(c);
125: InsChar(BOT); /* Open current line. */
126: break;
127: default:
128: if (c != ' ')
129: InsChar(c);
130: ++ColNo;
131: break;
132: }
133: InsChar(EOT); /* Close current line. */
134: Flush();
135: return (0);
136: }
137:
138:
139: /*
140: * Process command line arguments.
141: */
142: Aarghh(ac, av)
143: int ac;
144: register char *av[];
145: {
146: register char *cp;
147: register int c;
148:
149: ac = 0; /* To avoid "Strict" warning from compiler. */
150: while ((cp = *++av) != NULL) {
151: if (*cp++ != '-') {
152: Fatal(Usage);
153: NOTREACHED;
154: }
155: while ((c = *cp++) != '\0')
156: switch (c) {
157: case 'b':
158: Bflag = TRUE;
159: break;
160: case 'd':
161: Dflag = TRUE;
162: break;
163: case 'f':
164: Fflag = TRUE;
165: break;
166: case 'x':
167: Xflag = TRUE;
168: break;
169: case 'p':
170: Pflag = TRUE;
171: if ((PageSize = 2 * atoi(cp)) <= 0)
172: Fatal("Bad page length");
173: break;
174: default:
175: Fatal(Usage);
176: NOTREACHED;
177: }
178: }
179: }
180:
181: Init()
182: {
183: register LINE *lp;
184:
185: lp = CurLine = Page = (LINE *) malloc(sizeof(LINE) * PageSize);
186: lp += PageSize - 1;
187: while (lp-- > Page) {
188: lp->Len = 0;
189: lp->Line = lp->Extra = NULL;
190: }
191: Bottom = PageSize;
192: return;
193: }
194:
195:
196: /*
197: * Fetch grabs input characters and returns them after filtering.
198: */
199: Fetch()
200: {
201: static acset = 0; /* alternate character set flag */
202: register int c, c1;
203:
204: if ((c = Unfetched) != '\0') {
205: Unfetched = '\0';
206: return (c);
207: }
208: for(;;) {
209: if ((c = getchar()) > ' ' && c < 0177)
210: return (acset ? c | 0200 : c);
211: switch (c) {
212: case ' ':
213: case '\t':
214: case '\n':
215: case '\b':
216: case '\r':
217: case VT:
218: case EOF:
219: return (c);
220: case SO:
221: acset = 1;
222: continue;
223: case SI:
224: acset = 0;
225: continue;
226: case ESC:
227: switch (c1 = getchar()) {
228: case '7':
229: return (VT);
230: case '8':
231: return (HVT);
232: case '9':
233: return (HLF);
234: case 'B':
235: return (LF);
236: }
237: ungetc(c1, stdin);
238: continue;
239: }
240: }
241: }
242:
243:
244: VertMove(c)
245: register int c;
246: {
247: static bool warnflag = FALSE; /* Warn of move over top of page. */
248:
249: Unfetch(c);
250: for (;;) {
251: switch (c = Fetch()) {
252: case VT:
253: LineNo -= 2;
254: break;
255: case LF:
256: LineNo += 2;
257: break;
258: case HVT:
259: LineNo -= 1;
260: break;
261: case HLF:
262: LineNo += 1;
263: break;
264: case '\n':
265: ColNo = 0;
266: LineNo += 2;
267: break;
268: default:
269: Unfetch(c);
270: CurLine = Page + LineNo % PageSize;
271: return;
272: }
273:
274: /*
275: * Have we scrolled over the top of the Page window?
276: */
277: if (LineNo < Top)
278: if (not warnflag) {
279: Warning(BackScroll);
280: warnflag = TRUE;
281: }
282:
283: /*
284: * Update the water mark if needed.
285: */
286: if (LineNo > Wmark)
287: Wmark = LineNo;
288:
289:
290: /*
291: * If we've scrolled past the bottom of the window then we
292: * put out the Top line and move the window down.
293: */
294: if (Bottom <= LineNo) {
295: PutLine(Top);
296: Top += 2;
297: Bottom += 2;
298: }
299: }
300: }
301:
302: /*
303: * Insert the character c into Ibuf at column ColNo.
304: */
305: InsChar(c)
306: register int c;
307: {
308:
309: /*
310: * If (c == BOT) or (c == EOT) we open or close the line in Ibuf.
311: * Otherwise we are really adding a character to Ibuf.
312: */
313: if (c == BOT) {
314: register LINE *lp = CurLine;
315: if ((Ibuflen = lp->Len) != 0) {
316: strncpy(Ibuf, lp->Line, Ibuflen);
317: free(lp->Line);
318: }
319: return;
320: }
321: else if (c == EOT) {
322: register LINE *lp = CurLine;
323: if ((lp->Len = Ibuflen) != 0) {
324: lp->Line = malloc(Ibuflen);
325: strncpy(lp->Line, Ibuf, Ibuflen);
326: }
327: return;
328: }
329:
330: /*
331: * The case of appending a char to the end of Ibuf. Very common.
332: * Note that in this case Ibuf[ColNo] is virgin territory.
333: */
334: if (ColNo == Ibuflen) {
335: Ibuf[Ibuflen++] = c;
336: return;
337: }
338:
339: /*
340: * The case of adding a char beyond the end of Ibuf. We must pad the
341: * intervening space with spaces.
342: */
343: if (ColNo > Ibuflen) {
344: register char *ibuf = Ibuf;
345: while (Ibuflen < ColNo)
346: ibuf[Ibuflen++] = ' ';
347: ibuf[Ibuflen++] = c;
348: return;
349: }
350:
351:
352: /*
353: * The remaining case is adding a char into the interior of Ibuf. If
354: * the present char is a space or if Bflag is set we just insert c,
355: * otherwise we have to overstrike.
356: */
357: { register char *cp = Ibuf + ColNo;
358: register int c1;
359:
360: if (Bflag or (c1 = *cp) == ' ') {
361: *cp = c;
362: return;
363: }
364: if (c1 != OSTRK) {
365: Overstrike(c1);
366: *cp = OSTRK;
367: }
368: Overstrike(c);
369: }
370: return;
371: }
372:
373:
374: /*
375: * Handle overstruck characters.
376: */
377: Overstrike(c)
378: int c;
379: {
380: register EXTRA *ep;
381: register EXTRA **epp;
382:
383: /*
384: * Find the right EXTRA struct in CurLine.
385: */
386: epp = &CurLine->Extra;
387: for (ep = *epp; ep != NULL; epp = &ep->Next, ep = *epp) {
388: if (ep->Posn != ColNo)
389: continue;
390: /*
391: * We found it, check for overflow and add the char c.
392: */
393: if (ep->Howmany % EBUFSIZ == 0)
394: ep = *epp = (EXTRA *) realloc((char *)ep,
395: sizeof(EXTRA) + ep->Howmany);
396: ep->Ebuf[ep->Howmany++] = c;
397: return;
398: }
399:
400: /*
401: * We didn't find it, so make it, and install the char c.
402: */
403: ep = (EXTRA *) malloc(sizeof(EXTRA));
404: ep->Howmany = 1;
405: ep->Posn = ColNo;
406: ep->Ebuf[0] = c;
407: ep->Next = CurLine->Extra;
408: CurLine->Extra = ep;
409: return;
410: }
411:
412:
413: Flush()
414: {
415: register int i;
416:
417: for (i = Top; i <= Wmark; i += 2)
418: PutLine(i);
419: return;
420: }
421:
422:
423: /*
424: * Output one full line, which is possibly two half lines. All control for
425: * Dflag and Fflag takes place here.
426: */
427: PutLine(n)
428: int n;
429: {
430: static char HCR[] = {'\r', ESC, '9', '\0'}; /* Half Crg. Return */
431: register LINE *lp;
432:
433: lp = Page + n % PageSize;
434: if (lp->Len != 0)
435: PutHalf(lp);
436: ++lp;
437:
438: if (lp->Len == 0) {
439: if (Dflag and not Fflag) {
440: putchar('\n');
441: putchar('\n');
442: } else
443: putchar('\n');
444: } else {
445: if (Fflag) {
446: fputs(HCR, stdout);
447: PutHalf(lp);
448: fputs(HCR, stdout);
449: } else {
450: putchar('\n');
451: PutHalf(lp);
452: putchar('\n');
453: }
454: }
455: return;
456: }
457:
458: /*
459: * PutHalf() outputs the half-line lp with no vertical motion at the end.
460: * Alternate character sets are handled here. Entabbing is handled by Tab.
461: * Overstrikes are handled by Ostrikeout(), which also may have to handle
462: * alternate character sets.
463: */
464: PutHalf(lp)
465: register LINE *lp;
466: {
467: register int c;
468: register int colno;
469: register bool acset = FALSE;
470:
471: /*
472: * Note that since lp->Len is the number of valid columns, the number
473: * of the last valid column is (lp->Len - 1). That's why the test is
474: * "<" instead of "<=".
475: */
476: for (colno = 0; colno < lp->Len; ++colno)
477: switch (c = lp->Line[colno]) {
478: case OSTRK:
479: acset = Ostrikeout(lp, colno, acset);
480: break;
481: case ' ':
482: if (Xflag) {
483: putchar(' ');
484: break;
485: }
486: /* Entab white space. */
487: c = colno;
488: while (lp->Line[c] == ' ')
489: if (++c % 8 == 0) {
490: putchar('\t');
491: colno = c;
492: }
493: while (colno < c) {
494: putchar(' ');
495: ++colno;
496: }
497: --colno;
498: break;
499: default:
500: if (c & 0200) {
501: if (not acset) {
502: acset = TRUE;
503: putchar(SO);
504: }
505: putchar(c & ~0200);
506: }
507: else {
508: if (acset) {
509: acset = FALSE;
510: putchar(SI);
511: }
512: putchar(c);
513: }
514: break;
515: }
516: if (acset)
517: putchar(SI);
518: free(lp->Line);
519: lp->Len = 0;
520: lp->Line = lp->Extra = NULL;
521: return;
522: }
523:
524:
525: /*
526: * Ostrikeout puts out all the characters overstruck in position ColNo in the
527: * LINE lp. It pays attention to alternate character sets.
528: */
529: bool
530: Ostrikeout(lp, col, acset)
531: LINE *lp;
532: int col;
533: bool acset;
534: {
535: EXTRA *ep;
536:
537: /*
538: * Find the EXTRA struct for position 'col' and remove it from
539: * the EXTRA list.
540: */
541: { register EXTRA **epp = &lp->Extra;
542: register EXTRA *e;
543: register int n = col;
544:
545: for (e = *epp; e != NULL; epp = &e->Next, e = *epp) {
546: if (e->Posn != n)
547: continue;
548: *epp = e->Next;
549: ep = e;
550: goto FOUNDIT;
551: }
552: /*
553: * Didn't find it in the list.
554: */
555: putchar(' ');
556: Warning(Confused);
557: return (acset);
558: }
559:
560: /*
561: * Now that we found it, write out all the characters in ep->Ebuf,
562: * paying attention to alternate char sets, then free ep.
563: */
564: FOUNDIT:
565: { register int c;
566: register bool ac = acset;
567: register int count = ep->Howmany;
568: register char *cp = ep->Ebuf;
569:
570: while (count-- > 0) {
571: if ((c = *cp++) & 0200) {
572: if (not ac) {
573: ac = TRUE;
574: putchar(SO);
575: }
576: putchar(c & ~0200);
577: }
578: else {
579: if (ac) {
580: ac = FALSE;
581: putchar(SI);
582: }
583: putchar(c);
584: }
585: if (count > 0)
586: putchar('\b');
587: }
588: free(ep);
589: return (ac);
590: }
591: }
592:
593:
594: Fatal(cp)
595: char *cp;
596: {
597: Warning(cp);
598: exit(1);
599: }
600:
601: Warning(cp)
602: char *cp;
603: {
604: fputs(cp, stderr);
605: putc('\n', stderr);
606: return;
607: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.