punct.cpp

Go to the documentation of this file.

 
#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"
#include "punct.h"
 
 
#if defined (_RWSTD_MSVC) && 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,
                     _RWSTD_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++ = '#';
 
        // follows resolution of lwg issue 231
        if (0 <= prec) {
 
            // 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