path: root/FreeRTOS-Plus/Source/Reliance-Edge/tests/util/printf.c

/*             ----> DO NOT REMOVE THE FOLLOWING NOTICE <----

                   Copyright (c) 2014-2015 Datalight, Inc.
                       All Rights Reserved Worldwide.

    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; use version 2 of the License.

    This program is distributed in the hope that it will be useful,
    but "AS-IS," 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.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
/*  Businesses and individuals that for commercial or other reasons cannot
    comply with the terms of the GPLv2 license may obtain a commercial license
    before incorporating Reliance Edge into proprietary software for
    distribution in any form.  Visit http://www.datalight.com/reliance-edge for
    more information.
*/
/** @file
    @brief Implements functions for printing.

    These functions are intended to be used in portable test code, which cannot
    assume the standard I/O functions will be available.  Similar to their ANSI
    C counterparts, these functions allow formatting text strings and (if the
    configuration allows it) outputing formatted text.  The latter ability
    relies on the RedOsOutputString() OS service function.

    Do *not* use these functions in code which can safely assume the standard
    I/O functions are available (e.g., in host tools code).

    Do *not* use these functions from within the file system driver.  These
    functions use variable arguments and thus are not MISRA-C:2012 compliant.
*/
#include <redfs.h>
#include <redtestutils.h>
#include <limits.h>
#include <stdarg.h>


/** @brief Maximum number of bytes of output supported by RedPrintf().

    Typically only Datalight code uses these functions, and that could should be
    written to respect this limit, so it should not normally be necessary to
    adjust this value.
*/
#define OUTPUT_BUFFER_SIZE 256U


typedef enum
{
    PRFMT_UNKNOWN = 0,
    PRFMT_CHAR,
    PRFMT_ANSISTRING,
    PRFMT_SIGNED8BIT,
    PRFMT_UNSIGNED8BIT,
    PRFMT_SIGNED16BIT,
    PRFMT_UNSIGNED16BIT,
    PRFMT_SIGNED32BIT,
    PRFMT_UNSIGNED32BIT,
    PRFMT_SIGNED64BIT,
    PRFMT_UNSIGNED64BIT,
    PRFMT_HEX8BIT,
    PRFMT_HEX16BIT,
    PRFMT_HEX32BIT,
    PRFMT_HEX64BIT,
    PRFMT_POINTER,
    PRFMT_DOUBLEPERCENT
} PRINTTYPE;

typedef struct
{
    PRINTTYPE       type;               /* The PRFMT_* type found */
    uint32_t        ulSpecifierIdx;     /* Returns a pointer to the % sign */
    uint32_t        ulFillLen;
    char            cFillChar;
    bool            fLeftJustified;
    bool            fHasIllegalType;    /* TRUE if an illegal sequence was skipped over */
    bool            fHasVarWidth;
} PRINTFORMAT;


/*  Our output handlers are written for standard fixed width data types.  Map
    the standard ANSI C data types onto our handlers.  Currently this code has
    the following requirements:

    1) shorts must be either 16 or 32 bits
    2) ints must be either 16 or 32 bits
    3) longs must be between 32 or 64 bits
    4) long longs must be 64 bits
*/
#if (USHRT_MAX == 0xFFFFU)
  #define MAPSHORT          PRFMT_SIGNED16BIT
  #define MAPUSHORT         PRFMT_UNSIGNED16BIT
  #define MAPHEXUSHORT      PRFMT_HEX16BIT
#elif (USHRT_MAX == 0xFFFFFFFFU)
  #define MAPSHORT          PRFMT_SIGNED32BIT
  #define MAPUSHORT         PRFMT_UNSIGNED32BIT
  #define MAPHEXUSHORT      PRFMT_HEX32BIT
#else
  #error "The 'short' data type does not have a 16 or 32-bit width"
#endif

#if (UINT_MAX == 0xFFFFU)
  #define MAPINT            PRFMT_SIGNED16BIT
  #define MAPUINT           PRFMT_UNSIGNED16BIT
  #define MAPHEXUINT        PRFMT_HEX16BIT
#elif (UINT_MAX == 0xFFFFFFFFU)
  #define MAPINT            PRFMT_SIGNED32BIT
  #define MAPUINT           PRFMT_UNSIGNED32BIT
  #define MAPHEXUINT        PRFMT_HEX32BIT
#else
  #error "The 'int' data type does not have a 16 or 32-bit width"
#endif

#if (ULONG_MAX == 0xFFFFFFFFU)
  #define MAPLONG           PRFMT_SIGNED32BIT
  #define MAPULONG          PRFMT_UNSIGNED32BIT
  #define MAPHEXULONG       PRFMT_HEX32BIT
#elif (ULONG_MAX <= UINT64_SUFFIX(0xFFFFFFFFFFFFFFFF))
  /*  We've run into unusual environments where "longs" are 40-bits wide.
      In this event, map them to 64-bit types so no data is lost.
  */
  #define MAPLONG         PRFMT_SIGNED64BIT
  #define MAPULONG        PRFMT_UNSIGNED64BIT
  #define MAPHEXULONG     PRFMT_HEX64BIT
#else
  #error "The 'long' data type is not between 32 and 64 bits wide"
#endif

#if defined(ULLONG_MAX) && (ULLONG_MAX != UINT64_SUFFIX(0xFFFFFFFFFFFFFFFF))
  #error "The 'long long' data type is not 64 bits wide"
#else
  #define MAPLONGLONG       PRFMT_SIGNED64BIT
  #define MAPULONGLONG      PRFMT_UNSIGNED64BIT
  #define MAPHEXULONGLONG   PRFMT_HEX64BIT
#endif


static uint32_t ProcessFormatSegment(char *pcBuffer, uint32_t ulBufferLen, const char *pszFormat, PRINTFORMAT *pFormat, uint32_t *pulSpecifierLen);
static uint32_t ParseFormatSpecifier(char const *pszFormat, PRINTFORMAT *pFormatType);
static PRINTTYPE ParseFormatType(const char *pszFormat, uint32_t *pulTypeLen);
static uint32_t LtoA(char *pcBuffer, uint32_t ulBufferLen, int32_t lNum, uint32_t ulFillLen, char cFill);
static uint32_t LLtoA(char *pcBuffer, uint32_t ulBufferLen, int64_t llNum, uint32_t ulFillLen, char cFill);
static uint32_t ULtoA(char *pcBuffer, uint32_t ulBufferLen, uint32_t ulNum, bool fHex, uint32_t ulFillLen, char cFill);
static uint32_t ULLtoA(char *pcBuffer, uint32_t ulBufferLen, uint64_t ullNum, bool fHex, uint32_t ulFillLen, char cFill);
static uint32_t FinishToA(const char *pcDigits, uint32_t ulDigits, char *pcOutBuffer, uint32_t ulBufferLen, uint32_t ulFillLen, char cFill);


/*  Digits for the *LtoA() routines.
*/
static const char gacDigits[] = "0123456789ABCDEF";


#if REDCONF_OUTPUT == 1
/** @brief Print formatted data with a variable length argument list.

    This function provides a subset of the ANSI C printf() functionality with
    several extensions to support fixed size data types.

    See RedVSNPrintf() for the list of supported types.

    @param pszFormat    A pointer to the null-terminated format string.
    @param ...          The variable length argument list.
*/
void RedPrintf(
    const char *pszFormat,
    ...)
{
    va_list     arglist;

    va_start(arglist, pszFormat);

    RedVPrintf(pszFormat, arglist);

    va_end(arglist);
}


/** @brief Print formatted data using a pointer to a variable length argument
           list.

    This function provides a subset of the ANSI C vprintf() functionality.

    See RedVSNPrintf() for the list of supported types.

    This function accommodates a maximum output length of #OUTPUT_BUFFER_SIZE.
    If this function must truncate the output, and the original string was
    \n terminated, the truncated output will be \n terminated as well.

    @param pszFormat    A pointer to the null-terminated format string.
    @param arglist      The variable length argument list.
*/
void RedVPrintf(
    const char *pszFormat,
    va_list     arglist)
{
    char        achBuffer[OUTPUT_BUFFER_SIZE];

    if(RedVSNPrintf(achBuffer, sizeof(achBuffer), pszFormat, arglist) == -1)
    {
        /*  Ensture the buffer is null terminated.
        */
        achBuffer[sizeof(achBuffer) - 1U] = '\0';

        /*  If the original string was \n terminated and the new one is not, due to
            truncation, stuff a \n into the new one.
        */
        if(pszFormat[RedStrLen(pszFormat) - 1U] == '\n')
        {
            achBuffer[sizeof(achBuffer) - 2U] = '\n';
        }
    }

    RedOsOutputString(achBuffer);
}
#endif /* #if REDCONF_OUTPUT == 1 */


/** @brief Format arguments into a string using a subset of the ANSI C
           vsprintf() functionality.

    This function is modeled after the Microsoft _snprint() extension to the
    ANSI C sprintf() function, and allows a buffer length to be specified so
    that overflow is avoided.

    See RedVSNPrintf() for the list of supported types.

    @param pcBuffer     A pointer to the output buffer
    @param ulBufferLen  The output buffer length
    @param pszFormat    A pointer to the null terminated format string
    @param ...          Variable argument list

    @return The length output, or -1 if the buffer filled up.  If -1 is
            returned, the output buffer may not be null-terminated.
*/
int32_t RedSNPrintf(
    char       *pcBuffer,
    uint32_t    ulBufferLen,
    const char *pszFormat,
    ...)
{
    int32_t     iLen;
    va_list     arglist;

    va_start(arglist, pszFormat);

    iLen = RedVSNPrintf(pcBuffer, ulBufferLen, pszFormat, arglist);

    va_end(arglist);

    return iLen;
}


/** @brief Format arguments into a string using a subset of the ANSI C
           vsprintf() functionality.

    This function is modeled after the Microsoft _vsnprint() extension to the
    ANSI C vsprintf() function, and requires a buffer length to be specified so
    that overflow is avoided.

    The following ANSI C standard formatting codes are supported:

    | Code | Meaning                            |
    | ---- | ---------------------------------- |
    | %c   | Format a character                 |
    | %s   | Format a null-terminated C string  |
    | %hd  | Format a signed short              |
    | %hu  | Format an unsigned short           |
    | %d   | Format a signed integer            |
    | %u   | Format an unsigned integer         |
    | %ld  | Format a signed long               |
    | %lu  | Format an unsigned long            |
    | %lld | Format a signed long long          |
    | %llu | Format an unsigned long long       |
    | %hx  | Format a short in hex              |
    | %x   | Format an integer in hex           |
    | %lx  | Format a long in hex               |
    | %llx | Format a long long in hex          |
    | %p   | Format a pointer (hex value)       |

    @note All formatting codes are case-sensitive.

    Fill characters and field widths are supported per the ANSI standard, as is
    left justification with the '-' character.

    The only supported fill characters are '0', ' ', and '_'.

    '*' is supported to specify variable length field widths.

    Hexidecimal numbers are always displayed in upper case.  Formatting codes
    which specifically request upper case (e.g., "%lX") are not supported.

    Unsupported behaviors:
      - Precision is not supported.
      - Floating point is not supported.

    Errata:
    - There is a subtle difference in the return value for this function versus
      the Microsoft implementation.  In the Microsoft version, if the buffer
      exactly fills up, but there is no room for a null-terminator, the return
      value will be the length of the buffer.  In this code, -1 will be returned
      when this happens.
    - When using left justified strings, the only supported fill character is a
      space, regardless of what may be specified.  It is not clear if this is
      ANSI standard or just the way the Microsoft function works, but we emulate
      the Microsoft behavior.

    @param pcBuffer     A pointer to the output buffer.
    @param ulBufferLen  The output buffer length.
    @param pszFormat    A pointer to the null terminated ANSI format string.
    @param arglist      Variable argument list.

    @return  The length output, or -1 if the buffer filled up.  If -1 is
             returned, the output buffer may not be null-terminated.
*/
int32_t RedVSNPrintf(
    char       *pcBuffer,
    uint32_t    ulBufferLen,
    const char *pszFormat,
    va_list     arglist)
{
    uint32_t    ulBufIdx = 0U;
    uint32_t    ulFmtIdx = 0U;
    int32_t     iLen;

    while((pszFormat[ulFmtIdx] != '\0') && (ulBufIdx < ulBufferLen))
    {
        PRINTFORMAT fmt;
        uint32_t    ulSpecifierLen;
        uint32_t    ulWidth;

        /*  Process the next segment of the format string, outputting
            any non-format specifiers, as output buffer space allows,
            and return information about the next format specifier.
        */
        ulWidth = ProcessFormatSegment(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, &pszFormat[ulFmtIdx], &fmt, &ulSpecifierLen);
        if(ulWidth)
        {
            REDASSERT(ulWidth <= (ulBufferLen - ulBufIdx));

            ulBufIdx += ulWidth;
        }

        /*  If no specifier was found, or if the output buffer is
            full, we're done -- get out.
        */
        if((ulSpecifierLen == 0U) || (ulBufIdx == ulBufferLen))
        {
            break;
        }

        /*  Otherwise, the math should add up for these things...
        */
        REDASSERT(&pszFormat[fmt.ulSpecifierIdx] == &pszFormat[ulWidth]);

        /*  Point past the specifier, to the next piece of the format string.
        */
        ulFmtIdx = ulFmtIdx + fmt.ulSpecifierIdx + ulSpecifierLen;

        if(fmt.fHasVarWidth)
        {
            int iFillLen = va_arg(arglist, int);

            if(iFillLen >= 0)
            {
                fmt.ulFillLen = (uint32_t)iFillLen;
            }
            else
            {
                /*  Bogus fill length.  Ignore.
                */
                fmt.ulFillLen = 0U;
            }
        }

        switch(fmt.type)
        {
            case PRFMT_DOUBLEPERCENT:
            {
                /*  Nothing to do.  A single percent has already been output,
                    and we just finished skipping past the second percent.
                */
                break;
            }

            /*----------------->  Small int handling  <------------------
             *
             *  Values smaller than "int" will be promoted to "int" by
             *  the compiler, so we must retrieve them using "int" when
             *  calling va_arg().  Once we've done that, we immediately
             *  put the value into the desired data type.
             *---------------------------------------------------------*/

            case PRFMT_CHAR:
            {
                pcBuffer[ulBufIdx] = (char)va_arg(arglist, int);
                ulBufIdx++;
                break;
            }
            case PRFMT_SIGNED8BIT:
            {
                int8_t num = (int8_t)va_arg(arglist, int);

                ulBufIdx += LtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, num, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_UNSIGNED8BIT:
            {
                uint8_t bNum = (uint8_t)va_arg(arglist, unsigned);

                ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, bNum, false, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_HEX8BIT:
            {
                uint8_t bNum = (uint8_t)va_arg(arglist, unsigned);

                ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, bNum, true, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_SIGNED16BIT:
            {
                int16_t num = (int16_t)va_arg(arglist, int);

                ulBufIdx += LtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, num, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_UNSIGNED16BIT:
            {
                uint16_t uNum = (uint16_t)va_arg(arglist, unsigned);

                ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, uNum, false, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_HEX16BIT:
            {
                uint16_t uNum = (uint16_t)va_arg(arglist, unsigned);

                ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, uNum, true, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_SIGNED32BIT:
            {
                int32_t lNum = va_arg(arglist, int32_t);

                ulBufIdx += LtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, lNum, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_UNSIGNED32BIT:
            {
                uint32_t ulNum = va_arg(arglist, uint32_t);

                ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, ulNum, false, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_HEX32BIT:
            {
                uint32_t ulNum = va_arg(arglist, uint32_t);

                ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, ulNum, true, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_SIGNED64BIT:
            {
                int64_t llNum = va_arg(arglist, int64_t);

                ulBufIdx += LLtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, llNum, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_UNSIGNED64BIT:
            {
                uint64_t ullNum = va_arg(arglist, uint64_t);

                ulBufIdx += ULLtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, ullNum, false, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_HEX64BIT:
            {
                uint64_t ullNum = va_arg(arglist, uint64_t);

                ulBufIdx += ULLtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, ullNum, true, fmt.ulFillLen, fmt.cFillChar);
                break;
            }
            case PRFMT_POINTER:
            {
                const void *ptr = va_arg(arglist, const void *);

                /*  Assert our assumption.
                */
                REDASSERT(sizeof(void *) <= 8U);

                /*  Format as either a 64-bit or a 32-bit value.
                */
                if(sizeof(void *) > 4U)
                {
                    /*  Attempt to quiet warnings.
                    */
                    uintptr_t   ptrval = (uintptr_t)ptr;
                    uint64_t    ullPtrVal = (uint64_t)ptrval;

                    ulBufIdx += ULLtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, ullPtrVal, true, fmt.ulFillLen, fmt.cFillChar);
                }
                else
                {
                    /*  Attempt to quiet warnings.
                    */
                    uintptr_t   ptrval = (uintptr_t)ptr;
                    uint32_t    ulPtrVal = (uint32_t)ptrval;

                    ulBufIdx += ULtoA(&pcBuffer[ulBufIdx], ulBufferLen - ulBufIdx, ulPtrVal, true, fmt.ulFillLen, fmt.cFillChar);
                }

                break;
            }
            case PRFMT_ANSISTRING:
            {
                const char *pszArg = va_arg(arglist, const char *);
                uint32_t    ulArgIdx = 0U;

                if(pszArg == NULL)
                {
                    pszArg = "null";
                }

                if(fmt.ulFillLen > 0U)
                {
                    if(!fmt.fLeftJustified)
                    {
                        uint32_t ulLen = RedStrLen(pszArg);

                        /*  So long as we are not left justifying, fill as many
                            characters as is necessary to make the string right
                            justified.
                        */
                        while(((ulBufferLen - ulBufIdx) > 0U) && (fmt.ulFillLen > ulLen))
                        {
                            pcBuffer[ulBufIdx] = fmt.cFillChar;
                            ulBufIdx++;
                            fmt.ulFillLen--;
                        }
                    }

                    /*  Move as many characters as we have space for into the
                        output buffer.
                    */
                    while(((ulBufferLen - ulBufIdx) > 0U) && (pszArg[ulArgIdx] != '\0'))
                    {
                        pcBuffer[ulBufIdx] = pszArg[ulArgIdx];
                        ulBufIdx++;
                        ulArgIdx++;
                        if(fmt.ulFillLen > 0U)
                        {
                            fmt.ulFillLen--;
                        }
                    }

                    /*  If there is any space left to fill, do it (the string
                        must have been left justified).
                    */
                    while(((ulBufferLen - ulBufIdx) > 0U) && (fmt.ulFillLen > 0U))
                    {
                        /*  This is NOT a typo -- when using left justified
                            strings, spaces are the only allowed fill character.
                            See the errata.
                        */
                        pcBuffer[ulBufIdx] = ' ';
                        ulBufIdx++;
                        fmt.ulFillLen--;
                    }
                }
                else
                {
                    /*  No fill characters, just move up to as many
                        characters as we have space for in the output
                        buffer.
                    */
                    while(((ulBufferLen - ulBufIdx) > 0U) && (pszArg[ulArgIdx] != '\0'))
                    {
                        pcBuffer[ulBufIdx] = pszArg[ulArgIdx];
                        ulBufIdx++;
                        ulArgIdx++;
                    }
                }
                break;
            }
            default:
            {
                REDERROR();
                break;
            }
        }
    }

    /*  If there is space, tack on a null and return the output length
        processed, not including the null.
    */
    if(ulBufIdx < ulBufferLen)
    {
        pcBuffer[ulBufIdx] = '\0';
        iLen = (int32_t)ulBufIdx;
    }
    else
    {
        /*  Not enough space, just return -1, with no null termination
        */
        iLen = -1;
    }

    return iLen;
}


/** @brief  Process the next segment of the format string, outputting any
            non-format specifiers, as output buffer space allows, and return
            information about the next format specifier.

    @note   If the returned value is the same as the supplied @p ulBufferLen,
            the output buffer will not be null-terminated.  In all other cases,
            the result will be null-terminated.  The returned length will never
            include the null in the count.

    @param pcBuffer         The output buffer.
    @param ulBufferLen      The output buffer length.
    @param pszFormat        The format string to process.
    @param pFormat          The PRINTFORMAT structure to fill.
    @param pulSpecifierLen  Returns the length of any format specifier string,
                            or zero if no specifier was found.

    @return The count of characters from pszFormatt which were processed and
            copied to pcBuffer.
        - If zero is returned and *pulSpecifierLen is non-zero, then
          a format specifier string was found at the start of pszFmt.
        - If non-zero is returned and *pulSpecifierLen is zero, then
          no format specifier string was found, and the entire pszFmt
          string was copied to pBuffer (or as much as will fit).
*/
static uint32_t ProcessFormatSegment(
    char           *pcBuffer,
    uint32_t        ulBufferLen,
    const char     *pszFormat,
    PRINTFORMAT    *pFormat,
    uint32_t       *pulSpecifierLen)
{
    uint32_t        ulWidth = 0U;

    /*  Find the next format specifier string, and information about it.
    */
    *pulSpecifierLen = ParseFormatSpecifier(pszFormat, pFormat);

    if(*pulSpecifierLen == 0U)
    {
        /*  If no specifier was found at all, then simply output the full length
            of the string, or as much as will fit.
         */
        ulWidth = REDMIN(ulBufferLen, RedStrLen(pszFormat));

        RedMemCpy(pcBuffer, pszFormat, ulWidth);
    }
    else
    {
        /*  If we encountered a double percent, skip past one of them so it is
            copied into the output buffer.
        */
        if(pFormat->type == PRFMT_DOUBLEPERCENT)
        {
            pFormat->ulSpecifierIdx++;

            /*  A double percent specifier always has a length of two.  Since
                we're processing one of those percent signs, reduce the length
                to one.  Assert it so.
            */
            REDASSERT(*pulSpecifierLen == 2U);

            (*pulSpecifierLen)--;
        }

        /*  So long as the specifier is not the very first thing in the format
            string...
        */
        if(pFormat->ulSpecifierIdx != 0U)
        {
            /*  A specifier was found, but there is other data preceding it.
                Copy as much as allowed to the output buffer.
            */
            ulWidth = REDMIN(ulBufferLen, pFormat->ulSpecifierIdx);

            RedMemCpy(pcBuffer, pszFormat, ulWidth);
        }
    }

    /*  If there is room in the output buffer, null-terminate whatever is there.
        But note that the returned length never includes the null.
    */
    if(ulWidth < ulBufferLen)
    {
        pcBuffer[ulWidth] = 0U;
    }

    return ulWidth;
}


/** @brief Parse the specified format string for a valid RedVSNPrintf() format
           sequence, and return information about it.

    @param pszFormat    The format string to process.
    @param pFormatType  The PRINTFORMAT structure to fill.  The data is only
                        valid if a non-zero length is returned.

    @return The length of the full format specifier string, starting at
            pFormat->ulSpecifierIdx.  Returns zero if a valid specifier was
            not found.
*/
static uint32_t ParseFormatSpecifier(
    char const     *pszFormat,
    PRINTFORMAT    *pFormatType)
{
    bool            fContainsIllegalSequence = false;
    uint32_t        ulLen = 0U;
    uint32_t        ulIdx = 0U;

    while(pszFormat[ulIdx] != '\0')
    {
        uint32_t    ulTypeLen;

        /*  general output
        */
        if(pszFormat[ulIdx] != '%')
        {
            ulIdx++;
        }
        else
        {
            RedMemSet(pFormatType, 0U, sizeof(*pFormatType));

            /*  Record the location of the start of the format sequence
            */
            pFormatType->ulSpecifierIdx = ulIdx;
            ulIdx++;

            if(pszFormat[ulIdx] == '-')
            {
                pFormatType->fLeftJustified = true;
                ulIdx++;
            }

            if((pszFormat[ulIdx] == '0') || (pszFormat[ulIdx] == '_'))
            {
                pFormatType->cFillChar = pszFormat[ulIdx];
                ulIdx++;
            }
            else
            {
                pFormatType->cFillChar = ' ';
            }

            if(pszFormat[ulIdx] == '*')
            {
                pFormatType->fHasVarWidth = true;
                ulIdx++;
            }
            else if(ISDIGIT(pszFormat[ulIdx]))
            {
                pFormatType->ulFillLen = (uint32_t)RedAtoI(&pszFormat[ulIdx]);
                while(ISDIGIT(pszFormat[ulIdx]))
                {
                    ulIdx++;
                }
            }
            else
            {
                /*  No fill length.
                */
            }

            pFormatType->type = ParseFormatType(&pszFormat[ulIdx], &ulTypeLen);
            if(pFormatType->type != PRFMT_UNKNOWN)
            {
                /*  Even though we are returning successfully, keep track of
                    whether an illegal sequence was encountered and skipped.
                */
                pFormatType->fHasIllegalType = fContainsIllegalSequence;

                ulLen = (ulIdx - pFormatType->ulSpecifierIdx) + ulTypeLen;
                break;
            }

            /*  In the case of an unrecognized type string, simply ignore
                it entirely.  Reset the pointer to the position following
                the percent sign, so it is not found again.
            */
            fContainsIllegalSequence = false;
            ulIdx = pFormatType->ulSpecifierIdx + 1U;
        }
    }

    return ulLen;
}


/** @brief Parse a RedPrintf() format type string to determine the proper data
           type.

    @param pszFormat    The format string to process.  This must be a pointer to
                        the character following any width or justification
                        characters.
    @param pulTypeLen   The location in which to store the type length.  The
                        value will be 0 if PRFMT_UNKNOWN is returned.

    @return Rhe PRFMT_* type value, or PRFMT_UNKNOWN if the type is not
            recognized.
*/
static PRINTTYPE ParseFormatType(
    const char     *pszFormat,
    uint32_t       *pulTypeLen)
{
    PRINTTYPE       fmtType = PRFMT_UNKNOWN;
    uint32_t        ulIdx = 0U;

    switch(pszFormat[ulIdx])
    {
        case '%':
            fmtType = PRFMT_DOUBLEPERCENT;
            break;
        case 'c':
            fmtType = PRFMT_CHAR;
            break;
        case 's':
            fmtType = PRFMT_ANSISTRING;
            break;
        case 'p':
            fmtType = PRFMT_POINTER;
            break;
        case 'd':
            fmtType = MAPINT;
            break;
        case 'u':
            fmtType = MAPUINT;
            break;
        case 'x':
            fmtType = MAPHEXUINT;
            break;
        case 'h':
        {
            ulIdx++;
            switch(pszFormat[ulIdx])
            {
                case 'd':
                    fmtType = MAPSHORT;
                    break;
                case 'u':
                    fmtType = MAPUSHORT;
                    break;
                case 'x':
                    fmtType = MAPHEXUSHORT;
                    break;
                default:
                    break;
            }
            break;
        }
        case 'l':
        {
            ulIdx++;
            switch(pszFormat[ulIdx])
            {
                case 'd':
                    fmtType = MAPLONG;
                    break;
                case 'u':
                    fmtType = MAPULONG;
                    break;
                case 'x':
                    fmtType = MAPHEXULONG;
                    break;
                case 'l':
                {
                    ulIdx++;
                    switch(pszFormat[ulIdx])
                    {
                        case 'd':
                            fmtType = MAPLONGLONG;
                            break;
                        case 'u':
                            fmtType = MAPULONGLONG;
                            break;
                        case 'x':
                        case 'X':
                            fmtType = MAPHEXULONGLONG;
                            break;
                        default:
                            break;
                    }
                    break;
                }
                default:
                    break;
            }
            break;
        }
        default:
            break;
    }

    if(fmtType != PRFMT_UNKNOWN)
    {
        *pulTypeLen = ulIdx + 1U;
    }
    else
    {
        *pulTypeLen = 0U;
    }

    return fmtType;
}


/** @brief Format a signed 32-bit integer as a base 10 ASCII string.

    @note   If the output buffer length is exhausted, the result will *not* be
            null-terminated.

    @note   If the @p ulFillLen value is greater than or equal to the buffer
            length, the result will not be null-terminated, even if the
            formatted portion of the data is shorter than the buffer length.

    @param pcBuffer     The output buffer
    @param ulBufferLen  A pointer to the output buffer length
    @param lNum         The 32-bit signed number to convert
    @param ulFillLen    The fill length, if any
    @param cFill        The fill character to use

    @return The length of the string.
*/
static uint32_t LtoA(
    char       *pcBuffer,
    uint32_t    ulBufferLen,
    int32_t     lNum,
    uint32_t    ulFillLen,
    char        cFill)
{
    uint32_t    ulLen;

    if(pcBuffer == NULL)
    {
        REDERROR();
        ulLen = 0U;
    }
    else
    {
        char                ach[12U]; /* big enough for a int32_t in base 10 */
        uint32_t            ulDigits = 0U;
        uint32_t            ulNum;
        bool                fSign;

        if(lNum < 0)
        {
            fSign = true;
            ulNum = (uint32_t)-lNum;
        }
        else
        {
            fSign = false;
            ulNum = (uint32_t)lNum;
        }

        do
        {
            ach[ulDigits] = gacDigits[ulNum % 10U];
            ulNum = ulNum / 10U;
            ulDigits++;
        }
        while(ulNum);

        if(fSign)
        {
            ach[ulDigits] = '-';
            ulDigits++;
        }

        ulLen = FinishToA(ach, ulDigits, pcBuffer, ulBufferLen, ulFillLen, cFill);
    }

    return ulLen;
}


/** @brief Format a signed 64-bit integer as a base 10 ASCII string.

    @note   If the output buffer length is exhausted, the result will *not* be
            null-terminated.

    @note   If the @p ulFillLen value is greater than or equal to the buffer
            length, the result will not be null-terminated, even if the
            formatted portion of the data is shorter than the buffer length.

    @param pcBuffer     The output buffer
    @param ulBufferLen  A pointer to the output buffer length
    @param llNum        The 64-bit signed number to convert
    @param ulFillLen    The fill length, if any
    @param cFill        The fill character to use

    @return The length of the string.
*/
static uint32_t LLtoA(
    char       *pcBuffer,
    uint32_t    ulBufferLen,
    int64_t     llNum,
    uint32_t    ulFillLen,
    char        cFill)
{
    uint32_t    ulLen;

    if(pcBuffer == NULL)
    {
        REDERROR();
        ulLen = 0U;
    }
    else
    {
        char                ach[12U]; /* big enough for a int32_t in base 10 */
        uint32_t            ulDigits = 0U;
        uint64_t            ullNum;
        bool                fSign;

        if(llNum < 0)
        {
            fSign = true;
            ullNum = (uint64_t)-llNum;
        }
        else
        {
            fSign = false;
            ullNum = (uint64_t)llNum;
        }

        /*  Not allowed to assume that 64-bit division is OK, so use a
            software division routine.
        */
        do
        {
            uint64_t ullQuotient;
            uint32_t ulRemainder;

            /*  Note: RedUint64DivMod32() is smart enough to use normal division
                once ullNumericVal <= UINT32_MAX.
            */
            ullQuotient = RedUint64DivMod32(ullNum, 10U, &ulRemainder);

            ach[ulDigits] = gacDigits[ulRemainder];
            ullNum = ullQuotient;
            ulDigits++;
        }
        while(ullNum > 0U);

        if(fSign)
        {
            ach[ulDigits] = '-';
            ulDigits++;
        }

        ulLen = FinishToA(ach, ulDigits, pcBuffer, ulBufferLen, ulFillLen, cFill);
    }

    return ulLen;
}


/** @brief Format an unsigned 32-bit integer as an ASCII string as decimal or
           hex.

    @note If the output buffer length is exhausted, the result will *not* be
          null-terminated.

    @param pcBuffer     The output buffer
    @param ulBufferLen  The output buffer length
    @param ulNum        The 32-bit unsigned number to convert
    @param fHex         If true, format as hex; if false, decimal.
    @param ulFillLen    The fill length, if any
    @param cFill        The fill character to use

    @return The length of the string.
*/
static uint32_t ULtoA(
    char       *pcBuffer,
    uint32_t    ulBufferLen,
    uint32_t    ulNum,
    bool        fHex,
    uint32_t    ulFillLen,
    char        cFill)
{
    uint32_t    ulLen;

    if(pcBuffer == NULL)
    {
        REDERROR();
        ulLen = 0U;
    }
    else
    {
        char        ach[11U];   /* Big enough for a uint32_t in radix 10 */
        uint32_t    ulDigits = 0U;
        uint32_t    ulNumericVal = ulNum;
        uint32_t    ulRadix = fHex ? 16U : 10U;

        do
        {
            ach[ulDigits] = gacDigits[ulNumericVal % ulRadix];
            ulNumericVal = ulNumericVal / ulRadix;
            ulDigits++;
        }
        while(ulNumericVal > 0U);

        ulLen = FinishToA(ach, ulDigits, pcBuffer, ulBufferLen, ulFillLen, cFill);
    }

    return ulLen;
}


/** @brief Format an unsigned 64-bit integer as an ASCII string as decimal or
           hex.

    @note If the output buffer length is exhausted, the result will *not* be
          null-terminated.

    @param pcBuffer     The output buffer.
    @param ulBufferLen  The output buffer length.
    @param ullNum       The unsigned 64-bit number to convert.
    @param fHex         If true, format as hex; if false, decimal.
    @param ulFillLen    The fill length, if any.
    @param cFill        The fill character to use.

    @return The length of the string.
*/
static uint32_t ULLtoA(
    char       *pcBuffer,
    uint32_t    ulBufferLen,
    uint64_t    ullNum,
    bool        fHex,
    uint32_t    ulFillLen,
    char        cFill)
{
    uint32_t    ulLen;

    if(pcBuffer == NULL)
    {
        REDERROR();
        ulLen = 0U;
    }
    else
    {

        char        ach[21U];   /* Big enough for a uint64_t in radix 10 */
        uint32_t    ulDigits = 0U;
        uint64_t    ullNumericVal = ullNum;

        if(fHex)
        {
            /*  We can figure out the digits using bit operations.
            */
            do
            {
                ach[ulDigits] = gacDigits[ullNumericVal & 15U];
                ullNumericVal >>= 4U;
                ulDigits++;
            }
            while(ullNumericVal > 0U);
        }
        else
        {
            /*  Not allowed to assume that 64-bit division is OK, so use a
                software division routine.
            */
            do
            {
                uint64_t ullQuotient;
                uint32_t ulRemainder;

                /*  Note: RedUint64DivMod32() is smart enough to use normal division
                    once ullNumericVal <= UINT32_MAX.
                */
                ullQuotient = RedUint64DivMod32(ullNumericVal, 10U, &ulRemainder);

                ach[ulDigits] = gacDigits[ulRemainder];
                ullNumericVal = ullQuotient;
                ulDigits++;
            }
            while(ullNumericVal > 0U);
        }

        ulLen = FinishToA(ach, ulDigits, pcBuffer, ulBufferLen, ulFillLen, cFill);
    }

    return ulLen;
}


/** @brief Finish converting a number into an ASCII string representing that
           number.

    This helper function contains common logic that needs to run at the end of
    all the "toA" functions.  It adds the fill character and reverses the digits
    string.

    @param pcDigits     The digits (and sign) for the ASCII string, in reverse
                        order as they were computed.
    @param ulDigits     The number of digit characters.
    @param pcOutBuffer  The output buffer.
    @param ulBufferLen  The length of the output buffer.
    @param ulFillLen    The fill length.  If the number string is shorter than
                        this, the remaining bytes are filled with @p cFill.
    @param cFill        The fill character.

    @return The length of @p pcOutBuffer.
*/
static uint32_t FinishToA(
    const char *pcDigits,
    uint32_t    ulDigits,
    char       *pcOutBuffer,
    uint32_t    ulBufferLen,
    uint32_t    ulFillLen,
    char        cFill)
{
    uint32_t    ulIdx = 0U;
    uint32_t    ulDigitIdx = ulDigits;

    /*  user may have asked for a fill char
    */
    if(ulFillLen > ulDigits)
    {
        uint32_t ulFillRem = ulFillLen - ulDigits;

        while((ulFillRem > 0U) && (ulIdx < ulBufferLen))
        {
            pcOutBuffer[ulIdx] = cFill;
            ulIdx++;
            ulFillRem--;
        }
    }

    /*  reverse the string
    */
    while((ulDigitIdx > 0) && (ulIdx < ulBufferLen))
    {
        ulDigitIdx--;
        pcOutBuffer[ulIdx] = pcDigits[ulDigitIdx];
        ulIdx++;
    }

    if(ulIdx < ulBufferLen)
    {
        pcOutBuffer[ulIdx] = '\0';
    }

    return ulIdx;
}