bprintf.c

Go to the documentation of this file.

/* BeeOS v0.1. Created: 2004/02/27 Modified: 2004/03/03
 * Copyright (C) 2004 Paul Harvey - ROMA, Australia.
 * csirac@users.sourceforge.net
 */

/*   This program 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 verspion 2 of the License, or
 *   (at your option) any later version.
 * 
 *   This program 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 program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "../include/beeos.h"
#include "../include/bstring.h"
/*#include "../include/bmalloc.h"*/
#include <stdarg.h> /* va_start(), va_arg(), va_list, va_end() */
#define IN_BPRINTF
#include "../include/bprintf.h"
#ifndef HOSTED_BUILD
#   include "../include/arch/param.h"
#   include "../include/asm/ports.h"
#   include "../include/asm/ports_std.h"
#   include "../include/sci.h"
#else
#   include <stdio.h>   /* HOSTED_BUILD putchar(). */
#endif

/* GLOBALS */
bool lk_bputs;
bool lk_putchar;
/* END GLOBALS */

#define digit2char(dst, num) do {\
    if ((char)10 > num) {\
        dst = num + '0';\
    } else {\
        dst = num + (char)'a' - (char)10;\
    }\
} while(0);

#ifndef HOSTED_BUILD

void putchar(char c)
{
/*  while (lk_putchar);*/
    lk_putchar = true;
    sci_tx(((uchar *) (&SCI0BDH)), c);
    lk_putchar = false;
}
#endif

/*@-redef@*/
void bputs(char *pSrc)
/*@=redef@*/
{   
/*@-nullderef@*/ /*@-retvalint@*/ /*@-internalglobs@*/ /*@-modfilesys@*/
    while (lk_bputs);
    lk_bputs = true;
    do {
        putchar(*pSrc);
    } while ('\0' != *pSrc++);
    lk_bputs = false;
/*@=nullderef@*/ /*@=retvalint@*/ /*@=internalglobs@*/ /*@=modfilesys@*/
    
    return;
}

#ifdef INT2STRING

void int2string(char **ppDst, sshort number, uchar intbase)
{   
    ushort quotient, multiplier, i;

    switch (intbase) {  /* Should handle 16 bit ints. */
        case 10:    multiplier = 10000;     break;  /* For decimal numbers */
        case 0x10:  multiplier = 0x1000;    break;  /* For hex numbers */
        default:    multiplier = 0x8000;    break;  /* For oct+bin numbers */
    }
    if (0 == number) *(*ppDst)++ = '0'; /* Just print a '0' to the string... */
    else {  /* ...otherwise, deal with non-zero ints  */
        if (0 > number) {               /* Deal with negatives */
            *(*ppDst)++ = '-';
            number *= -1;
        }
        do {                            /* Deal with non-zero, positive int */
            if (number >= multiplier) { /* Find a base multiple for number */
                quotient = number/multiplier;   /* quotient will be printed, */
                number -= quotient*multiplier;  /* so update number accordingly */
                digit2char(**ppDst, quotient);
                (*ppDst)++;
                if (multiplier/intbase > number)    /* Detect if zeroes need to be */
                    for (i = multiplier/intbase; i > number; i /= intbase) /* printed, */
                        *(*ppDst)++ = '0';  /* otherwise they will be skipped */
            }
            multiplier /= intbase;          /* Update multiplier for next digit print */
        } while (multiplier > 0);
    }
    
    return;
}
#endif

#ifdef INT2STRINGPADDED

/*@-redef@*/
void int2stringpadded(char **ppDst, sshort number, uchar intbase, uchar padsize,
    bool numgroup, bool plussign)
/*@-redef@*/
/*@+charint@*/
{   
    ushort multiplier, i;
    uchar quotient, groupsize;
    uchar ndigit = (uchar)0;    /* ndigit: counts digit no. for grouping */

    /* Calc. groupsize, "thousand" comma grouping. Should handle 16 bit ints. */
    switch (intbase) {
        case 10:    
            groupsize = 3;  
            multiplier = 10000;     /* For decimal numbers */
        break;
        case 0x10:
            groupsize = 4;
            multiplier = 0x1000;    /* For hex numbers */
        break;
        default:    
            groupsize = 4;
            multiplier = 0x8000;    /* To get full 16bit range for oct+bin */
        break;
    }
    if (!numgroup) {
        groupsize = 127;    /* Cheap way of saying "no grouping" */
    }
    /* Deal with +/- signs. */
    if (0 > number) {
/*@-nullderef@*/
        *(*ppDst)++ = '-';
        number *= -1;               /* Int printing assumes positive numbers */
    } else if (0 == number) {
        if (0 != padsize) padsize--;
        *(*ppDst)++ = '0';
    } else if (plussign) {
        *(*ppDst)++ = '+';  /* Mandatory plussign if needed */
    }
    /* Calc. no. digits; necessary for "thousand" grouping commas. */
    for (i = number; 0 < i; i /= intbase) {
        ndigit++;
    }
    /* Do zero padding, with "thousand" grouping of those zeroes */
    for (i = padsize; i > ndigit; i--) {
            *(*ppDst)++ = '0';
        if ((0 == ((i - 1) % (groupsize))) && (1 != i)) {   /* != 1: no end comma */
            *(*ppDst)++ = ',';
        }
    }
    /* The main int printing loop.  */
    do {                            /* Deal with non-zero, positive int */
        if (number >= multiplier) { /* Find a base multiple for number */
            quotient = number/multiplier;   /* quotient will be printed, */
            number -= quotient*multiplier;  /* so update number accordingly */
            digit2char(**ppDst, quotient);  /* print the quotient to string */
            (*ppDst)++;
            ndigit--;
            if ((0 == (ndigit % groupsize)) && (0 != ndigit)) {
                *(*ppDst)++ = ',';  /* "thousand" comma grouping */
            }
            if (multiplier/intbase > number) {  /* Detect zero printing */
                for (i = multiplier/intbase; i > number; i /= intbase) {
                    *(*ppDst)++ = '0';  /* otherwise they will be skipped */
                    ndigit--;
                    if ((0 == (ndigit % groupsize)) && (0 != ndigit)) {
                        *(*ppDst)++ = ',';
                    }
/*@=nullderef@*/
                }
            }
        }
        multiplier /= intbase;      /* Update multiplier for next digit print */
    } while (multiplier > 0);
    
    return;
}
/*@=charint@*/
#endif

void bvsnprintf(char *pDst, ushort maxn, const char *pSrc, va_list ap)
/*@+charint@*/
{   
    char *pString = NULL;
    ushort ncopied = 0;
    sshort intvar = 0;
    uchar intbase = 0;
    uchar padzeroes = 0;
    bool plussign = false, numgroup = false;
    bool foundvar = false;
    
#ifdef BPRINTF_DEBUG
    printf("bprintf(): pDst(%p), maxn(%i), pSrc = \"%s\"\n", pDst, maxn, pSrc);
#endif
    do {
        if (*pSrc == '%') {
            foundvar = true;
        }
        if (foundvar) { /* If a '%' was hit, then interpret following chars. */
            switch (*(++pSrc)) {
                case '%':   /* '%%' == '%' */
                    *pDst++ = *pSrc++;
                    ncopied++;
                    foundvar = false;
                /*@switchbreak@*/break; 
                case 'i':   /* decimal int */
                    intbase = 10;
                /*@switchbreak@*/break;
                case 'X':   /* hex int */
                case 'x':
                case 'p':
                    intbase = 0x10;
                /*@switchbreak@*/break;
                case 'o':   /* octal int */
                    intbase = 010;
                /*@switchbreak@*/break;
                case 'B':   /* binary int */
                    intbase = 2;
                /*@switchbreak@*/break;
                case 'c':   /* character char */
                    *pDst++ = (char) va_arg(ap, int);
                    ncopied++;      /*after here,finished with vartype*/
                /*@switchbreak@*/break;
                case 's':   /* a string var is to be printed */
                    pString = va_arg(ap, char *);
                    ncopied += bstrncpy(pDst, pString, maxn - ncopied);
                /*@switchbreak@*/break;
                case '0':   /* Zero padding */
                    padzeroes = *(pSrc + 1) - '0';
                /*@switchbreak@*/break;
                case '+':
                    plussign = true;
                /*@switchbreak@*/break;
                case '\'':
                    numgroup = true;
                /*@switchbreak@*/break;
                default:
                /*@switchbreak@*/break;
            }
            if (0 < intbase) {
                intvar = (sshort) (va_arg(ap, int));
                pString = pDst;
/*@-nullstate@*/
#ifdef INT2STRINGPADDED
                int2stringpadded(&pDst, intvar, intbase, padzeroes, numgroup, plussign);
#else
#ifdef INT2STRING
                int2string(&pDst, intvar, intbase);
#endif
#endif
/*@=nullstate@*/
                pSrc++; /* Inc. past vartype char */
                ncopied += pDst - pString;
                intbase = 0;
                foundvar = false;
            }
        } else {
            *(pDst++) = *pSrc;
            if ('\0' != *pSrc) pSrc++;
            ncopied++;
        }
    } while ( ((ushort)ncopied < maxn) && ('\0' != *(pSrc)) );
/*@-nullderef@*/
    *pDst = '\0';
/*@=nullderef@*/
    
    return;
}
/*@=charint@*/

void bsnprintf(char *pDst, ushort maxn, const char *pSrc, ...)
{   
    va_list ap;
    
    va_start(ap, pSrc);
    bvsnprintf(pDst, maxn, pSrc, ap);
    va_end(ap);
    
    return;
}

void bprintf(ushort extra, const char *pString, ...)
{   
    char pWorking[80]; 
    va_list ap;
    
    va_start(ap, pString);
    bvsnprintf(pWorking, 80, pString, ap);
    va_end(ap);
    bputs(pWorking);
        
    return;
}

---