git.gag.com Git - fw/sdcc/blob - device/lib/printf_fast.c

   1 /* Fast printf routine for use with sdcc/mcs51
   2  * Copyright (c) 2001, Paul Stoffregen, paul@pjrc.com
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19
  20 // include support for 32 bit base 10 integers (%ld and %lu)
  21 #define LONG_INT
  22
  23 // include support for minimum field widths (%8d, %20s)
  24 #define FIELD_WIDTH
  25
  26
  27 /* extern void putchar(char ); */
  28
  29
  30 static bit long_flag, short_flag, print_zero_flag, negative_flag;
  31
  32 #ifdef FIELD_WIDTH
  33 static bit field_width_flag;
  34 static data unsigned char field_width;
  35 #endif
  36
  37
  38 void printf_fast(code char *fmt, ...) reentrant
  39 {
  40         fmt;    /* supress unreferenced variable warning */
  41
  42         _asm
  43
  44 printf_begin:
  45         mov     a, _bp          // r0 will point to va_args (stack)
  46         add     a, #253
  47         mov     r0, a           // r0 points to MSB of fmt
  48         mov     dph, @r0
  49         dec     r0
  50         mov     dpl, @r0        // dptr has address of fmt
  51         dec     r0
  52
  53 printf_main_loop:
  54         clr     a
  55         movc    a, @a+dptr      // get next byte of fmt string
  56         inc     dptr
  57         //cjne  a, #'%', printf_normal
  58         cjne    a, #37, printf_normal
  59
  60 printf_format:
  61         clr     _long_flag
  62         clr     _short_flag
  63         clr     _print_zero_flag
  64         clr     _negative_flag
  65 #ifdef FIELD_WIDTH
  66         clr     _field_width_flag
  67         mov     _field_width, #0
  68 #endif
  69
  70 printf_format_loop:
  71         clr     a
  72         movc    a, @a+dptr      // get next byte of data format
  73         inc     dptr
  74
  75         /* parse and consume the field width digits, even if */
  76         /* we don't build the code to make use of them */
  77         add     a, #198
  78         jc      printf_nondigit1
  79         add     a, #10
  80         jnc     printf_nondigit2
  81 #ifdef FIELD_WIDTH
  82 printf_digit:
  83         setb    _field_width_flag
  84         mov     r1, a
  85         mov     a, _field_width
  86         mov     b, #10
  87         mul     ab
  88         add     a, r1
  89         mov     _field_width, a
  90 #endif
  91         sjmp    printf_format_loop
  92 printf_nondigit1:
  93         add     a, #10
  94 printf_nondigit2:
  95         add     a, #48
  96
  97
  98 printf_format_l:
  99         //cjne  a, #'l', printf_format_h
 100         cjne    a, #108, printf_format_h
 101         setb    _long_flag
 102         sjmp    printf_format_loop
 103
 104 printf_format_h:
 105         //cjne  a, #'h', printf_format_s
 106         cjne    a, #104, printf_format_s
 107         setb    _short_flag
 108         sjmp    printf_format_loop
 109
 110 printf_format_s:
 111         //cjne  a, #'s', printf_format_d
 112         cjne    a, #115, printf_format_d
 113         ljmp    printf_string
 114
 115 printf_format_d:
 116         //cjne  a, #'d', printf_format_u
 117         cjne    a, #100, printf_format_u
 118         lcall   printf_get_int
 119         ljmp    printf_int
 120
 121 printf_format_u:
 122         //cjne  a, #'u', printf_format_c
 123         cjne    a, #117, printf_format_c
 124         lcall   printf_get_int
 125         ljmp    printf_uint
 126
 127 printf_format_c:
 128         //cjne  a, #'c', printf_format_x
 129         cjne    a, #99, printf_format_x
 130         mov     a, @r0          // Acc has the character to print
 131         dec     r0
 132         sjmp    printf_char
 133
 134 printf_format_x:
 135         //cjne  a, #'x', printf_normal
 136         cjne    a, #120, printf_normal
 137         ljmp    printf_hex
 138
 139 printf_normal:
 140         jz      printf_eot
 141 printf_char:
 142         lcall   printf_putchar
 143         sjmp    printf_main_loop
 144
 145 printf_eot:
 146         ljmp    printf_end
 147
 148
 149
 150
 151         /* print a string... just grab each byte with __gptrget */
 152         /* the user much pass a 24 bit generic pointer */
 153
 154 printf_string:
 155         push    dph             // save addr in fmt onto stack
 156         push    dpl
 157         mov     b, @r0          // b has type of address (generic *)
 158         dec     r0
 159         mov     dph, @r0
 160         dec     r0
 161         mov     dpl, @r0        // dptr has address of user's string
 162         dec     r0
 163
 164 #ifdef FIELD_WIDTH
 165         jnb     _field_width_flag, printf_str_loop
 166         push    dpl
 167         push    dph
 168 printf_str_fw_loop:
 169         lcall   __gptrget
 170         jz      printf_str_space
 171         inc     dptr
 172         dec     _field_width
 173         mov     a, _field_width
 174         jnz     printf_str_fw_loop
 175 printf_str_space:
 176         lcall   printf_space
 177         pop     dph
 178         pop     dpl
 179 #endif // FIELD_WIDTH
 180
 181 printf_str_loop:
 182         lcall   __gptrget
 183         jz      printf_str_done
 184         inc     dptr
 185         lcall   printf_putchar
 186         sjmp    printf_str_loop
 187 printf_str_done:
 188         pop     dpl             // restore addr withing fmt
 189         pop     dph
 190         ljmp    printf_main_loop
 191
 192
 193
 194
 195
 196
 197
 198
 199         /* printing in hex is easy because sdcc pushes the LSB first */
 200
 201 printf_hex:
 202         lcall   printf_hex8
 203         jb      _short_flag, printf_hex_end
 204         lcall   printf_hex8
 205         jnb     _long_flag, printf_hex_end
 206         lcall   printf_hex8
 207         lcall   printf_hex8
 208 printf_hex_end:
 209         lcall   printf_zero
 210         ljmp    printf_main_loop
 211 printf_hex8:
 212         mov     a, @r0
 213         lcall   printf_phex_msn
 214         mov     a, @r0
 215         dec     r0
 216         ljmp    printf_phex_lsn
 217
 218
 219 #ifndef LONG_INT
 220 printf_ld_in_hex:
 221         //mov   a, #'0'
 222         mov     a, #48
 223         lcall   printf_putchar
 224         //mov   a, #'x'
 225         mov     a, #120
 226         lcall   printf_putchar
 227         mov     a, r0
 228         add     a, #4
 229         mov     r0, a
 230         sjmp    printf_hex
 231 #endif
 232
 233
 234         /* printing an integer is not so easy.  For a signed int */
 235         /* check if it is negative and print the minus sign and */
 236         /* invert it to a positive integer */
 237
 238 printf_int:
 239         mov     a, r5
 240         jnb     acc.7, printf_uint      /* check if negative */
 241         setb    _negative_flag
 242         mov     a, r1                   /* invert integer */
 243         cpl     a
 244         addc    a, #1
 245         mov     r1, a
 246         jb      _short_flag, printf_uint
 247         mov     a, r2
 248         cpl     a
 249         addc    a, #0
 250         mov     r2, a
 251         jnb     _long_flag, printf_uint
 252         mov     a, r3
 253         cpl     a
 254         addc    a, #0
 255         mov     r3, a
 256         mov     a, r4
 257         cpl     a
 258         addc    a, #0
 259         mov     r4, a
 260
 261
 262         /* printing integers is a lot of work... because it takes so */
 263         /* long, the first thing to do is make sure we're doing as */
 264         /* little work as possible, then convert the binary int to */
 265         /* packed BCD, and finally print each digit of the BCD number */
 266
 267 printf_uint:
 268
 269         jb      _short_flag, printf_uint_ck8
 270         jnb     _long_flag, printf_uint_ck16
 271 printf_uint_ck32:
 272         /* it's a 32 bit int... but if the upper 16 bits are zero */
 273         /* we can treat it like a 16 bit integer and convert much faster */
 274 #ifdef LONG_INT
 275         mov     a, r3
 276         jnz     printf_uint_begin
 277         mov     a, r4
 278         jnz     printf_uint_begin
 279 #else
 280         mov     a, r3
 281         jnz     printf_ld_in_hex        ;print long integer as hex
 282         mov     a, r4                   ;rather than just the low 16 bits
 283         jnz     printf_ld_in_hex
 284 #endif
 285         clr     _long_flag
 286 printf_uint_ck16:
 287         /* it's a 16 bit int... but if the upper 8 bits are zero */
 288         /* we can treat it like a 8 bit integer and convert much faster */
 289         mov     a, r2
 290         jnz     printf_uint_begin
 291         setb    _short_flag
 292 printf_uint_ck8:
 293         /* it's an 8 bit int... if it's zero, it's a lot faster to just */
 294         /* print the digit zero and skip all the hard work! */
 295         mov     a, r1
 296         jnz     printf_uint_begin
 297 #ifdef FIELD_WIDTH
 298         jnb     _field_width_flag, printf_uint_zero
 299         dec     _field_width
 300         lcall   printf_space
 301 #endif
 302 printf_uint_zero:
 303         //mov   a, #'0'
 304         mov     a, #48
 305         lcall   printf_putchar
 306         ljmp    printf_main_loop
 307
 308
 309 printf_uint_begin:
 310         push    dpl
 311         push    dph
 312         lcall   printf_int2bcd          // bcd number in r3/r2/r7/r6/r5
 313
 314 #ifdef FIELD_WIDTH
 315         jnb     _field_width_flag, printf_uifw_end
 316 #ifdef LONG_INT
 317 printf_uifw_32:
 318         mov     r1, #10
 319         jnb     _long_flag, printf_uifw_16
 320         mov     a, r3
 321         anl     a, #0xF0
 322         jnz     printf_uifw_sub
 323         dec     r1
 324         mov     a, r3
 325         anl     a, #0x0F
 326         jnz     printf_uifw_sub
 327         dec     r1
 328         mov     a, r2
 329         anl     a, #0xF0
 330         jnz     printf_uifw_sub
 331         dec     r1
 332         mov     a, r2
 333         anl     a, #0x0F
 334         jnz     printf_uifw_sub
 335         dec     r1
 336         mov     a, r7
 337         anl     a, #0xF0
 338         jnz     printf_uifw_sub
 339 #endif
 340 printf_uifw_16:
 341         mov     r1, #5
 342         jb      _short_flag, printf_uifw_8
 343         mov     a, r7
 344         anl     a, #0x0F
 345         jnz     printf_uifw_sub
 346         dec     r1
 347         mov     a, r6
 348         anl     a, #0xF0
 349         jnz     printf_uifw_sub
 350 printf_uifw_8:
 351         mov     r1, #3
 352         mov     a, r6
 353         anl     a, #0x0F
 354         jnz     printf_uifw_sub
 355         dec     r1
 356         mov     a, r5
 357         anl     a, #0xF0
 358         jnz     printf_uifw_sub
 359         dec     r1
 360 printf_uifw_sub:
 361         ;r1 has the number of digits for the number
 362         mov     a, _field_width
 363         mov     c, _negative_flag
 364         subb    a, r1
 365         jc      printf_uifw_end
 366         mov     _field_width, a
 367
 368 #ifdef LONG_INT
 369         push    ar3
 370         push    ar2
 371 #endif
 372         push    ar7
 373         push    ar6
 374         push    ar5
 375         lcall   printf_space
 376         pop     ar5
 377         pop     ar6
 378         pop     ar7
 379 #ifdef LONG_INT
 380         pop     ar2
 381         pop     ar3
 382 #endif
 383 printf_uifw_end:
 384 #endif
 385
 386
 387 printf_uint_doit:
 388         jnb     _negative_flag, printf_uint_pos
 389         //mov   a, #"-"
 390         mov     a, #45
 391         lcall   printf_putchar
 392 printf_uint_pos:
 393         jb      _short_flag, printf_uint8
 394 #ifdef LONG_INT
 395         jnb     _long_flag, printf_uint16
 396 printf_uint32:
 397         push    ar5
 398         push    ar6
 399         push    ar7
 400         mov     dpl, r2
 401         mov     a, r3
 402         mov     dph, a
 403         lcall   printf_phex_msn
 404         mov     a, dph
 405         lcall   printf_phex_lsn
 406         mov     a, dpl
 407         lcall   printf_phex_msn
 408         mov     a, dpl
 409         lcall   printf_phex_lsn
 410         pop     acc
 411         mov     dpl, a
 412         lcall   printf_phex_msn
 413         mov     a, dpl
 414         pop     dph
 415         pop     dpl
 416         sjmp    printf_uint16a
 417 #endif
 418
 419 printf_uint16:
 420         mov     dpl, r5
 421         mov     dph, r6
 422         mov     a, r7
 423 printf_uint16a:
 424         lcall   printf_phex_lsn
 425         mov     a, dph
 426         lcall   printf_phex_msn
 427         mov     a, dph
 428         sjmp    printf_uint8a
 429
 430 printf_uint8:
 431         mov     dpl, r5
 432         mov     a, r6
 433 printf_uint8a:
 434         lcall   printf_phex_lsn
 435         mov     a, dpl
 436         lcall   printf_phex_msn
 437         mov     a, dpl
 438         lcall   printf_phex_lsn
 439         lcall   printf_zero
 440         pop     dph
 441         pop     dpl
 442         ljmp    printf_main_loop
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454         /* read an integer into r1/r2/r3/r4, and msb into r5 */
 455 printf_get_int:
 456         mov     a, @r0
 457         mov     r1, a
 458         mov     r5, a
 459         dec     r0
 460         jb      _short_flag, printf_get_done
 461         mov     r2, ar1
 462         mov     a, @r0
 463         mov     r1, a
 464         dec     r0
 465         jnb     _long_flag, printf_get_done
 466         mov     r4, ar2
 467         mov     r3, ar1
 468         mov     a, @r0
 469         mov     r2, a
 470         dec     r0
 471         mov     a, @r0
 472         mov     r1, a
 473         dec     r0
 474 printf_get_done:
 475         ret
 476
 477
 478
 479
 480
 481
 482
 483         /* convert binary number in r4/r3/r2/r1 into bcd packed number
 484          * in r3/r2/r7/r6/r5.  The input number is destroyed in the
 485          * process, to avoid needing extra memory for the result (and
 486          * r1 gets used for temporary storage).  dptr is overwritten,
 487          * but r0 is not changed.
 488          */
 489
 490 printf_int2bcd:
 491         mov     a, r1
 492         anl     a, #0x0F
 493         mov     dptr, #_int2bcd_0
 494         movc    a, @a+dptr
 495         mov     r5, a
 496
 497         mov     a, r1
 498         swap    a
 499         anl     a, #0x0F
 500         mov     r1, a                   // recycle r1 for holding nibble
 501         mov     dptr, #_int2bcd_1
 502         movc    a, @a+dptr
 503         add     a, r5
 504         da      a
 505         mov     r5, a
 506         mov     a, r1
 507         orl     a, #16
 508         movc    a, @a+dptr
 509         addc    a, #0
 510         da      a
 511         mov     r6, a
 512
 513         jnb     _short_flag, printf_i2bcd_16    // if 8 bit int, we're done
 514         ret
 515
 516 printf_i2bcd_16:
 517         mov     a, r2
 518         anl     a, #0x0F
 519         mov     r1, a
 520         mov     dptr, #_int2bcd_2
 521         movc    a, @a+dptr
 522         add     a, r5
 523         da      a
 524         mov     r5, a
 525         mov     a, r1
 526         orl     a, #16
 527         movc    a, @a+dptr
 528         addc    a, r6
 529         da      a
 530         mov     r6, a
 531
 532         mov     a, r2
 533         swap    a
 534         anl     a, #0x0F
 535         mov     r1, a
 536         mov     dptr, #_int2bcd_3
 537         movc    a, @a+dptr
 538         add     a, r5
 539         da      a
 540         mov     r5, a
 541         mov     a, r1
 542         orl     a, #16
 543         movc    a, @a+dptr
 544         addc    a, r6
 545         da      a
 546         mov     r6, a
 547         mov     a, r1
 548         orl     a, #32
 549         movc    a, @a+dptr
 550         addc    a, #0
 551         da      a
 552         mov     r7, a
 553
 554         jb      _long_flag, printf_i2bcd_32     // if 16 bit int, we're done
 555         ret
 556
 557 printf_i2bcd_32:
 558
 559 #ifdef LONG_INT
 560         mov     a, r3
 561         anl     a, #0x0F
 562         mov     r1, a
 563         mov     dptr, #_int2bcd_4
 564         movc    a, @a+dptr
 565         add     a, r5
 566         da      a
 567         mov     r5, a
 568         mov     a, r1
 569         orl     a, #16
 570         movc    a, @a+dptr
 571         addc    a, r6
 572         da      a
 573         mov     r6, a
 574         mov     a, r1
 575         orl     a, #32
 576         movc    a, @a+dptr
 577         addc    a, r7
 578         da      a
 579         mov     r7, a
 580         clr     a
 581         addc    a, #0
 582         mov     r2, a
 583
 584         mov     a, r3
 585         swap    a
 586         anl     a, #0x0F
 587         mov     r1, a
 588         mov     dptr, #_int2bcd_5
 589         movc    a, @a+dptr
 590         add     a, r5
 591         da      a
 592         mov     r5, a
 593         mov     a, r1
 594         orl     a, #16
 595         movc    a, @a+dptr
 596         addc    a, r6
 597         da      a
 598         mov     r6, a
 599         mov     a, r1
 600         orl     a, #32
 601         movc    a, @a+dptr
 602         addc    a, r7
 603         da      a
 604         mov     r7, a
 605         mov     a, r1
 606         orl     a, #48
 607         movc    a, @a+dptr
 608         addc    a, r2
 609         da      a
 610         mov     r2, a
 611
 612         mov     a, r4
 613         anl     a, #0x0F
 614         mov     r1, a
 615         mov     dptr, #_int2bcd_6
 616         mov     r3, #0
 617         lcall   printf_bcd_add10        // saves 27 bytes, costs 5 cycles
 618
 619         mov     a, r4
 620         swap    a
 621         anl     a, #0x0F
 622         mov     r1, a
 623         mov     dptr, #_int2bcd_7
 624 printf_bcd_add10:
 625         movc    a, @a+dptr
 626         add     a, r5
 627         da      a
 628         mov     r5, a
 629         mov     a, r1
 630         orl     a, #16
 631         movc    a, @a+dptr
 632         addc    a, r6
 633         da      a
 634         mov     r6, a
 635         mov     a, r1
 636         orl     a, #32
 637         movc    a, @a+dptr
 638         addc    a, r7
 639         da      a
 640         mov     r7, a
 641         mov     a, r1
 642         orl     a, #48
 643         movc    a, @a+dptr
 644         addc    a, r2
 645         da      a
 646         mov     r2, a
 647         mov     a, r1
 648         orl     a, #64
 649         movc    a, @a+dptr
 650         addc    a, r3
 651         da      a
 652         mov     r3, a
 653 #endif
 654         ret
 655
 656
 657
 658
 659 #ifdef FIELD_WIDTH
 660 printf_space_loop:
 661         //mov   a, #' '
 662         mov     a, #32
 663         lcall   printf_putchar
 664         dec     _field_width
 665 printf_space:
 666         mov     a, _field_width
 667         jnz     printf_space_loop
 668         ret
 669 #endif
 670
 671
 672
 673
 674
 675         /* print a hex digit, either upper 4 bit (msn) or lower 4 bits (lsn) */
 676
 677 printf_phex_msn:
 678         swap    a
 679 printf_phex_lsn:
 680         anl     a, #15
 681         jnz     printf_phex_ok
 682         jnb     _print_zero_flag, printf_ret
 683 printf_phex_ok:
 684         setb    _print_zero_flag
 685         add     a, #0x90
 686         da      a
 687         addc    a, #0x40
 688         da      a
 689 printf_putchar:
 690         push    dph
 691         push    dpl
 692         push    ar0
 693         mov     dpl, a
 694         lcall   _putchar
 695         pop     ar0
 696         pop     dpl
 697         pop     dph
 698 printf_ret:
 699         ret
 700
 701         /* print a zero if all the calls to print the digits ended up */
 702         /* being leading zeros */
 703
 704 printf_zero:
 705         jb      _print_zero_flag, printf_ret
 706         //mov   a, #'0'
 707         mov     a, #48
 708         ljmp    printf_putchar
 709
 710 printf_end:
 711         _endasm;
 712 }
 713
 714
 715 /*
 716  * #! /usr/bin/perl
 717  * for ($d=0; $d < 8; $d++) {
 718  *      $n = 16 ** $d;
 719  *      for ($p=0; $p < 5; $p++) {
 720  *              last unless (((16 ** $d) * 15) / (10 ** ($p * 2))) % 100;
 721  *              printf "code unsigned char int2bcd_%d_%d[15] = {", $d, $p;
 722  *              for ($i=0; $i < 16; $i++) {
 723  *                      printf "0x%02d",
 724  *                         (((16 ** $d) * $i) / (10 ** ($p * 2))) % 100;
 725  *                      print ", " if $i < 15;
 726  *              }
 727  *              print "};\n";
 728  *      }
 729  * }
 730  */
 731
 732
 733 code unsigned char int2bcd_0[] = {
 734 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 735 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15};
 736
 737 code unsigned char int2bcd_1[] = {
 738 0x00, 0x16, 0x32, 0x48, 0x64, 0x80, 0x96, 0x12,
 739 0x28, 0x44, 0x60, 0x76, 0x92, 0x08, 0x24, 0x40,
 740 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 741 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02};
 742
 743 code unsigned char int2bcd_2[] = {
 744 0x00, 0x56, 0x12, 0x68, 0x24, 0x80, 0x36, 0x92,
 745 0x48, 0x04, 0x60, 0x16, 0x72, 0x28, 0x84, 0x40,
 746 0x00, 0x02, 0x05, 0x07, 0x10, 0x12, 0x15, 0x17,
 747 0x20, 0x23, 0x25, 0x28, 0x30, 0x33, 0x35, 0x38};
 748
 749 code unsigned char int2bcd_3[] = {
 750 0x00, 0x96, 0x92, 0x88, 0x84, 0x80, 0x76, 0x72,
 751 0x68, 0x64, 0x60, 0x56, 0x52, 0x48, 0x44, 0x40,
 752 0x00, 0x40, 0x81, 0x22, 0x63, 0x04, 0x45, 0x86,
 753 0x27, 0x68, 0x09, 0x50, 0x91, 0x32, 0x73, 0x14,
 754 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02,
 755 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x06};
 756
 757 #ifdef LONG_INT
 758 code unsigned char int2bcd_4[] = {
 759 0x00, 0x36, 0x72, 0x08, 0x44, 0x80, 0x16, 0x52,
 760 0x88, 0x24, 0x60, 0x96, 0x32, 0x68, 0x04, 0x40,
 761 0x00, 0x55, 0x10, 0x66, 0x21, 0x76, 0x32, 0x87,
 762 0x42, 0x98, 0x53, 0x08, 0x64, 0x19, 0x75, 0x30,
 763 0x00, 0x06, 0x13, 0x19, 0x26, 0x32, 0x39, 0x45,
 764 0x52, 0x58, 0x65, 0x72, 0x78, 0x85, 0x91, 0x98};
 765
 766 code unsigned char int2bcd_5[] = {
 767 0x00, 0x76, 0x52, 0x28, 0x04, 0x80, 0x56, 0x32,
 768 0x08, 0x84, 0x60, 0x36, 0x12, 0x88, 0x64, 0x40,
 769 0x00, 0x85, 0x71, 0x57, 0x43, 0x28, 0x14, 0x00,
 770 0x86, 0x71, 0x57, 0x43, 0x29, 0x14, 0x00, 0x86,
 771 0x00, 0x04, 0x09, 0x14, 0x19, 0x24, 0x29, 0x34,
 772 0x38, 0x43, 0x48, 0x53, 0x58, 0x63, 0x68, 0x72,
 773 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 774 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15};
 775
 776 code unsigned char int2bcd_6[] = {
 777 0x00, 0x16, 0x32, 0x48, 0x64, 0x80, 0x96, 0x12,
 778 0x28, 0x44, 0x60, 0x76, 0x92, 0x08, 0x24, 0x40,
 779 0x00, 0x72, 0x44, 0x16, 0x88, 0x60, 0x32, 0x05,
 780 0x77, 0x49, 0x21, 0x93, 0x65, 0x38, 0x10, 0x82,
 781 0x00, 0x77, 0x55, 0x33, 0x10, 0x88, 0x66, 0x44,
 782 0x21, 0x99, 0x77, 0x54, 0x32, 0x10, 0x88, 0x65,
 783 0x00, 0x16, 0x33, 0x50, 0x67, 0x83, 0x00, 0x17,
 784 0x34, 0x50, 0x67, 0x84, 0x01, 0x18, 0x34, 0x51,
 785 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
 786 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02};
 787
 788 code unsigned char int2bcd_7[] = {
 789 0x00, 0x56, 0x12, 0x68, 0x24, 0x80, 0x36, 0x92,
 790 0x48, 0x04, 0x60, 0x16, 0x72, 0x28, 0x84, 0x40,
 791 0x00, 0x54, 0x09, 0x63, 0x18, 0x72, 0x27, 0x81,
 792 0x36, 0x91, 0x45, 0x00, 0x54, 0x09, 0x63, 0x18,
 793 0x00, 0x43, 0x87, 0x30, 0x74, 0x17, 0x61, 0x04,
 794 0x48, 0x91, 0x35, 0x79, 0x22, 0x66, 0x09, 0x53,
 795 0x00, 0x68, 0x36, 0x05, 0x73, 0x42, 0x10, 0x79,
 796 0x47, 0x15, 0x84, 0x52, 0x21, 0x89, 0x58, 0x26,
 797 0x00, 0x02, 0x05, 0x08, 0x10, 0x13, 0x16, 0x18,
 798 0x21, 0x24, 0x26, 0x29, 0x32, 0x34, 0x37, 0x40};
 799 #endif
 800
 801