![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vsort.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / versatec|
Return to vsort.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / versatec |
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 cycle for(;;)
7: #define NULL 0
8:
9: #define INTR 2
10: #define QUIT 3
11: #define HUP 1
12: #define BROKENPIPE 13
13:
14: double atof();
15:
16: FILE *inbuf,*outbuf;
17:
18: int skmagic = 1; /* skip the first leading so start at top of page */
19: int cpsize = 02; /* Funny sizes */
20: struct point_sizes
21: {
22: int stupid_code;
23: int real_code;
24: } point_sizes[]
25: {
26: 010, 6,
27: 0, 7,
28: 01, 8,
29: 07, 9,
30: 02, 10,
31: 03, 11,
32: 04, 12,
33: 05, 14,
34: 0211, 16,
35: 06, 18,
36: 0212, 20,
37: 0213, 22,
38: 0214, 24,
39: 0215, 28,
40: 0216, 36,
41: 0, 0
42: };
43:
44: int overflow = 144 * 11;
45: int pagemod;
46: #define MODOFF 3672 /* 432 * 8.5 */
47:
48: int esc, lead, back, verd, mcase, railmag;
49: int col, row;
50: int pstart 0; /* Means a startline is pending */
51:
52: int oback, omcase, orailmag, ocol;
53: int opsize 02;
54:
55: struct lstate
56: {
57: int row;
58: int col;
59: int psize;
60: char railmag;
61: char verd;
62: char back;
63: char mcase;
64: };
65:
66: struct line
67: {
68: struct line *nextp;
69: struct line *lastp;
70: int len;
71: struct lstate start;
72: struct lstate end;
73: char *codep;
74: };
75:
76: struct line *head;
77: struct line *tail;
78: struct line cline { -1,-1,-1,-1};
79:
80: #define TBUFLEN 1024
81: char *codep;
82: char tbuf[TBUFLEN];
83:
84: #ifdef MONITORING
85: extern etext();
86: int monbuf[1000];
87: #endif
88:
89: main(argc, argv)
90: int argc;
91: char *argv[];
92: {
93: register i;
94:
95: #ifndef TESTING
96: signal(BROKENPIPE, 1);
97: #endif
98:
99: for(i = 3; i < 15; i++)
100: close(i);
101: #ifdef MONITORING
102: monitor(2,etext,monbuf,sizeof monbuf/2,0);
103: #endif
104: if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'l') {
105: float f = 144 * atof(argv[1] + 2);
106: if (f < 144) {
107: error("bad length");
108: exit(1);
109: }
110: overflow = f;
111: argc--, argv++;
112: }
113: outbuf = stdout;
114: if(argc > 1)
115: {
116: while(--argc)
117: {
118: argv++;
119: process(argv[0]);
120: }
121: }
122: else
123: {
124: inbuf = stdin;
125: ofile();
126: }
127: #ifdef MONITORING
128: monitor(0);
129: #endif
130: done();
131: }
132:
133:
134: process(name)
135: char *name;
136: {
137: if((inbuf=fopen(name, "r")) == NULL)
138: error("cannot open data file");
139: ofile();
140: }
141:
142: ofile()
143: {
144: register int c;
145: static int initialized;
146:
147: while((c = getch()) != -1) {
148: if(!c)
149: continue;
150: if(c & 0200)
151: {
152: if(!pstart)
153: stuffc(c);
154: esc += (~c) & 0177;
155: continue;
156: }
157: if(esc)
158: {
159: if(back)
160: esc = -esc;
161: col += esc;
162: esc = 0;
163: }
164: if((c & 0377) < 0100) /* Purely for efficiency */
165: goto normal_char;
166: switch(c) {
167: case 0100:
168: if(initialized++)
169: goto out;
170: row = 0;
171: col = 0; esc = 0;
172: lead = 0;
173: verd = 0; back = 0; mcase = 0;
174: railmag = 0;
175: ocol = 0;
176: oback = 0; omcase = 0;
177: orailmag = 0;
178: if(loadfont(railmag, cpsize) < 0)
179: error("init");
180: startline();
181: putc(0100, outbuf); /* Dont stuff it guys */
182: break;
183: case 0101: /* lower rail */
184: crail(railmag =& ~01);
185: if(!pstart)
186: stuffc(c);
187: break;
188: case 0102: /* upper rail */
189: crail(railmag =| 01);
190: if(!pstart)
191: stuffc(c);
192: break;
193: case 0103: /* upper mag */
194: crail(railmag =| 02);
195: if(!pstart)
196: stuffc(c);
197: break;
198: case 0104: /* lower mag */
199: crail(railmag =& ~02);
200: if(!pstart)
201: stuffc(c);
202: break;
203: case 0105: /* lower case */
204: mcase = 0;
205: if(!pstart)
206: stuffc(c);
207: break;
208: case 0106: /* upper case */
209: mcase = 0100;
210: if(!pstart)
211: stuffc(c);
212: break;
213: case 0107: /* escape forward */
214: back = 0;
215: if(!pstart)
216: stuffc(c);
217: break;
218: case 0110: /* escape backwards */
219: back = 1;
220: if(!pstart)
221: stuffc(c);
222: break;
223: case 0111: /* stop */
224: stuffc(c);
225: break;
226: case 0112: /* lead forward */
227: verd = 0;
228: break;
229: case 0113: /* undefined */
230: break;
231: case 0114: /* lead backward */
232: verd = 1;
233: break;
234: case 0115: /* undefined */
235: case 0116:
236: case 0117:
237: break;
238: default:
239: if((c & 0340) == 0140) /* leading */
240: {
241: termline();
242: lead = (~c) & 037;
243: if(verd)
244: lead = -lead;
245: if (skmagic > 0) {
246: skmagic--;
247: ptlead(lead);
248: continue;
249: }
250: row += lead;
251: if (row >= overflow) {
252: if (pagemod == 3) {
253: allflush();
254: col %= MODOFF;
255: pagemod = 0;
256: } else {
257: pagemod++;
258: col += MODOFF;
259: row -= overflow;
260: }
261: }
262: if (row >= overflow)
263: write(2, "URK\n", 4);
264: /*
265: if (row > overflow)
266: miniflush();
267: */
268: if (row < 0) {
269: if (pagemod) {
270: pagemod--;
271: col -= MODOFF;
272: row += overflow;
273: }
274: }
275: if (row < 0)
276: write(2, "URK2\n", 5);
277: pstart++;
278: continue;
279: }
280: if((c & 0360) == 0120) /* size change */
281: {
282: if(!pstart)
283: stuffc(c);
284: col += stupidadj(c & 017, cpsize);
285: loadfont(railmag, c & 017);
286: continue;
287: }
288: if(c & 0300)
289: continue;
290: normal_char:
291: c = (c & 077);
292: stuffc(c);
293: }
294: }
295: out:
296: termline();
297: allflush();
298: fclose(inbuf);
299: }
300:
301: done() {
302: termline();
303: allflush();
304: exit();
305: }
306:
307: int peekc;
308: getch() {
309: register c;
310: if(peekc) {
311: c = peekc;
312: peekc = 0;
313: return(c);
314: }
315: return(getc(inbuf));
316: }
317:
318: ungetc(c) {
319: peekc = c;
320: }
321:
322:
323: error(s)
324: char *s;
325: {
326:
327: fflush(outbuf);
328: fprintf(stderr, "Vsort: %s\n", s);
329: }
330:
331: crail(nrail)
332: register int nrail;
333: {
334: register int psize;
335:
336: psize = cpsize;
337: loadfont(nrail, psize);
338: }
339:
340: loadfont(fnum, size)
341: register int fnum;
342: register int size;
343: {
344:
345: cpsize = size;
346: return(0);
347: }
348:
349: startline()
350: {
351:
352: if(pstart != 0) {
353: cline.start.row = row;
354: return;
355: }
356: cline.len = 0;
357: cline.start.row = row;
358: cline.start.col = col;
359: cline.start.psize = cpsize;
360: cline.start.mcase = mcase;
361: cline.start.back = back;
362: cline.start.verd = verd;
363: cline.start.railmag = railmag;
364: codep = tbuf;
365: }
366:
367: termline()
368: {
369: register struct line *linep;
370: register char *allp;
371: register char *cp;
372: int i;
373:
374: if(pstart != 0)
375: return;
376: if((allp = calloc(sizeof *linep,1)) == -1)
377: error("alloc");
378: linep = allp;
379: linep->end.row = row;
380: linep->end.col = col;
381: linep->end.psize = cpsize;
382: linep->end.mcase = mcase;
383: linep->end.back = back;
384: linep->end.verd = verd;
385: linep->end.railmag = railmag;
386: linep->start.row = cline.start.row;
387: linep->start.col = cline.start.col;
388: linep->start.psize = cline.start.psize;
389: linep->start.mcase = cline.start.mcase;
390: linep->start.back = cline.start.back;
391: linep->start.verd = cline.start.verd;
392: linep->start.railmag = cline.start.railmag;
393: linep->len = cline.len;
394: if((allp = calloc(cline.len,1)) == -1)
395: error("alloc");
396: linep->codep = allp;
397: cp = tbuf;
398: for(i = 0; i < cline.len; i++)
399: *allp++ = *cp++;
400: sortin(linep);
401: }
402:
403: sortin(linep)
404: register struct line *linep;
405: {
406: register struct line *clp;
407:
408: if((clp = tail) == NULL) {
409: head = tail = linep;
410: linep->lastp = linep->nextp = NULL;
411: return;
412: }
413: while(clp != NULL && clp->start.row > linep->start.row)
414: clp = clp->lastp;
415: if(clp == tail) {
416: linep->lastp = tail;
417: linep->nextp = NULL;
418: tail->nextp = linep;
419: tail = linep;
420: } else
421: if(clp == NULL) /* goes at head of list */ {
422: linep->lastp = NULL;
423: linep->nextp = head;
424: head->lastp = linep;
425: head = linep;
426: } else {
427: linep->lastp = clp;
428: linep->nextp = clp->nextp;
429: clp->nextp->lastp = linep;
430: clp->nextp = linep;
431: }
432: }
433:
434: stuffc(code)
435: register int code;
436: {
437:
438: if(pstart != 0) {
439: pstart = 0;
440: startline();
441: }
442: if(cline.len > TBUFLEN) {
443: termline();
444: startline();
445: }
446: *codep++ = code;
447: cline.len++;
448: }
449:
450: miniflush()
451: {
452:
453: sendline();
454: }
455:
456: allflush()
457: {
458:
459: while(head != NULL)
460: sendline();
461: sendline();
462: fflush(outbuf);
463: }
464:
465: sendline()
466: {
467: register char *cp;
468: register struct line *linep;
469: register int i;
470: int drow;
471:
472: if((linep = head) == NULL) {
473: while(row >= overflow) {
474: /* fprintf(stderr, "spitting %d\n", overflow - row); */
475: if (overflow - row)
476: ptlead(overflow - row);
477: updatelist(overflow);
478: }
479: return;
480: }
481: adjparms(linep);
482: cp = linep->codep;
483: for(i = 0; i < linep->len; i++)
484: putc(*cp++, outbuf);
485: setparms(linep);
486: if(linep->nextp != NULL)
487: drow = linep->nextp->start.row;
488: else
489: drow = overflow;
490: head = linep->nextp;
491: cfree(linep->codep);
492: cfree(linep);
493: if(head == NULL)
494: tail = NULL;
495: else
496: head->lastp = NULL;
497: ptlead(drow - row);
498: row = drow;
499: /* updatelist(drow); */
500: }
501:
502: adjparms(linep)
503: register struct line *linep;
504: {
505:
506: if(linep->start.railmag != orailmag)
507: ptrail(linep->start.railmag);
508: if(linep->start.psize != opsize)
509: ptsize(linep->start.psize);
510: if(linep->start.mcase != omcase)
511: ptmcase();
512: if(linep->start.row != row) /* lead forward */
513: {
514: ptlead(linep->start.row - row);
515: row = linep->start.row;
516: /* updatelist(linep->start.row); */
517: }
518: if(linep->start.col != ocol)
519: ptesc(linep->start.col-ocol);
520: if(linep->start.back != oback)
521: ptback();
522: }
523:
524: ptrail(rlmg)
525: register int rlmg;
526: {
527:
528: if((rlmg & 01) != (orailmag & 01))
529: putc((rlmg & 01) ? 0102:0101, outbuf); /* rail */
530: if((rlmg & 02) != (orailmag & 02))
531: putc((rlmg & 02) ? 0103:0104, outbuf); /* mag */
532: }
533:
534: ptback()
535: {
536:
537: putc(oback ? 0107:0110, outbuf);
538: oback = !oback;
539: }
540:
541: ptsize(size)
542: register int size;
543: {
544:
545: putc(0120 | (size & 017), outbuf);
546: ptesc(-stupidadj(size, opsize));
547: }
548:
549: stupidadj(code, lcode)
550: register int code;
551: int lcode;
552: {
553: register struct point_sizes *psp;
554: register struct point_sizes *lpsp;
555:
556: psp = point_sizes;
557: while(psp->real_code != 0) {
558: if((psp->stupid_code & 017) == code)
559: break;
560: psp++;
561: }
562: lpsp = point_sizes;
563: while(lpsp->real_code != 0) {
564: if((lpsp->stupid_code & 017) == lcode)
565: break;
566: lpsp++;
567: }
568: code = 0;
569: if(!(lpsp->stupid_code & 0200) && (psp->stupid_code & 0200))
570: code = -55;
571: else
572: if((lpsp->stupid_code & 0200) && !(psp->stupid_code & 0200))
573: code = 55;
574: return(code);
575: }
576:
577: ptmcase()
578: {
579:
580: putc(omcase ? 0105:0106, outbuf);
581: }
582:
583: ptesc(escc)
584: register int escc;
585: {
586:
587: if((escc < 0 && !oback ) || (escc >= 0 && oback))
588: ptback();
589: escc = abs(escc);
590: while(escc > 0177) {
591: putc(0200, outbuf);
592: escc -= 0177;
593: }
594: if(escc)
595: putc(0200 | ((~escc) & 0177), outbuf);
596: }
597:
598: ptlead(leadd)
599: register int leadd;
600: {
601:
602: while(leadd > 037) {
603: putc(0140, outbuf);
604: leadd -= 037;
605: }
606: if(leadd)
607: putc(0140 | ((~leadd) & 037), outbuf);
608: }
609:
610: setparms(linep)
611: register struct line *linep;
612: {
613:
614: orailmag = linep->end.railmag;
615: opsize = linep->end.psize;
616: omcase = linep->end.mcase;
617: ocol = linep->end.col;
618: oback = linep->end.back;
619: }
620:
621: updatelist(drow)
622: register int drow;
623: {
624: register struct line *clp;
625:
626: for(clp = head; clp != NULL; clp = clp->nextp)
627: clp->start.row -= drow;
628: row -= drow;
629: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.