string.integer.spin

' Original authors: Chip Gracey, Jon Williams
{{
    Provides simple numeric conversion methods; all methods return a pointer to
    a string.
}}
CON

    MAX_LEN = 64                                          ' 63 chars + zero terminator

VAR

    long  idx                                             ' pointer into string
    byte  nstr[MAX_LEN]                                   ' string for numeric data

PUB Bin(value, digits)
{{
    Returns pointer to a digits-wide binary string
}}

    ClearStr(@nstr, MAX_LEN)
    return BinToStr(value, digits)

PUB BinIndicated(value, digits)
{{
    Returns pointer to a digits-wide, indicated (with %) binary string
}}

    ClearStr(@nstr, MAX_LEN)
    nstr[idx++] := "%"                                    ' preface with binary indicator
    return BinToStr(value, digits)

PUB Dec(value)
{{
    Returns pointer to signed-decimal string
}}

    ClearStr(@nstr, MAX_LEN)                                ' clear output string
    return DecToStr(value)                                  ' return pointer to numeric string

PUB DecPadded(value, width) | t_val, field
{{
    Returns pointer to signed-decimal, fixed-width (space padded) string
}}

    ClearStr(@nstr, MAX_LEN)
    width := 1 #> width <# constant(MAX_LEN - 1)          ' qualify field width

    t_val := ||value                                      ' work with absolute
    field~                                                ' clear field

    repeat while t_val > 0                                ' count number of digits
        field++
        t_val /= 10

    field #>= 1                                           ' min field width is 1
    if value < 0                                          ' if value is negative
        field++                                             '   bump field for neg sign indicator

    if field < width                                      ' need padding?
        repeat (width - field)                              ' yes
            nstr[idx++] := " "                                '   pad with space(s)

    return DecToStr(value)

PUB DecZeroed(value, digits) | div
{{
    Returns pointer to zero-padded, signed-decimal string

    -- if value is negative, field width is digits+1
}}

    ClearStr(@nstr, MAX_LEN)
    digits := 1 #> digits <# 10

    if (value < 0)                                        ' negative value?
        -value                                              '   yes, make positive
        nstr[idx++] := "-"                                  '   and print sign indicator

    div := 1_000_000_000                                  ' initialize divisor
    if digits < 10                                        ' less than 10 digits?
        repeat (10 - digits)                                '   yes, adjust divisor
            div /= 10

    value //= (div * 10)                                  ' truncate unused digits

    repeat digits
        nstr[idx++] := (value / div + "0")                  ' convert digit to ASCII
        value //= div                                       ' update value
        div /= 10                                           ' update divisor

    return @nstr

PUB Hex(value, digits)
{{
    Returns pointer to a digits-wide hexadecimal string
}}

    ClearStr(@nstr, MAX_LEN)
    return HexToStr(value, digits)

PUB HexL(value, digits): ptr_str
' Returns: pointer to a digits-wide hexadecimal string (lower-case digits)
    clearstr(@nstr, MAX_LEN)
    return hextostrl(value, digits)

PUB HexIndicated(value, digits)
{{
    Returns pointer to a digits-wide, indicated (with $) hexadecimal string
}}

    ClearStr(@nstr, MAX_LEN)
    nstr[idx++] := "$"
    return HexToStr(value, digits)

PUB StrToBase(stringptr, base) : value | chr, index
{{
    Converts a zero terminated string representation of a number to a value in the designated base.

    Ignores all non-digit characters (except negative (-) when base is decimal (10)).
}}

    value := index := 0
    repeat until ((chr := byte[stringptr][index++]) == 0)
        chr := -15 + --chr & %11011111 + 39*(chr > 56)                      ' Make "0"-"9","A"-"F","a"-"f" be 0 - 15, others out of range
        if (chr > -1) and (chr < base)                                      ' Accumulate valid values into result; ignore others
            value := value * base + chr
    if (base == 10) and (byte[stringptr] == "-")                            ' If decimal, address negative sign; ignore otherwise
        value := - value

PRI BinToStr(value, digits)
{{
    Converts value to digits-wide binary string equivalent
    -- characters written to current position of idx
    -- returns pointer to nstr
}}

    digits := 1 #> digits <# 32                           ' qualify digits
    value <<= 32 - digits                                 ' prep MSB
    repeat digits
        nstr[idx++] := (value <-= 1) & 1 + "0"              ' move digits (ASCII) to string

    return @nstr

PRI ClearStr(strAddr, size)
{{
    Clears string at strAddr

    -- also resets global character pointer (idx)
}}

    bytefill(strAddr, 0, size)                            ' clear string to zeros
    idx~                                                  ' reset index

PRI DecToStr(value) | div, z_pad
{{
    Converts value to signed-decimal string equivalent
    -- characters written to current position of idx
    -- returns pointer to nstr
}}

    if (value < 0)                                        ' negative value?
        -value                                              '   yes, make positive
        nstr[idx++] := "-"                                  '   and print sign indicator

    div := 1_000_000_000                                  ' initialize divisor
    z_pad~                                                ' clear zero-pad flag

    repeat 10
        if (value => div)                                   ' printable character?
            nstr[idx++] := (value / div + "0")                '   yes, print ASCII digit
            value //= div                                     '   update value
            z_pad~~                                           '   set zflag
        elseif z_pad or (div == 1)                          ' printing or last column?
            nstr[idx++] := "0"
        div /= 10

    return @nstr

PRI HexToStr(value, digits)
{{
    Converts value to digits-wide hexadecimal string equivalent
    -- characters written to current position of idx
    -- returns pointer to nstr
}}

    digits := 1 #> digits <# 8                            ' qualify digits
    value <<= (8 - digits) << 2                           ' prep most significant digit
    repeat digits
        nstr[idx++] := lookupz((value <-= 4) & $F : "0".."9", "A".."F")

    return @nstr

PRI HexToStrL(value, digits)
' Converts value to digits-wide hexadecimal string equivalent
'   NOTE: Hex characters are lower-case digits
'   NOTE: Characters are written to current position of idx
'   Returns: pointer to nstr

    digits := 1 #> digits <# 8                            ' qualify digits
    value <<= (8 - digits) << 2                           ' prep most significant digit
    repeat digits
        nstr[idx++] := lookupz((value <-= 4) & $F : "0".."9", "a".."f")

    return @nstr

DAT
{
    --------------------------------------------------------------------------------------------------------
    TERMS OF USE: MIT License

    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
    associated documentation files (the "Software"), to deal in the Software without restriction, including
    without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
    following conditions:

    The above copyright notice and this permission notice shall be included in all copies or substantial
    portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
    LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    --------------------------------------------------------------------------------------------------------
}