Subversion Repositories forwardcom

/***************************  print_integer_light.as **************************
* Author:        Agner Fog
* date created:  2021-05-16
* Last modified: 2021-05-16
* Version:       1.11
* Project:       ForwardCom library libc_light.li
* Description:   puts: print a string to stdout. Does not append linefeed
* This version is for CPUs with limited capabilities
* C declaration: void print_integer(int32_t i);
* C declaration: void print_unsigned(uint32_t i);
*
* Copyright 2021 GNU General Public License http://www.gnu.org/licenses
******************************************************************************/

code section execute align = 4                   // code section

// Print a 32-bit signed integer as decimal number to stdout
_print_integer function public reguse=3,0

if (int32 r0 < 0) {
    int32 r0 = -r0
    int8+ r1 = '-'
    int8 output(r1, r1, 10)  // print '-'
}
// continue in _print_unsigned

// Print a 32-bit unsigned integer as decimal number to stdout
_print_unsigned function public reguse=3,0

// This function is using the double dabble algorithm for binary to BCD conversion.
// This method is slow, but it is used here because it does not require division
// or multiplication. This makes sure it will work on small cores without mul and div instructions.

// save r2-r5
int64 sp -= 4*8
int64 [sp]      = r2
int64 [sp+8]    = r3
int64 [sp+0x10] = r4
int64 [sp+0x18] = r5

// First two BCD digits are made with simple subtraction to avoid the need for a larger bit field
int r5 = 0
while (uint32 r0 >= 1000000000) {
    uint32 r0 -= 1000000000
    uint32 r5 += 0x10
}
while (uint32 r0 >= 100000000) {
    uint32 r0 -= 100000000
    uint32 r5 += 0x01
}
uint32 r5 <<= 24

// Generate 8 BCD digits using double dabble algorithm
int32 r1 = 0
for (int r2 = 0; r2 < 32; r2++) {           // loop for 32 bits
    int32 r3 = r1 + 0x33333333              // digit values 5-9 will set bit 3 in each 4-bit nibble
    int32 r3 &= 0x88888888                  // isolate bit 3 in each nibble
    int32 r4 = r3 >> 3                      // generate value 3 in nibbles with value 5-9
    int32 r3 >>= 2
    int32 r3 |= r4                          // this will have 3 for each nibble with a value 5-9
    int32 r1 += r3                          // add 3 to nibble values 5-9 to generate 8-12
    int32 r1 = funnel_shift(r0, r1, 31)     // shift most significant bit of r0 into r1
    int32 r0 <<= 1
}

// r5:r1 = BCD value

int r4 = 0                                  // remember if first digit has been printed

for (int r2 = 2; r2 > 0; r2--) {
    int32 r5 = rotate(r5, 4)                // get most significant digit first
    int8 r3 = r5 & 0x0F
    int r4 = (r3 != 0) || r4                // digit has been printed
    int8 r3 += '0'
    if (int r4 != 0) {
        int8 output(r3, r3, 10)             // print character to stdout
    }
}

// print 8 decimal digits
for (int r2 = 8; r2 > 0; r2--) {
    int32 r1 = rotate(r1, 4)                // get most significant digit first
    int8 r3 = r1 & 0x0F
    int r4 = (r3 != 0) || r4                // digit has been printed
    int r4 = (r2 == 1) || r4                // last digit must be printed
    int8 r3 += '0'
    if (int r4 != 0) {
        int8 output(r3, r3, 10)             // print character to stdout
    }
}

// restore r2-r5
int64 r2 = [sp]
int64 r3 = [sp+8]
int64 r4 = [sp+0x10]
int64 r5 = [sp+0x18]
int64 sp += 4*8
return
_print_integer end

code end