1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2010 Nexenta Systems, Inc. All rights reserved.
14 */
15
16 /*
17 * Copyright 2019 Joyent, Inc.
18 */
19
20 /*
21 * od - octal dump. Not really just octal anymore; read the POSIX
22 * specification for it -- its more complex than you think!
23 *
24 * NB: We followed the POSIX semantics fairly strictly, where the
25 * legacy code's behavior was in conflict. In many cases the legacy
26 * Solaris code was so completely broken as to be completely unusable.
27 * (For example, the long double support was broken beyond
28 * imagination!) Note that GNU coreutils violates POSIX in a few
29 * interesting ways, such as changing the numbering of the addresses
30 * when skipping. (Address starts should always be at 0, according to
31 * the sample output in the Open Group man page.)
32 */
33
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <sys/types.h>
37 #include <string.h>
38 #include <err.h>
39 #include <wchar.h>
40 #include <locale.h>
41 #include <unistd.h>
42 #include <sys/stat.h>
43
44 #define _(x) gettext(x)
45
46
47 #ifndef TEXT_DOMAIN
48 #define TEXT_DOMAIN "SYS_TEST"
49 #endif
50
51 /* address format */
52 static char *afmt = "%07llo";
53 static char *cfmt = " ";
54
55 static FILE *input = NULL;
56 static size_t lcm = 1;
57 static size_t blocksize = 16;
58 static int numfiles = 0;
59 static int curfile = 0;
60 static char **files = NULL;
61 static off_t limit = -1;
62
63 /*
64 * This structure describes our ring buffer. Its always a power of 2
65 * in size to make wrap around calculations fast using a mask instead
66 * of doing modulo.
67 *
68 * The size is calculated thusly: We need three "blocks" of data, as
69 * we process a block at a time (one block == one line of od output.)
70 *
71 * We need lookahead of an extra block to support multibyte chars. We
72 * also have a look behind so that we can avoid printing lines that
73 * are identical to what we've already printed. Finally, we need the
74 * current block.
75 *
76 * The block size is determined by the least common multiple of the
77 * data items being displayed. Usually it will be 16, but sometimes
78 * it is 24 (when 12-byte long doubles are presented.)
79 *
80 * The data buffer is allocaed via memalign to make sure it is
81 * properly aligned.
82 */
83 typedef struct buffer {
84 char *data; /* data buffer */
85 int prod; /* producer index */
86 int cons; /* consumer index */
87 int mask; /* buffer size - 1, wraparound index */
88 int navail; /* total bytes avail */
89 } buffer_t;
90
91 /*
92 * This structure is used to provide information on a specific output
93 * format. We link them together in a list representing the output
94 * formats that the user has selected.
95 */
96 typedef struct output {
97 int width; /* bytes consumed per call */
98 void (*func)(buffer_t *, int); /* output function */
99 struct output *next; /* link node */
100 } output_t;
101
102 /*
103 * Specifiers
104 */
105
106 typedef unsigned char u8;
107 typedef unsigned short u16;
108 typedef unsigned int u32;
109 typedef unsigned long long u64;
110 typedef char s8;
111 typedef short s16;
112 typedef int s32;
113 typedef long long s64;
114 typedef float fF;
115 typedef double fD;
116 typedef long double fL;
117
118 static void
119 usage(void)
120 {
121 (void) fprintf(stderr, _("usage: od [-bcCdDfFoOsSvxX] "
122 "[-t types ]... [-A base] [-j skip] [-N count] [file]...\n"));
123 exit(1);
124 }
125
126 #define DECL_GET(typ) \
127 static typ \
128 get_ ## typ(buffer_t *b, int index) \
129 { \
130 typ val = *(typ *)(void *)(b->data + index); \
131 return (val); \
132 }
133 DECL_GET(u8)
134 DECL_GET(u16)
135 DECL_GET(u32)
136 DECL_GET(u64)
137 DECL_GET(s8)
138 DECL_GET(s16)
139 DECL_GET(s32)
140 DECL_GET(s64)
141 DECL_GET(fF)
142 DECL_GET(fD)
143 DECL_GET(fL)
144
145 #define DECL_OUT(nm, typ, fmt) \
146 static void \
147 do_ ## nm(buffer_t *buf, int index) \
148 { \
149 typ v = get_ ## typ(buf, index); \
150 (void) printf(fmt, v); \
151 } \
152 \
153 static output_t output_ ## nm = { \
154 sizeof (typ), do_ ## nm \
155 };
156
157 DECL_OUT(oct_b, u8, " %03o")
158 DECL_OUT(oct_w, u16, " %06ho")
159 DECL_OUT(oct_d, u32, " %011o")
160 DECL_OUT(oct_q, u64, " %022llo")
161 DECL_OUT(dec_b, u8, " %03u")
162 DECL_OUT(dec_w, u16, " %05hu")
163 DECL_OUT(dec_d, u32, " %010u")
164 DECL_OUT(dec_q, u64, " %020llu")
165 DECL_OUT(sig_b, s8, " %03d")
166 DECL_OUT(sig_w, s16, " %6.05hd")
167 DECL_OUT(sig_d, s32, " %11.010d")
168 DECL_OUT(sig_q, s64, " %20.019lld")
169 DECL_OUT(hex_b, u8, " %02x")
170 DECL_OUT(hex_w, u16, " %04hx")
171 DECL_OUT(hex_d, s32, " %08x")
172 DECL_OUT(hex_q, s64, " %016llx")
173 DECL_OUT(float, fF, " %14.7e")
174 DECL_OUT(double, fD, " %21.14e")
175 DECL_OUT(ldouble, fL, " %24.14Le")
176
177 static char *ascii[] = {
178 "nul", "soh", "stx", "etx", "eot", "enq", "ack", " be",
179 " bs", " ht", " lf", " vt", " ff", " cr", " so", " si",
180 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
181 "can", " em", "sub", "esc", " fs", " gs", " rs", " us",
182 " sp", " !", " \"", " #", " $", " %", " &", " '",
183 " (", " )", " *", " +", " ,", " -", " .", " /",
184 " 0", " 1", " 2", " 3", " 4", " 5", " 6", " 7",
185 " 8", " 9", " :", " ;", " <", " =", " >", " ?",
186 " @", " A", " B", " C", " D", " E", " F", " G",
187 " H", " I", " J", " K", " L", " M", " N", " O",
188 " P", " Q", " R", " S", " T", " U", " V", " W",
189 " X", " Y", " Z", " [", " \\", " ]", " ^", " _",
190 " `", " a", " b", " c", " d", " e", " f", " g",
191 " h", " i", " j", " k", " l", " m", " n", " o",
192 " p", " q", " r", " s", " t", " u", " v", " w",
193 " x", " y", " z", " {", " |", " }", " ~", "del"
194 };
195
196 static void
197 do_ascii(buffer_t *buf, int index)
198 {
199 uint8_t v = get_u8(buf, index);
200
201 (void) fputc(' ', stdout);
202 (void) fputs(ascii[v & 0x7f], stdout);
203 }
204
205 static output_t output_ascii = {
206 1, do_ascii,
207 };
208
209 static void
210 do_char(buffer_t *buf, int index)
211 {
212 static int nresid = 0;
213 static int printable = 0;
214 int cnt;
215 int avail;
216 int nb;
217 char scratch[10];
218 wchar_t wc;
219 int which;
220
221 uint8_t v = get_u8(buf, index);
222
223 /*
224 * If there were residual bytes from an earlier
225 * character, then just display the ** continuation
226 * indication.
227 */
228 if (nresid) {
229 if (printable) {
230 (void) fputs(" **", stdout);
231 } else {
232 (void) printf(" %03o", v);
233 }
234 nresid--;
235 return;
236 }
237
238 /*
239 * Peek ahead up to MB_CUR_MAX characters. This has to be
240 * done carefully because we might need to look into the next
241 * block to really know for sure.
242 */
243 scratch[0] = v;
244 avail = buf->navail;
245 if (avail > MB_CUR_MAX)
246 avail = MB_CUR_MAX;
247 for (cnt = 1, which = index + 1; cnt < avail; cnt++, which++) {
248 scratch[cnt] = buf->data[which & buf->mask];
249 }
250
251 /* now see if the value is a real character */
252 nresid = 0;
253 wc = 0;
254 nb = mbtowc(&wc, scratch, avail);
255 if (nb < 0) {
256 (void) printf(" %03o", v);
257 return;
258 }
259 if (nb == 0) {
260 (void) fputs(" \\0", stdout);
261 return;
262 }
263 nresid = nb - 1;
264 if (nb && iswprint(wc)) {
265 scratch[nb] = 0;
266 (void) fputs(" ", stdout);
267 (void) fputs(scratch, stdout);
268 printable = 1;
269 return;
270 }
271 printable = 0;
272 if (wc == 0) {
273 (void) fputs(" \\0", stdout);
274 } else if (wc == '\b') {
275 (void) fputs(" \\b", stdout);
276 } else if (wc == '\f') {
277 (void) fputs(" \\f", stdout);
278 } else if (wc == '\n') {
279 (void) fputs(" \\n", stdout);
280 } else if (wc == '\r') {
281 (void) fputs(" \\r", stdout);
282 } else if (wc == '\t') {
283 (void) fputs(" \\t", stdout);
284 } else {
285 (void) printf(" %03o", v);
286 }
287 }
288
289 static output_t output_char = {
290 1, do_char,
291 };
292
293 /*
294 * List of output formatting structures.
295 */
296 static output_t *head = NULL;
297 static output_t **tailp = &head;
298
299 static void
300 add_out(output_t *src)
301 {
302 output_t *out;
303 int m;
304
305 if ((out = calloc(1, sizeof (*src))) == NULL) {
306 err(1, "malloc");
307 }
308
309 m = lcm;
310 while ((m % src->width) != 0) {
311 m += lcm;
312 }
313 lcm = m;
314 blocksize = lcm;
315 while (blocksize < 16)
316 blocksize *= 2;
317
318 (void) memcpy(out, src, sizeof (*src));
319 *tailp = out;
320 tailp = &out->next;
321 }
322
323 static FILE *
324 next_input(void)
325 {
326 for (;;) {
327 if (curfile >= numfiles)
328 return (NULL);
329
330 if (input != NULL) {
331 if ((input = freopen(files[curfile], "r", input)) !=
332 NULL) {
333 curfile++;
334 return (input);
335 }
336 } else {
337 if ((input = fopen(files[curfile], "r")) != NULL) {
338 curfile++;
339 return (input);
340 }
341 }
342 warn("open: %s", files[curfile]);
343 curfile++;
344 }
345 }
346
347 static void
348 refill(buffer_t *b)
349 {
350 int n;
351 int want;
352 int zero;
353
354 /*
355 * If we have 2 blocks of bytes available, we're done. Note
356 * that each iteration usually loads up 16 bytes, unless we
357 * run out of data.
358 */
359 while ((input != NULL) && (b->navail < (2 * blocksize))) {
360
361 /* we preload the next one in advance */
362
363 if (limit == 0) {
364 (void) fclose(input);
365 input = NULL;
366 continue;
367 }
368
369 /* we want to read a whole block if possible */
370 want = blocksize;
371 if ((limit >= 0) && (want > limit)) {
372 want = limit;
373 }
374 zero = blocksize;
375
376 while (want && input) {
377 int c;
378 b->prod &= b->mask;
379 c = (b->prod + want > (b->mask + 1)) ?
380 b->mask - b->prod :
381 want;
382
383 n = fread(b->data + b->prod, 1, c, input);
384 if (n < 0) {
385 warn("read: %s",
386 files ? files[curfile-1] : "stdin");
387 input = next_input();
388 continue;
389 }
390 if (n == 0) {
391 input = next_input();
392 continue;
393 }
394 if (limit >= 0)
395 limit -= n;
396 b->navail += n;
397 b->prod += n;
398 want -= n;
399 zero -= n;
400 }
401
402 while (zero) {
403 b->data[b->prod & b->mask] = 0;
404 b->prod++;
405 b->prod &= b->mask;
406 zero--;
407 }
408 }
409 }
410
411 #define STR1 "C1"
412 #define STR2 "S2"
413 #ifdef _LP64
414 #define STR8 "L8"
415 #define STR4 "I4"
416 #else
417 #define STR8 "8"
418 #define STR4 "IL4"
419 #endif
420
421 static void
422 do_type_string(char *typestr)
423 {
424 if (*typestr == 0) {
425 errx(1, _("missing type string"));
426 }
427 while (*typestr) {
428 switch (*typestr) {
429 case 'a':
430 typestr++;
431 add_out(&output_ascii);
432 break;
433 case 'c':
434 add_out(&output_char);
435 typestr++;
436 break;
437 case 'f':
438 typestr++;
439 switch (*typestr) {
440 case 'F':
441 case '4':
442 add_out(&output_float);
443 typestr++;
444 break;
445 case '8':
446 case 'D':
447 add_out(&output_double);
448 typestr++;
449 break;
450 case 'L':
451 add_out(&output_ldouble);
452 typestr++;
453 break;
454 default:
455 add_out(&output_float);
456 break;
457 }
458 break;
459
460
461 case 'd':
462 typestr++;
463 if (strchr(STR1, *typestr)) {
464 typestr++;
465 add_out(&output_sig_b);
466 } else if (strchr(STR2, *typestr)) {
467 typestr++;
468 add_out(&output_sig_w);
469 } else if (strchr(STR4, *typestr)) {
470 typestr++;
471 add_out(&output_sig_d);
472 } else if (strchr(STR8, *typestr)) {
473 typestr++;
474 add_out(&output_sig_q);
475 } else {
476 add_out(&output_sig_d);
477 }
478 break;
479
480 case 'u':
481 typestr++;
482 if (strchr(STR1, *typestr)) {
483 typestr++;
484 add_out(&output_dec_b);
485 } else if (strchr(STR2, *typestr)) {
486 typestr++;
487 add_out(&output_dec_w);
488 } else if (strchr(STR4, *typestr)) {
489 typestr++;
490 add_out(&output_dec_d);
491 } else if (strchr(STR8, *typestr)) {
492 typestr++;
493 add_out(&output_dec_q);
494 } else {
495 add_out(&output_dec_d);
496 }
497 break;
498
499 case 'o':
500 typestr++;
501 if (strchr(STR1, *typestr)) {
502 typestr++;
503 add_out(&output_oct_b);
504 } else if (strchr(STR2, *typestr)) {
505 typestr++;
506 add_out(&output_oct_w);
507 } else if (strchr(STR4, *typestr)) {
508 typestr++;
509 add_out(&output_oct_d);
510 } else if (strchr(STR8, *typestr)) {
511 typestr++;
512 add_out(&output_oct_q);
513 } else {
514 add_out(&output_oct_d);
515 }
516 break;
517
518 case 'x':
519 typestr++;
520 if (strchr(STR1, *typestr)) {
521 typestr++;
522 add_out(&output_hex_b);
523 } else if (strchr(STR2, *typestr)) {
524 typestr++;
525 add_out(&output_hex_w);
526 } else if (strchr(STR4, *typestr)) {
527 typestr++;
528 add_out(&output_hex_d);
529 } else if (strchr(STR8, *typestr)) {
530 typestr++;
531 add_out(&output_hex_q);
532 } else {
533 add_out(&output_hex_d);
534 }
535 break;
536
537 default:
538 errx(1, _("unrecognized type string character: %c"),
539 *typestr);
540 }
541 }
542 }
543
544 int
545 main(int argc, char **argv)
546 {
547 int c;
548 int i;
549 buffer_t buffer;
550 boolean_t first = B_TRUE;
551 boolean_t doall = B_FALSE;
552 boolean_t same = B_FALSE;
553 boolean_t newarg = B_FALSE;
554 off_t offset = 0;
555 off_t skip = 0;
556 char *eptr;
557 char *offstr = 0;
558
559 input = stdin;
560
561 (void) setlocale(LC_ALL, "");
562 (void) textdomain(TEXT_DOMAIN);
563
564 while ((c = getopt(argc, argv, "A:bCcdDfFj:N:oOsSxXvt:")) != EOF) {
565 switch (c) {
566 case 'A':
567 newarg = B_TRUE;
568 if (strlen(optarg) > 1) {
569 afmt = NULL;
570 }
571 switch (*optarg) {
572 case 'o':
573 afmt = "%07llo";
574 cfmt = " ";
575 break;
576 case 'd':
577 afmt = "%07lld";
578 cfmt = " ";
579 break;
580 case 'x':
581 afmt = "%07llx";
582 cfmt = " ";
583 break;
584 case 'n':
585 /*
586 * You could argue that the code should
587 * use the same 7 spaces. Legacy uses 8
588 * though. Oh well. Better to avoid
589 * gratuitous change.
590 */
591 afmt = " ";
592 cfmt = " ";
593 break;
594 default:
595 afmt = NULL;
596 break;
597 }
598 if (strlen(optarg) != 1) {
599 afmt = NULL;
600 }
601 if (afmt == NULL)
602 warnx(_("invalid address base, "
603 "must be o, d, x, or n"));
604 break;
605
606 case 'b':
607 add_out(&output_oct_b);
608 break;
609
610 case 'c':
611 case 'C':
612 add_out(&output_char);
613 break;
614
615 case 'f':
616 add_out(&output_float);
617 break;
618
619 case 'F':
620 add_out(&output_double);
621 break;
622
623 case 'd':
624 add_out(&output_dec_w);
625 break;
626
627 case 'D':
628 add_out(&output_dec_d);
629 break;
630
631 case 't':
632 newarg = B_TRUE;
633 do_type_string(optarg);
634 break;
635
636 case 'o':
637 add_out(&output_oct_w);
638 break;
639
640 case 'O':
641 add_out(&output_oct_d);
642 break;
643
644 case 's':
645 add_out(&output_sig_w);
646 break;
647
648 case 'S':
649 add_out(&output_sig_d);
650 break;
651
652 case 'x':
653 add_out(&output_hex_w);
654 break;
655
656 case 'X':
657 add_out(&output_hex_d);
658 break;
659
660 case 'v':
661 doall = B_TRUE;
662 break;
663
664 case 'j':
665 newarg = B_TRUE;
666 skip = strtoll(optarg, &eptr, 0);
667 if (*eptr == 'b') {
668 skip <<= 9; /* 512 bytes */
669 eptr++;
670 } else if (*eptr == 'k') {
671 skip <<= 10; /* 1k */
672 eptr++;
673 } else if (*eptr == 'm') {
674 skip <<= 20; /* 1m */
675 eptr++;
676 } else if (*eptr == 'g') {
677 skip <<= 30; /* 1g */
678 eptr++;
679 }
680 if ((skip < 0) || (eptr[0] != 0)) {
681 warnx(_("invalid skip count '%s' specified"),
682 optarg);
683 exit(1);
684 }
685 break;
686
687 case 'N':
688 newarg = B_TRUE;
689 limit = strtoll(optarg, &eptr, 0);
690 /*
691 * POSIX doesn't specify this, but I think these
692 * may be helpful.
693 */
694 if (*eptr == 'b') {
695 limit <<= 9;
696 eptr++;
697 } else if (*eptr == 'k') {
698 limit <<= 10;
699 eptr++;
700 } else if (*eptr == 'm') {
701 limit <<= 20;
702 eptr++;
703 } else if (*eptr == 'g') {
704 limit <<= 30;
705 eptr++;
706 }
707 if ((limit < 0) || (eptr[0] != 0)) {
708 warnx(_("invalid byte count '%s' specified"),
709 optarg);
710 exit(1);
711 }
712 break;
713
714 default:
715 usage();
716 break;
717 }
718 }
719
720 /* this finds the smallest power of two size we can use */
721 buffer.mask = (1 << (ffs(blocksize * 3) + 1)) - 1;
722 buffer.data = memalign(16, buffer.mask + 1);
723 if (buffer.data == NULL) {
724 err(1, "memalign");
725 }
726
727
728 /*
729 * Wow. This option parsing is hideous.
730 *
731 * If the we've not seen a new option, and there is just one
732 * operand, if it starts with a "+", then treat it as an
733 * offset. Otherwise if two operands, and the second operand
734 * starts with + or a digit, then it is an offset.
735 */
736 if (!newarg) {
737 if (((argc - optind) == 1) && (argv[optind][0] == '+')) {
738 offstr = argv[optind];
739 argc--;
740 } else if (((argc - optind) == 2) &&
741 (strchr("+0123456789", (argv[optind + 1][0])) != NULL)) {
742 offstr = argv[optind + 1];
743 argc--;
744 }
745 }
746 if (offstr) {
747 int base = 0;
748 int mult = 1;
749 int l;
750 if (*offstr == '+') {
751 offstr++;
752 }
753 l = strlen(offstr);
754 if ((strncmp(offstr, "0x", 2) == 0)) {
755 afmt = "%07llx";
756 base = 16;
757 offstr += 2;
758 if (offstr[l - 1] == 'B') {
759 offstr[l - 1] = 0;
760 l--;
761 mult = 512;
762 }
763 } else {
764 base = 8;
765 afmt = "%07llo";
766 if ((offstr[l - 1] == 'B') || (offstr[l - 1] == 'b')) {
767 offstr[l - 1] = 0;
768 l--;
769 mult = 512;
770 }
771 if (offstr[l - 1] == '.') {
772 offstr[l - 1] = 0;
773 base = 10;
774 afmt = "%07lld";
775 }
776 }
777 skip = strtoll(offstr, &eptr, base);
778 if (*eptr != '\0') {
779 errx(1, _("invalid offset string specified"));
780 }
781 skip *= mult;
782 offset += skip;
783 }
784
785 /*
786 * Allocate an array for all the input files.
787 */
788 if (argc > optind) {
789 files = calloc(sizeof (char *), argc - optind);
790 for (i = 0; i < argc - optind; i++) {
791 files[i] = argv[optind + i];
792 numfiles++;
793 }
794 input = next_input();
795 } else {
796 input = stdin;
797 }
798
799 /*
800 * We need to seek ahead. fseek would be faster.
801 */
802 while (skip && (input != NULL)) {
803 struct stat sbuf;
804
805 /*
806 * Only fseek() on regular files. (Others
807 * we have to read().
808 */
809 if (fstat(fileno(input), &sbuf) < 0) {
810 warn("fstat: %s", files[curfile-1]);
811 input = next_input();
812 continue;
813 }
814 if (S_ISREG(sbuf.st_mode)) {
815 /*
816 * No point in seeking a file that is too
817 * short to begin with.
818 */
819 if (sbuf.st_size < skip) {
820 skip -= sbuf.st_size;
821 input = next_input();
822 continue;
823 }
824 if (fseeko(input, skip, SEEK_SET) < 0) {
825 err(1, "fseek:%s", files[curfile-1]);
826 }
827 /* Done seeking. */
828 skip = 0;
829 break;
830 }
831
832 /*
833 * fgetc seems like it would be slow, but it uses
834 * buffered I/O, so it should be fast enough.
835 */
836 flockfile(input);
837 while (skip) {
838 if (getc_unlocked(input) == EOF) {
839 funlockfile(input);
840 if (ferror(input)) {
841 warn("read: %s", files[curfile-1]);
842 }
843 input = next_input();
844 if (input != NULL) {
845 flockfile(input);
846 }
847 break;
848 }
849 skip--;
850 }
851 if (input != NULL)
852 funlockfile(input);
853 }
854
855 if (head == NULL) {
856 add_out(&output_oct_w);
857 }
858
859 buffer.navail = 0;
860 buffer.prod = 0;
861 buffer.cons = 0;
862
863 for (refill(&buffer); buffer.navail > 0; refill(&buffer)) {
864 output_t *out;
865 int mx;
866 int j, k;
867
868 /*
869 * If this buffer was the same as last, then just
870 * dump an asterisk.
871 */
872 if ((!first) && (buffer.navail >= blocksize) && (!doall)) {
873 j = buffer.cons;
874 k = j - blocksize;
875 for (i = 0; i < blocksize; i++) {
876 if (buffer.data[j & buffer.mask] !=
877 buffer.data[k & buffer.mask]) {
878 break;
879 }
880 j++;
881 k++;
882 }
883 if (i == blocksize) {
884 if (!same) {
885 (void) fputs("*\n", stdout);
886 same = B_TRUE;
887 }
888 buffer.navail -= blocksize;
889 offset += blocksize;
890 buffer.cons += blocksize;
891 buffer.cons &= buffer.mask;
892 continue;
893 }
894 }
895
896 first = B_FALSE;
897 same = B_FALSE;
898 mx = (buffer.navail > blocksize) ? blocksize : buffer.navail;
899
900 for (out = head; out != NULL; out = out->next) {
901
902 if (out == head) {
903 /*LINTED E_SEC_PRINTF_VAR_FMT*/
904 (void) printf(afmt, offset);
905 } else {
906 (void) fputs(cfmt, stdout);
907 }
908 for (i = 0, j = buffer.cons; i < mx; i += out->width) {
909 out->func(&buffer, j);
910 j += out->width;
911 j &= buffer.mask;
912 }
913 (void) fputs("\n", stdout);
914 }
915 buffer.cons += mx;
916 buffer.cons &= buffer.mask;
917 offset += mx;
918 buffer.navail -= mx;
919 }
920 /*LINTED E_SEC_PRINTF_VAR_FMT*/
921 (void) printf(afmt, offset);
922 (void) fputs("\n", stdout);
923 return (0);
924 }