/***************************************************************************
 *
 * punct.cpp
 *
 * $Id$
 *
 ***************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you 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.
 *
 * Copyright 2001-2007 Rogue Wave Software, Inc.
 * 
 **************************************************************************/

#define _RWSTD_LIB_SRC
#include <rw/_defs.h>

#include <locale.h>   // for lconv, localeconv(), setlocale()
#include <stdio.h>    // for sprintf()
#include <stdlib.h>   // for mbstowcs()
#include <string.h>   // for memcpy()

#include <ios>        // for ios_base, needed by <rw/_punct.h>
#include <memory>     // for operator new() and delete()

#include "access.h"

#include <loc/_localedef.h>
#include <loc/_moneypunct.h>
#include <loc/_numpunct.h>

#include <rw/_error.h>

#include "setlocale.h"


#if defined (_MSC_VER) && defined (_WIN64)
  // shut up MSVC/Win64 complaints about possible loss of data
#  pragma warning (disable: 4244)
#endif   // MSVC/Win64


_RWSTD_NAMESPACE (__rw) {


static inline void
__rw_copy (void *dst, const void *src, size_t n)
{
    memcpy (dst, src, n);
}

static inline void
__rw_widen (void *dst, const void *src, size_t n)
{
    mbstowcs (_RWSTD_STATIC_CAST (wchar_t*, dst),
              _RWSTD_STATIC_CAST (const char*, src), n);
}


static const void*
__rw_get_numpunct (const __rw_facet *pfacet, int flags)
{
    const int   member = flags & ~(__rw_mon | __rw_wide | __rw_intl);
    const bool  winx   = !!(flags & __rw_wide);   // wide or narrow index
    const void *pdata  = pfacet->_C_data ();      // mapped locale database

    if (pdata) {

        const __rw_punct_t* const pun =
            _RWSTD_STATIC_CAST (const __rw_punct_t*, pdata);

        const __rw_num_t *num;
    
        switch (member) {

        case __rw_dp: return pun->decimal_point (winx);
        case __rw_ts: return pun->thousands_sep (winx);
        case __rw_gr: return pun->grouping ();

        case __rw_tn:
            num = _RWSTD_STATIC_CAST (const __rw_num_t*, pun->get_ext ());
            _RWSTD_ASSERT (num);
            return num->truename (winx);

        case __rw_fn:
            num = _RWSTD_STATIC_CAST (const __rw_num_t*, pun->get_ext ());
            _RWSTD_ASSERT (num);
            return num->falsename (winx);

        default: _RWSTD_ASSERT (!"bad discriminant");
        }

        return 0;
    }
    else if (0 == __rw_access::_C_get_name (*pfacet)) {   // "C" locale

        static const void* const cdata[] = {
            ".", L".", ",", L",", "", L"", "true", L"true", "false", L"false"
        };

        switch (member) {

        case __rw_dp: return cdata [0 + winx];   // 22.2.3.1.2, p1
        case __rw_ts: return cdata [2 + winx];   // 22.2.3.1.2, p2
        case __rw_gr: return cdata [4 + winx];   // 22.2.3.1.2, p3
        case __rw_tn: return cdata [6 + winx];   // 22.2.3.1.2, p4
        case __rw_fn: return cdata [8 + winx];

        default: _RWSTD_ASSERT (!"bad discriminant");
        }

        return 0;
    }

    const char* const locname = __rw_access::_C_get_name (*pfacet) ?
        __rw_access::_C_get_name (*pfacet) : "C";
    
    // set all categories -- need LC_NUMERIC and LC_CTYPE
    const __rw_setlocale clocale (locname, _RWSTD_LC_ALL);

    if (pfacet->_C_data ()) {
        // check to see if another thread may have set _C_data()
        // while we were waiting for the lock in __rw_setlocale
        // ctor above and, if so, call self recursively on the
        // already initialized `impdata'
        return __rw_get_numpunct (pfacet, flags);
    }

    // get the lconv data
    const lconv* const pconv = localeconv ();
    if (!pconv)
        __rw_throw (_RWSTD_ERROR_LOCALE_BAD_NAME, locname);

    // be prepared to handle (non-conforming) null pointers
    // (e.g., AIX -- see bug #558)
    const char* const grp = pconv->grouping ? pconv->grouping : "";
    const char* const dp  = pconv->decimal_point ? pconv->decimal_point : "";
    const char* const ts  = pconv->thousands_sep ? pconv->thousands_sep : "";

    // the size of the narrow grouping string in bytes
    const size_t grsz = strlen (grp) + 1;

    // compute the sizes of all members in bytes
    size_t dpsz = strlen (dp) + 1;
    size_t tssz = strlen (ts) + 1;
    size_t tnsz = sizeof "true";
    size_t fnsz = sizeof "false";

    if (winx) {
        // adjust for wide characters
        dpsz *= sizeof (wchar_t);
        tssz *= sizeof (wchar_t);
        tnsz *= sizeof (wchar_t);
        fnsz *= sizeof (wchar_t);
    }

    // compute the actual size of the variable size structure
    const size_t size =
          sizeof (__rw_punct_t)
        + sizeof (__rw_num_t)
        + sizeof (size_t)   // maximum padding for alignment
        + grsz + dpsz + tssz + tnsz + fnsz;

    // allocate variable size structure(s)
    __rw_punct_t* const pun = 
        _RWSTD_STATIC_CAST (__rw_punct_t*, ::operator new (size));

    // compute offsets into the varaiable size structure
    pun->decimal_point_off [winx] = 0;
    pun->thousands_sep_off [winx] = pun->decimal_point_off [winx] + int (dpsz);

    // point widen to a wrapper for mbstowcs() for wchar_t or memcpy otherwise
    void (*widen)(void*, const void*, size_t) =
        winx ? __rw_widen : __rw_copy;

    // copy strings from lconv data members to the varaiable size structure
    char* s = _RWSTD_REINTERPRET_CAST (char*, pun + 1);

    widen (s + pun->decimal_point_off [winx], dp, dpsz);
    widen (s + pun->thousands_sep_off [winx], ts, tssz);

    // set the offset of the extended punctuation data
    pun->punct_ext_off = pun->thousands_sep_off [winx] + int (tssz);

    // adjust alignment
    const size_t misalign = pun->punct_ext_off % sizeof (size_t);
    if (misalign)
        pun->punct_ext_off += int (sizeof (size_t) - misalign);

    s = _RWSTD_REINTERPRET_CAST (char*, pun + 1) + pun->punct_ext_off;

    __rw_num_t* const num = _RWSTD_REINTERPRET_CAST (__rw_num_t*, s);

    s += sizeof *num;

    // invalidate members (offsets) by setting them to 0xff
    memset (num, ~0, sizeof *num);

    num->truename_off  [winx] = 0;
    num->falsename_off [winx] = num->truename_off [winx] + int (tnsz);

    widen (s + num->truename_off  [winx], "true", tnsz);
    widen (s + num->falsename_off [winx], "false", fnsz);

    // place narrow grouping string last to avoid alignment issues
    pun->grouping_off =
        _RWSTD_STATIC_CAST (_RWSTD_UINT32_T,
        pun->punct_ext_off + sizeof *num + num->falsename_off [winx] + fnsz);

    memcpy (s + num->falsename_off [winx] + fnsz, grp, grsz);

    // set `impdata' and `impsize' (facet base dtor will delete)
    __rw_access::_C_get_impdata (*_RWSTD_CONST_CAST (__rw_facet*, pfacet)) =
        pun;

    __rw_access::_C_get_impsize (*_RWSTD_CONST_CAST (__rw_facet*, pfacet)) =
        (size_t)(-1);

    // call self recursively on already initialized `impdata'
    return __rw_get_numpunct (pfacet, flags);
}

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


static const void*
__rw_get_moneypunct (const __rw_facet *pfacet, int flags)
{
    const int   member = flags & ~(__rw_mon | __rw_wide | __rw_intl);
    const bool  winx   = !!(flags & __rw_wide);   // wide or narrow index
    const bool  intl   = !!(flags & __rw_intl);   // international or domestic
    const void *pdata  = pfacet->_C_data ();      // mapped locale database

    if (pdata) {

        const __rw_punct_t* const pun =
            _RWSTD_STATIC_CAST (const __rw_punct_t*, pdata);

        const __rw_mon_t *mon;
    
        switch (member) {
        case __rw_dp: return pun->decimal_point (winx);
        case __rw_ts: return pun->thousands_sep (winx);
        case __rw_gr: return pun->grouping ();

        }

        // get extended data
        mon = _RWSTD_STATIC_CAST (const __rw_mon_t*, pun->get_ext ());
        _RWSTD_ASSERT (mon);

        typedef unsigned char UChar;

        switch (member) {

        case __rw_cs: return mon->curr_symbol (intl, winx);
        case __rw_ps: return mon->positive_sign (winx);
        case __rw_ns: return mon->negative_sign (winx);

        case __rw_pf: return mon->pos_format [intl];
        case __rw_nf: return mon->neg_format [intl];

        case __rw_fd:
            return _RWSTD_REINTERPRET_CAST (void*, (size_t)
                                            UChar (mon->frac_digits [intl]));

        default: _RWSTD_ASSERT (!"bad discriminant");
        }

        return 0;
    }
    else if (0 == __rw_access::_C_get_name (*pfacet)) {   // "C" locale

        static const void* const cdata[] = {
            ".", L".", ",", L",", "", L"", "", L"", "", L"",
            "", L"", "", L"", "\2\3\0\4", "\2\3\0\4", 
        };

        switch (member) {

        case __rw_dp: return cdata [0 + winx];
        case __rw_ts: return cdata [2 + winx];
        case __rw_gr: return cdata [4 + winx];
        case __rw_cs: return cdata [6 + winx + 2 * intl];
        case __rw_ps: return cdata [10 + winx];
        case __rw_ns: return cdata [12 + winx];
        case __rw_pf: return cdata [14];
        case __rw_nf: return cdata [15];

        // the number of fractional digits in the "C" locale is not specified
        case __rw_fd: return 0;   // no fractional digits

        default: _RWSTD_ASSERT (!"bad discriminant");
        }

        return 0;
    }

    const char* const locname = __rw_access::_C_get_name (*pfacet) ?
        __rw_access::_C_get_name (*pfacet) : "C";
    
    // set all categories -- need LC_NUMERIC and LC_CTYPE
    const __rw_setlocale clocale (locname, _RWSTD_LC_ALL);

    if (pfacet->_C_data ()) {
        // check to see if another thread may have set _C_data()
        // while we were waiting for the lock in __rw_setlocale
        // ctor above and, if so, call self recursively on the
        // already initialized `impdata'
        return __rw_get_moneypunct (pfacet, flags);
    }

    // get the lconv data
    const lconv* const pconv = localeconv ();
    if (!pconv)
        __rw_throw (_RWSTD_ERROR_LOCALE_BAD_NAME, locname);

    _RWSTD_ASSERT (pconv->mon_grouping);
    _RWSTD_ASSERT (pconv->mon_decimal_point);
    _RWSTD_ASSERT (pconv->mon_thousands_sep);

    // the size of the narrow grouping string in bytes
    const size_t grsz = strlen (pconv->mon_grouping) + 1;

    // compute the sizes of all members in bytes
    size_t dpsz = strlen (pconv->mon_decimal_point) + 1;
    size_t tssz = strlen (pconv->mon_thousands_sep) + 1;
    size_t pssz = strlen (pconv->positive_sign) + 1;
    size_t nssz = strlen (pconv->negative_sign) + 1;

    const char* const cs = intl ? pconv->int_curr_symbol
                                : pconv->currency_symbol;

    size_t cssz = strlen (cs) + 1;

    if (winx) {
        // adjust for wide characters
        dpsz *= sizeof (wchar_t);
        tssz *= sizeof (wchar_t);
        pssz *= sizeof (wchar_t);
        nssz *= sizeof (wchar_t);
        cssz *= sizeof (wchar_t);
    }

    // compute the actual size of the variable size structure
    const size_t size =
          sizeof (__rw_punct_t)
        + sizeof (__rw_mon_t)
        + sizeof (size_t)   // maximum padding for alignment
        + grsz + dpsz + tssz + pssz + nssz + cssz;

    // allocate variable size structure(s)
    __rw_punct_t* const pun = 
        _RWSTD_STATIC_CAST (__rw_punct_t*, ::operator new (size));

    // compute offsets into the varaiable size structure
    pun->decimal_point_off [winx] = 0;
    pun->thousands_sep_off [winx] = pun->decimal_point_off [winx] + int (dpsz);

    // point widen to a wrapper for mbstowcs() for wchar_t or memcpy otherwise
    void (*widen)(void*, const void*, size_t) =
        winx ? __rw_widen : __rw_copy;

    // copy strings from lconv data members to the varaiable size structure
    char* s = _RWSTD_REINTERPRET_CAST (char*, pun + 1);

    widen (s + pun->decimal_point_off [winx], pconv->mon_decimal_point, dpsz);
    widen (s + pun->thousands_sep_off [winx], pconv->mon_thousands_sep, tssz);

    // set the offset of the extended punctuation data
    pun->punct_ext_off = pun->thousands_sep_off [winx] + int (tssz);

    // adjust alignment
    const size_t misalign = pun->punct_ext_off % sizeof (size_t);
    if (misalign)
        pun->punct_ext_off += int (sizeof (size_t) - misalign);

    s = _RWSTD_REINTERPRET_CAST (char*, pun + 1) + pun->punct_ext_off;

    __rw_mon_t* const mon = _RWSTD_REINTERPRET_CAST (__rw_mon_t*, s);

    s += sizeof *mon;

    // invalidate members (offsets) by setting them to 0xff
    memset (mon, ~0, sizeof *mon);

    mon->positive_sign_off [winx] = 0;
    mon->negative_sign_off [winx] = mon->positive_sign_off [winx] + int (pssz);

    widen (s + mon->positive_sign_off [winx], pconv->positive_sign, pssz);
    widen (s + mon->negative_sign_off [winx], pconv->negative_sign, nssz);

    mon->curr_symbol_off [intl][winx] =
        mon->negative_sign_off [winx] + int (nssz);

    widen (s + mon->curr_symbol_off [intl][winx], cs, cssz);

    pun->grouping_off =
        _RWSTD_STATIC_CAST (_RWSTD_UINT32_T,
          pun->punct_ext_off + sizeof *mon
        + mon->curr_symbol_off [intl][winx] + cssz);

    // place narrow grouping string last to avoid alignment issues
    memcpy (s + mon->curr_symbol_off [intl][winx] + cssz,
            pconv->mon_grouping, grsz);

    mon->frac_digits [0]    = pconv->frac_digits;
    mon->frac_digits [1]    = pconv->int_frac_digits;

    // initialize domestic C90 formats
    mon->p_cs_precedes [0]  = pconv->p_cs_precedes;
    mon->n_cs_precedes [0]  = pconv->n_cs_precedes;
    mon->p_sep_by_space [0] = pconv->p_sep_by_space;
    mon->n_sep_by_space [0] = pconv->n_sep_by_space;
    mon->p_sign_posn [0]    = pconv->p_sign_posn;
    mon->n_sign_posn [0]    = pconv->n_sign_posn;

#ifndef _RWSTD_NO_LCONV_INT_FMAT

    // copy international formats from C99 members
    mon->p_cs_precedes [1]  = pconv->int_p_cs_precedes;
    mon->n_cs_precedes [1]  = pconv->int_n_cs_precedes;
    mon->p_sep_by_space [1] = pconv->int_p_sep_by_space;
    mon->n_sep_by_space [1] = pconv->int_n_sep_by_space;
    mon->p_sign_posn [1]    = pconv->int_p_sign_posn;
    mon->n_sign_posn [1]    = pconv->int_n_sign_posn;

#else   // if defined (_RWSTD_NO_LCONV_INT_FMAT)

    // copy international formats from local members
    mon->p_cs_precedes [1]  = mon->p_cs_precedes [0];
    mon->n_cs_precedes [1]  = mon->n_cs_precedes [0];
    mon->p_sep_by_space [1] = mon->p_sep_by_space [0];
    mon->n_sep_by_space [1] = mon->n_sep_by_space [0];
    mon->p_sign_posn [1]    = mon->p_sign_posn [0];
    mon->n_sign_posn [1]    = mon->n_sign_posn [0];

#endif   // _RWSTD_NO_LCONV_INT_FMAT

    enum {
        // for syntactic convenience
        none   = _STD::money_base::none,
        space  = _STD::money_base::space,
        symbol = _STD::money_base::symbol,
        sign   = _STD::money_base::sign,
        value  = _STD::money_base::value
    };

    static const _STD::money_base::pattern pat[] = {

        // cs_precedes [0..1]:
        //
        // An integer set to 1 if the currency_symbol precedes the value
        // for a monetary value, and set to 0 if the symbol succeeds
        // the value.

        // sep_by_space [0..2]:
        //
        // 0  No space separates the currency_symbol from the value for
        //    a monetary value.
        // 1  If the currency symbol and sign string are adjacent, a space
        //    separates them from the value; otherwise, a space separates
        //    the currency symbol from the value.
        // 2  If the currency symbol and sign string are adjacent, a space
        //    separates them; otherwise, a space separates the sign string
        //    from the value.

        // sign_posn [0..4]:
        //
        // An integer set to a value indicating the positioning of the
        // positive_sign for a monetary value. The following integer
        // values shall be recognized:
        //
        // 0  Parentheses enclose the value and the currency_symbol.
        // 1  The sign string precedes the value and the currency_symbol.
        // 2  The sign string succeeds the value and the currency_symbol.
        // 3  The sign string immediately precedes the currency_symbol.
        // 4  The sign string immediately succeeds the currency_symbol.

        // +-------- cs_precedes
        // |+----- sep_by_space
        // ||+-- sign_posn
        // |||
        // VVV  ....        -     1      $       .           // pattern
        /* 000: -1$. */ { { sign, value, symbol, none } },   // "\3\4\2\0"
        /* 001: -1$. */ { { sign, value, symbol, none } },   // "\3\4\2\0"
        /* 002: 1$-. */ { { value, symbol, sign, none } },   // "\4\2\3\0"
        /* 003: 1-$. */ { { value, sign, symbol, none } },   // "\4\3\2\0"
        /* 004: 1$-. */ { { value, symbol, sign, none } },   // "\4\2\3\0"

        /* 010: -1 $ */ { { sign, value, space, symbol } },  // "\3\4\1\2"
        /* 011: -1 $ */ { { sign, value, space, symbol } },  // "\3\4\1\2"
        /* 012: 1 $- */ { { value, space, symbol, sign } },  // "\4\1\2\3"
        /* 013: 1 -$ */ { { value, space, sign, symbol } },  // "\4\3\3\2"
        /* 014: 1 $- */ { { value, space, symbol, sign } },  // "\4\1\2\3"

        /* 020: - 1$ */ { { sign, space, value, symbol } },  // "\3\1\4\2"
        /* 021: - 1$ */ { { sign, space, value, symbol } },  // "\3\1\4\2"
        /* 022: 1$ - */ { { value, symbol, space, sign } },  // "\4\2\1\3"
        /* 023: 1- $ */ { { value, sign, space, symbol } },  // "\4\3\1\2"
        /* 024: 1$ - */ { { value, symbol, space, sign } },  // "\4\2\1\3"

        /* 100: -$1. */ { { sign, symbol, value, none } },   // "\3\2\4\0"
        /* 101: -$1. */ { { sign, symbol, value, none } },   // "\3\2\4\0"
        /* 102: $1-. */ { { symbol, value, sign, none } },   // "\2\4\3\0"
        /* 103: -$1. */ { { sign, symbol, value, none } },   // "\3\2\4\0"
        /* 104: $-1. */ { { symbol, sign, value, none } },   // "\2\3\4\0"

        /* 110: -$ 1 */ { { sign, symbol, space, value } },  // "\3\2\1\4"
        /* 111: -$ 1 */ { { sign, symbol, space, value } },  // "\3\2\1\4"
        /* 112: $ 1- */ { { symbol, space, value, sign } },  // "\2\1\4\3"
        /* 113: -$ 1 */ { { sign, symbol, space, value } },  // "\3\2\1\4"
        /* 114: $- 1 */ { { symbol, sign, space, value } },  // "\2\3\1\4"

        /* 120: - $1 */ { { sign, space, symbol, value } },  // "\3\1\2\4"
        /* 121: - $1 */ { { sign, space, symbol, value } },  // "\3\1\2\4"
        /* 122: $1 - */ { { symbol, value, space, sign } },  // "\2\4\1\3"
        /* 123: - $1 */ { { sign, space, symbol, value } },  // "\3\1\2\4"
        /* 124: $ -1 */ { { symbol, space, sign, value } }   // "\2\1\3\4"
    };

    size_t inx =   size_t (mon->p_cs_precedes [intl]) * (3U * 5U)
                 + size_t (mon->p_sep_by_space [intl]) * 5U
                 + size_t (mon->p_sign_posn [intl]);

    if (inx < sizeof pat / sizeof *pat)
        memcpy (mon->pos_format [intl], pat + inx, sizeof *pat);
    else
        memset (mon->pos_format [intl], none, sizeof *pat);

    inx =   size_t (mon->n_cs_precedes [intl]) * (3U * 5U)
          + size_t (mon->n_sep_by_space [intl]) * 5U
          + size_t (mon->n_sign_posn [intl]);

    if (inx < sizeof pat / sizeof *pat)
        memcpy (mon->neg_format [intl], pat + inx, sizeof *pat);
    else
        memset (mon->neg_format [intl], none, sizeof *pat);

    // set `impdata' and `impsize' (facet base dtor will delete)
    __rw_access::_C_get_impdata (*_RWSTD_CONST_CAST (__rw_facet*, pfacet)) =
        pun;

    __rw_access::_C_get_impsize(*_RWSTD_CONST_CAST (__rw_facet*, pfacet)) =
        (size_t)(-1);

    // call self recursively on already initialized `impdata'
    return __rw_get_moneypunct (pfacet, flags);
}

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


/* _RWSTD_SPECIALIZED_FUNCTION */ _RWSTD_EXPORT
const char*
__rw_get_punct(const __rw_facet *pfacet, int flags, char)
{
    typedef const char *CPChar;

    if (flags & __rw_mon)
        return CPChar (__rw_get_moneypunct (pfacet, flags & ~__rw_mon));

    return CPChar (__rw_get_numpunct (pfacet, flags));
}


#ifndef _RWSTD_NO_WCHAR_T

/* _RWSTD_SPECIALIZED_FUNCTION */ _RWSTD_EXPORT
const wchar_t*
__rw_get_punct(const __rw_facet *pfacet, int flags, wchar_t)
{
    flags |= __rw_wide;

    typedef const wchar_t *CPWChar;

    if (flags & __rw_mon)
        return CPWChar (__rw_get_moneypunct (pfacet, flags & ~__rw_mon));

    return CPWChar (__rw_get_numpunct (pfacet, flags));
}

#endif   // _RWSTD_NO_WCHAR_T


const char*
__rw_get_stdio_fmat (char buf [32], int type, unsigned fmtflags,
                     _STD::streamsize prec)
{
    char *pbuf = buf;

    // format of the specifier:
    //     "%[+][#](.[0-9]*)(h|l|L|LL)(o|x|X|i|d|e|E|f|F|g|G|p)"

    *pbuf++ = '%';

    if (fmtflags & _RWSTD_IOS_SHOWPOS)
        *pbuf++ = '+';

    if (type & __rw_facet::_C_floating) {
        if (fmtflags & _RWSTD_IOS_SHOWPOINT)
            *pbuf++ = '#';

        const int fltfld = fmtflags & _RWSTD_IOS_FLOATFIELD;

        // follows resolution of lwg issue 231
        if (   (   _RWSTD_IOS_FIXED      == fltfld
                || _RWSTD_IOS_SCIENTIFIC == fltfld)
            && prec >= 0 || prec > 0) {

            // 7.19.6.1, p5 of C99 specifies that, when given using the
            // asterisk, negative precision is treated the same as if
            // it were omitted; treat negative precision the same here
            pbuf += sprintf (pbuf, ".%ld", long (prec));
        }
    }
    else if (fmtflags & _RWSTD_IOS_SHOWBASE)
        *pbuf++ = '#';

    enum {
        // for convenience
        Short   = __rw_facet::_C_ushort  & __rw_facet::_C_typemask,
        Long    = __rw_facet::_C_ulong   & __rw_facet::_C_typemask,
        LLong   = __rw_facet::_C_ullong  & __rw_facet::_C_typemask,
        Double  = __rw_facet::_C_double  & __rw_facet::_C_typemask,
        LDouble = __rw_facet::_C_ldouble & __rw_facet::_C_typemask
    };

    const int basetype = type & __rw_facet::_C_typemask;

    switch (basetype) {

    case Short: *pbuf++ = 'h'; break;
    case Long:
    case Double:
        *pbuf++ = 'l';
        break;

    case LDouble: *pbuf++ = 'L'; break;

    case LLong:

#ifdef _RWSTD_LLONG_PRINTF_PREFIX

        memcpy (pbuf, _RWSTD_LLONG_PRINTF_PREFIX,
                sizeof _RWSTD_LLONG_PRINTF_PREFIX - 1);
        pbuf += sizeof _RWSTD_LLONG_PRINTF_PREFIX - 1;

#else

        _RWSTD_ASSERT (!"long long printf prefix not configured");

#endif   // _RWSTD_LLONG_PRINTF_PREFIX

        break;
    }

    if (type & __rw_facet::_C_floating) {

        switch (fmtflags & _RWSTD_IOS_FLOATFIELD) {
        case _RWSTD_IOS_FIXED:
            *pbuf++ = 'f';
            break;

        case _RWSTD_IOS_SCIENTIFIC:
            *pbuf++ = fmtflags & _RWSTD_IOS_UPPERCASE ? 'E' : 'e';
            break;

        default:
            *pbuf++ = fmtflags & _RWSTD_IOS_UPPERCASE ? 'G' : 'g';
        }
    }
    else if (type == __rw_facet::_C_pvoid)
        *pbuf++ = 'p';
    else if (type == __rw_facet::_C_bool && fmtflags & _RWSTD_IOS_BOOLALPHA)
        --pbuf;   // empty format indicates bool
    else {
        switch (fmtflags & _RWSTD_IOS_BASEFIELD) {
        case _RWSTD_IOS_OCT: *pbuf++ = 'o'; break;
        case _RWSTD_IOS_DEC: *pbuf++ = 'd'; break;
        case _RWSTD_IOS_HEX:
            *pbuf++ = fmtflags & _RWSTD_IOS_UPPERCASE ? 'X' : 'x';
            break;
        default:
            *pbuf++ = 'i';
            
        }
    }

    *pbuf++ = '\0';

    _RWSTD_ASSERT (pbuf - buf < 32);

    return buf;
}


}   // namespace __rw