Subversion Repositories forwardcom

/****************************  printf_light.as ********************************

* Author:        Agner Fog

* date created:  2021-05-24

* Last modified: 2021-05-25

* Version:       1.11

* Project:       ForwardCom library libc_light.li

* Description:   printf, sprintf, snprintf: Print formatted output

* This version is for small CPUs with limited capabilities

* The following instructions are avoided: mul, div, push, pop, sys_call.

* Output to stdout goes directly to output port 10. It does not wait if

* the output buffer is full.

*

* C declarations:

* int printf   (const char * format, ... );

* int sprintf  (char * string, const char * format, ... );

* int snprintf (char * string, size_t max_length, const char * format, ... );

*

* printf:   print to stdout

* sprintf:  print to string

* snprintf: print to string with length limit

* fprintf:  print to file. not implemented yet

*

* These functions are following the definitions in the C standard.

* All standard features are supported, except the following:

* - cannot print floating point numbers

* - cannot print octal

* - cannot print decimal integers with more than 32 bits

*

* Copyright 2021 GNU General Public License http://www.gnu.org/licenses

*****************************************************************************/

const section read ip

// call table for dispatching format string specifiers

call_table: int8  (specif_space-def)/4 // ' ': print space or minus

int8  0                                // !

int8  0                                // "

int8  (specif_hash-def)/4              // #: prepend 0x

int8  0                                // $

int8  (specif_percent-def)/4           // %: print percent sign

int8  0                                // &

int8  0                                // '

int8  0                                // (

int8  0                                // )

int8  (specif_star-def)/4              // *: width specified by parameter

int8  (specif_plus-def)/4              // +: print sign

int8  0                                // ,

int8  (specif_minus-def)/4             // -: left justified

int8  0                                // .

int8  0                                // /

int8  (specif_number-def)/4            // 0

int8  (specif_number-def)/4            // 1

int8  (specif_number-def)/4            // 2

int8  (specif_number-def)/4            // 3

int8  (specif_number-def)/4            // 4

int8  (specif_number-def)/4            // 5

int8  (specif_number-def)/4            // 6

int8  (specif_number-def)/4            // 7

int8  (specif_number-def)/4            // 8

int8  (specif_number-def)/4            // 9

int8  0                                // :

int8  0                                // ;

int8  0                                // <

int8  0                                // =

int8  0                                // >

int8  0                                // ?

int8  0                                // @

int8  (specif_hex-def)/4               // A: hexadecimal float

int8  0                                // B

int8  0                                // C

int8  0                                // D

int8  (specif_float-def)/4             // E: float

int8  (specif_float-def)/4             // F: float

int8  (specif_float-def)/4             // G: float

int8  0                                // H

int8  0                                // I

int8  0                                // J

int8  0                                // K

int8  (specif_l-def)/4                 // L: long (long double)

int8  0                                // M

int8  0                                // N

int8  0                                // O

int8  0                                // P

int8  0                                // Q

int8  0                                // R

int8  0                                // S

int8  0                                // T

int8  0                                // U

int8  0                                // V

int8  0                                // W

int8  (specif_hex-def)/4               // X: hexadecimal

int8  0                                // Y

int8  0                                // Z

int8  0                                // [

int8  0                                // \

int8  0                                // ]

int8  0                                // ^

int8  0                                // _

int8  0                                // `

int8  (specif_hex-def)/4               // a: hexadecimal float

int8  0                                // b

int8  (specif_char-def)/4              // c: character

int8  (specif_dec-def)/4               // d: signed decimal

int8  (specif_float-def)/4             // e: float

int8  (specif_float-def)/4             // f: float

int8  (specif_float-def)/4             // g: float

int8  (specif_h-def)/4                 // h: short

int8  (specif_dec-def)/4               // i: signed decimal

int8  (specif_l-def)/4                 // j: intmax_t

int8  0                                // k

int8  (specif_l-def)/4                 // l: long

int8  0                                // m

int8  (specif_num-def)/4               // n: read number of characters printed so far

int8  0                                // o

int8  (specif_hex-def)/4               // p: pointer, print as hexadecimal

int8  0                                // q

int8  0                                // r

int8  (specif_string-def)/4            // s: string

int8  (specif_l-def)/4                 // t: ptrdiff_t

int8  (specif_uns-def)/4               // u: unsigned decimal

int8  0                                // v

int8  0                                // w

int8  (specif_hex-def)/4               // x: hexadecimal

int8  0                                // y

int8  (specif_l-def)/4                 // z: size_t

const end

code section execute align = 4         // code section

// _printf: print formatted string to stdout

// parameters: r0: format string, r1: parameter list

_printf function public reguse = 0xF, 0

  int64 r2 = r0                        // format string

  int64 r3 = r1                        // parameter list

  int64 sp -= 10*8                     // start saving registers

  int64 [sp+0x30] = r10                // save r10. The rest are saved under printf_generic

  int64 r10 = address ([char_to_stdout])

  jump printf_generic

// _sprintf: print formatted string to string buffer

// parameters: r0: destination string, r1: format string, r2: parameter list

_sprintf function public reguse = 0xF, 0

  int64 r3 = r2                        // parameter list

  int64 r2 = r1                        // format string

  int64 r1 = -1                        // character count limit = UINT_MAX

  int64 sp -= 10*8                     // start saving registers

  int64 [sp+0x30] = r10                // save r10. The rest are saved under printf_generic

  int64 r10 = address ([char_to_string])

  jump printf_generic

// _snprintf: print formatted string to string buffer with limit

// parameters: r0: destination string, r1: length limit, r2: format string, r3: parameter list

_snprintf function public reguse = 0xF, 0

  int64 r1--                           // character count limit. make space for terminating zero

  int64 sp -= 10*8                     // start saving registers

  int64 [sp+0x30] = r10                // save r10. The rest are saved under printf_generic

  int64 r10 = address ([char_to_string])

  // continue in printf_generic

printf_generic:                        // common procedure for all printf variants

  // save r4 - r13

  //int64 sp -= 10*8                   // this is done above

  int64 [sp+0x00] = r4

  int64 [sp+0x08] = r5

  int64 [sp+0x10] = r6

  int64 [sp+0x18] = r7

  int64 [sp+0x20] = r8

  int64 [sp+0x28] = r9

  // int64 [sp+0x30] = r10             // r10 saved above

  int64 [sp+0x38] = r11

  int64 [sp+0x40] = r12

  int64 [sp+0x48] = r13

  if (int64 r2 == 0) {jump finish}     // format string pointer is null

  int r13  = 0                         // reset field width

  int r11 = 0                          // reset modifiers

  int r12 = 0                          // state start

  // loop through format string

  while (true) {

    int8 r8 = [r2]                     // read character from format string

    if (int8+ r8 == 0) {break}         // end of format string

    int64 r2++                         // increment format string pointer

    if (int r12 == 0) {                // state start

      if (int8+ r8 == '%') {

        int r12 = 1                    // state after '%'

      }

      else {

        call (r10)                     // print character from format string

      }

      nop

    }

    else {                             // after '%' or modifier

      int r6 = r8 - ' '                // table index

      int64 r4 = address ([unknown_character])

      if (uint r6 > 91) {

        call (r4)                      // call unknown_character

      }

      else {

        int64 r5 = address ([call_table])

        int8 call_relative (r4, [r5 + r6*1])  // dispatch format specifier or modifier

      }

    }

  }

  finish:

  // if printing to string, insert terminating zero

  int64 r4 = address ([char_to_string])

  if (uint64 r10 >= r4) {

    int r4 = 0

    int8 [r0] = r4

  }

  int64 r0 = r9                        // return number of characters written

  // restore r4 - r13

  int64 r4  = [sp+0x00]

  int64 r5  = [sp+0x08]

  int64 r6  = [sp+0x10]

  int64 r7  = [sp+0x18]

  int64 r8  = [sp+0x20]

  int64 r9  = [sp+0x28]

  int64 r10 = [sp+0x30]

  int64 r11 = [sp+0x38]

  int64 r12 = [sp+0x40]

  int64 r13 = [sp+0x48]

  int64 sp += 10*8

  return                               // return from _printf, etc.

/////////////////////////////////////////////////////////////

// subfunctions for different characters in format string

/////////////////////////////////////////////////////////////

specif_space:                          // ' ': print space or minus

  if (int r12 != 1) {jump unknown_character}

  int r11 |= 8                         // set modifier flag

  return

specif_plus:                           // +: print sign

  if (int r12 != 1) {jump unknown_character}

  int r11 |= 4                         // set modifier flag

  return

specif_minus:                          // -: left justified

  if (int r12 != 1) {jump unknown_character}

  int r11 |= 1                         // set modifier flag

  return

specif_hash:                           // hash sign: print prefix 0x

  if (int r12 != 1) {jump unknown_character}

  int r11 |= 0x10                      // set modifier flag

  return

specif_h:                              // h: short

  int r4 = test_bits_or(r11, 0x40)     // is there a preceding h?

  int r11 |= 0x40                      // set modifier flag h

  int r11 |= 0x80, mask = r4           // set modifier flag hh

  int r12 = 3                          // state after sub_specifier

  return

specif_l:                              // l: long

  int r11 |= 0x20                      // set modifier flag l

  int r12 = 3                          // state after sub_specifier

  return

specif_percent:                        // %: print percent sign

  jump unknown_character               // just print % sign and reset state

specif_star:                           // *: width specified by parameter

  if (int r12 != 1) {jump unknown_character}

  int r13 = [r3]                        // read width from paramter

  int64 r3 += 8

  int r12 = 2                          // state after width

  int r11 |= 0x100                     // set modifier flag

  return

specif_number:                         // 0-9

  if (int r12 == 1) {

    if (int r8 == '0') {               // leading '0' means print leading zeroes

      int r11 |= 2                     // set modifier flag 2

      return

    }

  }

  // number specifies width

  // width = previous_width * 10 + new_digit

  int r4 = r13 << 3                     // multiply width by 10

  int r13 <<= 1

  int r13 += r4

  int r8 -= '0'                        // convert from ASCII

  int r13 += r8                        // new width

  int r12 = 2                          // state after width

  int r11 |= 0x100                     // set modifier flag

  return

// subfunction for writing to stdout

char_to_stdout:

  int8 output(r8, r8, 10)              // write to stdout

  int64 r9++                           // count characters written

  return

// subfunction for writing to string

char_to_string:

  int64 r9++                           // count characters written or potentially written

  if (uint64 r9 > r1) {                // compare with string length limit

    jump char_to_string9               // stop printing

  }

  int8 [r0] = r8                       // write to string

  int64 r0++                           // increment string pointer

char_to_string9:

  return

// %n: read number of characters printed so far

specif_num:                            // n: read number of characters printed so far

  int64 r4 = [r3]                      // read pointer from parameter list

  int64 r3 += 8                        // increment parameter list

  int32 [r4] = r9                      // save number of characters written

  jump reset_state

// %c: Print character

specif_char:                           // c: print character

  int r13--                            // number of leading or trailing spaces to pring

  if (int !(r11 & 1)) {                // field is right justified. print leading spaces

    int r8 = ' '                       // leading spaces

    for (int; r13 > 0; r13--) {

      call (r10)                       // print space

    }

  }

  int8 r8 = [r3]                       // read character from parameter list

  int64 r3 += 8                        // increment parameter list

  call (r10)                           // print character

  int r8 = ' '                         // print any trailing spaces

  for (int; r13 > 0; r13--) {

    call (r10)                         // print space

  }

  jump reset_state

// %s: Print string

specif_string:                         // s: string

  int64 r6 = [r3]                      // read string pointer from parameter list

  int64 r3 += 8                        // increment parameter list

  if (int64 r6 == 0) {jump unknown_character} // null string

  int r4 = r11 ^ 1                     // check if right justified

  int16+ test_bits_and(r4, 0x101), jump_false specif_string2

  // string is right justified with specified width. check if leading spaces are needed

  for (int r5 = 0; r5 < r13; r5++) {

    int8 r8 = [r6+r5]                  // read string character

    if (int8+ r8 == 0) {break}         // string is shorter. leading spaces needed

  }

  // print leading spaces

  int r8 = ' '

  for (int ; r5 < r13; r5++) {

    call (r10)                         // print space

  }

  int r13 = 0                           // avoid printing trailing spaces also

  specif_string2:

  while (true) {

    int8 r8 = [r6]                     // read character from string

    if (int8+ r8 == 0) {break}         // end of string

    int64 r6++                         // increment string pointer

    call (r10)                         // print character

    int r13--                           // count down field width

  }

  // print any trailing space

  int r8 = ' '

  while (int r13 > 0) {

    call (r10)                         // print character

    int r13--                           // count down field width

  }

  jump reset_state

// %e, %f, %g: Print floating point number

specif_float:

    //jump specif_float1               // (intermediate jump target specif_float placed here to avoid overflow in call table)

    // float not implemented. print as %#LX

    int r11 |= 0x30                    // print 0x prefix, 64 bits

    jump specif_hex

// reference point, default in call table, print unknown character:

def:                                   // default, reference point in call table

unknown_character:                     // unknown character after '%'

  call r10                             // print character

  //jump reset_state

reset_state:                           // reset state after '%' command

  int r11 = 0                          // reset modifiers

  int r12 = 0                          // state start

  int r13 = 0                          // reset field width

  return

// %x: Print hexadecimal

specif_hex:                            // X: hexadecimal

  int r7 = r8 & 0x20                   // is lower case

  int64 r4 = [r3]                      // read integer from parameter list

  int64 r3 += 8                        // increment parameter list

  if (int !(r11 & 0x20)) {             // check if long int

    int32 r4 = r4                      // not long. truncate to 32 bits

  }

specif_hex2:                           // entry from %i (decimal) if number too big

  int64 r5 = bitscan(r4, 1)            // find number of bits

  uint32 r5 >>= 2

  int32 r5++                           // number of digits to print

  int r13 -= r5                        // number of leading or trailing spaces to print

  int r6 = test_bit(r11, 4)            // '#' option

  int r13 -= 2, mask = r6              // make space of 0x prefix

  if (int !(r11 & 1)) {                // field is right justified. print leading spaces

    int r8 = ' '                       // leading spaces

    int r6 = test_bit(r11, 1)          // get bit 1: leading zeroes

    int r8 = '0', mask=r6, fallback=r8 // leading zeroes instead of leading spaces

    while (int r13 > 0) {              // print r13 leading spaces or zeroes

      call r10

      int r13--

    }

  }

  if (int r11 & 0x10) {                // '#' flag. Print 0x prefix

    int r8 = '0'

    call r10

    int r8 = 'X' | r7                  // 'x' or 'X'

    call r10

  }

  // convert to hexadecimal

  if (int r5 > 8) {                    // must use 64 bits

      int r6 = 16 - r5                 // number of digits to skip

      int r6 <<= 2                     // number of bits to skip

      uint64 r4 <<= r6                 // remove leading zero bits

      for (int ; r5 > 0; r5--) {       // loop for r5 digits

          uint64 r4 = rotate(r4, 4)    // get digit into low position

          int r8 = r4 & 0xF            // get digit

          int r8 += '0'                // convert to ASCII

          int r6 = r8 > '9'            // digit is A - F

          int r8 += 7, mask = r6       // add 7 to get letter A - F

          int r8 |= r7                 // lower case

          call r10                     // print character

      }

  }

  else {   // use 32 bits. CPU may not support 64 bits

      int r6 = 8 - r5                  // number of digits to skip

      int r6 <<= 2                     // number of bits to skip

      uint32 r4 <<= r6                 // remove leading zero bits

      for (int ; r5 > 0; r5--) {       // loop for r5 digits

          uint32 r4 = rotate(r4, 4)    // get digit into low position

          int r8 = r4 & 0xF            // get digit

          int r8 += '0'                // convert to ASCII

          int r6 = r8 > '9'            // digit is A - F

          int r8 += 7,  mask = r6      // add 7 to get letter A - F

          int r8 |= r7                 // lower case

          call r10                     // print character

      }

  }

  // print any trailing spaces

  int r8 = ' '                         // trailing spaces

  while (int r13 > 0) {                // print r13 trailing spaces

    call r10

    int r13--

  }

  jump reset_state

// %i, %d: Print signed decimal integer

specif_dec:                            // i: signed decimal

  int64 r4 = [r3]                      // read integer from parameter list

  int64 r3 += 8                        // increment parameter list

  if (int r11 & 0x20) {                // %li: 64-bit integer

    int64 r5 = test_bit(r4, 63)        // get sign bit

    int64 r4 = -r4, mask = r5          // change sign if negative

    int r11 |= 0x200, mask = r5        // set bit to remember negative

    int64 r6 = bitscan(r4, 1)          // find number of bits

    if (int r6 > 31) {                 // cannot handle 64 bits decimal. Do hexadecimal instead

      int r11 |= 0x11                  // prepare for hexadecimal escape. get 0x prefix and left justify

      int r7 = 0                       // use upper case for hexadecimal escape

      if (int8+ r5 & 1) {

        int r8 = '-'                   // print '-'

        call r10

      }

      jump specif_hex2                 // print as hexadecimal

    }

  }

  else {

    if (int r11 & 0x80) {              // %hhi: int8

      int32 r5 = test_bit(r4, 7)       // get sign bit

      int8 r4 = -r4, mask = r5         // change sign if negative. truncate to 8 bits

      int r11 |= 0x200, mask = r5      // set bit to remember negative

    }

    else {

      if (int r11 & 0x40) {            // %hhi: int16

        int32 r5 = test_bit(r4, 15)    // get sign bit

        int16 r4 = -r4, mask = r5      // change sign if negative. truncate to 16 bits

        int r11 |= 0x200, mask = r5    // set bit to remember negative

      }

      else {

        // %i: int32

        int32 r5 = test_bit(r4, 31)    // get sign bit

        int32 r4 = -r4, mask = r5      // change sign if negative. truncate to 16 bits

        int r11 |= 0x200, mask = r5    // set bit to remember negative

      }

    }

  }

  jump specif_uns2                     // sign has been stored in r11. continue in unsigned

// %u: Print unsigned decimal integer

specif_uns:                           // u: unsigned decimal

  int64 r4 = [r3]                      // read integer from parameter list

  int64 r3 += 8                        // increment parameter list

  if (int r11 & 0x20) {                // %li: 64-bit integer

    int64 r6 = bitscan(r4, 1)          // find number of bits

    int r8 |= 0x10                     // prepare for hexadecimal escape. get 0x prefix

    int r7 = 0                         // use upper case for hexadecimal escape

    if (int r6 > 31) {jump specif_hex2}// cannot handle 64 bits decimal. Do hexadecimal instead

  }

specif_uns2:

  int64 sp -= 8                        // save r14

  int64 [sp] = r14

  // 32 bit decimal signed or unsigned

  // First two BCD digits are made with simple subtraction to avoid the need for a larger bit field

  int r5 = 0                           // upper two BCD digits

  while (uint32 r4 >= 1000000000) {

  nop

    uint32 r4 -= 1000000000

    uint32 r5 += 0x10

    nop

  }

  while (uint32 r4 >= 100000000) {

    uint32 r4 -= 100000000

    uint32 r5 += 0x01

  }

  // Generate 8 BCD digits using double dabble algorithm

  int32 r14 = 0                        // generate BCD in r14

  for (int r6 = 0; r6 < 32; r6++) {    // loop for 32 bits

      int32 r7 = r14 + 0x33333333      // digit values 5-9 will set bit 3 in each 4-bit nibble

      int32 r7 &= 0x88888888           // isolate bit 3 in each nibble

      int32 r8 = r7 >> 3               // generate value 3 in nibbles with value 5-9

      int32 r7 >>= 2

      int32 r7 |= r8                   // this will have 3 for each nibble with a value 5-9

      int32 r14 += r7                  // add 3 to nibble values 5-9 to generate 8-12

      int32 r14 = funnel_shift(r4, r14, 31)  // shift most significant bit of r4 into r14

      int32 r4 <<= 1

  }

  // r5:r14 = BCD value

  // determine width

  int r6 = bitscan(r14, 1)             // number of significant bits

  uint r6 >>= 2                        // number of significant digits in low part

  int r6++                             // number of digits in low part

  if (int r5 != 0) {                   // high part is nonzero

    int r6 = bitscan(r5, 1)            // find number of digits in high part

    uint r6 >>= 2

    int r6 += 9                        // number of digits total

  }

  int r7 = test_bits_or(r11, 0x20C)    // leading sign needed

  int r6 += r7                         // number of characters needed

  int r13 -= r6                        // number of leading or trailing spaces needed

  if (int !(r11 & 1)) {                // right justified

    int r6 = r13 > 0 && r7             // leading sign && leading spaces

    int r4 = test_bit(r11, 1), options=1, fallback=r6 // leading zeroes and leading sign. sign must come first

    int r8 = ' '                       // leading sign to print

    int r6 = test_bit(r11, 2)          // flag for '+' prefix

    int r8 = '+', mask=r6, fallback=r8 // leading + required if not negative

    int r6 = test_bit(r11, 9)          // flag for negative

    int r8 = '-', mask=r6, fallback=r8 // leading -. value is negative

    if (int r4 & 1) {                  // sign must come before leading zeroes

      call r10                         // print leading sign

      int r7 = 0                       // remember leading sign has been written

    }

    // print leading spaces or zeroes

    int r8 = ' '                       // space

    int r6 = test_bit(r11, 1)          // flag for leading zeroes

    int r8 = '0', mask=r6, fallback=r8

    while (int r13 > 0) {              // write leading spaces or zeroes

      call r10

      int r13--

    }

  }

  if (int r7 & 1) {                  // sign after leading spaces

    int r8 = ' '                     // space

    int r6 = test_bit(r11, 2)        // flag for '+' prefix

    int r8 = '+', mask=r6, fallback=r8 // leading + required if not negative

    int r6 = test_bit(r11, 9)        // flag for negative

    int r8 = '-', mask=r6, fallback=r8 // leading -. value is negative

    call r10                         // write sign

  }

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

  // print high two digits

  uint32 r5 <<= 24                     // left justify high part

  for (int r6 = 2; r6 > 0; r6--) {     // print two high digits if any

      int32 r5 = rotate(r5, 4)         // get most significant digit first

      int8 r8 = r5 & 0x0F

      int r4 = (r8 != 0) || r4         // digit has been printed

      int8 r8 += '0'                   // convert to ASCII

      if (int r4 != 0) {

          call r10                     // print character to stdout

      }

  }

  // print low 8 decimal digits

  for (int r6 = 8; r6 > 0; r6--) {

      int32 r14 = rotate(r14, 4)       // get most significant digit first

      int8 r8 = r14 & 0x0F

      int r4 = (r8 != 0) || r4         // digit has been printed

      int r4 = (r6 == 1) || r4         // last digit must be printed

      int8 r8 += '0'                   // convert to ASCII

      if (int r4 != 0) {

          call r10                     // print character to stdout

      }

  }

  // print trailing spaces

  int r8 = ' '                         // space

  while (int r13 > 0) {                // write trailing spaces

    call r10

    int r13--

  }

  int64 r14 = [sp]                     // restore r14

  int64 sp += 8

  jump reset_state                     // finished

  // %e, %f, %g: Print floating point number. not implemented

specif_float1:

  nop

  jump reset_state                     // finished

code end