/*

 * Copyright (c) 1983, 1995, 1996 Eric P. Allman

 * Copyright (c) 1988, 1993

 *  The Regents of the University of California.  All rights reserved.

 * Copyright (C) 2007 Nokia Inc. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 * $PostgreSQL: pgsql/src/port/snprintf.c,v 1.34 2007/03/26 21:44:11 momjian Exp $

 */

#include <ctype.h>

#include <string.h>

#include <stdlib.h>

#include <stdarg.h>

#include <sys/types.h>

#include <e32def.h>

#include <limits.h>

#include <stdio.h>

#ifndef WIN32

#include <sys/ioctl.h>

#endif

#include <sys/param.h>

#ifndef NL_ARGMAX

#define NL_ARGMAX 16

#endif

/*

 *  SNPRINTF, VSNPRINTF and friends

 *

 * These versions have been grabbed off the net.  They have been

 * cleaned up to compile properly and support for most of the Single Unix

 * Specification has been added.  Remaining unimplemented features are:

 *

 * 1. No locale support: the radix character is always '.' and the '

 * (single quote) format flag is ignored.

 *

 * 2. No support for the "%n" format specification.

 *

 * 3. No support for wide characters ("lc" and "ls" formats).

 *

 * 4. No support for "long double" ("Lf" and related formats).

 *

 * 5. Space and '#' flags are not implemented.

 *

 *

 * The result values of these functions are not the same across different

 * platforms.  This implementation is compatible with the Single Unix Spec:

 *

 * 1. -1 is returned only if processing is abandoned due to an invalid

 * parameter, such as incorrect format string.  (Although not required by

 * the spec, this happens only when no characters have yet been transmitted

 * to the destination.)

 *

 * 2. For snprintf and sprintf, 0 is returned if str == NULL or count == 0;

 * no data has been stored.

 *

 * 3. Otherwise, the number of bytes actually transmitted to the destination

 * is returned (excluding the trailing '\0' for snprintf and sprintf).

 *

 * For snprintf with nonzero count, the result cannot be more than count-1

 * (a trailing '\0' is always stored); it is not possible to distinguish

 * buffer overrun from exact fit.  This is unlike some implementations that

 * return the number of bytes that would have been needed for the complete

 * result string.

 */

/**************************************************************

 * Original:

 * Patrick Powell Tue Apr 11 09:48:21 PDT 1995

 * A bombproof version of doprnt (dopr) included.

 * Sigh.  This sort of thing is always nasty do deal with.  Note that

 * the version here does not include floating point. (now it does ... tgl)

 **************************************************************/

/* Prevent recursion */

#undef  vsnprintf

#undef  snprintf

#undef  sprintf

#undef  vfprintf

#undef  fprintf

#undef  printf

static int errno;

#define EINVAL -1

#define int64 long long

#define uint64 unsigned long long

#ifndef MAX

#define MAX(p,q) (((p) >= (q)) ? (p) : (q))

#endif

#ifndef MIN

#define MIN(p,q) (((p) <= (q)) ? (p) : (q))

#endif

/* Info about where the formatted output is going */

typedef struct

{

    char       *bufptr;         /* next buffer output position */

    char       *bufstart;       /* first buffer element */

    char       *bufend;         /* last buffer element, or NULL */

    /* bufend == NULL is for sprintf, where we assume buf is big enough */

    FILE       *stream;         /* eventual output destination, or NULL */

    int         nchars;         /* # chars already sent to stream */

} PrintfTarget;

/*

 * Info about the type and value of a formatting parameter.  Note that we

 * don't currently support "long double", "wint_t", or "wchar_t *" data,

 * nor the '%n' formatting code; else we'd need more types.  Also, at this

 * level we need not worry about signed vs unsigned values.

 */

typedef enum

{

    ATYPE_NONE = 0,

    ATYPE_INT,

    ATYPE_LONG,

    ATYPE_LONGLONG,

    ATYPE_DOUBLE,

    ATYPE_CHARPTR

} PrintfArgType;

typedef union

{

    int         i;

    long        l;

    int64       ll;

    double      d;

    char       *cptr;

} PrintfArgValue;

EXPORT_C int

vsnprintf(char *str, size_t count, const char *fmt, va_list args)

{

    PrintfTarget target;

    if (str == NULL || count == 0)

        return 0;

    target.bufstart = target.bufptr = str;

    target.bufend = str + count - 1;

    target.stream = NULL;

    /* target.nchars is unused in this case */

    if (dopr(&target, fmt, args))

    {

        *(target.bufptr) = '\0';

        errno = EINVAL;         /* bad format */

        return -1;

    }

    *(target.bufptr) = '\0';

    return target.bufptr - target.bufstart;

}

EXPORT_C int

snprintf(char *str, size_t count, const char *fmt,...)

{

    int         len;

    va_list     args;

    va_start(args, fmt);

    len = vsnprintf(str, count, fmt, args);

    va_end(args);

    return len;

}

static int

pg_vsprintf(char *str, const char *fmt, va_list args)

{

    PrintfTarget target;

    if (str == NULL)

        return 0;

    target.bufstart = target.bufptr = str;

    target.bufend = NULL;

    target.stream = NULL;

    /* target.nchars is unused in this case */

    if (dopr(&target, fmt, args))

    {

        *(target.bufptr) = '\0';

        errno = EINVAL;         /* bad format */

        return -1;

    }

    *(target.bufptr) = '\0';

    return target.bufptr - target.bufstart;

}

int

pg_sprintf(char *str, const char *fmt,...)

{

    int         len;

    va_list     args;

    va_start(args, fmt);

    len = pg_vsprintf(str, fmt, args);

    va_end(args);

    return len;

}

int

pg_vfprintf(FILE *stream, const char *fmt, va_list args)

{

    PrintfTarget target;

    char        buffer[1024];   /* size is arbitrary */

    if (stream == NULL)

    {

        errno = EINVAL;

        return -1;

    }

    target.bufstart = target.bufptr = buffer;

    target.bufend = buffer + sizeof(buffer) - 1;

    target.stream = stream;

    target.nchars = 0;

    if (dopr(&target, fmt, args))

    {

        errno = EINVAL;         /* bad format */

        return -1;

    }

    /* dump any remaining buffer contents */

    flushbuffer(&target);

    return target.nchars;

}

int

pg_fprintf(FILE *stream, const char *fmt,...)

{

    int         len;

    va_list     args;

    va_start(args, fmt);

    len = pg_vfprintf(stream, fmt, args);

    va_end(args);

    return len;

}

int

pg_printf(const char *fmt,...)

{

    int         len;

    va_list     args;

    va_start(args, fmt);

    len = pg_vfprintf(stdout, fmt, args);

    va_end(args);

    return len;

}

/* call this only when stream is defined */

static void

flushbuffer(PrintfTarget *target)

{

    size_t      nc = target->bufptr - target->bufstart;

    if (nc > 0)

        target->nchars += fwrite(target->bufstart, 1, nc, target->stream);

    target->bufptr = target->bufstart;

}

static void fmtstr(char *value, int leftjust, int minlen, int MAXwidth,

       int pointflag, PrintfTarget *target);

static void fmtptr(void *value, PrintfTarget *target);

static void fmtint(int64 value, char type, int forcesign,

       int leftjust, int minlen, int zpad, int precision, int pointflag,

       PrintfTarget *target);

static void fmtchar(int value, int leftjust, int minlen, PrintfTarget *target);

static void fmtfloat(double value, char type, int forcesign,

         int leftjust, int minlen, int zpad, int precision, int pointflag,

         PrintfTarget *target);

static void dostr(const char *str, int slen, PrintfTarget *target);

static void dopr_outch(int c, PrintfTarget *target);

static int  adjust_sign(int is_negative, int forcesign, int *signvalue);

static void adjust_padlen(int minlen, int vallen, int leftjust, int *padlen);

static void leading_pad(int zpad, int *signvalue, int *padlen,

            PrintfTarget *target);

static void trailing_pad(int *padlen, PrintfTarget *target);

/*

 * dopr(): poor man's version of doprintf

 */

static int

dopr(PrintfTarget *target, const char *format, va_list args)

{

    const char *format_start = format;

    int         ch;

    int have_dollar;

    int have_non_dollar;

    int have_star;

    int afterstar;

    int         accum;

    int         longlongflag;

    int         longflag;

    int         pointflag;

    int         leftjust;

    int         fieldwidth;

    int         precision;

    int         zpad;

    int         forcesign;

    int         last_dollar;

    int         fmtpos;

    int         cvalue;

    int64       numvalue;

    double      fvalue;

    char       *strvalue;

    int         i;

    PrintfArgType argtypes[NL_ARGMAX + 1];

    PrintfArgValue argvalues[NL_ARGMAX + 1];

    /*

     * Parse the format string to determine whether there are %n$ format

     * specs, and identify the types and order of the format parameters.

     */

    have_dollar = have_non_dollar = 0;

    last_dollar = 0;

    memset(argtypes, 0, sizeof(argtypes));

    while ((ch = *format++) != '\0')

    {

        if (ch != '%')

            continue;

        longflag = longlongflag = pointflag = 0;

        fmtpos = accum = 0;

        afterstar = 0;

nextch1:

        ch = *format++;

        if (ch == '\0')

            break;              /* illegal, but we don't complain */

        switch (ch)

        {

            case '-':

            case '+':

                goto nextch1;

            case '0':

            case '1':

            case '2':

            case '3':

            case '4':

            case '5':

            case '6':

            case '7':

            case '8':

            case '9':

                accum = accum * 10 + (ch - '0');

                goto nextch1;

            case '.':

                pointflag = 1;

                accum = 0;

                goto nextch1;

            case '*':

                if (afterstar)

                    have_non_dollar = 1;     /* multiple stars */

                afterstar = 1;

                accum = 0;

                goto nextch1;

            case '$':

                have_dollar = 1;

                if (accum <= 0 || accum > NL_ARGMAX)

                    return -1;

                if (afterstar)

                {

                    if (argtypes[accum] &&

                        argtypes[accum] != ATYPE_INT)

                        return -1;

                    argtypes[accum] = ATYPE_INT;

                    last_dollar = MAX(last_dollar, accum);

                    afterstar = 0;

                }

                else

                    fmtpos = accum;

                accum = 0;

                goto nextch1;

            case 'l':

                if (longflag)

                    longlongflag = 1;

                else

                    longflag = 1;

                goto nextch1;

            case 'h':

            case '\'':

                /* ignore these */

                goto nextch1;

            case 'd':

            case 'i':

            case 'o':

            case 'u':

            case 'x':

            case 'X':

                if (fmtpos)

                {

                    PrintfArgType atype;

                    if (longlongflag)

                        atype = ATYPE_LONGLONG;

                    else if (longflag)

                        atype = ATYPE_LONG;

                    else

                        atype = ATYPE_INT;

                    if (argtypes[fmtpos] &&

                        argtypes[fmtpos] != atype)

                        return -1;

                    argtypes[fmtpos] = atype;

                    last_dollar = MAX(last_dollar, fmtpos);

                }

                else

                    have_non_dollar = 1;

                break;

            case 'c':

                if (fmtpos)

                {

                    if (argtypes[fmtpos] &&

                        argtypes[fmtpos] != ATYPE_INT)

                        return -1;

                    argtypes[fmtpos] = ATYPE_INT;

                    last_dollar = MAX(last_dollar, fmtpos);

                }

                else

                    have_non_dollar = 1;

                break;

            case 's':

            case 'p':

                if (fmtpos)

                {

                    if (argtypes[fmtpos] &&

                        argtypes[fmtpos] != ATYPE_CHARPTR)

                        return -1;

                    argtypes[fmtpos] = ATYPE_CHARPTR;

                    last_dollar = MAX(last_dollar, fmtpos);

                }

                else

                    have_non_dollar = 1;

                break;

            case 'e':

            case 'E':

            case 'f':

            case 'g':

            case 'G':

                if (fmtpos)

                {

                    if (argtypes[fmtpos] &&

                        argtypes[fmtpos] != ATYPE_DOUBLE)

                        return -1;

                    argtypes[fmtpos] = ATYPE_DOUBLE;

                    last_dollar = MAX(last_dollar, fmtpos);

                }

                else

                    have_non_dollar = 1;

                break;

            case '%':

                break;

        }

        /*

         * If we finish the spec with afterstar still set, there's a

         * non-dollar star in there.

         */

        if (afterstar)

            have_non_dollar = 1;

    }

    /* Per spec, you use either all dollar or all not. */

    if (have_dollar && have_non_dollar)

        return -1;

    /*

     * In dollar mode, collect the arguments in physical order.

     */

    for (i = 1; i <= last_dollar; i++)

    {

        switch (argtypes[i])

        {

            case ATYPE_NONE:

                return -1;      /* invalid format */

            case ATYPE_INT:

                argvalues[i].i = va_arg(args, int);

                break;

            case ATYPE_LONG:

                argvalues[i].l = va_arg(args, long);

                break;

            case ATYPE_LONGLONG:

                argvalues[i].ll = va_arg(args, int64);

                break;

            case ATYPE_DOUBLE:

                argvalues[i].d = va_arg(args, double);

                break;

            case ATYPE_CHARPTR:

                argvalues[i].cptr = va_arg(args, char *);

                break;

        }

    }

    /*

     * At last we can parse the format for real.

     */

    format = format_start;

    while ((ch = *format++) != '\0')

    {

        if (ch != '%')

        {

            dopr_outch(ch, target);

            continue;