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

 *

 * printf.cpp - definitions of the rw_printf family of functions

 *

 * $Id: printf.cpp 351515 2005-12-01 23:19:44Z sebor $

 *

 ************************************************************************

 *

 * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

 * Software division. Licensed under the Apache License, Version 2.0 (the

 * "License");  you may  not use this file except  in compliance with the

 * License.    You    may   obtain   a   copy   of    the   License    at

 * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

 * applicable law  or agreed to  in writing,  software  distributed under

 * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

 * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

 * for the specific language governing permissions  and limitations under

 * the License.

 * 

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

// expand _TEST_EXPORT macros

#define _RWSTD_TEST_SRC

#include <testdefs.h>

#include <printf.h>

#include <assert.h>   // for assert

#include <errno.h>    // for errno, errno constants

#include <float.h>    // for floating point macros

#include <locale.h>

#ifndef __SYMBIAN32__

#include <signal.h>   // for signal constant

#endif

#include <stdarg.h>   // for va_list, va_start, ...

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <wchar.h>

#if (defined (_WIN32) || defined (_WIN64)) && !defined(__SYMBIAN32__)

   // define macros to enable Win98 + WinNT support in <windows.h>

#  define _WIN32_WINNT 0x0410

#  define WINVER       0x400

#  include <windows.h>   // for IsDebuggerPresent()

#else

#  include <dlfcn.h>

#endif   // _WIN{32,64}

#include <ios>

#include <iostream>

#include <locale>

//#include <string>

#include <string.h>

#ifdef __ARMCC__

#pragma diag_suppress 61

#pragma diag_suppress 63

#endif

#define _RWSTD_NO_EXT_BIN_IO

#define _RWSTD_NO_EXT_REENTRANT_IO

#ifndef __SYMBIAN32__

_RWSTD_NAMESPACE (__rw) {

_RWSTD_EXPORT _RWSTD_SSIZE_T

 __rw_memattr (const void*, size_t, int);

}

#endif

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

static const union {

    int           ival;

    unsigned char bytes [sizeof (int)];

} _rw_one = { 1 };

static const int

_rw_big_endian = '\0' == _rw_one.bytes [0];

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

struct FmtSpec;

static int

_rw_fmtlong (const FmtSpec&, char**, size_t*, long);

#ifdef _RWSTD_LONG_LONG

static int

_rw_fmtllong (const FmtSpec&, char**, size_t*, _RWSTD_LONG_LONG);

#endif   // _RWSTD_LONG_LONG

static int

_rw_fmtinteger (FmtSpec*, size_t, char**, size_t*, va_list*);

static int

_rw_fmtfloating (const FmtSpec&, char**, size_t*, const void*);

_RWSTD_INTERNAL int

_rw_fmtptr (const FmtSpec&, char**, size_t*, const void*);

typedef void (*funptr_t)();

static int

_rw_fmtfunptr (const FmtSpec&, char**, size_t*, funptr_t);

struct DummyStruct;

typedef void (DummyStruct::*memptr_t)() const;

static int

_rw_fmtmemptr (const FmtSpec&, char**, size_t*, memptr_t);

static int

_rw_fmtstr (const FmtSpec&, char**, size_t*, const char*, size_t);

static int

_rw_fmtchr (const FmtSpec&, char**, size_t*, int);

static int

_rw_fmtwchr (const FmtSpec&, char**, size_t*, wint_t);

static int

_rw_fmtwstr (const FmtSpec&, char**, size_t*, const wchar_t*, size_t);

static int

_rw_fmterrno (const FmtSpec&, char**, size_t*, int);

static int

_rw_fmtopenmode (const FmtSpec&, char**, size_t*, int);

static int

_rw_fmtevent (const FmtSpec&, char**, size_t*, int);

static int

_rw_fmtmonpat (const FmtSpec&, char**, size_t*, const char [4]);

static int

_rw_fmtsignal (const FmtSpec&, char**, size_t*, int);

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

struct FmtSpec

{

    // optional flags

    unsigned fl_minus  : 1;

    unsigned fl_plus   : 1;

    unsigned fl_pound  : 1;

    unsigned fl_space  : 1;

    unsigned fl_zero   : 1;

    // optional modifiers

    unsigned mod_A     : 1;    // extension (Arrays)

    unsigned mod_h     : 1;    // short modifier

    unsigned mod_hh    : 1;    // char modifier

    unsigned mod_l     : 1;    // long modifier

    unsigned mod_ll    : 1;    // long long modifier

    unsigned mod_j     : 1;    // intmax_t modifier

    unsigned mod_z     : 1;    // size_t modifier

    unsigned mod_t     : 1;    // ptrdiff_t modifier

    unsigned mod_L     : 1;    // long double modifier

    unsigned mod_I     : 1;    // extension

    unsigned cond       : 1;   // have an if/else clause

    unsigned cond_true  : 1;   // if/else clause is active (true)

    unsigned cond_begin : 1;   // beginning of an if/else clause

    unsigned cond_end   : 1;   // end of an if/else clause

    // note that the signedness of a bitfield is implementation-defined

    // unless explicitly declared signed or unsigned

    // extension: 8, 16, 32, and 64 bit integer width modifier

    signed int iwidth : 4;

    // extension: optional numerical base 2 - 36

    signed int base   : 7;

    // extension: optional parameter number

    long paramno;

    // optional width and precision

    int width;

    int prec;

    // extension: string argument

    char *strarg;

    // required conversion specifier

    int cvtspec;

    // extension: fill character

    int fill;

    union {

#ifndef _RWSTD_NO_LONG_DOUBLE

        long double      ldbl;

#endif   // _RWSTD_NO_LONG_DOUBLE

#ifdef _RWSTD_LONG_LONG

        _RWSTD_LONG_LONG llong;

#endif   // _RWSTD_LONG_LONG

        void*            ptr;

        int              i;

        long             lng;

        _RWSTD_INT32_T   i32;

#ifdef _RWSTD_INT64_T

        _RWSTD_INT64_T   i64;

#endif   // _RWSTD_INT64_T

        ptrdiff_t        diff;

        size_t           size;

        wint_t           wi;

        double           dbl;

        memptr_t         memptr;

        funptr_t         funptr;

    } param;

};

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

/*

  C99 format specifier:

  % flags width [ . prec ] mod cvtspec

  GNU glibc format specifier:

  % [ paramno $] flags width [ . prec ] mod cvtspec

  or

  % [ paramno $] flags width . * [ paramno $] mod cvtspec

  Extended format specifier:

  % { [ paramno $] [ flags ] [ width [. prec ]] mod cvtspec }

  or

  % { [ paramno $] [ flags ] [@ base [. width [. prec ]]] mod cvtspec }

  or

  % { $ envvar }

*/

static int

_rw_fmtspec (FmtSpec *pspec, bool ext, const char *fmt, va_list *pva)

{

    assert (0 != pspec);

    assert (0 != fmt);

    assert (0 != pva);

    memset (pspec, 0, sizeof *pspec);

    pspec->iwidth  = -1;   // integer width not specified

    pspec->width   = -1;   // width not specified

    pspec->prec    = -1;   // precision not specified

    pspec->base    = -1;   // base not specified

    pspec->paramno = -1;   // paramno not specified

    const char* const fmtbeg = fmt;

    if (ext) {

        if ('$' == *fmt) {

            ++fmt;

            const char *str;

            if ('*' == *fmt) {

                str = va_arg (*pva, char*);

                if (!str)

                    str = "";

                ++fmt;

            }

            else {

                str  = fmt;

                fmt += strlen (fmt);

            }

            char *tmp = (char*)malloc (strlen (str));

            pspec->strarg = strcpy (tmp, str);

            return int (fmt - fmtbeg);

        }

    }

    // extension: extract the parameter number (if followed by '$')

    if ('1' <= *fmt && *fmt <= '9') {

        char *end;

        const long tmp = strtol (fmt, &end, 10);

        fmt = end;

        if ('$' == *fmt) {

            pspec->paramno = tmp;

            ++fmt;

        }

        else {

            // when not followed by '$' interpret the number

            // as the width (i.e., that follows the empty set

            // of flags)

            pspec->width = int (tmp);

        }

    }

    if (-1 == pspec->width) {

        // extract any number of optional flags

        for ( ; ; ++fmt) {

            switch (*fmt) {

            case '-': pspec->fl_minus = true; continue;

            case '+': pspec->fl_plus = true; continue;

            case '#': pspec->fl_pound = true; continue;

            case ' ': pspec->fl_space = true; continue;

            case '0': pspec->fl_zero = true; continue;

            }

            break;

        }

    }

    if (ext && '@' == *fmt) {

        ++fmt;

        // extract the numerical base

        if ('0' <= fmt [1] && fmt [1] <= '9') {

            char *end;

            pspec->base = int (strtol (fmt, &end, 10));

            fmt         = end;

        }

        else if ('*' == *fmt) {

            pspec->base = va_arg (*pva, int);

            ++fmt;

        }

        if ('.' == *fmt)

            ++fmt;

    }

    if (-1 == pspec->width) {

        // extract the optional width

        if ('0' <= *fmt && *fmt <= '9') {

            char *end;

            pspec->width = int (strtol (fmt, &end, 10));

            fmt          = end;

        }

        else if ('*' == *fmt) {

            pspec->width = va_arg (*pva, int);

            if (pspec->width < 0) {

                // 7.19.6.1, p5 of ISO/IEC 9899:1999:

                //   A negative field width argument is taken

                //   as a - flag followed by a positive field width.

                pspec->width    = -pspec->width;

                pspec->fl_minus = true;

            }

            ++fmt;

        }

    }

    // extract the optional precision

    if ('.' == *fmt) {

        ++fmt;

        if ('0' <= *fmt && *fmt <= '9') {

            char *end;

            pspec->prec = int (strtol (fmt, &end, 10));

            fmt         = end;

        }

        else if ('*' == *fmt) {

            pspec->prec = va_arg (*pva, int);

            ++fmt;

        }

    }

    // extract an optional modifier

    switch (*fmt) {

    case 'A':

        if (ext) {

            ++fmt;

            pspec->mod_A = true;

            break;

        }

        // fall thru

    case 'h':

        if ('h' == fmt [1]) {

            ++fmt;

            pspec->mod_hh = true;

        }

        else

            pspec->mod_h = true;

        ++fmt;

        break;

    case 'l':

        if ('l' == fmt [1]) {

            ++fmt;

            pspec->mod_ll = true;

        }

        else

            pspec->mod_l = true;

        ++fmt;

        break;

    case 'j': pspec->mod_j = true; ++fmt; break;

    case 'z': pspec->mod_z = true; ++fmt; break;

    case 't': pspec->mod_t = true; ++fmt; break;

    case 'L': pspec->mod_L = true; ++fmt; break;

    case 'I':

        if (ext) {

            ++fmt;

            if ('8' == *fmt) {

                pspec->iwidth = 1;

                ++fmt;

            }

            else if ('1' == fmt [0] && '6' == fmt [1]) {

                pspec->iwidth = 2;

                fmt += 2;

            }

            else if ('3' == fmt [0] && '2' == fmt [1]) {

                pspec->iwidth = 3;

                fmt += 2;

            }

            else if ('6' == fmt [0] && '4' == fmt [1]) {

                pspec->iwidth = 4;

                fmt += 2;

            }

            else {

                pspec->mod_I = true;

            }

            break;

        }

    }

    pspec->cvtspec = *fmt;

    if (pspec->cvtspec)

        ++fmt;

    return int (fmt - fmtbeg);

}

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

_RWSTD_INTERNAL char*

_rw_bufcat (char **pbuf, size_t *pbufsize, const char *str, size_t len)

{

    assert (0 != pbuf);

    assert (0 != pbufsize);

          size_t buflen = *pbuf ? strlen (*pbuf) : 0;

    const size_t bufree = *pbuf ? *pbufsize - buflen : 0;

    if (bufree <= len || !*pbuf) {

        // for guard block

        static const char deadbeef[] = "\xde\xad\xbe\xef";

        size_t newbufsize = *pbufsize * 2 + 4;

        if (newbufsize <= buflen + len + 4)

            newbufsize = 2 * (buflen + len + 1) + 4;

        char* const newbuf = (char*)malloc (newbufsize);

        // return 0 on failure to allocate, let caller deal with it

        if (0 == newbuf)

            return 0;

        memcpy (newbuf, *pbuf, buflen);

        // append a guard block to the end of the buffer

        memcpy (newbuf + newbufsize - 4, deadbeef, 4);

        if (*pbuf) {

            // verify that we didn't write past the end of the buffer

            assert (0 == memcmp (*pbuf + *pbufsize, deadbeef, 4));

            free (*pbuf);

        }

        *pbuf     = newbuf;

        *pbufsize = newbufsize - 4;

        (*pbuf)[buflen] = '\0';

    }

    if (0 != str) {

        memcpy (*pbuf + buflen, str, len);

        buflen += len;

        (*pbuf)[buflen] = '\0';

    }

    return *pbuf + buflen;

}

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

// rw_asnprintf_cb is called to format a character string according

// to the single format specifier `fmt' to the end of the provided

// buffer `*pbuf'; the function can reallocate the buffer

// returns the number of characters appended to the buffer

extern int

(*rw_vasnprintf_cb)(FmtSpec*, size_t, char**, size_t*, const char*, va_list*);

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

static int