printf.c

Go to the documentation of this file.

 
#ifdef USER_CONFIG
#include "user_config.h"
#else
//#include <stdio.h>
#endif
 
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <math.h>
 
#include "mathio.h"
 
// =============================================
 
// Below we included functions that are defined elsewhere
// They are included within printf to allow this to be standalone
// This is done by looking at header defines for the time being
 
MEMSPACE
size_t
WEAK_ATR
strlen(const char *str)
{
    int len=0;
// String length
    while(*str++)
        ++len;
    return(len);
}
 
 
// Skip if we have linux ctype.h
#undef isdigit
MEMSPACE
int
WEAK_ATR
isdigit(int c)
{
    if(c >= '0' && c <= '9')
        return(1);
    return(0);
}
 
 
// =============================================
// start of support functions
// =============================================
 
MEMSPACE
void
WEAK_ATR
reverse(char *str)
{
    char temp;
    int i;
    int len = strlen(str);
// Reverse
// We only exchange up to half way
    for (i = 0; i < (len >> 1); i++)
    {
        temp = str[len - i - 1];
        str[len - i - 1] = str[i];
        str[i] = temp;
    }
}
 
 
MEMSPACE
void
WEAK_ATR
strupper(char *str)
{
    while(*str)
    {
        if(*str >= 'a' && *str <= 'z')
            *str -= ( 'a' - 'A');
        ++str;
    }
}
 
 
#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
#error bin2num ASSUME little endian
#endif
 
MEMSPACE
int bin2num(uint8_t *str, int strmax, int nummin, int base, uint8_t *nump, int numsize, int sign_ch)
{
    int i,j,carry;
    uint8_t data;
 
    int numbits = numsize * 8;
 
    for(i=0;i<=nummin;++i)
        str[i] = 0;                               // initial string starts out empty
 
// FIXME Little/Big-endian
// Loop for all bits (numsize in total) in the binary number (bin)
// Examine each bit MSB to LSB order
    for(i = numbits - 1; i>= 0; --i)
    {
// We extract 1 bit at a time from the binary number (MSB to LSB order)
//  FIXME Little/Big-endian
        data = nump[i>>3];
// If extracted bit was set carry = 1, else 0
//  FIXME Little/Big-endian
        carry = ( data & (1 << (i & 7)) ) ? 1 : 0;
 
// Multiply base number by two and add the previously extracted bit
// Next do base digit to digit carries as needed
// Note: nummin is the current string size that can grow as needed
// Carry test in the loop can optionally extend base strings size
        for(j=0;(j<nummin || carry) ;++j)
        {
            if(j >= (strmax - 2))
                break;
 
            data = str[j];
            data = (data<<1) | carry;
// process base carry
            carry = 0;
            if(data >= base)
            {
                data -= base;
                carry = 1;
            }
            str[j] = data;
        }
        str[j] = 0;                               // zero next digit if carry extends size
        nummin = j;                               // update nummin if carry extends size
    }
 
// Add ASCII '0' or 'a' offsets to base string
    for(i=0;i<nummin;++i)
    {
        if(str[i] < 10)
            str[i] += '0';
        else str[i] += 'a'-10;
    }
 
// Add optional sign character
    if(sign_ch && i <= (strmax - 2))
    {
        str[i++] = sign_ch;
        ++nummin;
    }
    str[i] = 0;                                   // Terminate string eith EOS
 
    reverse((char *)str);                         // Reverse in place to correct order
 
    return(nummin);                               // Return string size
}
 
 
// =============================================
 
MEMSPACE
void pch_init(p_ch_t *p, char *str, int max)
{
    p->str = str;                               
    p->ind = 0;                                 
    p->max = max-1;                             
    p->str[0] = 0;
}
 
 
MEMSPACE
int pch(p_ch_t *p, char ch)
{
// Add the character while ther is room
    if(p->ind < p->max)
        p->str[p->ind++] = ch;
    else
        p->str[p->ind] = 0;                   // Add EOS when limit exceeded
    return(p->ind);
}
 
 
MEMSPACE
int pch_ind(p_ch_t *p)
{
    return(p->ind);
}
 
 
MEMSPACE
int pch_max_ind(p_ch_t *p)
{
    return(p->max);
}
 
 
// =============================================
// end of support functions
// =============================================
MEMSPACE
void print_flags(f_t f)
{
    if(f.b.left)
        printf("left   flag\n");
    if(f.b.plus)
        printf("plus   flag\n");
    if(f.b.space)
        printf("space  flag\n");
    if(f.b.zero)
        printf("zero   flag\n");
    if(f.b.alt)
        printf("alt    flag\n");
    if(f.b.width)
        printf("width  flag\n");
    if(f.b.prec)
        printf("prec   flag\n");
    if(f.b.neg)
        printf("< 0    flag\n");
}
 
 
 
MEMSPACE
int p_ntoa(uint8_t *nump, int numsize, char *str, int strmax, int radix, int width, int prec, f_t f)
{
    unsigned int sign_ch;
    int ind;
    int digits;
 
    digits = 0;
 
// Unsigned, hex,octal,binary should leave these flasg zero
//f.b.space = 0;
//f.b.plus = 0;
//f.b.neg = 0;
 
    sign_ch = 0;
    if(f.b.neg)
        sign_ch = '-';
    else if(f.b.plus)
        sign_ch = '+';
    else if(f.b.space)
        sign_ch = ' ';
 
//print_flags(f);
 
/* Some Combinations of flags are not permitted
 * - or impact the interpretation of others */
    if(f.b.zero)
    {
// 0 disabled if precision or left align
        if(f.b.left || f.b.prec)
            f.b.zero = 0;
    }
 
    if(f.b.prec)
        digits = prec;
 
    if(!f.b.width && !f.b.prec)
        digits = 1;                               // at least one digit
 
    if(f.b.width)
    {
        if(!f.b.zero)
        {
// Width and no leading zeros require at least one digit
            if(!f.b.prec)
                digits = 1;                       // at least one digit
        }
        else                                      /* precision and 0 can not occur together - previously tested */
        {
            digits = width;
/* make room for a sign ? */
            if(f.b.plus || f.b.neg || f.b.space)
                --digits;
        }
    }
    ind = bin2num((uint8_t *)str, strmax, digits, radix, nump, numsize, sign_ch);
    return(ind);
}
 
 
#ifdef FLOATIO
MEMSPACE
int p_ftoa(double val, char *str, int max, int width, int prec, f_t f)
{
 
    char *save = str;
    double fscale;
    int idigits, digits;
    int digit;
    p_ch_t _pch;
    p_ch_t *p = (p_ch_t *) &_pch;
    pch_init(p, str,max);
 
/* 
FIXME
Notice rounding - testing will be tricky
ERROR: [% 15.1f], [-10252956608208.250000]
    G[-10252956608208.2]
    B[-10252956608208.3]
    error:9.90567929632045986708e-15
 
*/
//printf("val:%.20e\n", val);
//print_flags(f);
    if(val < 0.0)
    {
        val = -val;
        f.b.neg = 1;
    }
    if(f.b.neg)
        pch(p,'-');
    else if(f.b.plus)
        pch(p,'+');
    else if(f.b.space)
        pch(p,' ');
 
// prec only applies to fractional digits
    if(prec < 0)
        prec = 0;
 
// NOTE: prec is anchored at the decimal point
 
    fscale = 0.0;
    idigits = 1;                                  // number of integer digits
    if(val)                                       // if zero no rounding needed
    {
// do rounding - IF precision specified
// number of fractional digits to display
        fscale = 0.5;                             // rounding value if prec = 0
        if(f.b.prec)
        {
            digits = prec;
            while(digits > 0)
            {
                fscale /= 10.0;                   // adjust rounding value
                --digits;
            }
        }
//printf("val;:%.20e, fscale:%.20e\n", val, fscale);
        val += fscale;                            // round to prec
 
        while(val >= 10.0)
        {
            ++idigits;
            val /= 10.0;
        }
// So we know that fval < 1.0;
    }
 
//printf("idigits:%d\n",idigits);
 
    if(f.b.zero && !f.b.left)
    {
        if(f.b.prec && prec)
            digits = width - idigits - pch_ind(p) - prec -1;
        else
            digits = width - idigits - pch_ind(p);
 
        while(digits > 0)
        {
            pch(p,'0');
            --digits;
        }
    }
 
// Display integer part of number
    while(idigits > 0)
    {
        digit = val;
//printf("ival:%.16e, int:%d\n", ival, digit);
        pch(p,digit + '0');
        val -= (double) digit;
        --idigits;
        val *= 10.0;
    }
// display fractional part
    if(f.b.prec && prec > 0 )
    {
        pch(p,'.');
        while(prec > 0 )
        {
            digit = val;
            val -= (double) digit;
            digit += '0';
            pch(p,digit);
            --prec;
            val *= 10.0;
        }
    }
    pch(p,0);
    return(strlen(save));
}
 
 
MEMSPACE
int p_etoa(double val,char *str, int max, int width, int prec, f_t f)
{
    double fscale;
    int digits;
    int digit;
    int exp10;
    uint8_t exp10_str[7];                         // +E123  and EOS
    int  expsize;
    int i;
    int sign_ch;
    p_ch_t _pch;
    p_ch_t *p = (p_ch_t *) &_pch;
    pch_init(p, str,max);
 
/* FIXME
Notice rounding - testing will be tricky
ERROR: [% 15.1f], [-10252956608208.250000]
    G[-10252956608208.2]
    B[-10252956608208.3]
    error:9.90567929632045986708e-15
 
*/
//printf("val:%.20e\n", val);
//print_flags(f);
    if(val < 0.0)
    {
        val = -val;
        f.b.neg = 1;
    }
    if(f.b.neg)
        pch(p,'-');
    else if(f.b.plus)
        pch(p,'+');
    else if(f.b.space)
        pch(p,' ');
 
// prec only applies to fractional digits
    if(prec < 0)
        prec = 0;
 
// NOTE: prec is anchored at the decimal point
 
    fscale = 1.0;                                 // rounding value if prec = 0
    exp10 = 0;
 
    if(val)                                       // if zero no rounding needed
    {
        fscale = 0.5;                             // rounding value if prec = 0
// do rounding - IF precision specified
// number of fractional digits to display
        if(f.b.prec)
        {
            digits = prec;
            while(digits > 0)
            {
                fscale /= 10.0;                   // adjust rounding value
                --digits;
            }
        }
 
// scale number  1.0 <= x < 10.0
        while(val < 1.0 )
        {
            val *= 10.0;
            exp10--;
 
        }
        while(val >= 10.0)
        {
            ++exp10;
            val /= 10.0;
        }
        val += fscale;
        while(val >= 10.0)
        {
            ++exp10;
            val /= 10.0;
        }
// round
//printf("val;:%.20e, fscale:%.20e\n", val, fscale);
//val += fscale;        // round to prec
    }
 
// ====================
// Exponent
    exp10_str[0] = 'e';
    if ( exp10 < 0 )
    {
        sign_ch = '-';
        exp10 = -exp10;
    }
    else
    {
        sign_ch = '+';
    }
// result is +NN[N] if we have three digits shorten digits by one
    expsize = bin2num(exp10_str+1, sizeof(exp10_str)-1-1, 2, 10, (uint8_t *) &exp10, sizeof(int), sign_ch);
 
#if 0
    if ( exp10 < 0 )
    {
        exp10_str[1] = '-';
        exp10 = -exp10;
    }
    else
    {
        exp10_str[1] = '+';
    }
    if(exp >= 100)
        ind = 4;
    else
        ind = 3;
 
    exp10_str[ind] = '0' + (exp % 10);
    exp10 /= 10;
    exp10_str[ind] = '0' + (exp % 10);
    exp10 /= 10;
    exp10_str[ind] = '0' + (exp % 10);
#endif
 
// ====================
 
// [+]N.FFe+00, where ".e+00" = 5 digits, pch_ind holds optional sign offset
    if(f.b.zero && !f.b.left)
    {
        if(f.b.prec && prec)
            digits = width - pch_ind(p) - prec - 6;
        else
            digits = width - pch_ind(p) - 5;
        if(expsize > 3)
            --digits;
        while(digits > 0)
        {
            pch(p,'0');
            --digits;
        }
    }
 
// Number
    digit = val;
//printf("ival:%.16e, int:%d\n", ival, digit);
    pch(p,digit + '0');
    val -= (double) digit;
    val *= 10.0;
 
// display fractional part
    if(f.b.prec && prec > 0 )
    {
        pch(p,'.');
        while(prec > 0 )
        {
            digit = val;
            val -= (double) digit;
            digit += '0';
            pch(p,digit);
            val *= 10.0;
            --prec;
        }
    }
 
    for(i=0;exp10_str[i];++i)
        pch(p,exp10_str[i]);
 
    pch(p,0);
    return(strlen(str));
}
#endif // FLOATIO
 
 
// =============================================
MEMSPACE
void _puts_pad(printf_t *fn, char *s, int width, int count, int left)
{
    int size = 0;
    int pad = 0;
 
// note - if width > count we pad
//        if width <= count we do not pad
    if(width > count)
    {
        pad = width - count;
    }
 
//printf("_puts_pad:(%s) width:%d, count:%d, left:%d, pad:%d, len:%d\n", s, width, count, left, pad, len);
 
// left padding ?
    if(!left)
    {
//printf("_puts_pad:pad:%d\n", pad);
        while(pad--)
        {
            fn->put(fn,' ');
            ++size;
        }
    }
//printf("_puts_pad:count:%d\n", count);
 
// string
    while(*s && count--)
    {
        fn->put(fn,*s);
        ++s;
        ++size;
    }
// right padding
    if(left)
    {
//printf("_puts_pad:pad:%d\n", pad);
 
        while(pad--)
        {
            fn->put(fn,' ');
            ++size;
        }
    }
//printf("_puts_pad:size:%d\n", size);
}                                                 // _puts_pad()
 
#ifdef AVR
// =============================================
MEMSPACE
void _puts_pad_X(printf_t *fn, __memx const char *s, int width, int count, int left)
{
    int size = 0;
    int pad = 0;
 
// note - if width > count we pad
//        if width <= count we do not pad
    if(width > count)
    {
        pad = width - count;
    }
 
//printf("_puts_pad:(%s) width:%d, count:%d, left:%d, pad:%d, len:%d\n", s, width, count, left, pad, len);
 
// left padding ?
    if(!left)
    {
//printf("_puts_pad:pad:%d\n", pad);
        while(pad--)
        {
            fn->put(fn,' ');
            ++size;
        }
    }
//printf("_puts_pad:count:%d\n", count);
 
// string
    while(*s && count--)
    {
        fn->put(fn,*s);
        ++s;
        ++size;
    }
// right padding
    if(left)
    {
//printf("_puts_pad:pad:%d\n", pad);
 
        while(pad--)
        {
            fn->put(fn,' ');
            ++size;
        }
    }
//printf("_puts_pad:size:%d\n", size);
}                                                 // _puts_pad()
 
MEMSPACE
size_t
WEAK_ATR
strlen_X(__memx const char *str)
{
    int len=0;
// String length
    while(*str++)
        ++len;
    return(len);
}
 
#endif
 
 
MEMSPACE
void _printf_fn(printf_t *fn, __memx const char *fmt, va_list va)
{
    int prec, width;
    int count;
    int spec;
    int size;
    int sign;
    short nums;
    int numi;
    long numl;
    long long numll;
    void * numv;
#ifdef __SIZEOF_INT128__
    __uint128_t num128;
#endif
    uint8_t *nump;
 
    f_t f;
#ifdef FLOATIO
    double dnum = 0;
#endif
    char chartmp[2];
    char *ptr;
    __memx const char *fmtptr;
    __memx const char *Xptr;
 
 
// buff has to be at least as big at the largest converted number
// in this case base 2 long long with sign and end of string
#ifdef PRINTF_TEST
    char buff[307 * 2 + 5 + 1];                   // double to full size
#else
    char buff[sizeof( long long ) * 8 + 2];
#endif
 
    while(*fmt)
    {
// emit up to %
        if(*fmt != '%')
        {
            fn->put(fn,*fmt++);
            continue;
        }
 
        fmtptr = fmt;
// process % specifier
        fmt++;
 
        prec = 0;                                 // minimum number of digits displayed
        width = 0;                                // padded width
 
// we accept multiple flag combinations and duplicates as does GLIBC printf
// ['#']['-'][' '|'+']
// [' '|'+']['-']['#']
// ...
 
// reset flags
        f.all = 0;
        while(*fmt == '#' || *fmt == '+' || *fmt == '-' || *fmt == ' ' || *fmt == '0')
        {
            if(*fmt == '#')
                f.b.alt = 1;
            else if(*fmt == '+')
                f.b.plus = 1;
            else if(!f.b.left && *fmt == '-')
                f.b.left = 1;
            else if(!f.b.space && *fmt == ' ')
                f.b.space = 1;
            else if(!f.b.zero && *fmt == '0')
                f.b.zero = 1;
// format error
            ++fmt;
        }
 
// width specifier
// Note: we permit zero as the first digit
        if(isdigit(*fmt))
        {
// optional width
            width = 0;
            while(isdigit(*fmt))
                width = width*10 + *fmt++ - '0';
            f.b.width = 1;
        }
 
// prec always impiles zero fill to prec digigits for ints and longs
//      is the number of digits after the . for float and double
// regardlles of sign
        if( *fmt == '.' )
        {
            fmt++;
            prec = 0;
            while(isdigit(*fmt))
                prec = prec*10 + *fmt++ - '0';
            f.b.prec = 1;
        }
 
        size = sizeof(int);                       // int is default
 
        if( *fmt == 'I' )
        {
            fmt++;
            size = 0;
            while(isdigit(*fmt))
                size = size*10 + *fmt++ - '0';
            if(size == 0 || size & 7)
                size = 0;
            else
                size >>= 3;
        }
        else if(*fmt == 'h')
        {
            fmt++;
            size = sizeof(short);
        }
        else if(*fmt == 'l')
        {
            fmt++;
            size = sizeof(long);
            if(*fmt == 'l')
            {
                fmt++;
                size = sizeof(long long);
            }
        }
 
        if(size)
            spec = *fmt;
        else
            spec = 0;
 
        sign = 0;
        if(spec == 'd' || spec == 'D')
            sign = 1;
 
        nump = (uint8_t *) &numi;
 
// process integer arguments
        switch(spec)
        {
            case 'p':
            case 'P':
                size = sizeof(void *);
// Unsigned numbers
            case 'b':
            case 'B':
            case 'o':
            case 'O':
            case 'x':
            case 'X':
                if(f.b.zero && f.b.left)
                    f.b.zero = 0;
                if(f.b.zero && f.b.prec)
                    f.b.zero = 0;
                if(f.b.zero && f.b.width)
                {
                    if(width > prec)
                        prec = width;
                }
                if(f.b.zero && f.b.width && f.b.prec)
                {
                    if(width > prec)
                        prec = width;
                }
            case 'u':
            case 'U':
                f.b.space = 0;
                f.b.plus = 0;
                f.b.neg = 0;
            case 'D':
            case 'd':
// make lint shut up
//FIXME vararg functions promote short - make this a conditional
                if(size == sizeof(short))
                {
                    nums = (short) va_arg(va, int);
                    if(sign && nums < 0)
                    {
                        f.b.neg = 1;
                        nums = -nums;
                    }
                    nump = (uint8_t *) &nums;
                }
                else if(size == sizeof(int))
                {
                    numi = (int) va_arg(va, int);
                    if(sign && numi < 0)
                    {
                        f.b.neg = 1;
                        numi = -numi;
                    }
                    nump = (uint8_t *) &numi;
                }
                else if(size == sizeof(long))
                {
                    numl = (long) va_arg(va, long);
                    if(sign && numl < 0)
                    {
                        f.b.neg = 1;
                        numl = -numl;
                    }
                    nump = (uint8_t *) &numl;
                }
                else if(size == sizeof(long long))
                {
                    numll = (long long) va_arg(va, long long);
                    if(sign && numll < 0)
                    {
                        f.b.neg = 1;
                        numll = -numll;
                    }
                    nump = (uint8_t *) &numll;
                }
#ifdef __SIZEOF_INT128__
                else if(size == sizeof(__uint128_t))
                {
                    num128 = (__uint128_t) va_arg(va, __uint128_t);
                    if(sign && numll < 0)
                    {
                        f.b.neg = 1;
                        num128 = -128;
                    }
                    nump = (uint8_t *) &num128;
                }
#endif
                else if(size == sizeof(void *))
                {
                    numv = (void *) va_arg(va, void *);
                    nump = (uint8_t *) &numv;
                }
                else
                {
                    spec = 0;
                }
// FIXME default;
                ++fmt;
                break;
#ifdef FLOATIO
            case 'f':
            case 'F':
            case 'e':
            case 'E':
// K&R defines 'f' type as 6 - and matches GNU printf
                if(!f.b.prec)
                {
                    prec = 6;
                    f.b.prec = 1;
                }
                dnum = va_arg(va, double);
                ++fmt;
                break;
#endif
            case 's':
                ++fmt;
                break;
            case 'S':
                ++fmt;
                break;
            case 'c':
                ++fmt;
                break;
            default:
                break;
        }
 
        switch(spec)
        {
            case 'u':
            case 'U':
                f.b.space = 0;
                f.b.plus = 0;
// FIXME sign vs FILL
//count = p_itoa(nump, size, buff, sizeof(buff), width, prec, f);
                count = p_ntoa(nump, size, buff, sizeof(buff), 10, width, prec, f);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
// FIXME sign vs FILL
            case 'd':
            case 'D':
                count = p_ntoa(nump, size, buff, sizeof(buff), 10, width, prec, f);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
            case 'b':
            case 'B':
                count = p_ntoa(nump, size, buff, sizeof(buff), 2, width, prec,f);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
            case 'o':
            case 'O':
                count = p_ntoa(nump, size, buff, sizeof(buff), 8, width, prec,f);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
            case 'p':
            case 'P':
// size = sizeof(void *);
            case 'x':
            case 'X':
                count = p_ntoa(nump, size, buff, sizeof(buff), 16, width, prec,f);
                if(spec == 'X' || spec == 'P')
                    strupper(buff);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
#ifdef FLOATIO
            case 'f':
            case 'F':
                count = p_ftoa(dnum, buff, sizeof(buff), width, prec, f);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
 
            case 'e':
            case 'E':
                count = p_etoa(dnum, buff, sizeof(buff), width, prec, f);
                if(spec == 'E')
                    strupper(buff);
                _puts_pad(fn,buff, width, count, f.b.left);
                break;
#endif
            case 's':
            case 'c':
                ptr = NULL;                       // stops bogus error that ptr may be uninitalized
    
                if(spec == 's') 
                {
                    ptr = va_arg(va, char *);
                    if(!ptr)
                        ptr = "(null)";
                }
                else                              // 'c'
                {
                    chartmp[0] = (char) va_arg(va, int);
                    chartmp[1] = 0;
                    ptr = chartmp;
                }
                count = strlen(ptr);
                if(prec)
                    count = prec;
                if(count > width && width != 0)
                    count = width;
//printf("width:%d,count:%d,left:%d\n", width, count, f.b.left);
                _puts_pad(fn, ptr, width, count, f.b.left);
                break;
// Added string in program memory - testing
#ifdef AVR
            case 'S':
                // Xptr = va_arg(va, __memx const char *);
                Xptr = va_arg(va, __flash const char *);
                if(!Xptr)
                    Xptr = (__memx const char *) "(null)";
                count = strlen_X(Xptr);
                if(prec)
                    count = prec;
                if(count > width && width != 0)
                    count = width;
                _puts_pad_X(fn, Xptr, width, count, f.b.left);
                break;
#endif
            default:
                while(fmtptr <= fmt && *fmtptr)
                    fn->put(fn, *fmtptr++);
                break;
        }
//printf("fmt:(%s)\n", fmt);
    }
//printf("fmt exit:(%s)\n", fmt);
 
}
 
 
// =============================================
MEMSPACE
void _putc_buffer_fn(struct _printf_t *p, char ch)
{
    char *str;
    if (p->len )
    {
        if(ch)
        {
            p->len--;
            p->sent++;
            str = (char *) p->buffer;
            *str++ = ch;
            p->buffer = (void *) str;
        }
    }
    *((char *)p->buffer) = 0;
}
 
 
#ifdef PRINTF_TEST
#ifdef DEFINE_PRINTF
#error DEFINE_PRINTF must not be defined when testing
#endif
#endif
 
#ifndef PRINTF_TEST
// =============================================
MEMSPACE
int vsnprintf(char* str, size_t size, const char *format, va_list va)
{
 
    int len;
    char *save = str;
    printf_t fn;
 
    *str = 0;
 
    fn.put = _putc_buffer_fn;
    fn.len = size;
    fn.sent = 0;
    fn.buffer = (void *) str;
 
    _printf_fn(&fn, format, va);
 
// FIXME check size should == fn.size on exit
    len = strlen(save);
    return( len );
}
 
 
// =============================================
MEMSPACE
int snprintf(char* str, size_t size, const char *format, ...)
{
    int len;
    va_list va;
 
    va_start(va, format);
    len = vsnprintf(str, size, format, va);
    va_end(va);
 
    return len;
}
 
 
#ifdef AVR
MEMSPACE
int vsnprintf_P(char* str, size_t size, __memx const char *format, va_list va)
{
 
    int len;
    char *save = str;
    printf_t fn;
 
    *str = 0;
 
    fn.put = _putc_buffer_fn;
    fn.len = size;
    fn.sent = 0;
    fn.buffer = (void *) str;
 
    _printf_fn(&fn, format, va);
 
// FIXME check size should == fn.size on exit
    len = strlen(save);
    return( len );
}
 
 
MEMSPACE
int snprintf_P(char* str, size_t size, __memx const char *format, ...)
{
    int len;
    va_list va;
 
    va_start(va, format);
    len = vsnprintf_P(str, size, format, va);
    va_end(va);
 
    return len;
}
 
 
MEMSPACE
int sprintf_P(char* str, __memx const char *format, ...)
{
    int len;
    va_list va;
 
    va_start(va, format);
// FIXME max string size limit !!!!
    len = vsnprintf_P(str, 1024, format, va);
    va_end(va);
 
    return len;
}
#endif
// =============================================
// =============================================
 
#ifdef DEFINE_PRINTF
// =============================================
MEMSPACE
static void _putc_fn(struct _printf_t *p, char ch)
{
    p->sent++;
    putchar(ch);
}
 
 
MEMSPACE
int
printf(const char *format, ...)
{
    printf_t fn;
    va_list va;
 
    fn.put = _putc_fn;
    fn.sent = 0;
 
    va_start(va, format);
    _printf_fn(&fn, format, va);
    va_end(va);
 
    return ((int)fn.sent);
}
 
 
#ifdef AVR
MEMSPACE
int
printf_P(__memx const char *format, ...)
{
    printf_t fn;
    va_list va;
 
    fn.put = _putc_fn;
    fn.sent = 0;
 
    va_start(va, format);
    _printf_fn(&fn, format, va);
    va_end(va);
 
    return ((int)fn.sent);
}
#endif
#endif
#endif