/*-------------------------------------------------------------------------
printf_fast.c - Fast printf routine for use with sdcc/mcs51
Copyright (C) 2004, Paul Stoffregen, paul@pjrc.com
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the
Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA.
As a special exception, if you link this library with other files,
some of which are compiled with SDCC, to produce an executable,
this library does not by itself cause the resulting executable to
be covered by the GNU General Public License. This exception does
not however invalidate any other reasons why the executable file
might be covered by the GNU General Public License.
-------------------------------------------------------------------------*/
/******************************************************************/
/** **/
/** Major features. These determine what capabilities your **/
/** compiled printf_fast will have. **/
/** **/
/******************************************************************/
// Include support for 32 bit base 10 integers (%ld and %lu). Without
// this, you won't be able to print 32 bit integers as base 10. They
// will appear in hexadecimal.
#define LONG
// Include support for floating point numbers (%f). Don't forget to
// enable LONG above, if you want to print floats greater than
// 65535.997. You can have 6 good digits after the decimal point,
// or an 8th if a small error is ok. +/- 2^32 to 1/10^8 isn't the
// full dynamic range of 32 bit floats, but it covers the most
// commonly used range. Adds about 500-600 bytes of code.
//#define FLOAT
// Include support for minimum field widths (%8d, %20s, %12.5f)
#define FIELD_WIDTH
// Include fast integer conversion. Without this, a compact but slower
// algorithm is used to convert integers (%d, %u, int part of %f).
// Even the slow algorithm is much faster than a typical C implementation
// based on repetitive division by 10. If you enable this, you get an
// extremely fast version (only 8 table lookups and 8 adds to convert a
// 32 bit integer), but it costs extra code space for larger lookup
// tables and optimized non-looping code.
#define FAST_INTEGER
/******************************************************************/
/** **/
/** Minor tweaks. These provide small code savings, with **/
/** a partial loss of functionality. **/
/** **/
/******************************************************************/
// If you enabled FLOAT, enabling this replaces the normal %f float
// output with a very compact version that always prints 4 fractional
// digits and does not have round off. Zero will print as "0.0000",
// and 1.999997 will print as "1.9999" (not rounded up to 2). The
// 4th digit is not accurate (+/- 2). This simpler version also
// avoids using 5 bytes of internal data memory. Code size is about
// 240 bytes less.
//#define FLOAT_FIXED4
// If you used FLOAT (not FLOAT_FIXED4), this will remove the smart
// default number of digits code. When you use "%f" without a field
// width, normally the smart default width code chooses a good number
// of digits based on size of the number. If you enabled FIELD_WIDTH
// and use a number, like "%.5f", this smart default code is never
// used anyway. Saves about 40 bytes of code.
//#define FLOAT_DEFAULT_FRAC_DIGITS 6
// If you used FLOAT (not FLOAT_FIXED4) and you do not specify a
// field width, normally trailing zeros are trimmed. Using this
// removes that feature (saves only a few bytes).
//#define DO_NOT_TRIM_TRAILING_ZEROS
// Omit saving and restoring registers when calling putchar(). If you
// are desparate for a little more code space, this will give you a
// small savings. You MUST define putchar() with #pragma callee_saves,
// or implement it in assembly and avoid changing the registers.
//#define PUTCHAR_CALLEE_SAVES
/* extern void putchar(char ); */
// Warning: using static/global variables makes these functions NON-reentrant!
// reentrant keyword is only used for parameter passing method
static __bit long_flag
, short_flag
, print_zero_flag
, negative_flag
;
#ifdef FIELD_WIDTH
static __bit field_width_flag
;
static __bit leading_zero_flag
;
static __data
unsigned char field_width
;
#endif
#ifdef FLOAT
#define __SDCC_FLOAT_LIB
#include <float.h>
static __bit continue_float
;
#ifndef FLOAT_FIXED4
static __data
unsigned char frac_field_width
;
static __data
unsigned char float_frac_bcd
[4];
// TODO: can float_frac_bcd be overlaid with temps used by trig functions
#endif
#endif
#ifndef FAST_INTEGER
#ifdef LONG
static __data
unsigned int i2bcd_tmp
; // slow 32 int conversion needs temp space
#endif
#endif
#ifndef PRINTF_FAST
#define PRINTF_FAST printf_fast
#endif
#if !defined(__SDCC_mcs51) || defined(__SDCC_USE_XSTACK) || defined(_SDCC_NO_ASM_LIB_FUNCS)
// Does printf_fast really work on ds390 and ds400?
// If it does, enable them in the line above
#if defined(__SDCC_USE_XSTACK)
#warning "printf_fast not built, does not support --xstack"
#elif defined(_SDCC_NO_ASM_LIB_FUNCS)
#warning "printf_fast not built, _SDCC_NO_ASM_LIB_FUNCS defined"
#endif
#else // defines are compatible with printf_fast
void PRINTF_FAST
(__code
const char *fmt
, ...
) __reentrant
{
fmt
; /* suppress unreferenced variable warning */
__asm
printf_begin
:
mov a
, _bp
// r0 will point to va_args (stack)
add a
, #253
mov r0
, a
// r0 points to MSB of fmt
mov dph
, @r0
dec r0
mov dpl
, @r0
// dptr has address of fmt
dec r0
printf_main_loop
:
clr a
movc a
, @a
+dptr
// get next byte of fmt string
inc dptr
//cjne a, #'%', printf_normal
cjne a
, #37, printf_normal
printf_format
:
clr _long_flag
clr _short_flag
clr _print_zero_flag
clr _negative_flag
#ifdef FIELD_WIDTH
clr _field_width_flag
clr _leading_zero_flag
mov r1
, #_field_width
mov @r1
, #0
#endif
#ifdef FLOAT
clr _continue_float
#endif
printf_format_loop
:
clr a
movc a
, @a
+dptr
// get next byte of data format
inc dptr
/* parse and consume the field width digits, even if */
/* we don't build the code to make use of them */
add a
, #198
jc printf_nondigit1
add a
, #10
jnc printf_nondigit2
#ifdef FIELD_WIDTH
printf_digit
:
jnz printf_digit_2
cjne a
, _field_width
, printf_digit_2
setb _leading_zero_flag
printf_digit_2
:
setb _field_width_flag
mov r2
, a
mov a
, @r1
mov b
, #10
mul ab
add a
, r2
mov @r1
, a
#endif
sjmp printf_format_loop
printf_nondigit1
:
add a
, #10
printf_nondigit2
:
add a
, #48
printf_format_l
:
//cjne a, #'l', printf_format_h
cjne a
, #108, printf_format_h
setb _long_flag
sjmp printf_format_loop
printf_format_h
:
//cjne a, #'h', printf_format_s
cjne a
, #104, printf_format_s
setb _short_flag
sjmp printf_format_loop
printf_format_s
:
//cjne a, #'s', printf_format_d
cjne a
, #115, printf_format_d
ljmp printf_string
printf_format_d
:
//cjne a, #'d', printf_format_u
cjne a
, #100, printf_format_u
lcall printf_get_int
ljmp printf_int
printf_format_u
:
//cjne a, #'u', printf_format_c
cjne a
, #117, printf_format_c
lcall printf_get_int
ljmp printf_uint
printf_format_c
:
//cjne a, #'c', printf_format_x
cjne a
, #99, printf_format_x
dec r0
mov a
, @r0
// Acc has the character to print
dec r0
sjmp printf_char
printf_format_x
:
//cjne a, #'x', printf_format_f
cjne a
, #120, printf_format_f
ljmp printf_hex
printf_format_f
:
#ifdef FLOAT
//cjne a, #'f', printf_format_dot
cjne a
, #102, printf_format_dot
ljmp print_float
#endif
printf_format_dot
:
//cjne a, #'.', printf_normal
cjne a
, #46, printf_normal
#ifdef FLOAT
#ifdef FLOAT_FIXED4
mov r1
, #ar3 // parse frac field, but discard if FIXED4
#else
mov r1
, #_frac_field_width
mov @r1
, #0
#endif
#endif
sjmp printf_format_loop
printf_normal
:
jz printf_eot
printf_char
:
lcall printf_putchar
ljmp printf_main_loop
printf_eot
:
ljmp printf_end
/* print a string... just grab each byte with __gptrget */
/* the user much pass a 24 bit generic pointer */
printf_string
:
push dph
// save addr in fmt onto stack
push dpl
mov b
, @r0
// b has type of address (generic *)
dec r0
mov dph
, @r0
dec r0
mov dpl
, @r0
// dptr has address of user's string
dec r0
#ifdef FIELD_WIDTH
jnb _field_width_flag
, printf_str_loop
clr _leading_zero_flag
// never leading zeros for strings
push dpl
push dph
printf_str_fw_loop
:
lcall __gptrget
jz printf_str_space
inc dptr
dec _field_width
mov a
, _field_width
jnz printf_str_fw_loop
printf_str_space
:
lcall printf_space
pop dph
pop dpl
#endif // FIELD_WIDTH
printf_str_loop
:
lcall __gptrget
jz printf_str_done
inc dptr
lcall printf_putchar
sjmp printf_str_loop
printf_str_done
:
pop dpl
// restore addr withing fmt
pop dph
ljmp printf_main_loop
/* printing in hex is easy because sdcc pushes the LSB first */
printf_hex
:
lcall printf_hex8
jb _short_flag
, printf_hex_end
lcall printf_hex8
jnb _long_flag
, printf_hex_end
lcall printf_hex8
lcall printf_hex8
printf_hex_end
:
lcall printf_zero
ljmp printf_main_loop
printf_hex8
:
mov a
, @r0
lcall printf_phex_msn
mov a
, @r0
dec r0
ljmp printf_phex_lsn
#ifndef LONG
printf_ld_in_hex
:
//mov a, #'0'
mov a
, #48
lcall printf_putchar
//mov a, #'x'
mov a
, #120
lcall printf_putchar
mov a
, r0
add a
, #4
mov r0
, a
sjmp printf_hex
#endif
/* printing an integer is not so easy. For a signed int */
/* check if it is negative and print the minus sign and */
/* invert it to a positive integer */
printf_int
:
mov a
, r5
jnb acc.7
, printf_uint
/* check if negative */
setb _negative_flag
mov a
, r1
/* invert integer */
cpl a
add a
, #1
mov r1
, a
jb _short_flag
, printf_uint
mov a
, r2
cpl a
addc a
, #0
mov r2
, a
jnb _long_flag
, printf_uint
mov a
, r3
cpl a
addc a
, #0
mov r3
, a
mov a
, r4
cpl a
addc a
, #0
mov r4
, a
/* printing integers is a lot of work... because it takes so */
/* long, the first thing to do is make sure we're doing as */
/* little work as possible, then convert the binary int to */
/* packed BCD, and finally print each digit of the BCD number */
printf_uint
:
jb _short_flag
, printf_uint_ck8
jnb _long_flag
, printf_uint_ck16
printf_uint_ck32
:
/* it's a 32 bit int... but if the upper 16 bits are zero */
/* we can treat it like a 16 bit integer and convert much faster */
#ifdef LONG
mov a
, r3
jnz printf_uint_begin
mov a
, r4
jnz printf_uint_begin
#else
mov a
, r3
jnz printf_ld_in_hex
// print long integer as hex
mov a
, r4
// rather than just the low 16 bits
jnz printf_ld_in_hex
#endif
clr _long_flag
printf_uint_ck16
:
/* it's a 16 bit int... but if the upper 8 bits are zero */
/* we can treat it like a 8 bit integer and convert much faster */
mov a
, r2
jnz printf_uint_begin
setb _short_flag
printf_uint_ck8
:
/* it's an 8 bit int... if it's zero, it's a lot faster to just */
/* print the digit zero and skip all the hard work! */
mov a
, r1
jnz printf_uint_begin
#ifdef FLOAT
/* never use the "just print zero" shortcut if we're printing */
/* the integer part of a float (fixes bug 1255403) */
jb _continue_float
, printf_uint_begin
#endif
#ifdef FIELD_WIDTH
jnb _field_width_flag
, printf_uint_zero
mov a
, _field_width
jz printf_uint_zero
dec _field_width
lcall printf_space
#endif
printf_uint_zero
:
//mov a, #'0'
mov a
, #48
lcall printf_putchar
ljmp printf_main_loop
printf_uint_begin
:
push dpl
push dph
lcall printf_int2bcd
// bcd number in r3/r2/r7/r6/r5
printf_uint_2
:
#ifdef FIELD_WIDTH
jnb _field_width_flag
, printf_uifw_end
#ifdef LONG
printf_uifw_32
:
mov r1
, #10
jnb _long_flag
, printf_uifw_16
mov a
, r3
anl a
, #0xF0
jnz printf_uifw_sub
dec r1
mov a
, r3
anl a
, #0x0F
jnz printf_uifw_sub
dec r1
mov a
, r2
anl a
, #0xF0
jnz printf_uifw_sub
dec r1
mov a
, r2
anl a
, #0x0F
jnz printf_uifw_sub
dec r1
mov a
, r7
anl a
, #0xF0
jnz printf_uifw_sub
#endif // LONG
printf_uifw_16
:
mov r1
, #5
jb _short_flag
, printf_uifw_8
mov a
, r7
anl a
, #0x0F
jnz printf_uifw_sub
dec r1
mov a
, r6
anl a
, #0xF0
jnz printf_uifw_sub
printf_uifw_8
:
mov r1
, #3
mov a
, r6
anl a
, #0x0F
jnz printf_uifw_sub
dec r1
mov a
, r5
anl a
, #0xF0
jnz printf_uifw_sub
dec r1
printf_uifw_sub
:
//r1 has the number of digits for the number
mov a
, _field_width
mov c
, _negative_flag
subb a
, r1
jc printf_uifw_end
mov _field_width
, a
#ifndef PUTCHAR_CALLEE_SAVES
#ifdef LONG
push ar3
push ar2
#endif
push ar7
push ar6
push ar5
#endif
lcall printf_space
#ifndef PUTCHAR_CALLEE_SAVES
pop ar5
pop ar6
pop ar7
#ifdef LONG
pop ar2
pop ar3
#endif
#endif
printf_uifw_end
:
#endif // FIELD_WIDTH
printf_uint_doit
:
jnb _negative_flag
, printf_uint_pos
#ifdef PUTCHAR_CALLEE_SAVES
//mov a, #'-'
mov a
, #45
lcall printf_putchar
#else
#ifdef LONG
push ar3
push ar2
#endif
push ar7
push ar6
push ar5
//mov a, #'-'
mov a
, #45
lcall printf_putchar
pop ar5
pop ar6
pop ar7
#ifdef LONG
pop ar2
pop ar3
#endif
#endif // PUTCHAR_CALLEE_SAVES
printf_uint_pos
:
jb _short_flag
, printf_uint8
#ifdef LONG
jnb _long_flag
, printf_uint16
printf_uint32
:
push ar5
push ar6
push ar7
mov dpl
, r2
mov a
, r3
mov dph
, a
lcall printf_phex_msn
mov a
, dph
lcall printf_phex_lsn
mov a
, dpl
lcall printf_phex_msn
mov a
, dpl
lcall printf_phex_lsn
pop acc
mov dpl
, a
lcall printf_phex_msn
mov a
, dpl
pop dph
pop dpl
sjmp printf_uint16a
#endif // LONG
printf_uint16
:
mov dpl
, r5
mov dph
, r6
mov a
, r7
printf_uint16a
:
lcall printf_phex_lsn
mov a
, dph
lcall printf_phex_msn
mov a
, dph
sjmp printf_uint8a
printf_uint8
:
mov dpl
, r5
mov a
, r6
printf_uint8a
:
lcall printf_phex_lsn
mov a
, dpl
lcall printf_phex_msn
mov a
, dpl
lcall printf_phex_lsn
lcall printf_zero
pop dph
pop dpl
#ifdef FLOAT
jnb _continue_float
, 0002$
ret
0002$
:
#endif
ljmp printf_main_loop
#ifdef FLOAT
#ifdef FLOAT_FIXED4
// Print a float the easy way. First, extract the integer part and
// use the integer printing code. Then extract the fractional part,
// convert each bit to 4 digit BCD, and print the BCD sum. Absolutely
// no field width control, always 4 digits printed past the decimal
// point. No round off. 1.9999987 prints as 1.9999, not 2.0000.
print_float
:
#ifdef FIELD_WIDTH
jnb _field_width_flag
, print_float_begin
mov a
, _field_width
add a
, #251
mov _field_width
, a
jc print_float_begin
mov _field_width
, #0
#endif
print_float_begin
:
push ar0
// keep r0 safe, will need it again
lcall printf_get_float
clr c
mov a
, #158 // check for large float we can't print
subb a
, r7
jnc print_float_size_ok
printf_float_too_big
:
// TODO: should print some sort of overflow error??
pop ar0
ljmp printf_format_loop
print_float_size_ok
:
push dpl
lcall fs_rshift_a
pop dpl
setb _continue_float
#ifndef LONG
mov a
, r3
orl a
, r4
jnz printf_float_too_big
#endif
lcall printf_uint
// print the integer portion
//mov a, #'.'
mov a
, #0x2E
lcall printf_putchar
// now that the integer part is printed, we need to refetch the
// float from the va_args and extract the fractional part
pop ar0
lcall printf_get_float
push ar0
push dpl
push dph
mov a
, r7
cjne a
, #126, print_float_frac_lshift
sjmp print_float_frac
// input between 0.5 to 0.9999
print_float_frac_lshift
:
jc print_float_frac_rshift
//Acc (exponent) is greater than 126 (input >= 1.0)
add a
, #130
mov r5
, a
print_float_lshift_loop
:
clr c
mov a
, r2
rlc a
mov r2
, a
mov a
, r3
rlc a
mov r3
, a
mov a
, r4
rlc a
mov r4
, a
djnz r5
, print_float_lshift_loop
sjmp print_float_frac
print_float_frac_rshift
:
//Acc (exponent) is less than 126 (input < 0.5)
cpl a
add a
, #127
lcall fs_rshift_a
print_float_frac
:
// now we've got the fractional part, so now is the time to
// convert to BCD... just convert each bit to BCD using a
// lookup table and BCD sum them together
mov r7
, #14
clr a
mov r6
, a
mov r5
, a
mov dptr
, #_frac2bcd // FLOAT_FIXED4 version (14 entries)
print_float_frac_loop
:
mov a
, r3
rlc a
mov r3
, a
mov a
, r4
rlc a
mov r4
, a
jnc print_float_frac_skip
clr a
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, #1
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
print_float_frac_skip
:
inc dptr
inc dptr
djnz r7
, print_float_frac_loop
// the BCD sum is in dptr, so all we've got to do is output
// all 4 digits. No trailing zero suppression, no nice round
// off (impossible to change the integer part since we already
// printed it).
mov dph
, r6
mov dpl
, r5
setb _print_zero_flag
mov a
, dph
lcall printf_phex_msn
mov a
, dph
lcall printf_phex_lsn
mov a
, dpl
lcall printf_phex_msn
mov a
, dpl
lcall printf_phex_lsn
pop dph
pop dpl
pop ar0
ljmp printf_main_loop
#else // not FLOAT_FIXED4
print_float
:
// Print a float the not-as-easy way, with a configurable number of
// fractional digits (up to 8) and proper round-off (up to 7 digits).
// First, extract the fractional part, convert to BCD, and then add
// the scaled round-off. Store the rounded fractional digits and
// their carry. Then extract the integer portion, increment it if
// the rounding caused a carry. Use the integer printing to output
// the integer, and then output the stored fractional digits. This
// approach requires 5 bytes of internal RAM to store the 8 fractional
// digits and the number of them we'll actually print. This code is
// a couple hundred bytes larger and a bit slower than the FIXED4
// version, but it gives very nice results.
print_float_1
:
#ifdef FIELD_WIDTH
jnb _field_width_flag
, print_float_default_width
// The caller specified exact field width, so use it. Need to
// convert the whole float digits into the integer portion only.
mov a
, _field_width
setb c
subb a
, _frac_field_width
mov _field_width
, a
jnc print_float_begin
mov _field_width
, #0
sjmp print_float_begin
#endif
print_float_default_width
:
// The caller didn't specify field width (or FIELD_WIDTH is
// not defined so it's ignored). We've still got to know
// how many fractional digits are going to print, so we can
// round off properly.
#ifdef FLOAT_DEFAULT_FRAC_DIGITS
mov _frac_field_width
, #FLOAT_DEFAULT_FRAC_DIGITS
#else
// default fractional field width (between 0 to 7)
// attempt to scale the default number of fractional digits
// based on the magnitude of the float
mov a
, @r0
anl a
, #0x7F // ignore sign bit
mov r2
, a
// r2 is first byte of float
dec r0
mov ar3
, @r0
// r3 is second byte of float
inc r0
mov r6
, dpl
mov r7
, dph
mov dptr
, #_float_range_table
mov r5
, #7
print_float_default_loop
:
clr a
movc a
, @a
+dptr
add a
, r3
inc dptr
clr a
movc a
, @a
+dptr
addc a
, r2
jnc print_float_default_done
inc dptr
djnz r5
, print_float_default_loop
print_float_default_done
:
mov _frac_field_width
, r5
mov dpl
, r6
mov dph
, r7
#endif // not FLOAT_DEFAULT_FRAC_DIGITS
print_float_begin
:
push ar0
// keep r0 safe, will need it again
lcall printf_get_float
push dpl
push dph
mov a
, r7
cjne a
, #126, print_float_frac_lshift
sjmp print_float_frac
// input between 0.5 to 0.9999
print_float_frac_lshift
:
jc print_float_frac_rshift
//Acc (exponent) is greater than 126 (input >= 1.0)
add a
, #130
mov r5
, a
print_float_lshift_loop
:
clr c
mov a
, r2
rlc a
mov r2
, a
mov a
, r3
rlc a
mov r3
, a
mov a
, r4
rlc a
mov r4
, a
djnz r5
, print_float_lshift_loop
sjmp print_float_frac
print_float_frac_rshift
:
//Acc (exponent) is less than 126 (input < 0.5)
cpl a
add a
, #127
lcall fs_rshift_a
print_float_frac
:
// Convert the fraction in r4/r3/r2/r1 into 8 BCD digits in r0/r7/r6/r5
mov b
, #27
clr a
mov r0
, a
mov r7
, a
mov r6
, a
mov r5
, a
mov dptr
, #_frac2bcd // FLOAT version (27 entries)
print_float_frac_loop
:
mov a
, r1
rlc a
mov r1
, a
mov a
, r2
rlc a
mov r2
, a
mov a
, r3
rlc a
mov r3
, a
mov a
, r4
rlc a
mov r4
, a
jnc print_float_frac_skip
clr a
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, #1
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, #2
movc a
, @a
+dptr
addc a
, r7
da a
mov r7
, a
mov a
, #3
movc a
, @a
+dptr
addc a
, r0
da a
mov r0
, a
print_float_frac_skip
:
inc dptr
inc dptr
inc dptr
inc dptr
djnz b
, print_float_frac_loop
print_float_frac_roundoff
:
// Now it's time to round-off the BCD digits to the desired precision.
clr a
mov r4
, #0x50 // r4/r3/r2/r1 = 0.5 (bcd rounding)
mov r3
, a
mov r2
, a
mov r1
, a
mov a
, _frac_field_width
rl a
rl a
anl a
, #0xFC
mov dph
, r0
// fs_rshift_a will overwrite r0 & dpl
lcall fs_rshift_a
// divide r4/r3/r2/r1 by 10^frac_field_width
mov a
, r5
add a
, r1
// add rounding to fractional part
da a
mov _float_frac_bcd
+3, a
// and store it for later use
mov a
, r6
addc a
, r2
da a
mov _float_frac_bcd
+2, a
mov a
, r7
addc a
, r3
da a
mov _float_frac_bcd
+1, a
mov a
, dph
addc a
, r4
da a
mov _float_frac_bcd
+0, a
mov sign_b
, c
// keep fractional carry in sign_b
pop dph
pop dpl
print_float_int
:
// Time to work on the integer portion... fetch the float again, check
// size (exponent), scale to integer, add the fraction's carry, and
// let the integer printing code do all the work.
pop ar0
lcall printf_get_float
push ar0
clr c
mov a
, #158 // check for large float we can't print
subb a
, r7
jnc print_float_size_ok
printf_float_too_big
:
// TODO: should print some sort of overflow error??
pop ar0
ljmp printf_format_loop
print_float_size_ok
:
push dpl
lcall fs_rshift_a
pop dpl
jnb sign_b
, print_float_do_int
// if we get here, the fractional round off caused the
// integer part to increment. Add 1 for a proper result
mov a
, r1
add a
, #1
mov r1
, a
clr a
addc a
, r2
mov r2
, a
#ifdef LONG
clr a
addc a
, r3
mov r3
, a
clr a
addc a
, r4
mov r4
, a
#endif
jc printf_float_too_big
print_float_do_int
:
#ifndef LONG
mov a
, r3
orl a
, r4
jnz printf_float_too_big
#endif
setb _continue_float
lcall printf_uint
// print the integer portion
print_float_frac_width
:
// Now all we have to do is output the fractional digits that
// were previous computed and stored in memory.
#ifdef FIELD_WIDTH
jb _field_width_flag
, print_float_do_frac
#endif
#ifndef DO_NOT_TRIM_TRAILING_ZEROS
// if the user did not explicitly set a
// field width, trim off trailing zeros
print_float_frac_trim
:
mov a
, _frac_field_width
jz print_float_do_frac
lcall get_float_frac_digit
jnz print_float_do_frac
djnz _frac_field_width
, print_float_frac_trim
#endif
print_float_do_frac
:
mov a
, _frac_field_width
jz print_float_done
//mov a, #'.'
mov a
, #0x2E
lcall printf_putchar
mov r0
, #0
setb _print_zero_flag
print_float_do_frac_loop
:
inc r0
mov a
, r0
lcall get_float_frac_digit
lcall printf_phex_lsn
mov a
, r0
cjne a
, _frac_field_width
, print_float_do_frac_loop
print_float_done
:
pop ar0
ljmp printf_main_loop
// acc=1 for tenths, acc=2 for hundredths, etc
get_float_frac_digit
:
dec a
clr c
rrc a
mov psw.5
, c
add a
, #_float_frac_bcd
mov r1
, a
mov a
, @r1
jb psw.5
, get_float_frac_digit_done
swap a
get_float_frac_digit_done
:
anl a
, #15
ret
#endif // end of normal FLOAT code (not FLOAT_FIXED4)
// These helper functions are used, regardless of which type of
// FLOAT code is used.
#if 0
pm2_print_float
:
mov a
, r7
lcall pm2_entry_phex
mov a
, #0x20
lcall pm2_entry_cout
lcall _print_r4321
mov a
, #0x20
lcall pm2_entry_cout
ret
#endif
// Fetch a float from the va_args and put it into
// r7(exp) r4/r3/r2(mant) and also clear r1 and preset
// the flags
printf_get_float
:
mov a
, @r0
dec r0
mov r1
, a
mov a
, @r0
dec r0
mov r4
, a
rlc a
mov a
, r1
rlc a
mov _negative_flag
, c
mov r7
, a
jz printf_get_float_2
orl ar4
, #0x80
printf_get_float_2
:
mov a
, @r0
dec r0
mov r3
, a
mov a
, @r0
dec r0
mov r2
, a
mov r1
, #0
clr _short_flag
setb _long_flag
ret
#endif // FLOAT
/* read an integer into r1/r2/r3/r4, and msb into r5 */
printf_get_int
:
mov a
, @r0
mov r1
, a
mov r5
, a
dec r0
jb _short_flag
, printf_get_done
mov r2
, ar1
mov a
, @r0
mov r1
, a
dec r0
jnb _long_flag
, printf_get_done
mov r4
, ar2
mov r3
, ar1
mov a
, @r0
mov r2
, a
dec r0
mov a
, @r0
mov r1
, a
dec r0
printf_get_done
:
ret
#ifdef FAST_INTEGER
/* convert binary number in r4/r3/r2/r1 into bcd packed number
* in r3/r2/r7/r6/r5. The input number is destroyed in the
* process, to avoid needing extra memory for the result (and
* r1 gets used for temporary storage). dptr is overwritten,
* but r0 is not changed.
*/
printf_int2bcd
:
mov a
, r1
mov b
, #100
div ab
mov r6
, a
mov a
, #10
xch a
, b
div ab
swap a
orl a
, b
mov r5
, a
jnb _short_flag
, printf_i2bcd_16
// if 8 bit int, we're done
ret
printf_i2bcd_16
:
mov a
, r2
anl a
, #0x0F
mov r1
, a
mov dptr
, #_int2bcd_2
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, r1
orl a
, #16
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, r2
swap a
anl a
, #0x0F
mov r1
, a
mov dptr
, #_int2bcd_3
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, r1
orl a
, #16
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, r1
orl a
, #32
movc a
, @a
+dptr
addc a
, #0
da a
mov r7
, a
jb _long_flag
, printf_i2bcd_32
// if 16 bit int, we're done
ret
printf_i2bcd_32
:
#ifdef LONG
mov a
, r3
anl a
, #0x0F
mov r1
, a
mov dptr
, #_int2bcd_4
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, r1
orl a
, #16
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, r1
orl a
, #32
movc a
, @a
+dptr
addc a
, r7
da a
mov r7
, a
clr a
addc a
, #0
mov r2
, a
mov a
, r3
swap a
anl a
, #0x0F
mov r1
, a
mov dptr
, #_int2bcd_5
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, r1
orl a
, #16
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, r1
orl a
, #32
movc a
, @a
+dptr
addc a
, r7
da a
mov r7
, a
mov a
, r1
orl a
, #48
movc a
, @a
+dptr
addc a
, r2
da a
mov r2
, a
mov a
, r4
anl a
, #0x0F
mov r1
, a
mov dptr
, #_int2bcd_6
mov r3
, #0
lcall printf_bcd_add10
// saves 27 bytes, costs 5 cycles
mov a
, r4
swap a
anl a
, #0x0F
mov r1
, a
mov dptr
, #_int2bcd_7
printf_bcd_add10
:
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, r1
orl a
, #16
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, r1
orl a
, #32
movc a
, @a
+dptr
addc a
, r7
da a
mov r7
, a
mov a
, r1
orl a
, #48
movc a
, @a
+dptr
addc a
, r2
da a
mov r2
, a
mov a
, r1
orl a
, #64
movc a
, @a
+dptr
addc a
, r3
da a
mov r3
, a
#endif // LONG
ret
#else // not FAST_INTEGER
/* convert binary number in r4/r3/r2/r1 into bcd packed number
* in r3/r2/r7/r6/r5. The input number is destroyed in the
* process, to avoid needing extra memory for the result (and
* r1 gets used for temporary storage). dptr is overwritten,
* but r0 is not changed.
*/
#ifdef LONG
printf_int2bcd
:
mov a
, #8
jb _short_flag
, printf_int2bcd_begin
mov a
, #16
jnb _long_flag
, printf_int2bcd_begin
mov a
, #32
printf_int2bcd_begin
:
mov b
, a
clr a
mov r5
, a
mov r6
, a
mov r7
, a
mov
(_i2bcd_tmp
+ 0), a
mov
(_i2bcd_tmp
+ 1), a
mov dptr
, #_int2bcd
printf_i2bcd_loop
:
mov a
, r4
rrc a
mov r4
, a
mov a
, r3
rrc a
mov r3
, a
mov a
, r2
rrc a
mov r2
, a
mov a
, r1
rrc a
mov r1
, a
jnc print_i2bcd_skip
clr a
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, #1
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, #2
movc a
, @a
+dptr
addc a
, r7
da a
mov r7
, a
mov a
, #3
movc a
, @a
+dptr
addc a
, (_i2bcd_tmp
+ 0)
da a
mov
(_i2bcd_tmp
+ 0), a
mov a
, #4
movc a
, @a
+dptr
addc a
, (_i2bcd_tmp
+ 1)
da a
mov
(_i2bcd_tmp
+ 1), a
print_i2bcd_skip
:
inc dptr
inc dptr
inc dptr
inc dptr
inc dptr
djnz b
, printf_i2bcd_loop
mov r2
, (_i2bcd_tmp
+ 0)
mov r3
, (_i2bcd_tmp
+ 1)
ret
#else // not LONG
printf_int2bcd
:
mov a
, #8
jb _short_flag
, printf_int2bcd_begin
mov a
, #16
printf_int2bcd_begin
:
mov b
, a
clr a
mov r5
, a
mov r6
, a
mov r7
, a
mov dptr
, #_int2bcd
printf_i2bcd_loop
:
mov a
, r2
rrc a
mov r2
, a
mov a
, r1
rrc a
mov r1
, a
jnc printf_i2bcd_add_skip
clr a
movc a
, @a
+dptr
add a
, r5
da a
mov r5
, a
mov a
, #1
movc a
, @a
+dptr
addc a
, r6
da a
mov r6
, a
mov a
, #2
movc a
, @a
+dptr
addc a
, r7
da a
mov r7
, a
printf_i2bcd_add_skip
:
inc dptr
inc dptr
inc dptr
djnz b
, printf_i2bcd_loop
ret
#endif // not LONG
#endif // not FAST_INTEGER
#ifdef FIELD_WIDTH
printf_space_loop
:
//mov a, #' '
mov a
, #32
jnb _leading_zero_flag
, printf_space_output
//mov a, #'0'
mov a
, #48
printf_space_output
:
lcall printf_putchar
dec _field_width
printf_space
:
mov a
, _field_width
jnz printf_space_loop
ret
#endif
/* print a hex digit, either upper 4 bit (msn) or lower 4 bits (lsn) */
printf_phex_msn
:
swap a
printf_phex_lsn
:
anl a
, #15
jnz printf_phex_ok
jnb _print_zero_flag
, printf_ret
printf_phex_ok
:
setb _print_zero_flag
add a
, #0x90
da a
addc a
, #0x40
da a
printf_putchar
:
#ifdef PUTCHAR_CALLEE_SAVES
push dph
push dpl
mov dpl
, a
lcall _putchar
pop dpl
pop dph
#else
push dph
push dpl
push ar0
mov dpl
, a
lcall _putchar
pop ar0
pop dpl
pop dph
#endif
printf_ret
:
ret
/* print a zero if all the calls to print the digits ended up */
/* being leading zeros */
printf_zero
:
jb _print_zero_flag
, printf_ret
//mov a, #'0'
mov a
, #48
ljmp printf_putchar
printf_end
:
__endasm
;
}
#ifdef FAST_INTEGER
/*
* #! /usr/bin/perl
* for ($d=0; $d < 8; $d++) {
* $n = 16 ** $d;
* for ($p=0; $p < 5; $p++) {
* last unless (((16 ** $d) * 15) / (10 ** ($p * 2))) % 100;
* printf "code unsigned char int2bcd_%d_%d[15] = {", $d, $p;
* for ($i=0; $i < 16; $i++) {
* printf "0x%02d",
* (((16 ** $d) * $i) / (10 ** ($p * 2))) % 100;
* print ", " if $i < 15;
* }
* print "};\n";
* }
* }
*/
#if 0
static __code
unsigned char int2bcd_0
[] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15};
static __code
unsigned char int2bcd_1
[] = {
0x00, 0x16, 0x32, 0x48, 0x64, 0x80, 0x96, 0x12,
0x28, 0x44, 0x60, 0x76, 0x92, 0x08, 0x24, 0x40,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02};
#endif
static __code
unsigned char int2bcd_2
[] = {
0x00, 0x56, 0x12, 0x68, 0x24, 0x80, 0x36, 0x92,
0x48, 0x04, 0x60, 0x16, 0x72, 0x28, 0x84, 0x40,
0x00, 0x02, 0x05, 0x07, 0x10, 0x12, 0x15, 0x17,
0x20, 0x23, 0x25, 0x28, 0x30, 0x33, 0x35, 0x38};
static __code
unsigned char int2bcd_3
[] = {
0x00, 0x96, 0x92, 0x88, 0x84, 0x80, 0x76, 0x72,
0x68, 0x64, 0x60, 0x56, 0x52, 0x48, 0x44, 0x40,
0x00, 0x40, 0x81, 0x22, 0x63, 0x04, 0x45, 0x86,
0x27, 0x68, 0x09, 0x50, 0x91, 0x32, 0x73, 0x14,
0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02,
0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x06};
#ifdef LONG
static __code
unsigned char int2bcd_4
[] = {
0x00, 0x36, 0x72, 0x08, 0x44, 0x80, 0x16, 0x52,
0x88, 0x24, 0x60, 0x96, 0x32, 0x68, 0x04, 0x40,
0x00, 0x55, 0x10, 0x66, 0x21, 0x76, 0x32, 0x87,
0x42, 0x98, 0x53, 0x08, 0x64, 0x19, 0x75, 0x30,
0x00, 0x06, 0x13, 0x19, 0x26, 0x32, 0x39, 0x45,
0x52, 0x58, 0x65, 0x72, 0x78, 0x85, 0x91, 0x98};
static __code
unsigned char int2bcd_5
[] = {
0x00, 0x76, 0x52, 0x28, 0x04, 0x80, 0x56, 0x32,
0x08, 0x84, 0x60, 0x36, 0x12, 0x88, 0x64, 0x40,
0x00, 0x85, 0x71, 0x57, 0x43, 0x28, 0x14, 0x00,
0x86, 0x71, 0x57, 0x43, 0x29, 0x14, 0x00, 0x86,
0x00, 0x04, 0x09, 0x14, 0x19, 0x24, 0x29, 0x34,
0x38, 0x43, 0x48, 0x53, 0x58, 0x63, 0x68, 0x72,
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15};
static __code
unsigned char int2bcd_6
[] = {
0x00, 0x16, 0x32, 0x48, 0x64, 0x80, 0x96, 0x12,
0x28, 0x44, 0x60, 0x76, 0x92, 0x08, 0x24, 0x40,
0x00, 0x72, 0x44, 0x16, 0x88, 0x60, 0x32, 0x05,
0x77, 0x49, 0x21, 0x93, 0x65, 0x38, 0x10, 0x82,
0x00, 0x77, 0x55, 0x33, 0x10, 0x88, 0x66, 0x44,
0x21, 0x99, 0x77, 0x54, 0x32, 0x10, 0x88, 0x65,
0x00, 0x16, 0x33, 0x50, 0x67, 0x83, 0x00, 0x17,
0x34, 0x50, 0x67, 0x84, 0x01, 0x18, 0x34, 0x51,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02};
static __code
unsigned char int2bcd_7
[] = {
0x00, 0x56, 0x12, 0x68, 0x24, 0x80, 0x36, 0x92,
0x48, 0x04, 0x60, 0x16, 0x72, 0x28, 0x84, 0x40,
0x00, 0x54, 0x09, 0x63, 0x18, 0x72, 0x27, 0x81,
0x36, 0x91, 0x45, 0x00, 0x54, 0x09, 0x63, 0x18,
0x00, 0x43, 0x87, 0x30, 0x74, 0x17, 0x61, 0x04,
0x48, 0x91, 0x35, 0x79, 0x22, 0x66, 0x09, 0x53,
0x00, 0x68, 0x36, 0x05, 0x73, 0x42, 0x10, 0x79,
0x47, 0x15, 0x84, 0x52, 0x21, 0x89, 0x58, 0x26,
0x00, 0x02, 0x05, 0x08, 0x10, 0x13, 0x16, 0x18,
0x21, 0x24, 0x26, 0x29, 0x32, 0x34, 0x37, 0x40};
#endif // LONG
#else // not FAST_INTEGER
/*
* #! /usr/bin/perl
* print "__code unsigned char int2bcd[] = {\n";
* for ($i=0, $n=1; $i<32; $i++, $n*=2) {
* $r = sprintf "%010u", $n;
* $r =~ /([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])/;
* printf "0x%02d, 0x%02d, 0x%02d, 0x%02d, 0x%02d", $5, $4, $3, $2, $1;
* print ',' if $i < 31;
* printf "\t\t// %10u\n", $n;
* }
* print "}\n__code unsigned char int2bcd[] = {\n";
* for ($i=0, $n=1; $i<16; $i++, $n*=2) {
* $r = sprintf "%06u", $n;
* $r =~ /([0-9][0-9])([0-9][0-9])([0-9][0-9])/;
* printf "0x%02d, 0x%02d, 0x%02d", $3, $2, $1;
* print ',' if $i < 15;
* printf "\t\t// %10u\n", $n;
* }
* print "};\n";
*/
#ifdef LONG
static __code
unsigned char int2bcd
[] = {
0x01, 0x00, 0x00, 0x00, 0x00, // 1
0x02, 0x00, 0x00, 0x00, 0x00, // 2
0x04, 0x00, 0x00, 0x00, 0x00, // 4
0x08, 0x00, 0x00, 0x00, 0x00, // 8
0x16, 0x00, 0x00, 0x00, 0x00, // 16
0x32, 0x00, 0x00, 0x00, 0x00, // 32
0x64, 0x00, 0x00, 0x00, 0x00, // 64
0x28, 0x01, 0x00, 0x00, 0x00, // 128
0x56, 0x02, 0x00, 0x00, 0x00, // 256
0x12, 0x05, 0x00, 0x00, 0x00, // 512
0x24, 0x10, 0x00, 0x00, 0x00, // 1024
0x48, 0x20, 0x00, 0x00, 0x00, // 2048
0x96, 0x40, 0x00, 0x00, 0x00, // 4096
0x92, 0x81, 0x00, 0x00, 0x00, // 8192
0x84, 0x63, 0x01, 0x00, 0x00, // 16384
0x68, 0x27, 0x03, 0x00, 0x00, // 32768
0x36, 0x55, 0x06, 0x00, 0x00, // 65536
0x72, 0x10, 0x13, 0x00, 0x00, // 131072
0x44, 0x21, 0x26, 0x00, 0x00, // 262144
0x88, 0x42, 0x52, 0x00, 0x00, // 524288
0x76, 0x85, 0x04, 0x01, 0x00, // 1048576
0x52, 0x71, 0x09, 0x02, 0x00, // 2097152
0x04, 0x43, 0x19, 0x04, 0x00, // 4194304
0x08, 0x86, 0x38, 0x08, 0x00, // 8388608
0x16, 0x72, 0x77, 0x16, 0x00, // 16777216
0x32, 0x44, 0x55, 0x33, 0x00, // 33554432
0x64, 0x88, 0x10, 0x67, 0x00, // 67108864
0x28, 0x77, 0x21, 0x34, 0x01, // 134217728
0x56, 0x54, 0x43, 0x68, 0x02, // 268435456
0x12, 0x09, 0x87, 0x36, 0x05, // 536870912
0x24, 0x18, 0x74, 0x73, 0x10, // 1073741824
0x48, 0x36, 0x48, 0x47, 0x21 // 2147483648
};
#else // not LONG
static __code
unsigned char int2bcd
[] = {
0x01, 0x00, 0x00, // 1
0x02, 0x00, 0x00, // 2
0x04, 0x00, 0x00, // 4
0x08, 0x00, 0x00, // 8
0x16, 0x00, 0x00, // 16
0x32, 0x00, 0x00, // 32
0x64, 0x00, 0x00, // 64
0x28, 0x01, 0x00, // 128
0x56, 0x02, 0x00, // 256
0x12, 0x05, 0x00, // 512
0x24, 0x10, 0x00, // 1024
0x48, 0x20, 0x00, // 2048
0x96, 0x40, 0x00, // 4096
0x92, 0x81, 0x00, // 8192
0x84, 0x63, 0x01, // 16384
0x68, 0x27, 0x03 // 32768
};
#endif // not LONG
#endif // not FAST_INTEGER
#ifdef FLOAT
#ifndef FLOAT_FIXED4
/*
* #! /usr/bin/perl
* for ($i=0, $f=0.5; $i<24; $i++) {
* $r = sprintf "%.8f", $f;
* $r =~ /0\.([0-9][0-9])([0-9][0-9])([0-9][0-9])([0-9][0-9])/;
* printf "0x%02d, 0x%02d, 0x%02d, 0x%02d", $4, $3, $2, $1;
* print ',' if $i < 23;
* $sum += $r;
* printf "\t\t// %.15f %.8f\n", $f, $sum;
* $f /= 2;
* }
*/
static __code
unsigned char frac2bcd
[] = {
0x00, 0x00, 0x00, 0x50, // 0.500000000000000 0.50000000
0x00, 0x00, 0x00, 0x25, // 0.250000000000000 0.75000000
0x00, 0x00, 0x50, 0x12, // 0.125000000000000 0.87500000
0x00, 0x00, 0x25, 0x06, // 0.062500000000000 0.93750000
0x00, 0x50, 0x12, 0x03, // 0.031250000000000 0.96875000
0x00, 0x25, 0x56, 0x01, // 0.015625000000000 0.98437500
0x50, 0x12, 0x78, 0x00, // 0.007812500000000 0.99218750
0x25, 0x06, 0x39, 0x00, // 0.003906250000000 0.99609375
0x12, 0x53, 0x19, 0x00, // 0.001953125000000 0.99804687
0x56, 0x76, 0x09, 0x00, // 0.000976562500000 0.99902343
0x28, 0x88, 0x04, 0x00, // 0.000488281250000 0.99951171
0x14, 0x44, 0x02, 0x00, // 0.000244140625000 0.99975585
0x07, 0x22, 0x01, 0x00, // 0.000122070312500 0.99987792
0x04, 0x61, 0x00, 0x00, // 0.000061035156250 0.99993896
0x52, 0x30, 0x00, 0x00, // 0.000030517578125 0.99996948
0x26, 0x15, 0x00, 0x00, // 0.000015258789062 0.99998474
0x63, 0x07, 0x00, 0x00, // 0.000007629394531 0.99999237
0x81, 0x03, 0x00, 0x00, // 0.000003814697266 0.99999618
0x91, 0x01, 0x00, 0x00, // 0.000001907348633 0.99999809
0x95, 0x00, 0x00, 0x00, // 0.000000953674316 0.99999904
0x48, 0x00, 0x00, 0x00, // 0.000000476837158 0.99999952
0x24, 0x00, 0x00, 0x00, // 0.000000238418579 0.99999976
0x12, 0x00, 0x00, 0x00, // 0.000000119209290 0.99999988
0x06, 0x00, 0x00, 0x00, // 0.000000059604645 0.99999994
0x03, 0x00, 0x00, 0x00, // 0.000000029802322 0.99999997
0x01, 0x00, 0x00, 0x00, // 0.000000014901161 0.99999998
0x01, 0x00, 0x00, 0x00 // 0.000000007450581 0.99999999
};
#ifndef FLOAT_DEFAULT_FRAC_DIGITS
// TODO: Perhaps these should be tweaked a bit to take round up
// effects into account... or maybe give more default digits??
// Range #digits
// 0.0001 - 0.0009999 7
// 0.001 - 0.009999 6 0.001 = 0x3A83126F 3A83
// 0.01 - 0.09999 5 0.01 = 0x3C23D70A 3C23
// 0.1 - 9.9999 4 0.1 = 0x3DCCCCCD, 3DCC
// 10.0 - 99.99 3 10.0 = 0x41200000 4120
// 100.0 - 999.99 2 100.0 = 0x42C80000 42C8
// 1000 - 9999.9 1 1000 = 0x447A0000 447A
// 10000+ 0 10000 = 0x461C4000 461C
static __code
unsigned int float_range_table
[] = {
65536 - 0x3A83,
65536 - 0x3C23,
65536 - 0x3DCC,
65536 - 0x4120,
65536 - 0x42C8,
65536 - 0x447A,
65536 - 0x461C
};
#endif
#else // using FLOAT_FIXED4
/*
* #! /usr/bin/perl
* for ($i=0, $f=0.5; $i<14; $i++) {
* $r = sprintf "%.4f", $f;
* $r =~ /0\.([0-9][0-9])([0-9][0-9])/;
* printf "0x%02d, 0x%02d", $2, $1;
* print ',' if $i < 13;
* $sum += $r;
* printf "\t\t// %.15f %.4f\n", $f, $sum;
* $f /= 2;
* }
*/
static __code
unsigned char frac2bcd
[] = {
0x00, 0x50, // 0.500000000000000 0.5000
0x00, 0x25, // 0.250000000000000 0.7500
0x50, 0x12, // 0.125000000000000 0.8750
0x25, 0x06, // 0.062500000000000 0.9375
0x12, 0x03, // 0.031250000000000 0.9687
0x56, 0x01, // 0.015625000000000 0.9843
0x78, 0x00, // 0.007812500000000 0.9921
0x39, 0x00, // 0.003906250000000 0.9960
0x20, 0x00, // 0.001953125000000 0.9980
0x10, 0x00, // 0.000976562500000 0.9990
0x05, 0x00, // 0.000488281250000 0.9995
0x02, 0x00, // 0.000244140625000 0.9997
0x01, 0x00, // 0.000122070312500 0.9998
0x01, 0x00 // 0.000061035156250 0.9999
};
#endif // FLOAT_FIXED4
#endif // FLOAT
#endif // defines compatible with printf_fast