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 } 925