![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xpr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / xpr|
Return to xpr.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / xpr |
1.1 root 1: #include <X/mit-copyright.h>
2:
3: /*
4: * XPR - process xwd(1) files for the LN03 or LA100 printer
5: *
6: * Author: Michael R. Gretzinger, MIT Project Athena
7: * Copyright (C) 1985, Massachusetts Institute of Technology
8: */
9:
10: #ifndef lint
11: static char *rcsid_xpr_c = "$Header: xpr.c,v 10.4 86/02/01 16:03:38 tony Rel $";
12: #endif
13:
14: #include <sys/types.h>
15: #include <sys/file.h>
16: #include <sys/uio.h>
17: #include <stdio.h>
18: #include "lncmd.h"
19: #include "XWDFile.h"
20:
21: int debug = 0;
22:
23: enum device {LN01, LN03, LA100};
24: enum orientation {PORTRAIT, LANDSCAPE};
25:
26: #define W_MAX 2400
27: #define H_MAX 3150
28: #define W_MARGIN 75
29: #define H_MARGIN 37
30: #define W_PAGE 2550
31: #define H_PAGE 3225
32:
33: #ifdef NOINLINE
34: #define min(x,y) (((x)<(y))?(x):(y))
35: #endif NOINLINE
36:
37: #define F_PORTRAIT 1
38: #define F_LANDSCAPE 2
39: #define F_DUMP 4
40: #define F_NOSIXOPT 8
41: #define F_APPEND 16
42: #define F_NOFF 32
43: #define F_REPORT 64
44:
45:
46: main(argc, argv)
47: char **argv;
48: {
49: XWDFileHeader win;
50: register unsigned char (*sixmap)[];
51: register int i;
52: register int iw;
53: register int ih;
54: register int sixel_count;
55: char *w_name;
56: char *filename;
57: char *output_filename;
58: int scale, width, height, flags, split;
59: int left, top;
60: int top_margin, left_margin;
61: int wpad, hpad;
62: char *header, *trailer;
63: enum orientation orientation;
64: enum device device;
65:
66: parse_args (argc, argv, &scale, &width, &height, &left, &top, &device,
67: &flags, &split, &header, &trailer);
68:
69: /* read in window header */
70: read(0, &win, sizeof win);
71: w_name = (char *)malloc(win.header_size - sizeof win);
72: read(0, w_name, win.header_size - sizeof win);
73:
74: /* calculate orientation and scale */
75: setup_layout(device, win.pixmap_width, win.pixmap_height, flags, width,
76: height, header, trailer, &scale, &orientation);
77:
78: /* calculate w and h cell count */
79: wpad = (16 - (win.pixmap_width & 15)) & 15;
80: iw = win.pixmap_width;
81: ih = (win.pixmap_height + 5) / 6;
82: hpad = (ih * 6) - win.pixmap_height;
83:
84: /* build pixcells from input file */
85: sixel_count = iw * ih;
86: sixmap = (unsigned char (*)[])malloc(sixel_count);
87: build_sixmap(iw, ih, sixmap, wpad, hpad);
88:
89: /* output commands and sixel graphics */
90: if (device == LN03) {
91: /* ln03_grind_fonts(sixmap, iw, ih, scale, &pixmap); */
92: ln03_setup(iw, ih, orientation, scale, left, top,
93: &left_margin, &top_margin, flags, header, trailer);
94: ln03_output_sixels(sixmap, iw, ih, (flags & F_NOSIXOPT), split,
95: scale, top_margin, left_margin);
96: ln03_finish();
97: } else if (device == LA100) {
98: la100_setup(iw, ih, scale);
99: la100_output_sixels(sixmap, iw, ih, (flags & F_NOSIXOPT));
100: la100_finish();
101: } else {
102: fprintf(stderr, "xwd2: device not supported\n");
103: }
104:
105: /* print some statistics */
106: if (flags & F_REPORT) {
107: fprintf(stderr, "Name: %s\n", w_name);
108: fprintf(stderr, "Width: %d, Height: %d\n", win.pixmap_width,
109: win.pixmap_height);
110: fprintf(stderr, "Orientation: %s, Scale: %d\n",
111: (orientation==PORTRAIT) ? "Portrait" : "Landscape", scale);
112: }
113: if (flags & F_DUMP) dump_sixmap(sixmap, iw, ih);
114: }
115:
116: parse_args(argc, argv, scale, width, height, left, top, device, flags,
117: split, header, trailer)
118: register int argc;
119: register char **argv;
120: int *scale;
121: int *width;
122: int *height;
123: int *left;
124: int *top;
125: enum device *device;
126: int *flags;
127: int *split;
128: char **header;
129: char **trailer;
130: {
131: register char *output_filename;
132: register int f;
133: register int len;
134: register int pos;
135: double atof();
136: int atoi();
137:
138: output_filename = NULL;
139: *device = LN03; /* default */
140: *flags = 0;
141: *split = 1;
142: *width = -1;
143: *height = -1;
144: *top = -1;
145: *left = -1;
146: *header = NULL;
147: *trailer = NULL;
148:
149: argc--;
150: argv++;
151:
152: while (argc > 0 && argv[0][0] == '-') {
153: len = strlen(*argv);
154: switch (argv[0][1]) {
155: case 'a': /* -append <filename> */
156: if (!bcmp(*argv, "-append", len)) {
157: argc--; argv++;
158: output_filename = *argv;
159: *flags |= F_APPEND;
160: }
161: break;
162:
163: case 'd': /* -device {ln03 | la100} | -dump */
164: if (len <= 2) {
165: fprintf(stderr, "xwd2: ambiguous option: \"%s\"\n", *argv);
166: exit(1);
167: }
168: if (!bcmp(*argv, "-device", len)) {
169: argc--; argv++;
170: len = strlen(*argv);
171: if (!bcmp(*argv, "ln03", len)) {
172: *device = LN03;
173: } else if (!bcmp(*argv, "la100", len)) {
174: *device = LA100;
175: } else {
176: fprintf(stderr,
177: "xwd2: device \"%s\" not supported\n", *argv);
178: exit(1);
179: }
180: } else if (!bcmp(*argv, "-dump", len)) {
181: *flags |= F_DUMP;
182: }
183: break;
184:
185: case 'h': /* -height <inches> */
186: if (len <= 3) {
187: fprintf(stderr, "xwd2: ambiguous option: \"%s\"\n", *argv);
188: exit(1);
189: }
190: if (!bcmp(*argv, "-height", len)) {
191: argc--; argv++;
192: *height = (int)(300.0 * atof(*argv));
193: } else if (!bcmp(*argv, "-header", len)) {
194: argc--; argv++;
195: *header = *argv;
196: }
197: break;
198:
199: case 'l': /* -landscape | -left <inches> */
200: if (!bcmp(*argv, "-landscape", len)) {
201: *flags |= F_LANDSCAPE;
202: } else if (!bcmp(*argv, "-left", len)) {
203: argc--; argv++;
204: *left = (int)(300.0 * atof(*argv));
205: }
206: break;
207:
208: case 'n': /* -nosixopt | -noff */
209: if (len <= 3) {
210: fprintf(stderr, "xwd2: ambiguous option: \"%s\"\n", *argv);
211: exit(1);
212: }
213: if (!bcmp(*argv, "-nosixopt", len)) {
214: *flags |= F_NOSIXOPT;
215: } else if (!bcmp(*argv, "-noff", len)) {
216: *flags |= F_NOFF;
217: }
218: break;
219:
220: case 'o': /* -output <filename> */
221: if (!bcmp(*argv, "-output", len)) {
222: argc--; argv++;
223: output_filename = *argv;
224: }
225: break;
226:
227: case 'p': /* -portrait */
228: if (!bcmp(*argv, "-portrait", len)) {
229: *flags |= F_PORTRAIT;
230: }
231: break;
232:
233: case 'r': /* -report */
234: if (!bcmp(*argv, "-report", len)) {
235: *flags |= F_REPORT;
236: }
237: break;
238:
239: case 's': /* -scale <scale> | -split <n-pages> */
240: if (!bcmp(*argv, "-scale", len)) {
241: argc--; argv++;
242: *scale = atoi(*argv);
243: } else if (!bcmp(*argv, "-split", len)) {
244: argc--; argv++;
245: *split = atoi(*argv);
246: }
247: break;
248:
249: case 't': /* -top <inches> */
250: if (len <= 2) {
251: fprintf(stderr, "xwd2: ambigous option: \"%s\"\n", *argv);
252: exit(1);
253: }
254: if (!bcmp(*argv, "-top", len)) {
255: argc--; argv++;
256: *top = (int)(300.0 * atof(*argv));
257: } else if (!bcmp(*argv, "-trailer", len)) {
258: argc--; argv++;
259: *trailer = *argv;
260: }
261: break;
262:
263: case 'w': /* -width <inches> */
264: if (!bcmp(*argv, "-width", len)) {
265: argc--; argv++;
266: *width = (int)(300.0 * atof(*argv));
267: }
268: break;
269:
270: }
271: argc--; argv++;
272: }
273:
274: if (argc > 0) {
275: f = open(*argv, O_RDONLY, 0);
276: if (f < 0) {
277: fprintf(stderr, "xwd2: error opening \"%s\" for input\n", *argv);
278: perror("");
279: exit(1);
280: }
281: dup2(f, 0);
282: close(f);
283: /* if (output_filename == NULL) {
284: output_filename = (char *)malloc(strlen(*argv)+10);
285: build_output_filename(*argv, *device, output_filename);
286: } */
287: }
288:
289: if (output_filename != NULL) {
290: if (!(*flags & F_APPEND)) {
291: f = open(output_filename, O_CREAT|O_WRONLY|O_TRUNC, 0664);
292: } else {
293: f = open(output_filename, O_WRONLY, 0);
294: }
295: if (f < 0) {
296: fprintf(stderr, "xwd2: error opening \"%s\" for output\n",
297: output_filename);
298: perror("xwd2");
299: exit(1);
300: }
301: if (*flags & F_APPEND) {
302: pos = lseek(f, 0, 2); /* get eof position */
303: if (*flags & F_NOFF) pos -= 3; /* set position before trailing */
304: /* formfeed and reset */
305: lseek(f, pos, 0); /* set pointer */
306: }
307: dup2(f, 1);
308: close(f);
309: }
310: }
311:
312: setup_layout(device, win_width, win_height, flags, width, height,
313: header, trailer, scale, orientation)
314: enum device device;
315: int win_width;
316: int win_height;
317: int flags;
318: int width;
319: int height;
320: char *header;
321: char *trailer;
322: int *scale;
323: enum orientation *orientation;
324: {
325: register int w_scale;
326: register int h_scale;
327: register int iscale = *scale;
328: register int w_max;
329: register int h_max;
330:
331: if (header != NULL) win_height += 75;
332: if (trailer != NULL) win_height += 75;
333:
334: /* check maximum width and height; set orientation and scale*/
335: if (device == LN03) {
336: if ((win_width < win_height || (flags & F_PORTRAIT)) &&
337: !(flags & F_LANDSCAPE)) {
338: *orientation = PORTRAIT;
339: w_max = (width > 0)? width : W_MAX;
340: h_max = (height > 0)? height : H_MAX;
341: w_scale = w_max / win_width;
342: h_scale = h_max / win_height;
343: *scale = min(w_scale, h_scale);
344: } else {
345: *orientation = LANDSCAPE;
346: w_max = (width > 0)? width : H_MAX;
347: h_max = (height > 0)? height : W_MAX;
348: w_scale = w_max / win_width;
349: h_scale = h_max / win_height;
350: *scale = min(w_scale, h_scale);
351: }
352: } else { /* device == LA100 */
353: *orientation = PORTRAIT;
354: *scale = W_MAX / win_width;
355: }
356: if (*scale == 0) *scale = 1;
357: if (*scale > 6) *scale = 6;
358: if (iscale > 0 && iscale < *scale) *scale = iscale;
359: }
360:
361: dump_sixmap(sixmap, iw, ih)
362: register unsigned char (*sixmap)[];
363: int iw;
364: int ih;
365: {
366: register int i, j;
367: register unsigned char *c;
368:
369: c = (unsigned char *)sixmap;
370: fprintf(stderr, "Sixmap:\n");
371: for (i = 0; i < ih; i++) {
372: for (j = 0; j < iw; j++) {
373: fprintf(stderr, "%02X ", *c++);
374: }
375: fprintf(stderr, "\n\n");
376: }
377: }
378:
379: build_sixmap(iw, ih, sixmap, wpad, hpad)
380: int ih;
381: int iw;
382: unsigned char (*sixmap)[];
383: int wpad;
384: int hpad;
385: {
386: int iwb, iww;
387: int rsize, cc;
388: int w, maxw;
389: struct iovec linevec[6];
390: unsigned char line[6][150];
391: register unsigned char *c;
392: register int i, j, k, m;
393: register int sixel;
394: static int mask[] = {~1, ~2, ~4, ~8, ~16, ~32, ~64, ~128};
395:
396: c = (unsigned char *)sixmap;
397: iwb = (iw + wpad) / 8;
398:
399: for (i = 0; i <= 5; i++) {
400: linevec[i].iov_base = (caddr_t)line[i];
401: linevec[i].iov_len = iwb;
402: }
403:
404: while (--ih >= 0) {
405: if (ih > 0 || hpad == 0) {
406: rsize = iwb * 6;
407: while (rsize > 0) {
408: cc = readv(0, linevec, 6);
409: if (cc == 0) break;
410: rsize -= cc;
411: }
412: } else {
413: i = 6 - hpad;
414: rsize = iwb * i;
415: while (rsize > 0) {
416: cc = readv(0, linevec, i);
417: if (cc == 0) break;
418: rsize -= cc;
419: }
420: for (; i < 6; i++)
421: for (j = 0; j < iwb; j++) line[i][j] = 0xFF;
422: }
423:
424: #ifndef NOINLINE
425: for (i = 0; i < iw; i++) {
426: sixel = extzv(line[0], i, 1);
427: sixel |= extzv(line[1], i, 1) << 1;
428: sixel |= extzv(line[2], i, 1) << 2;
429: sixel |= extzv(line[3], i, 1) << 3;
430: sixel |= extzv(line[4], i, 1) << 4;
431: sixel |= extzv(line[5], i, 1) << 5;
432: *c++ = sixel;
433: }
434: #else
435: for (i = 0, w = iw; w > 0; i++) {
436: for (j = 0; j <= 7; j++) {
437: m = mask[j];
438: k = -j;
439: sixel = ((line[0][i] & ~m) << k++);
440: sixel |= ((line[1][i] & ~m) << k++);
441: sixel |= ((line[2][i] & ~m) << k++);
442: sixel |= ((line[3][i] & ~m) << k++);
443: sixel |= ((line[4][i] & ~m) << k++);
444: sixel |= ((line[5][i] & ~m) << k);
445: *c++ = sixel;
446: if (--w == 0) break;
447: }
448: }
449: #endif
450: }
451: }
452:
453: build_output_filename(name, device, oname)
454: register char *name, *oname;
455: enum device device;
456: {
457: while (*name && *name != '.') *oname++ = *name++;
458: switch (device) {
459: case LN03: bcopy(".ln03", oname, 6); break;
460: case LA100: bcopy(".la100", oname, 7); break;
461: }
462: }
463:
464:
465: ln03_grind_fonts(sixmap, iw, ih, scale, pixmap)
466: unsigned char (*sixmap)[];
467: int iw;
468: int ih;
469: int scale;
470: struct pixmap (**pixmap)[];
471: {
472: }
473:
474:
475: ln03_setup(iw, ih, orientation, scale, left, top, left_margin, top_margin,
476: flags, header, trailer)
477: int iw;
478: int ih;
479: enum orientation orientation;
480: int scale;
481: int left;
482: int top;
483: int *left_margin;
484: int *top_margin;
485: int flags;
486: char *header;
487: char *trailer;
488: {
489: register int i;
490: register int lm, tm, xm;
491: char fontname[6];
492: char buf[256];
493: register char *bp = buf;
494:
495: if (!(flags & F_APPEND)) {
496: sprintf(bp, LN_RIS); bp += 2;
497: sprintf(bp, LN_SSU, 7); bp += 5;
498: sprintf(bp, LN_PUM_SET); bp += sizeof LN_PUM_SET - 1;
499: }
500:
501: if (orientation == PORTRAIT) {
502: lm = (left > 0)? left : (((W_MAX - scale * iw) / 2) + W_MARGIN);
503: tm = (top > 0)? top : (((H_MAX - scale * ih * 6) / 2) + H_MARGIN);
504: sprintf(bp, LN_PFS, "?20"); bp += 7;
505: sprintf(bp, LN_DECOPM_SET); bp += sizeof LN_DECOPM_SET - 1;
506: sprintf(bp, LN_DECSLRM, lm, W_PAGE - lm); bp += strlen(bp);
507: } else {
508: lm = (left > 0)? left : (((H_MAX - scale * iw) / 2) + H_MARGIN);
509: tm = (top > 0)? top : (((W_MAX - scale * ih * 6) / 2) + W_MARGIN);
510: sprintf(bp, LN_PFS, "?21"); bp += 7;
511: sprintf(bp, LN_DECOPM_SET); bp += sizeof LN_DECOPM_SET - 1;
512: sprintf(bp, LN_DECSLRM, lm, H_PAGE - lm); bp += strlen(bp);
513: }
514:
515: if (header != NULL) {
516: sprintf(bp, LN_VPA, tm - 100); bp += strlen(bp);
517: i = strlen(header);
518: xm = (((scale * iw) - (i * 30)) / 2) + lm;
519: sprintf(bp, LN_HPA, xm); bp += strlen(bp);
520: sprintf(bp, LN_SGR, 3); bp += strlen(bp);
521: bcopy(header, bp, i);
522: bp += i;
523: }
524: if (trailer != NULL) {
525: sprintf(bp, LN_VPA, tm + (scale * ih * 6) + 75); bp += strlen(bp);
526: i = strlen(trailer);
527: xm = (((scale * iw) - (i * 30)) / 2) + lm;
528: sprintf(bp, LN_HPA, xm); bp += strlen(bp);
529: sprintf(bp, LN_SGR, 3); bp += strlen(bp);
530: bcopy(trailer, bp, i);
531: bp += i;
532: }
533:
534: sprintf(bp, LN_HPA, lm); bp += strlen(bp);
535: sprintf(bp, LN_VPA, tm); bp += strlen(bp);
536: sprintf(bp, LN_SIXEL_GRAPHICS, 9, 0, scale); bp += strlen(bp);
537: sprintf(bp, "\"1;1"); bp += 4; /* Pixel aspect ratio */
538: write(1, buf, bp-buf);
539: *top_margin = tm;
540: *left_margin = lm;
541: }
542:
543: #define LN03_RESET "\033c"
544:
545: ln03_finish()
546: {
547: write(1, LN03_RESET, sizeof LN03_RESET - 1);
548: }
549:
550: la100_setup(iw, ih, scale)
551: {
552: unsigned char buf[256];
553: register unsigned char *bp;
554: int lm, tm;
555:
556: bp = buf;
557: lm = ((80 - (int)((double)iw / 6.6)) / 2) - 1;
558: if (lm < 1) lm = 1;
559: tm = ((66 - (int)((double)ih / 2)) / 2) - 1;
560: if (tm < 1) tm = 1;
561: sprintf(bp, "\033[%d;%ds", lm, 81-lm); bp += strlen(bp);
562: sprintf(bp, "\033[?7l"); bp += 5;
563: sprintf(bp, "\033[%dd", tm); bp += strlen(bp);
564: sprintf(bp, "\033[%d`", lm); bp += strlen(bp);
565: sprintf(bp, "\033P0q"); bp += 4;
566: write(1, buf, bp-buf);
567: }
568:
569: #define LA100_RESET "\033[1;80s\033[?7h"
570:
571: la100_finish()
572: {
573: write(1, LA100_RESET, sizeof LA100_RESET - 1);
574: }
575:
576: ln03_alter_background(sixmap, iw, ih)
577: unsigned char (*sixmap)[];
578: int iw;
579: int ih;
580: {
581: register int size;
582: register unsigned char *c, *stopc;
583: register unsigned char *startc;
584: register int n;
585:
586: c = (unsigned char *)sixmap;
587: stopc = c + (iw * ih);
588: n = 0;
589: while (c < stopc) {
590: switch (*c) {
591: case 0x08: case 0x11: case 0x04: case 0x22:
592: case 0x20: case 0x21: case 0x24: case 0x00:
593: if (n == 0) startc = c;
594: n++;
595: break;
596:
597: default:
598: if (n >= 2) {
599: while (n-- > 0) *startc++ = 0x00;
600: } else {
601: n = 0;
602: }
603: break;
604: }
605: c++;
606: }
607: }
608:
609: ln03_output_sixels(sixmap, iw, ih, nosixopt, split, scale, top_margin,
610: left_margin)
611: unsigned char (*sixmap)[];
612: int iw;
613: int ih;
614: int nosixopt;
615: int split;
616: int top_margin;
617: int left_margin;
618: {
619: unsigned char *buf;
620: register unsigned char *bp;
621: int i;
622: int j;
623: register int k;
624: register unsigned char *c;
625: register int lastc;
626: register int count;
627: char snum[6];
628: register char *snp;
629:
630: bp = (unsigned char *)malloc(iw*ih+512);
631: buf = bp;
632: count = 0;
633: lastc = -1;
634: c = (unsigned char *)sixmap;
635: split = ih / split; /* number of lines per page */
636:
637: iw--; /* optimization */
638: for (i = 0; i < ih; i++) {
639: for (j = 0; j <= iw; j++) {
640: if (!nosixopt) {
641: if (*c == lastc && j < iw) {
642: count++;
643: c++;
644: continue;
645: }
646: if (count >= 3) {
647: bp--;
648: count++;
649: *bp++ = '!';
650: snp = snum;
651: while (count > 0) {
652: k = count / 10;
653: *snp++ = count - (k * 10) + '0';
654: count = k;
655: }
656: while (--snp >= snum) *bp++ = *snp;
657: *bp++ = (~lastc & 0x3F) + 0x3F;
658: } else if (count > 0) {
659: lastc = (~lastc & 0x3F) + 0x3F;
660: do {
661: *bp++ = lastc;
662: } while (--count > 0);
663: }
664: }
665: lastc = *c++;
666: *bp++ = (~lastc & 0x3F) + 0x3F;
667: }
668: *bp++ = '-'; /* New line */
669: lastc = -1;
670: if ((i % split) == 0 && i != 0) {
671: sprintf(bp, LN_ST); bp += sizeof LN_ST - 1;
672: *bp++ = '\f';
673: sprintf(bp, LN_VPA, top_margin + (i * 6 * scale)); bp += strlen(bp);
674: sprintf(bp, LN_HPA, left_margin); bp += strlen(bp);
675: sprintf(bp, LN_SIXEL_GRAPHICS, 9, 0, scale); bp += strlen(bp);
676: sprintf(bp, "\"1;1"); bp += 4;
677: }
678: }
679:
680: sprintf(bp, LN_ST); bp += sizeof LN_ST - 1;
681: *bp++ = '\f';
682: write(1, buf, bp-buf);
683: }
684:
685: la100_output_sixels(sixmap, iw, ih)
686: unsigned char (*sixmap)[];
687: int iw;
688: int ih;
689: {
690: unsigned char *buf;
691: register unsigned char *bp;
692: int i;
693: register int j, k;
694: register unsigned char *c;
695: register int lastc;
696: register int count;
697: char snum[6];
698:
699: bp = (unsigned char *)malloc(iw*ih+512);
700: buf = bp;
701: count = 0;
702: lastc = -1;
703: c = (unsigned char *)sixmap;
704:
705: for (i = 0; i < ih; i++) {
706: for (j = 0; j < iw; j++) {
707: if (*c == lastc && (j+1) < iw) {
708: count++;
709: c++;
710: continue;
711: }
712: if (count >= 2) {
713: bp -= 2;
714: count = 2 * (count + 1);
715: *bp++ = '!';
716: k = 0;
717: while (count > 0) {
718: snum[k++] = (count % 10) + '0';
719: count /= 10;
720: }
721: while (--k >= 0) *bp++ = snum[k];
722: *bp++ = (~lastc & 0x3F) + 0x3F;
723: count = 0;
724: } else if (count > 0) {
725: lastc = (~lastc & 0x3F) + 0x3F;
726: do {
727: *bp++ = lastc;
728: *bp++ = lastc;
729: } while (--count > 0);
730: }
731: lastc = (~*c & 0x3F) + 0x3F;
732: *bp++ = lastc;
733: *bp++ = lastc;
734: lastc = *c++;
735: }
736: *bp++ = '-'; /* New line */
737: lastc = -1;
738: }
739:
740: sprintf(bp, LN_ST); bp += sizeof LN_ST - 1;
741: *bp++ = '\f';
742: write(1, buf, bp-buf);
743: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.