//-----------------------------------------------------------------------------
// File:        FormattedPrint.cpp
//
//
// Contents:    Contains functions for handling Windows format strings
//              and UTF-16 on non-Windows platforms
//
// Microsoft Drivers 5.10 for PHP for SQL Server
// Copyright(c) Microsoft Corporation
// All rights reserved.
// 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.
//---------------------------------------------------------------------------------------------------------------------------------

#include <FormattedPrint.h>
#include <errno.h>

#include <iconv.h>

#include "StringFunctions.h"

// XPLAT_ODBC_TODO VSTS 819733 - MPlat: Reconcile std c++ usage between platforms
#include <vector>
#include <algorithm>
#include "sal_def.h"

#define PTR_IS_INT64 1

// SQL Server does not have a long double type
#define LONGDOUBLE_IS_DOUBLE 1
typedef double _LONGDOUBLE;

// XPLAT_ODBC_TODO VSTS VSTS 718708 Localization
#define _SAFECRT_IMPL

#if !defined(_countof)
#define _countof(_Array) (sizeof(_Array) / sizeof(_Array[0]))
#endif // _countof

#ifndef _VALIDATE_RETURN
#define _VALIDATE_RETURN( expr, errorcode, retexpr )                           \
    {                                                                          \
        int _Expr_val=!!(expr);                                                \
        if ( !( _Expr_val ) )                                                  \
        {                                                                      \
            assert(false);                                                     \
            errno = errorcode;                                                 \
            return ( retexpr );                                                \
        }                                                                      \
    }
#endif  /* _VALIDATE_RETURN */


static const char *__nullstring = "(null)";  /* string to print on null ptr */
static const wchar_t *__wnullstring = L"(null)";/* string to print on null ptr */

#define BUFFERSIZE    512
#define MAXPRECISION  BUFFERSIZE
#define _CVTBUFSIZE (309+40) /* # of digits in max. dp value + slop */


/* flag definitions */
#define FL_SIGN       0x00001   /* put plus or minus in front */
#define FL_SIGNSP     0x00002   /* put space or minus in front */
#define FL_LEFT       0x00004   /* left justify */
#define FL_LEADZERO   0x00008   /* pad with leading zeros */
#define FL_LONG       0x00010   /* long value given */
#define FL_SHORT      0x00020   /* short value given */
#define FL_SIGNED     0x00040   /* signed data given */
#define FL_ALTERNATE  0x00080   /* alternate form requested */
#define FL_NEGATIVE   0x00100   /* value is negative */
#define FL_FORCEOCTAL 0x00200   /* force leading '0' for octals */
#define FL_LONGDOUBLE 0x00400   /* long double value given */
#define FL_WIDECHAR   0x00800   /* wide characters */
#define FL_LONGLONG   0x01000   /* long long value given */
#define FL_I64        0x08000   /* __int64 value given */


/* state definitions */
enum STATE {
    ST_NORMAL,          /* normal state; outputting literal chars */
    ST_PERCENT,         /* just read '%' */
    ST_FLAG,            /* just read flag character */
    ST_WIDTH,           /* just read width specifier */
    ST_DOT,             /* just read '.' */
    ST_PRECIS,          /* just read precision specifier */
    ST_SIZE,            /* just read size specifier */
    ST_TYPE             /* just read type specifier */
    ,ST_INVALID           /* Invalid format */

};

#define NUMSTATES (ST_INVALID + 1)

/* character type values */
enum CHARTYPE {
    CH_OTHER,           /* character with no special meaning */
    CH_PERCENT,         /* '%' */
    CH_DOT,             /* '.' */
    CH_STAR,            /* '*' */
    CH_ZERO,            /* '0' */
    CH_DIGIT,           /* '1'..'9' */
    CH_FLAG,            /* ' ', '+', '-', '#' */
    CH_SIZE,            /* 'h', 'l', 'L', 'N', 'F', 'w' */
    CH_TYPE             /* type specifying character */
};


static const unsigned char __lookuptable_s[] = {
 /* ' ' */  0x06,
 /* '!' */  0x80,
 /* '"' */  0x80,
 /* '#' */  0x86,
 /* '$' */  0x80,
 /* '%' */  0x81,
 /* '&' */  0x80,
 /* ''' */  0x00,
 /* '(' */  0x00,
 /* ')' */  0x10,
 /* '*' */  0x03,
 /* '+' */  0x86,
 /* ',' */  0x80,
 /* '-' */  0x86,
 /* '.' */  0x82,
 /* '/' */  0x80,
 /* '0' */  0x14,
 /* '1' */  0x05,
 /* '2' */  0x05,
 /* '3' */  0x45,
 /* '4' */  0x45,
 /* '5' */  0x45,
 /* '6' */  0x85,
 /* '7' */  0x85,
 /* '8' */  0x85,
 /* '9' */  0x05,
 /* ':' */  0x00,
 /* ';' */  0x00,
 /* '<' */  0x30,
 /* '=' */  0x30,
 /* '>' */  0x80,
 /* '?' */  0x50,
 /* '@' */  0x80,
#if defined (_SAFECRT_IMPL)
 /* 'A' */  0x80,       // Disable %A format
#else  /* defined (_SAFECRT_IMPL) */
 /* 'A' */  0x88,
#endif  /* defined (_SAFECRT_IMPL) */
 /* 'B' */  0x00,
 /* 'C' */  0x08,
 /* 'D' */  0x00,
 /* 'E' */  0x28,
 /* 'F' */  0x27,
 /* 'G' */  0x38,
 /* 'H' */  0x50,
 /* 'I' */  0x57,
 /* 'J' */  0x80,
 /* 'K' */  0x00,
 /* 'L' */  0x07,
 /* 'M' */  0x00,
 /* 'N' */  0x37,
 /* 'O' */  0x30,
 /* 'P' */  0x30,
 /* 'Q' */  0x50,
 /* 'R' */  0x50,
 /* 'S' */  0x88,
 /* 'T' */  0x00,
 /* 'U' */  0x00,
 /* 'V' */  0x00,
 /* 'W' */  0x20,
 /* 'X' */  0x28,
 /* 'Y' */  0x80,
 /* 'Z' */  0x88,
 /* '[' */  0x80,
 /* '\' */  0x80,
 /* ']' */  0x00,
 /* '^' */  0x00,
 /* '_' */  0x00,
 /* '`' */  0x60,
#if defined (_SAFECRT_IMPL)
 /* 'a' */  0x60,       // Disable %a format
#else  /* defined (_SAFECRT_IMPL) */
 /* 'a' */  0x68,
#endif  /* defined (_SAFECRT_IMPL) */
 /* 'b' */  0x60,
 /* 'c' */  0x68,
 /* 'd' */  0x68,
 /* 'e' */  0x68,
 /* 'f' */  0x08,
 /* 'g' */  0x08,
 /* 'h' */  0x07,
 /* 'i' */  0x78,
 /* 'j' */  0x70,
 /* 'k' */  0x70,
 /* 'l' */  0x77,
 /* 'm' */  0x70,
 /* 'n' */  0x70,
 /* 'o' */  0x08,
 /* 'p' */  0x08,
 /* 'q' */  0x00,
 /* 'r' */  0x00,
 /* 's' */  0x08,
 /* 't' */  0x00,
 /* 'u' */  0x08,
 /* 'v' */  0x00,
 /* 'w' */  0x07,
 /* 'x' */  0x08
};

static inline CHARTYPE GetCharType( char ch )
{
    return ((ch < (' ') || ch > ('x')) ? CH_OTHER : (enum CHARTYPE)(__lookuptable_s[ch - (' ')] & 0xF));
}
static inline STATE GetState( CHARTYPE type, STATE oldState )
{
    return (enum STATE)(__lookuptable_s[type * NUMSTATES + oldState] >> 4);
}


static bool isleadbyte(unsigned char ch)
{
    return (FALSE != IsDBCSLeadByte(ch) );
}
static bool _isleadbyte_l(unsigned char ch, _locale_t loc)
{
    // XPLAT_ODBC_TODO VSTS 718708 Localization
    return ( FALSE != IsDBCSLeadByte(ch) );
}



#define _WCTOMB_S mplat_wctomb_s
errno_t mplat_wctomb_s(
   int *pRetValue,
   char *mbchar,
   size_t sizeInBytes,
   WCHAR wchar
)
{
    DWORD rc;
    size_t cch = SystemLocale::FromUtf16( CP_ACP, &wchar, 1, mbchar, sizeInBytes, NULL, &rc );
    *pRetValue = (int)cch;
    return (ERROR_SUCCESS == rc ? 0 : -1);
}

// Floating point print routines
void _CFLTCVT( double * dbl, char * buf, int bufSize, char fmt, int precision, int caps, _locale_t loc = NULL )
{
    const size_t local_bufsize = 8;
    char local_fmt[local_bufsize] = {'\0'};

    if ( 0 != caps )
    {
        fmt -= ('a') - ('A');    /* convert format char to upper */
    }
    int chars_printed = snprintf( local_fmt, local_bufsize, "%%.%d%c", precision-1, fmt );
    assert( 0 < chars_printed && (size_t)chars_printed < local_bufsize );

    // We want to use the platform version of snprintf so temporarily undef.
    // Formatting of floating pt values is complex so we didn't implement it here.
    // Even porting the CRT code would've been difficult.  Instead, we can use the
    // platform's snprintf for just floating pt values.  We have to undef to prevent
    // recursing right back to here.
#   undef snprintf
    chars_printed = snprintf( buf, bufSize, local_fmt, *dbl );
    assert( 0 < chars_printed && chars_printed < bufSize );
#   define snprintf mplat_snprintf
}

#if !LONGDOUBLE_IS_DOUBLE
// SQL Server does not support the long double data type so this should never be called.
// It will be compiled out on Linux.
void _CLDCVT( _LONGDOUBLE * dbl, char * buf, int bufSize, char fmt, int precision, int caps )
{
    assert(false);
}
#endif

static enum STATE ProcessSizeA( char sizeCh, char fmt_ch, char next_fmt_ch, int * advance, int * flags )
{
    *advance = 0;
    switch (sizeCh)
    {
    case 'l':
        /*
        * In order to handle the ll case, we depart from the
        * simple deterministic state machine.
        */
        if ( 'l' == fmt_ch )
        {
            *advance = 1;
            *flags |= FL_LONGLONG;
        }
        else
        {
            *flags |= FL_LONG;
        }
        break;

    case 'I':
        /*
        * In order to handle the I, I32, and I64 size modifiers, we
        * depart from the simple deterministic state machine. The
        * code below scans for characters following the 'I',
        * and defaults to 64 bit on WIN64 and 32 bit on WIN32
        */
#if PTR_IS_INT64
        *flags |= FL_I64;    /* 'I' => __int64 on WIN64 systems */
#endif  /* PTR_IS_INT64 */
        if ( '6' == fmt_ch && '4' == next_fmt_ch )
        {
            *advance = 2;
            *flags |= FL_I64;    /* I64 => __int64 */
        }
        else if ( '3' == fmt_ch && '2' == next_fmt_ch )
        {
            *advance = 2;
            *flags &= ~FL_I64;   /* I32 => __int32 */
        }
        else if (
            (fmt_ch == 'd') ||
            (fmt_ch == 'i') ||
            (fmt_ch == 'o') ||
            (fmt_ch == 'u') ||
            (fmt_ch == 'x') ||
            (fmt_ch == 'X') )
        {
            /*
            * Nothing further needed.  %Id (et al) is
            * handled just like %d, except that it defaults to 64 bits
            * on WIN64.  Fall through to the next iteration.
            */
        }
        else
        {
            return ST_NORMAL;
        }
        break;

    case 'h':
        *flags |= FL_SHORT;
        break;

    case 'w':
        *flags |= FL_WIDECHAR;
    }

    return ST_SIZE;
}

STATE ProcessSize( char sizeCh, const char * format, int * advance, int * flags )
{
    char formatCh = *format;
    char next_formatCh = ('\0' == formatCh ? '\0' : *(format+1));
    return ProcessSizeA( sizeCh, formatCh, next_formatCh, advance, flags );
}

// Tools\vc\src\crt\amd64\output.c
int FormattedPrintA( IFormattedPrintOutput<char> * output, const char *format, va_list argptr )
{
    int hexadd=0;          /* offset to add to number to get 'a'..'f' */
    char ch;               /* character just read */
    int flags=0;           /* flag word -- see #defines above for flag values */
    enum STATE state;      /* current state */
    enum CHARTYPE chclass; /* class of current character */
    int radix;             /* current conversion radix */
    int charsout;          /* characters currently written so far, -1 = IO error */
    int fldwidth = 0;      /* selected field width -- 0 means default */
    int precision = 0;     /* selected precision  -- -1 means default */
    char prefix[2];        /* numeric prefix -- up to two characters */
    int prefixlen=0;       /* length of prefix -- 0 means no prefix */
    int capexp=0;          /* non-zero = 'E' exponent signifient, zero = 'e' or unused */
    int no_output=0;       /* non-zero = prodcue no output for this specifier */
    union {
        char *sz;   /* pointer text to be printed, not zero terminated */
        WCHAR *wz;
        } text;

    int textlen;    /* length of the text in bytes/wchars to be printed.
                       textlen is in multibyte or wide chars if _UNICODE */
    union {
        char sz[BUFFERSIZE];
        } buffer = {'\0'};
    WCHAR wchar;                /* temp wchar_t */
    int bufferiswide=0;         /* non-zero = buffer contains wide chars already */

#ifndef _SAFECRT_IMPL
    _LocaleUpdate _loc_update(plocinfo);
#endif  /* _SAFECRT_IMPL */

    char *heapbuf = NULL; /* non-zero = test.sz using heap buffer to be freed */

    int advance; /* count of how much helper fxns need format ptr incremented */

    _VALIDATE_RETURN( ((output != NULL) && (format != NULL)), EINVAL, -1);

    charsout = 0;       /* no characters written yet */
    textlen = 0;        /* no text yet */
    state = ST_NORMAL;  /* starting state */
    heapbuf = NULL;     /* not using heap-allocated buffer */

    /* main loop -- loop while format character exist and no I/O errors */
    while ((ch = *format++) != '\0' && charsout >= 0) {
        // Find char class and next state
        chclass = GetCharType( ch );
        state = GetState( chclass, state );

        /* execute code for each state */
        switch (state) {

        case ST_INVALID:
            // "Incorrect format specifier"
            assert( false );
            errno = EINVAL;
            return -1;

        case ST_NORMAL:

        NORMAL_STATE:

            /* normal state -- just write character */
            bufferiswide = 0;
#ifdef _SAFECRT_IMPL
            if (isleadbyte((unsigned char)ch)) {
#else  /* _SAFECRT_IMPL */
            if (_isleadbyte_l((unsigned char)ch, _loc_update.GetLocaleT())) {
#endif  /* _SAFECRT_IMPL */
                // XPLAT_ODBC_TODO VSTS 718708 Localization
                // Deal with more than 2 storage units per character
                output->WRITE_CHAR(ch, &charsout);
                ch = *format++;
                /* don't fall off format string */
                _VALIDATE_RETURN( (ch != '\0'), EINVAL, -1);
            }
            output->WRITE_CHAR(ch, &charsout);
            break;

        case ST_PERCENT:
            /* set default value of conversion parameters */
            prefixlen = fldwidth = no_output = capexp = 0;
            flags = 0;
            precision = -1;
            bufferiswide = 0;   /* default */
            break;

        case ST_FLAG:
            /* set flag based on which flag character */
            switch (ch) {
            case ('-'):
                flags |= FL_LEFT;   /* '-' => left justify */
                break;
            case ('+'):
                flags |= FL_SIGN;   /* '+' => force sign indicator */
                break;
            case (' '):
                flags |= FL_SIGNSP; /* ' ' => force sign or space */
                break;
            case ('#'):
                flags |= FL_ALTERNATE;  /* '#' => alternate form */
                break;
            case ('0'):
                flags |= FL_LEADZERO;   /* '0' => pad with leading zeros */
                break;
            }
            break;

        case ST_WIDTH:
            /* update width value */
            if (ch == ('*')) {
                /* get width from arg list */
                fldwidth = va_arg(argptr, int);
                if (fldwidth < 0) {
                    /* ANSI says neg fld width means '-' flag and pos width */
                    flags |= FL_LEFT;
                    fldwidth = -fldwidth;
                }
            }
            else {
                /* add digit to current field width */
                fldwidth = fldwidth * 10 + (ch - ('0'));
            }
            break;

        case ST_DOT:
            /* zero the precision, since dot with no number means 0
               not default, according to ANSI */
            precision = 0;
            break;

        case ST_PRECIS:
            /* update precison value */
            if (ch == ('*')) {
                /* get precision from arg list */
                precision = va_arg(argptr, int);
                if (precision < 0)
                    precision = -1; /* neg precision means default */
            }
            else {
                /* add digit to current precision */
                precision = precision * 10 + (ch - ('0'));
            }
            break;

        case ST_SIZE:
            /* just read a size specifier, set the flags based on it */
            state = ProcessSize( ch, format, &advance, &flags );
            format += advance;
            if ( ST_NORMAL == state )
            {
                goto NORMAL_STATE;
            }
            break;

        case ST_TYPE:
            /* we have finally read the actual type character, so we       */
            /* now format and "print" the output.  We use a big switch     */
            /* statement that sets 'text' to point to the text that should */
            /* be printed, and 'textlen' to the length of this text.       */
            /* Common code later on takes care of justifying it and        */
            /* other miscellaneous chores.  Note that cases share code,    */
            /* in particular, all integer formatting is done in one place. */
            /* Look at those funky goto statements!                        */

            switch (ch) {

            case ('C'):   /* ISO wide character */
                if (!(flags & (FL_SHORT|FL_LONG|FL_WIDECHAR)))
                    flags |= FL_WIDECHAR;   /* ISO std. */
                /* fall into 'c' case */

            case ('c'): {
                /* print a single character specified by int argument */
                if (flags & (FL_LONG|FL_WIDECHAR)) {
                    errno_t e = 0;
                    wchar = (WCHAR) va_arg(argptr, int);
                    /* convert to multibyte character */
                    e = _WCTOMB_S(&textlen, buffer.sz, _countof(buffer.sz), wchar);

                    /* check that conversion was successful */
                    if (e != 0)
                        no_output = 1;
                } else {
                    /* format multibyte character */
                    /* this is an extension of ANSI */
                    unsigned short temp;
                    temp = (unsigned short) va_arg(argptr, int);
                    {
                        buffer.sz[0] = (char) temp;
                        textlen = 1;
                    }
                }
                text.sz = buffer.sz;
            }
            break;

            case ('Z'): {
                // 'Z' format specifier disabled
                _VALIDATE_RETURN(0, EINVAL, -1);
            }
            break;

            case ('S'):   /* ISO wide character string */
                if (!(flags & (FL_SHORT|FL_LONG|FL_WIDECHAR)))
                    flags |= FL_WIDECHAR;

            case ('s'): {
                /* print a string --                            */
                /* ANSI rules on how much of string to print:   */
                /*   all if precision is default,               */
                /*   min(precision, length) if precision given. */
                /* prints '(null)' if a null string is passed   */

                int i;
                char *p;       /* temps */
                WCHAR *pwch;

                /* At this point it is tempting to use strlen(), but */
                /* if a precision is specified, we're not allowed to */
                /* scan past there, because there might be no null   */
                /* at all.  Thus, we must do our own scan.           */

                i = (precision == -1) ? INT_MAX : precision;
                text.sz = (char *)va_arg(argptr, void *);

                /* scan for null upto i characters */
                if (flags & (FL_LONG|FL_WIDECHAR)) {
                    if (text.wz == NULL) /* NULL passed, use special string */
                        text.wz = (WCHAR *)__wnullstring;
                    bufferiswide = 1;
                    pwch = text.wz;
                    while ( i-- && *pwch )
                        ++pwch;
                    textlen = (int)(pwch - text.wz);
                    /* textlen now contains length in wide chars */
                } else {
                    if (text.sz == NULL) /* NULL passed, use special string */
                        text.sz = (char*) __nullstring;
                    p = text.sz;
                    while (i-- && *p)
                        ++p;
                    textlen = (int)(p - text.sz);    /* length of the string */
                }
            }
            break;


            case ('n'): {
                // We will not support %n
                _VALIDATE_RETURN(0, EINVAL, -1);
            }
            break;

            case ('E'):
            case ('G'):
            case ('A'):
                capexp = 1;                 /* capitalize exponent */
                ch += ('a') - ('A');    /* convert format char to lower */
                /* DROP THROUGH */
            case ('e'):
            case ('f'):
            case ('g'):
            case ('a'): {
                /* floating point conversion -- we call cfltcvt routines */
                /* to do the work for us.                                */
                flags |= FL_SIGNED;             /* floating point is signed conversion */
                text.sz = buffer.sz;            /* put result in buffer */
                int buffersize = BUFFERSIZE;    /* size of text.sz (used only for the call to _cfltcvt) */

                /* compute the precision value */
                if (precision < 0)
                    precision = 6;          /* default precision: 6 */
                else if (precision == 0 && ch == ('g'))
                    precision = 1;          /* ANSI specified */
                else if (precision > MAXPRECISION)
                    precision = MAXPRECISION;

                if (precision > BUFFERSIZE - _CVTBUFSIZE) {
                    /* conversion will potentially overflow local buffer */
                    /* so we need to use a heap-allocated buffer.        */
                    heapbuf = (char *)malloc(_CVTBUFSIZE + precision);
                    if (heapbuf != NULL)
                    {
                        text.sz = heapbuf;
                        buffersize = _CVTBUFSIZE + precision;
                    }
                    else
                        /* malloc failed, cap precision further */
                        precision = BUFFERSIZE - _CVTBUFSIZE;
                }

#ifdef _SAFECRT_IMPL
                /* for safecrt, we pass along the FL_ALTERNATE flag to _safecrt_cfltcvt */
                if (flags & FL_ALTERNATE)
                {
                    capexp |= FL_ALTERNATE;
                }
#endif  /* _SAFECRT_IMPL */

#if !LONGDOUBLE_IS_DOUBLE
                /* do the conversion */
                if (flags & FL_LONGDOUBLE) {
                    _LONGDOUBLE tmp;
                    tmp=va_arg(argptr, _LONGDOUBLE);
                    /* Note: assumes ch is in ASCII range */
                    _CLDCVT(&tmp, text.sz, buffersize, (char)ch, precision, capexp);
                } else
#endif  /* !LONGDOUBLE_IS_DOUBLE */
                {
                    double tmp;
                    tmp=va_arg(argptr, double);
                    /* Note: assumes ch is in ASCII range */
                    /* In safecrt, we provide a special version of _cfltcvt which internally calls printf (see safecrt_output_s.c) */
#ifndef _SAFECRT_IMPL
                    _cfltcvt_l(&tmp, text.sz, buffersize, (char)ch, precision, capexp, _loc_update.GetLocaleT());
#else  /* _SAFECRT_IMPL */
                    _CFLTCVT(&tmp, text.sz, buffersize, (char)ch, precision, capexp);
#endif  /* _SAFECRT_IMPL */
                }

#ifndef _SAFECRT_IMPL
                /* For safecrt, this is done already in _safecrt_cfltcvt */

                /* '#' and precision == 0 means force a decimal point */
                if ((flags & FL_ALTERNATE) && precision == 0)
                {
                    _forcdecpt_l(text.sz, _loc_update.GetLocaleT());
                }

                /* 'g' format means crop zero unless '#' given */
                if (ch == ('g') && !(flags & FL_ALTERNATE))
                {
                    _cropzeros_l(text.sz, _loc_update.GetLocaleT());
                }
#endif  /* _SAFECRT_IMPL */

                /* check if result was negative, save '-' for later */
                /* and point to positive part (this is for '0' padding) */
                if (*text.sz == '-') {
                    flags |= FL_NEGATIVE;
                    ++text.sz;
                }

                textlen = (int)strnlen_s(text.sz);     /* compute length of text */
            }
            break;

            case ('d'):
            case ('i'):
                /* signed decimal output */
                flags |= FL_SIGNED;
                radix = 10;
                goto COMMON_INT;

            case ('u'):
                radix = 10;
                goto COMMON_INT;

            case ('p'):
                /* write a pointer -- this is like an integer or long */
                /* except we force precision to pad with zeros and */
                /* output in big hex. */

                precision = 2 * sizeof(void *);     /* number of hex digits needed */
#if PTR_IS_INT64
                flags |= FL_I64;                    /* assume we're converting an int64 */
#endif  /* !PTR_IS_INT */
                /* DROP THROUGH to hex formatting */

            case ('X'):
                /* unsigned upper hex output */
                hexadd = ('A') - ('9') - 1;     /* set hexadd for uppercase hex */
                goto COMMON_HEX;

            case ('x'):
                /* unsigned lower hex output */
                hexadd = ('a') - ('9') - 1;     /* set hexadd for lowercase hex */
                /* DROP THROUGH TO COMMON_HEX */

            COMMON_HEX:
                radix = 16;
                if (flags & FL_ALTERNATE) {
                    /* alternate form means '0x' prefix */
                    prefix[0] = ('0');
                    prefix[1] = (char)(('x') - ('a') + ('9') + 1 + hexadd);  /* 'x' or 'X' */
                    prefixlen = 2;
                }
                goto COMMON_INT;

            case ('o'):
                /* unsigned octal output */
                radix = 8;
                if (flags & FL_ALTERNATE) {
                    /* alternate form means force a leading 0 */
                    flags |= FL_FORCEOCTAL;
                }
                /* DROP THROUGH to COMMON_INT */

            COMMON_INT: {
                /* This is the general integer formatting routine. */
                /* Basically, we get an argument, make it positive */
                /* if necessary, and convert it according to the */
                /* correct radix, setting text and textlen */
                /* appropriately. */

                ULONGLONG number;    /* number to convert */
                int digit;              /* ascii value of digit */
                LONGLONG l;              /* temp long value */

                /* 1. read argument into l, sign extend as needed */
                if (flags & FL_I64)
                    l = va_arg(argptr, LONGLONG);
                else if (flags & FL_LONGLONG)
                    l = va_arg(argptr, LONGLONG);
                else

                if (flags & FL_SHORT) {
                    if (flags & FL_SIGNED)
                        l = (short) va_arg(argptr, int); /* sign extend */
                    else
                        l = (unsigned short) va_arg(argptr, int);    /* zero-extend*/

                } else
                {
                    if (flags & FL_SIGNED)
                        l = (int)va_arg(argptr, int); /* sign extend */
                    else
                        l = (unsigned int) va_arg(argptr, int);    /* zero-extend*/
                }

                /* 2. check for negative; copy into number */
                if ( (flags & FL_SIGNED) && l < 0) {
                    number = -l;
                    flags |= FL_NEGATIVE;   /* remember negative sign */
                } else {
                    number = l;
                }

                if ( (flags & FL_I64) == 0 && (flags & FL_LONGLONG) == 0 ) {
                    /*
                     * Unless printing a full 64-bit value, insure values
                     * here are not in cananical longword format to prevent
                     * the sign extended upper 32-bits from being printed.
                     */
                    number &= 0xffffffff;
                }

                /* 3. check precision value for default; non-default */
                /*    turns off 0 flag, according to ANSI. */
                if (precision < 0)
                    precision = 1;  /* default precision */
                else {
                    flags &= ~FL_LEADZERO;
                    if (precision > MAXPRECISION)
                        precision = MAXPRECISION;
                }

                /* 4. Check if data is 0; if so, turn off hex prefix */
                if (number == 0)
                    prefixlen = 0;

                /* 5. Convert data to ASCII -- note if precision is zero */
                /*    and number is zero, we get no digits at all.       */

                text.sz = &buffer.sz[BUFFERSIZE-1];    /* last digit at end of buffer */

                while (precision-- > 0 || number != 0) {
                    digit = (int)(number % radix) + '0';
                    number /= radix;                /* reduce number */
                    if (digit > '9') {
                        /* a hex digit, make it a letter */
                        digit += hexadd;
                    }
                    *text.sz-- = (char)digit;       /* store the digit */
                }

                textlen = (int)((char *)&buffer.sz[BUFFERSIZE-1] - text.sz); /* compute length of number */
                ++text.sz;          /* text points to first digit now */


                /* 6. Force a leading zero if FORCEOCTAL flag set */
                if ((flags & FL_FORCEOCTAL) && (textlen == 0 || text.sz[0] != '0')) {
                    *--text.sz = '0';
                    ++textlen;      /* add a zero */
                }
            }
            break;
            }

            /* At this point, we have done the specific conversion, and */
            /* 'text' points to text to print; 'textlen' is length.  Now we */
            /* justify it, put on prefixes, leading zeros, and then */
            /* print it. */

            if (!no_output) {
                int padding;    /* amount of padding, negative means zero */

                if (flags & FL_SIGNED) {
                    if (flags & FL_NEGATIVE) {
                        /* prefix is a '-' */
                        prefix[0] = ('-');
                        prefixlen = 1;
                    }
                    else if (flags & FL_SIGN) {
                        /* prefix is '+' */
                        prefix[0] = ('+');
                        prefixlen = 1;
                    }
                    else if (flags & FL_SIGNSP) {
                        /* prefix is ' ' */
                        prefix[0] = (' ');
                        prefixlen = 1;
                    }
                }

                /* calculate amount of padding -- might be negative, */
                /* but this will just mean zero */
                padding = fldwidth - textlen - prefixlen;

                /* put out the padding, prefix, and text, in the correct order */

                if (!(flags & (FL_LEFT | FL_LEADZERO))) {
                    /* pad on left with blanks */
                    output->WRITE_MULTI_CHAR((' '), padding, &charsout);
                }

                /* write prefix */
                output->WRITE_STRING(prefix, prefixlen, &charsout);

                if ((flags & FL_LEADZERO) && !(flags & FL_LEFT)) {
                    /* write leading zeros */
                    output->WRITE_MULTI_CHAR(('0'), padding, &charsout);
                }

                /* write text */
                if (bufferiswide && (textlen > 0)) {
                    WCHAR *p;
                    int retval, count;
                    errno_t e = 0;
                    char L_buffer[MB_LEN_MAX+1] = {'\0'};

                    p = text.wz;
                    count = textlen;
                    while (count--) {
                        e = _WCTOMB_S(&retval, L_buffer, _countof(L_buffer), *p++);
                        if (e != 0 || retval == 0) {
                            charsout = -1;
                            break;
                        }
                        output->WRITE_STRING(L_buffer, retval, &charsout);
                    }
                } else {
                    output->WRITE_STRING(text.sz, textlen, &charsout);
                }

                if (charsout >= 0 && (flags & FL_LEFT)) {
                    /* pad on right with blanks */
                    output->WRITE_MULTI_CHAR((' '), padding, &charsout);
                }

                /* we're done! */
            }
            if (heapbuf) {
                free(heapbuf);
                heapbuf = NULL;
            }
            break;
        }
    }

    /* The format string shouldn't be incomplete - i.e. when we are finished
        with the format string, the last thing we should have encountered
        should have been a regular char to be output or a type specifier. Else
        the format string was incomplete */
    _VALIDATE_RETURN(((state == ST_NORMAL) || (state == ST_TYPE)), EINVAL, -1);

    return charsout;        /* return value = number of characters written */
}

// Used for holding the size and value of a variable argument.
// Uses INT and LONGLONG to hold all possible values.  Each is just a buffer to hold the right number of bits.
struct vararg_t
{
    enum ArgType_e
    {
        Unknown,
        Int32,
        Int64,
        ShouldBeInt32,
        ShouldBeInt64
    };

    vararg_t() : int64Val(0), int32Val(0), argType(vararg_t::Unknown) {}
    vararg_t( INT val ) : int64Val(0), int32Val(val), argType(vararg_t::Int32) {}
    vararg_t( LONGLONG ptr ) : int64Val(ptr), int32Val(0), argType(vararg_t::Int64) {}

    ArgType_e Type() const { return argType; }
    INT Int32Value() const { return int32Val; }
    LONGLONG Int64Value() const { return int64Val; }
    void * PtrValue() const
    {
#if PTR_IS_INT64
        return reinterpret_cast<void *>(int64Val);
#else
        return reinterpret_cast<void *>(int32Val);
#endif
    }

    void SetForInt32()
    {
        assert( vararg_t::Unknown == argType );
        argType = vararg_t::ShouldBeInt32;
    }
    void SetForInt64()
    {
        assert( vararg_t::Unknown == argType );
        argType = vararg_t::ShouldBeInt64;
    }
    void SetForPtr()
    {
#if PTR_IS_INT64
        SetForInt64();
#else
        SetForInt32();
#endif
    }

    void Int32Value( INT val )
    {
        assert( vararg_t::Unknown == argType || vararg_t::ShouldBeInt32 == argType );
        assert( 0 == int64Val );
        argType = vararg_t::Int32;
        int32Val = val;
    }
    void Int64Value( LONGLONG val )
    {
        assert( vararg_t::Unknown == argType || vararg_t::ShouldBeInt64 == argType );
        assert( 0 == int32Val );
        argType = vararg_t::Int64;
        int64Val = val;
    }

private:
    LONGLONG int64Val;
    INT int32Val;
    ArgType_e argType;
};

// Caches the var arg values in the supplied vector.  Types are determined by inspecting the format string.
// On error, sets errno and returns false
static bool GetFormatMessageArgsA( const char * format, std::vector< vararg_t > * argcache, va_list * Arguments )
{
    if ( NULL == format )
    {
        errno = EINVAL;
        return false;
    }

    const char *p = format;
    char fmt_ch;

    while( '\0' != (fmt_ch = *p++) )
    {
        if ( '%' != fmt_ch )
        {
            // continue to next format spec
        }
        else if ( '0' == *p || '\0' == *p )
        {
            // %0 or null term means end formatting
            break;
        }
        else if ( *p < '1' || '9' < *p )
        {
            // Escaped char, skip and keep going
            ++p;
        }
        else
        {
            // Integer must be [1..99]
            size_t argPos = *p++ - '0';
            if ( '0' <= *p && *p <= '9' )
            {
                argPos *= 10;
                argPos += *p++ - '0';
            }
            assert( 0 < argPos && argPos < 100 );

            if ( argcache->size() < argPos )
            {
                // Haven't processed this arg, yet
                argcache->resize( argPos );
            }

            if ( vararg_t::Unknown == argcache->at(argPos-1).Type() )
            {
                if ( '!' != *p )
                {
                    // Assume %s as per spec
                    argcache->at(argPos-1).SetForPtr();
                }
                else
                {
                    // Step over the initial '!' and process format specification
                    ++p;

                    char ch;
                    int flags = 0;
                    int advance = 0;
                    enum CHARTYPE chclass;
                    enum STATE state = ST_PERCENT;
                    bool found_terminator = false;
                    while ( !found_terminator && ('\0' != (ch = *p++)) )
                    {
                        chclass = GetCharType( ch );
                        state = GetState( chclass, state );

                        switch ( state )
                        {
                        case ST_DOT:
                        case ST_FLAG:
                            break;

                        case ST_WIDTH:
                        case ST_PRECIS:
                            if ( '*' == ch )
                            {
                                argcache->at(argPos-1).SetForInt32();
                                ++argPos;
                                if ( argcache->size() < argPos )
                                {
                                    argcache->resize( argPos );
                                }
                            }
                            break;

                        case ST_SIZE:
                            state = ProcessSize( ch, p, &advance, &flags );
                            p += advance;
                            if ( ST_SIZE != state )
                            {
                                // Size and type flags were inconsistent
                                errno = EINVAL;
                                return false;
                            }
                            break;

                        case ST_TYPE:
                            // Group into 32-bit and 64-bit sized args
                            assert( vararg_t::Unknown == argcache->at(argPos-1).Type() );
                            switch ( ch )
                            {
                            case 'C': // chars
                            case 'c':
                                argcache->at(argPos-1).SetForInt32();
                                break;

                            case 'd': // ints
                            case 'i':
                            case 'u':
                            case 'X':
                            case 'x':
                            case 'o':
                                // INT args
                                if ( (flags & FL_I64) || (flags & FL_LONGLONG) )
                                    argcache->at(argPos-1).SetForInt64();
                                else
                                    argcache->at(argPos-1).SetForInt32();
                                break;

                            case 'S': // strings
                            case 's':
                            case 'p': // pointer
                                argcache->at(argPos-1).SetForPtr();
                                break;

                            case 'E': // doubles (not supported as per spec)
                            case 'e':
                            case 'G':
                            case 'g':
                            case 'A':
                            case 'a':
                            case 'f':
                            default:
                                errno = EINVAL;
                                return false;
                            }
                            break;

                        case ST_NORMAL:
                            if ( '!' == ch )
                            {
                                found_terminator = true;
                                break;
                            }
                            // Fall thru to error, missing terminating '!'

                        default:
                            errno = EINVAL;
                            return false;
                        }
                    }

                    if ( !found_terminator )
                    {
                        // End of string before trailing '!' was found
                        errno = EINVAL;
                        return false;
                    }
                }
            }
        }
    }

    if ( 0 < argcache->size() && NULL == Arguments )
    {
        errno = EINVAL;
        return false;
    }

    // Cache var arg values now that we know the number and sizes
    for ( std::vector< vararg_t >::iterator arg = argcache->begin(); arg != argcache->end(); ++arg )
    {
        if ( vararg_t::Unknown == arg->Type() )
        {
            // Arg not referenced in format string so assume ptr sized.
            // This is a decent assumption since every arg gets ptr-size bytes to ensure alignment
            // of later arg values.  Verified this behavior with both Windows and Linux.
            arg->SetForPtr();
        }

        vararg_t::ArgType_e argtype = arg->Type();
        assert( vararg_t::ShouldBeInt32 == argtype || vararg_t::ShouldBeInt64 == argtype );

        if ( vararg_t::ShouldBeInt32 == argtype )
        {
            arg->Int32Value( (INT)va_arg(*Arguments, INT) );
        }
        else
        {
            arg->Int64Value( (LONGLONG)va_arg(*Arguments, LONGLONG) );
        }
    }

    return true;
}

// On success, returns the number of chars written into the buffer excluding null terminator.
// On error, sets errno and returns zero.
static DWORD FormatMessageToBufferA( const char * format, char * buffer, DWORD bufferWCharSize, const std::vector< vararg_t > & args )
{
    char * msg = buffer;
    DWORD bufsize = std::min(bufferWCharSize, (DWORD)64000);
    DWORD msg_pos = 0;
    const DWORD fmtsize = 32;
    char fmt[fmtsize] = {'\0'};
    DWORD fmt_pos;
    char fmt_ch;

    const char * p = format;
    while( msg_pos < bufsize && '\0' != (fmt_ch = *p++) )
    {
        if ( '%' != fmt_ch )
        {
            msg[msg_pos++] = fmt_ch;
        }
        else if ( '0' == *p || '\0' == *p )
        {
            // %0 or null term means end formatting
            break;
        }
        else if ( *p < '1' || '9' < *p )
        {
            // Escaped char, print and keep going
            // Eg.  "%n" == '\n'
            switch ( *p )
            {
            case 'a': msg[msg_pos++] = '\a'; break;
            case 'b': msg[msg_pos++] = '\b'; break;
            case 'f': msg[msg_pos++] = '\f'; break;
            case 'n': msg[msg_pos++] = '\n'; break;
            case 'r': msg[msg_pos++] = '\r'; break;
            case 't': msg[msg_pos++] = '\t'; break;
            case 'v': msg[msg_pos++] = '\v'; break;
            default:   msg[msg_pos++] = *p;    break;
            }
            ++p;
        }
        else
        {
            // Integer must be [1..99]
            size_t argPos = *p++ - '0';
            if ( '0' <= *p && *p <= '9' )
            {
                argPos *= 10;
                argPos += *p++ - '0';
            }
            assert( 0 < argPos && argPos < 100 );

            fmt_pos = 0;
            fmt[fmt_pos++] = '%';

            if ( '!' != *p )
            {
                // Assume %s as per spec
                fmt[fmt_pos++] = 's';
                fmt[fmt_pos] = '\0';
                int chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].PtrValue() );
                if ( chars_printed < 0 )
                {
                    errno = EINVAL;
                    return 0;
                }
                msg_pos += chars_printed;
            }
            else
            {
                // Skip over '!' and build format string
                ++p;
                char ch;
                int flags = 0;
                int advance = 0;
                enum CHARTYPE chclass;
                enum STATE state = ST_PERCENT;
                bool found_terminator = false;
                while ( fmt_pos < fmtsize && !found_terminator && ('\0' != (ch = *p++)) )
                {
                    chclass = GetCharType( ch );
                    state = GetState( chclass, state );

                    switch ( state )
                    {
                    case ST_SIZE:
                        state = ProcessSize( ch, p, &advance, &flags );
                        fmt[fmt_pos++] = ch;
                        while ( fmt_pos < fmtsize && 0 < advance-- )
                        {
                            fmt[fmt_pos++] = *p++;
                        }
                        break;

                    case ST_NORMAL:
                        assert( '!' == ch );
                        found_terminator = true;
                        break;

                    case ST_INVALID:
                    case ST_PERCENT:
                        errno = EINVAL;
                        return 0;

                    default:
                        fmt[fmt_pos++] = ch;
                        break;
                    }
                }

                if ( fmtsize <= fmt_pos )
                {
                    // Should not have a format string longer than 31 chars
                    // It can happen but shouldn't (eg. a bunch of size mods like %llllllllllllllld)
                    errno = EINVAL;
                    return 0;
                }

                fmt[fmt_pos] = '\0';

                // Format string might need up to 3 args (eg. %*.*d )
                // If more than one arg, then the first ones must be 32-bit ints
                // Hence, first 64-bit arg tells us the last arg we need to send.
                int chars_printed = 0;
                if ( vararg_t::Int64 == args[argPos-1].Type() )
                {
                    chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int64Value() );
                }
                else if ( args.size() == argPos )
                {
                    // No more args so send the one Int
                    chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value() );
                }
                else if ( vararg_t::Int64 == args[argPos].Type() )
                {
                    chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos].Int64Value() );
                }
                else if ( args.size() == (argPos+1) )
                {
                    // No more args so send the two Ints
                    chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos-1].Int32Value() );
                }
                else if ( vararg_t::Int64 == args[argPos+1].Type() )
                {
                    chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos].Int32Value(), args[argPos+1].Int64Value() );
                }
                else
                {
                    chars_printed = mplat_snprintf_s( &msg[msg_pos], bufsize-msg_pos, bufsize-msg_pos, fmt, args[argPos-1].Int32Value(), args[argPos].Int32Value(), args[argPos+1].Int32Value() );
                }

                if ( chars_printed < 0 )
                {
                    errno = EINVAL;
                    return 0;
                }
                msg_pos += chars_printed;
            }
        }
    }

    if ( bufsize <= msg_pos )
    {
        errno = ERANGE;
        return 0;
    }

    msg[msg_pos] = '\0';
    return msg_pos;
}

// FormatMessage implementation details (see MSDN for more info)
//
// The Windows FormatMessage API is very rich, complex.  This is not an exact duplication of that function.
// Instead, the most important aspects of this function have been implemented here along with constraints to
// match how we use it within SNAC, BCP, and SQLCMD.
//
// Only these combinations of dwFlags are supported:
//  FORMAT_MESSAGE_FROM_STRING
//      Writes formatted message into supplied buffer
//  FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING
//      Allocates a buffer, writes formatted message into that buffer, returns buffer in lpBufffer
//  FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS
//      Writes fixed, English message into the supplied buffer (do not have Windows resources to get real message)
//  FORMAT_MESSAGE_FROM_HMODULE
//      SQLCMD uses this to read strings from the RLL that have not been translated to the current lang
//
// dwLanguageId is ignored for FORMAT_MESSAGE_FROM_STRING as per spec
//      For FORMAT_MESSAGE_FROM_SYSTEM, we don't have Windows resources so language is irrelevant

DWORD FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPTSTR lpBuffer, DWORD nSize, va_list *Arguments)
{
    DWORD chars_printed = 0;

    // XPLAT_ODBC_TODO VSTS 718708 Localization by handling FORMAT_MESSAGE_FROM_HMODULE and dwLanguageId param
    if ( dwFlags & FORMAT_MESSAGE_FROM_STRING )
    {
        // Format specification allows for reordering of insertions relative to var arg position
        // This means we need to walk thru the format specification to find the types of the var args in var arg order
        // We extract the var args in order based on the identified types
        // Finally, we re-walk the format specfication and perform the insertions

        // First pass thru the format string to determine all args and their types
        // This first pass also validates the format string and will return an error
        // if it is invalid.  This allows FormatMessageToBuffer to have less error
        // checking.
        std::vector< vararg_t > args;
        // Based on quick scan of RC files, the largest arg count was 7 so reserve 8 slots to reduce allocations
        args.reserve(8);
        if ( GetFormatMessageArgsA( reinterpret_cast<const char *>(lpSource), &args, Arguments ) )
        {
            if ( dwFlags == (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING) )
            {
                *((char**)lpBuffer) = NULL;

                const DWORD max_size = 64000;
                char local_buf[max_size] = {'\0'};
                chars_printed = FormatMessageToBufferA( reinterpret_cast<const char *>(lpSource), local_buf, max_size, args );
                if ( 0 < chars_printed )
                {
                    size_t buf_size = std::min( max_size, std::max(nSize, (chars_printed+1)) );
                    char * return_buf = (char *)LocalAlloc(0, buf_size * sizeof(char));
                    if ( NULL == return_buf )
                    {
                        errno = ENOMEM;
                    }
                    else
                    {
                        mplat_cscpy(return_buf, local_buf);
                        *((char**)lpBuffer) = return_buf;
                    }
                }
            }
            else if ( dwFlags == FORMAT_MESSAGE_FROM_STRING )
            {
                chars_printed = FormatMessageToBufferA( reinterpret_cast<const char *>(lpSource), lpBuffer, std::min(nSize, (DWORD)64000), args );
            }
        }
    }
    else if ( dwFlags & FORMAT_MESSAGE_FROM_SYSTEM )
    {
        // Since we don't have the Windows system error messages available use a fixed message
        // Can not use a message ID for this since this same code is used by driver and tools,
        // each having their own RLL file.  Don't think we should be reserving an ID across all RLLs.
        const char systemMsg[] = "Error code 0x%X";
        if ( dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER )
        {
            *((char**)lpBuffer) = NULL;

            // Add 9 for up to 8 hex digits plus null term (ignore removal of format specs)
            const size_t msgsize = (9 + sizeof(systemMsg)/sizeof(systemMsg[0]));
            char * return_buf = (char *)LocalAlloc(0, msgsize * sizeof(char));
            if ( NULL == return_buf )
            {
                errno = ENOMEM;
            }
            else
            {
                chars_printed = mplat_snprintf_s( return_buf, msgsize, msgsize, systemMsg, dwMessageId );
                // Assert that we did our buffer size math right
                assert( chars_printed < msgsize );
                if ( 0 < chars_printed )
                {
                    *((char**)lpBuffer) = return_buf;
                }
                else
                {
                    LocalFree( return_buf );
                    errno = EINVAL;
                }
            }
        }
        else
        {
            chars_printed = mplat_snprintf_s( lpBuffer, nSize, nSize, systemMsg, dwMessageId );
        }
    }

    return chars_printed;
}


//--------Other definitions from xplat stub sources--------------

BOOL IsDBCSLeadByte(__inn BYTE  TestChar)
{
    // XPLAT_ODBC_TODO: This is to allow BatchParser to function
    // BatchParser will single step thru utf8 code points
    // BatchParser needs to become utf8-aware
    // VSTS 718708 Localization
    if ( CP_UTF8 == SystemLocale::Singleton().AnsiCP() )
        return FALSE;
    // XPLAT_ODBC_TODO

    return IsDBCSLeadByteEx(SystemLocale::Singleton().AnsiCP(), TestChar);
}

BOOL IsDBCSLeadByteEx(
    __inn UINT  CodePage,
    __inn BYTE  TestChar)
{
    if ( 1 == SystemLocale::MaxCharCchSize(CodePage) )
        return FALSE;

    // Lead byte ranges for code pages, inclusive:
    // CP932
    //      0x81-0x9f, 0xe0-0xfc
    // CP936, CP949, CP950
    //      0x81-0xfe
    assert( 932 == CodePage || 936 == CodePage || 949 == CodePage || 950 == CodePage );
    if ( 932 == CodePage )
    {
        if ( TestChar < (unsigned char)0x81
            || (unsigned char)0xfc < TestChar
            || ((unsigned char)0x9f < TestChar && TestChar < (unsigned char)0xe0) )
        {
            return FALSE;
        }
    }
    else if ( TestChar < (unsigned char)0x81 || TestChar == (unsigned char)0xff )
        return FALSE;

    return TRUE;
}

int mplat_vsnprintf( char * buffer, size_t count, const char * format, va_list args )
{
    BufferOutput<char> output( buffer, count );
    return FormattedPrintA( &output, format, args );
}

int mplat_snprintf_s( char *buffer, size_t bufsize, size_t count, const char *format, ... )
{
    va_list args;
    va_start( args, format );
    int retcode = mplat_vsnprintf( buffer, std::min(bufsize, count), format, args );
    va_end( args );
    return retcode;
}

char * mplat_cscpy( char * dst, const char * src )
{
    char * cp = dst;

    while( (*cp++ = *src++) )
        ;       /* Copy src over dst */

    return( dst );
}

size_t mplat_wcslen( const WCHAR * str )
{
    const WCHAR * eos = str;
    while( *eos++ )
    {
    }
    return( (size_t)(eos - str- 1) );
}

HLOCAL LocalAlloc(UINT uFlags, SIZE_T uBytes)
{
    assert(uFlags == 0); // For now
    return malloc(uBytes);
}

HLOCAL LocalFree(HLOCAL hMem)
{
    assert(hMem != NULL);

    free(hMem);
    return NULL;
}