![[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 [CSRG BSD Unix] / 43BSDTahoe / usr.bin|
Return to col.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin |
1.1 root 1: static char *sccsid = "@(#)col.c 4.2 (Berkeley) 5/15/84";
2: # include <stdio.h>
3: # define PL 256
4: # define ESC '\033'
5: # define RLF '\013'
6: # define SI '\017'
7: # define SO '\016'
8: # define GREEK 0200
9: # define LINELN 800
10:
11: char *page[PL];
12: char lbuff [LINELN], *line;
13: int bflag, hflag, fflag;
14: int half;
15: int cp, lp;
16: int ll, llh, mustwr;
17: int pcp = 0;
18: char *pgmname;
19: char *strcpy();
20:
21: main (argc, argv)
22: int argc; char **argv;
23: {
24: int i;
25: int greek;
26: register int c;
27:
28: pgmname = argv[0];
29:
30: for (i = 1; i < argc; i++) {
31: register char *p;
32: if (*argv[i] != '-') {
33: fprintf (stderr, "%s: bad option %s\n",
34: pgmname, argv[i]);
35: exit (2);
36: }
37: for (p = argv[i]+1; *p; p++) {
38: switch (*p) {
39: case 'b':
40: bflag++;
41: break;
42:
43: case 'h':
44: hflag++;
45: break;
46:
47: case 'f':
48: fflag++;
49: break;
50:
51: default:
52: fprintf (stderr, "%s: bad option letter %c\n",
53: pgmname, *p);
54: exit (2);
55: }
56: }
57: }
58:
59: for (ll=0; ll<PL; ll++)
60: page[ll] = 0;
61:
62: cp = 0;
63: ll = 0;
64: greek = 0;
65: mustwr = PL;
66: line = lbuff;
67:
68: while ((c = getchar()) != EOF) {
69: switch (c) {
70: case '\n':
71: incr();
72: incr();
73: cp = 0;
74: continue;
75:
76: case '\0':
77: continue;
78:
79: case ESC:
80: c = getchar();
81: switch (c) {
82: case '7': /* reverse full line feed */
83: decr();
84: decr();
85: break;
86:
87: case '8': /* reverse half line feed */
88: if (fflag)
89: decr();
90: else {
91: if (--half < -1) {
92: decr();
93: decr();
94: half += 2;
95: }
96: }
97: break;
98:
99: case '9': /* forward half line feed */
100: if (fflag)
101: incr();
102: else {
103: if (++half > 0) {
104: incr();
105: incr();
106: half -= 2;
107: }
108: }
109: break;
110: }
111: continue;
112:
113: case SO:
114: greek = GREEK;
115: continue;
116:
117: case SI:
118: greek = 0;
119: continue;
120:
121: case RLF:
122: decr();
123: decr();
124: continue;
125:
126: case '\r':
127: cp = 0;
128: continue;
129:
130: case '\t':
131: cp = (cp + 8) & -8;
132: continue;
133:
134: case '\b':
135: if (cp > 0)
136: cp--;
137: continue;
138:
139: case ' ':
140: cp++;
141: continue;
142:
143: default:
144: c &= 0177;
145: if (c > 040 && c < 0177) { /* if printable */
146: outc(c | greek);
147: cp++;
148: }
149: continue;
150: }
151: }
152:
153: for (i=0; i<PL; i++)
154: if (page[(mustwr+i)%PL] != 0)
155: emit (page[(mustwr+i) % PL], mustwr+i-PL);
156: emit (" ", (llh + 1) & -2);
157: exit(0);
158: }
159:
160: outc (c)
161: register char c;
162: {
163: if (lp > cp) {
164: line = lbuff;
165: lp = 0;
166: }
167:
168: while (lp < cp) {
169: switch (*line) {
170: case '\0':
171: *line = ' ';
172: lp++;
173: break;
174:
175: case '\b':
176: lp--;
177: break;
178:
179: default:
180: lp++;
181: }
182: line++;
183: }
184: while (*line == '\b') {
185: line += 2;
186: }
187: if (bflag || *line == '\0' || *line == ' ')
188: *line = c;
189: else {
190: register char c1, c2, c3;
191: c1 = *++line;
192: *line++ = '\b';
193: c2 = *line;
194: *line++ = c;
195: while (c1) {
196: c3 = *line;
197: *line++ = c1;
198: c1 = c2;
199: c2 = c3;
200: }
201: lp = 0;
202: line = lbuff;
203: }
204: }
205:
206: store (lno)
207: {
208: char *malloc();
209:
210: lno %= PL;
211: if (page[lno] != 0)
212: free (page[lno]);
213: page[lno] = malloc((unsigned)strlen(lbuff) + 2);
214: if (page[lno] == 0) {
215: fprintf (stderr, "%s: no storage\n", pgmname);
216: exit (2);
217: }
218: strcpy (page[lno],lbuff);
219: }
220:
221: fetch(lno)
222: {
223: register char *p;
224:
225: lno %= PL;
226: p = lbuff;
227: while (*p)
228: *p++ = '\0';
229: line = lbuff;
230: lp = 0;
231: if (page[lno])
232: strcpy (line, page[lno]);
233: }
234: emit (s, lineno)
235: char *s;
236: int lineno;
237: {
238: static int cline = 0;
239: register int ncp;
240: register char *p;
241: static int gflag = 0;
242:
243: if (*s) {
244: while (cline < lineno - 1) {
245: putchar ('\n');
246: pcp = 0;
247: cline += 2;
248: }
249: if (cline != lineno) {
250: putchar (ESC);
251: putchar ('9');
252: cline++;
253: }
254: if (pcp)
255: putchar ('\r');
256: pcp = 0;
257: p = s;
258: while (*p) {
259: ncp = pcp;
260: while (*p++ == ' ') {
261: if ((++ncp & 7) == 0 && hflag) {
262: pcp = ncp;
263: putchar ('\t');
264: }
265: }
266: if (!*--p)
267: break;
268: while (pcp < ncp) {
269: putchar (' ');
270: pcp++;
271: }
272: if (gflag != (*p & GREEK) && *p != '\b') {
273: if (gflag)
274: putchar (SI);
275: else
276: putchar (SO);
277: gflag ^= GREEK;
278: }
279: putchar (*p & ~GREEK);
280: if (*p++ == '\b')
281: pcp--;
282: else
283: pcp++;
284: }
285: }
286: }
287:
288: incr()
289: {
290: store (ll++);
291: if (ll > llh)
292: llh = ll;
293: if (ll >= mustwr && page[ll%PL]) {
294: emit (page[ll%PL], ll - PL);
295: mustwr++;
296: free (page[ll%PL]);
297: page[ll%PL] = 0;
298: }
299: fetch (ll);
300: }
301:
302: decr()
303: {
304: if (ll > mustwr - PL) {
305: store (ll--);
306: fetch (ll);
307: }
308: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.