![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rvsort.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / vpr|
Return to rvsort.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / vpr |
1.1 root 1: # include <stdio.h>
2: /*
3: * vsort - Sort troff output for versatec to reduce amount of reverse leading
4: */
5:
6: #define NULL 0
7:
8: double atof();
9: char *calloc();
10:
11: FILE *in,*out;
12:
13: struct achar *piles[500], *afreel;
14:
15: int skipfirst = 1; /* skip the first leading so start at top of page */
16: int cpsize = 02; /* Funny sizes */
17: struct point_sizes {
18: int stupid_code;
19: int real_code;
20: } point_sizes[] = {
21: 010, 6,
22: 0, 7,
23: 01, 8,
24: 07, 9,
25: 02, 10,
26: 03, 11,
27: 04, 12,
28: 05, 14,
29: 0211, 16,
30: 06, 18,
31: 0212, 20,
32: 0213, 22,
33: 0214, 24,
34: 0215, 28,
35: 0216, 36,
36: 0, 0
37: };
38:
39: int pagelength = 144 * 11; /* in Leading units */
40: int pagemod; /* horizontal page number (for versatec) */
41: #define MODOFF 3672 /* 432 * 8.5 */
42:
43: int esc, lead, back, verd, mcase, railmag;
44: int col, row;
45:
46: int oback, omcase, orailmag, ocol, orow, overd;
47: int opsize = 02;
48:
49: struct achar
50: {
51: char code;
52: char psize;
53: short col;
54: short row;
55: char railmag;
56: char verd;
57: char back;
58: char mcase;
59: struct achar *next;
60: };
61:
62: main(argc, argv)
63: int argc;
64: char *argv[];
65: {
66: register i;
67:
68: for(i = 3; i < 15; i++)
69: close(i);
70: while (argc > 1 && argv[1][0] == '-') {
71: switch (argv[1][1]) {
72: case 'l': {
73: float f = 144 * atof(argv[1] + 2);
74: if (f < 144) {
75: error("bad length");
76: exit(1);
77: }
78: pagelength = f;
79: break;
80: }
81: }
82: argc--; argv++;
83: }
84: out = stdout;
85: if(argc > 1) {
86: while(--argc) {
87: argv++;
88: if((in=fopen(argv[0], "r")) == NULL)
89: perror("vsort");
90: else {
91: ofile();
92: fclose(in);
93: }
94: }
95: } else {
96: in = stdin;
97: ofile();
98: }
99: exit(0);
100: }
101:
102: ofile()
103: {
104: register int c;
105: static int initialized;
106:
107: while((c = getch()) != -1) {
108: if(!c)
109: continue;
110: if(c & 0200) { /* escape (left/right) */
111: esc += (~c) & 0177;
112: continue;
113: }
114: if(esc) {
115: if(back)
116: esc = -esc;
117: col += esc;
118: esc = 0;
119: }
120: if((c & 0377) < 0100) /* Purely for efficiency */
121: goto normal_char;
122: switch(c) {
123:
124: case 0100:
125: if(initialized++) {
126: linesflush();
127: return;
128: }
129: row = 0;
130: col = 0; esc = 0;
131: lead = 0;
132: verd = 0; back = 0; mcase = 0;
133: railmag = 0;
134: ocol = 0;
135: orow = 0;
136: oback = 0; omcase = 0;
137: orailmag = 0;
138: if(loadfont(railmag, cpsize) < 0)
139: error("init");
140: putc(0100, out);
141: break;
142:
143: case 0101: /* lower rail */
144: crail(railmag &= ~01);
145: break;
146:
147: case 0102: /* upper rail */
148: crail(railmag |= 01);
149: break;
150:
151: case 0103: /* upper mag */
152: crail(railmag |= 02);
153: break;
154:
155: case 0104: /* lower mag */
156: crail(railmag &= ~02);
157: break;
158:
159: case 0105: /* lower case */
160: mcase = 0;
161: break;
162:
163: case 0106: /* upper case */
164: mcase = 1;
165: break;
166:
167: case 0107: /* escape forward */
168: back = 0;
169: break;
170:
171: case 0110: /* escape backwards */
172: back = 1;
173: break;
174:
175: case 0111: /* stop */
176: break;
177:
178: case 0112: /* lead forward */
179: verd = 0;
180: break;
181:
182: case 0113: /* undefined */
183: break;
184:
185: case 0114: /* lead backward */
186: verd = 1;
187: break;
188:
189: case 0115: /* undefined */
190: case 0116:
191: case 0117:
192: break;
193:
194: default:
195: if((c & 0340) == 0140) {/* leading */
196: lead = (~c) & 037;
197: if(verd)
198: lead = -lead;
199: if (skipfirst > 0) {
200: skipfirst--;
201: continue;
202: }
203: row += lead;
204: if (row >= pagelength)
205: allflush();
206: continue;
207: }
208: if((c & 0360)== 0120) { /* size change */
209: col += stupidadj(c & 017, cpsize);
210: loadfont(railmag, c & 017);
211: continue;
212: }
213: if(c & 0300)
214: continue;
215: normal_char:
216: c = (c & 077);
217: stuffc(c);
218: }
219: }
220: linesflush();
221: putc(0111, out);
222: putc(0111, out);
223: putc(0111, out);
224: putc(0111, out);
225: putc(0111, out);
226: putc(0111, out);
227: putc(0111, out);
228: putc(0111, out);
229: }
230:
231: int peekc;
232:
233: getch()
234: {
235: register c;
236:
237: if(peekc) {
238: c = peekc;
239: peekc = 0;
240: return(c);
241: }
242: return(getc(in));
243: }
244:
245: ungetc(c)
246: {
247: peekc = c;
248: }
249:
250: error(s)
251: char *s;
252: {
253:
254: fflush(out);
255: fprintf(stderr, "vsort: %s\n", s);
256: }
257:
258: crail(nrail)
259: int nrail;
260: {
261:
262: railmag = nrail;
263: loadfont(nrail, cpsize);
264: }
265:
266: loadfont(fnum, size)
267: int fnum;
268: int size;
269: {
270:
271: cpsize = size;
272: return(0);
273: }
274:
275: stuffc(code)
276: register int code;
277: {
278: register struct achar *ap, **bp;
279:
280: if (col < 0 || col >= 500*8)
281: return;
282: if (afreel) {
283: ap = afreel;
284: afreel = ap->next;
285: } else
286: ap = (struct achar *)malloc(sizeof (*ap));
287: ap->row = row;
288: ap->col = col;
289: ap->psize = cpsize;
290: ap->verd = verd;
291: ap->back = back;
292: ap->mcase = mcase;
293: ap->code = code;
294: ap->railmag = railmag;
295: bp = &piles[col / 8];
296: ap->next = *bp;
297: *bp = ap;
298: }
299:
300: allflush()
301: {
302:
303: linesflush();
304: if (row > orow)
305: ptlead(row - orow);
306: row -= pagelength;
307: orow = row;
308: }
309:
310:
311: linesflush()
312: {
313: register struct achar **ap, *bp, *cp;
314: static notfirst;
315:
316: if (notfirst)
317: putc(0115, out);
318: orow = 0;
319: ocol = 0;
320: notfirst = 1;
321: for (ap = &piles[0]; ap < &piles[500]; ap++) {
322: for (bp = *ap; bp; bp = cp) {
323: sendchar(bp);
324: cp = bp->next;
325: bp->next = afreel;
326: afreel = bp;
327: }
328: *ap = 0;
329: }
330: }
331:
332: sendchar(cp)
333: register struct achar *cp;
334: {
335: register int i;
336:
337: #ifdef DUMPCHAR
338: dumpchar(cp);
339: #endif
340: if(cp->railmag != orailmag)
341: ptrail(cp->railmag);
342: if(cp->psize != opsize)
343: ptsize(cp->psize);
344: if(cp->mcase != omcase)
345: ptmcase();
346: if(cp->row != orow)
347: ptlead(cp->row - orow);
348: if(cp->col != ocol)
349: ptesc(cp->col - ocol);
350: if(cp->back != oback)
351: ptback();
352: putc(cp->code, out);
353: orow = cp->row;
354: orailmag = cp->railmag;
355: opsize = cp->psize;
356: omcase = cp->mcase;
357: ocol = cp->col;
358: oback = cp->back;
359: }
360:
361: ptrail(rlmg)
362: register int rlmg;
363: {
364:
365: if((rlmg & 01) != (orailmag & 01))
366: putc((rlmg & 01) ? 0102:0101, out); /* rail */
367: if((rlmg & 02) != (orailmag & 02))
368: putc((rlmg & 02) ? 0103:0104, out); /* mag */
369: }
370:
371: ptback()
372: {
373:
374: putc(oback ? 0107:0110, out);
375: oback = !oback;
376: }
377:
378: ptsize(size)
379: register int size;
380: {
381:
382: putc(0120 | (size & 017), out);
383: ptesc(-stupidadj(size, opsize));
384: }
385:
386: stupidadj(code, lcode)
387: register int code;
388: int lcode;
389: {
390: register struct point_sizes *psp;
391: register struct point_sizes *lpsp;
392:
393: psp = point_sizes;
394: while(psp->real_code != 0) {
395: if((psp->stupid_code & 017) == code)
396: break;
397: psp++;
398: }
399: lpsp = point_sizes;
400: while(lpsp->real_code != 0) {
401: if((lpsp->stupid_code & 017) == lcode)
402: break;
403: lpsp++;
404: }
405: code = 0;
406: if(!(lpsp->stupid_code & 0200) && (psp->stupid_code & 0200))
407: code = -55;
408: else
409: if((lpsp->stupid_code & 0200) && !(psp->stupid_code & 0200))
410: code = 55;
411: return(code);
412: }
413:
414: ptmcase()
415: {
416:
417: putc(omcase ? 0105:0106, out);
418: }
419:
420: ptesc(escc)
421: register int escc;
422: {
423:
424: if((escc < 0 && !oback ) || (escc >= 0 && oback))
425: ptback();
426: escc = abs(escc);
427: while(escc > 0177) {
428: putc(0200, out);
429: escc -= 0177;
430: }
431: if(escc)
432: putc(0200 | ((~escc) & 0177), out);
433: }
434:
435: ptlead(leadd)
436: register int leadd;
437: {
438:
439: if (leadd == 0)
440: return;
441: if (leadd < 0) {
442: if (overd == 0)
443: putc(0114, out), overd = 1;
444: leadd = -leadd;
445: } else {
446: if (overd)
447: putc(0112, out), overd = 0;
448: }
449: if (leadd > 64) {
450: putc(0116, out);
451: putc(leadd / 64, out);
452: leadd %= 64;
453: }
454: while (leadd > 037) {
455: putc(0140, out);
456: leadd -= 037;
457: }
458: if (leadd)
459: putc(0140 | ((~leadd) & 037), out);
460: }
461:
462: #ifdef DUMPLINE
463: dumpchar(cp)
464: register struct achar *cp;
465: {
466:
467: fprintf(stderr,
468: "code %o psize %d col %d row %d railmag %d verd %d back %d mcase %d\n",
469: cp->code, cp->psize, cp->col, cp->row, cp->railmag, cp->verd,
470: cp->back, cp->mcase);
471: }
472: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.