/************************************************************************
 *
 * fmt_bits.cpp - definitions of snprintfa helpers
 *
 * $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 2005-2008 Rogue Wave Software. Inc.
 * 
 **************************************************************************/

// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC

#include "fmt_defs.h"

#include <rw_printf.h>

#include <ctype.h>    // for isalnum(), ...
#include <errno.h>    // for errno, errno constants
#include <locale.h>
#include <signal.h>   // for signal constant
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>   // memcpy(), memmove(), strcat(), ...

#ifndef _RWSTD_NO_WCHAR_H
#  include <wchar.h>
#endif   // _RWSTD_NO_WCHAR_H

#ifndef _RWSTD_NO_WCTYPE_H
#  include <wctype.h>   // for iswalpha(), ...
#endif   // _RWSTD_NO_WCTYPE_H

#ifdef _WIN32
#  include <windows.h>   // for FormatMessage()
#endif   // _WIN32

#include <ios>
#include <iostream>
#include <locale>

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

struct Bitnames
{
    const char *longname;
    const char *name;
    int         bits;
};

#define BITNAME(qual, name)   { #qual "::" #name, #name, qual::name }

static int
_rw_bmpfmt (const FmtSpec &spec, Buffer &buf,
            const Bitnames  bmap[],
            size_t          size,
            int             bits)
{
    RW_ASSERT (0 != buf.pbuf);

    char buffer [1024];
    *buffer = '\0';

    // string to use when no bits are set
    const char* all_clear = "0";

    for (size_t i = 0; i != size; ++i) {
        if (bmap [i].bits) {
            if ((bits & bmap [i].bits) == bmap [i].bits) {

                const char* const name = spec.fl_pound ?
                    bmap [i].longname : bmap [i].name;

                strcat (*buffer ? strcat (buffer, " | ") : buffer, name);

                bits &= ~bmap [i].bits;
            }
        }
        else {
            // save the name of the constant to use for 0
            all_clear = spec.fl_pound ? bmap [i].longname : bmap [i].name;
        }
    }

    size_t buffersize;

    if ('\0' == *buffer) {
        // no constant matched, format teh value either as a number
        // or, when 0, using the all_clear name (see above)
        if (bits)
            sprintf (buffer, "%#x", bits);
        else
            strcpy (buffer, all_clear);

        buffersize = strlen (buffer);
    }
    else if (bits) {
        buffersize = strlen (buffer);

        // verify that buffer wasn't overflowed
        RW_ASSERT (buffersize <= sizeof buffer);

        char bitstr [32];
        const int n = sprintf (bitstr, "%#x | ", bits);

        RW_ASSERT (0 < n);

        memmove (buffer + n, buffer, buffersize);
        memcpy (buffer, bitstr, size_t (n));

        buffersize += n;
    }
    else {
        buffersize = strlen (buffer);
    }

    // verify that buffer wasn't overflowed
    RW_ASSERT (buffersize <= sizeof buffer);

    // NUL-terminate string so that it can be appended to using
    // the %{+} directive, taking care not to make the NUL a part
    // of the formatted string
    FmtSpec newspec (spec);
    newspec.fl_pound = 0;

    const int len = _rw_fmtstr (newspec, buf, buffer, buffersize + 1);
    --buf.endoff;

    return 0 < len ? len - 1 : len;
}

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

/* extern */ int
_rw_fmtflags (const FmtSpec &spec, Buffer &buf, int bits)
{
    static const Bitnames names [] = {
        BITNAME (std::ios, adjustfield),
        BITNAME (std::ios, basefield),
        BITNAME (std::ios, boolalpha),
        BITNAME (std::ios, dec),
        BITNAME (std::ios, fixed),
        BITNAME (std::ios, hex),
        BITNAME (std::ios, internal),
        BITNAME (std::ios, left),
        BITNAME (std::ios, oct),
        BITNAME (std::ios, right),
        BITNAME (std::ios, scientific),
        BITNAME (std::ios, showbase),
        BITNAME (std::ios, showpoint),
        BITNAME (std::ios, showpos),
        BITNAME (std::ios, skipws),
        BITNAME (std::ios, unitbuf),
        BITNAME (std::ios, uppercase),

#ifndef _RWSTD_NO_EXT_BIN_IO

        // extension: produce binary output (similar to oct, dec, and hex)
        BITNAME (std::ios, bin),

#endif   // _RWSTD_NO_EXT_BIN_IO

#ifndef _RWSTD_NO_EXT_REENTRANT_IO

        // extension: allow unsychronized access to stream and/or its buffer
        BITNAME (std::ios, nolock),
        BITNAME (std::ios, nolockbuf),

#endif   // _RWSTD_NO_EXT_REENTRANT_IO

        { "std::ios::fmtflags(0)", "fmtflags(0)", std::ios::fmtflags () }

    };

    static const size_t count = sizeof names / sizeof *names;

    const int base = (bits >> _RWSTD_IOS_BASEOFF) & _RWSTD_IOS_BASEMASK;

    // zero out bits representingthe numeric base
    bits &= ~(_RWSTD_IOS_BASEMASK << _RWSTD_IOS_BASEOFF);

    int len = _rw_bmpfmt (spec, buf, names, count, bits);

    if (0 < len && base && base != 8 && base != 10 && base != 16) {

        // for numeric bases other than those required by the standard,
        // use the text "base (%d)" to show the extended numeric base

#ifndef _RWSTD_NO_EXT_BIN_IO

        if (bits & std::ios::bin)
            return len;

#endif   // _RWSTD_NO_EXT_BIN_IO

        const int n = rw_asnprintf (buf.pbuf, buf.pbufsize,
                                    "%{+} | %{?}std::ios::%{;}base(%d)",
                                    spec.fl_pound, base);

        if (0 < n) {
            // adjust length and the end offset after appending above
            len        += n;
            buf.endoff += n;
        }
        else {
            // error (most likely ENOMEM)
            len = n;
        }
    }

    return len;
}

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

/* extern */ int
_rw_fmtiostate (const FmtSpec &spec, Buffer &buf, int bits)
{
    static const Bitnames names [] = {
        BITNAME (std::ios, goodbit),
        BITNAME (std::ios, badbit),
        BITNAME (std::ios, eofbit),
        BITNAME (std::ios, failbit)
    };

    static const size_t count = sizeof names / sizeof *names;

    return _rw_bmpfmt (spec, buf, names, count, bits);
}

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

/* extern */ int
_rw_fmtopenmode (const FmtSpec &spec, Buffer &buf, int bits)
{
    static const Bitnames names [] = {

#ifndef _RWSTD_NO_EXTENSIONS

        { "std::ios::nocreate", "nocreate", std::ios::nocreate },
        { "std::ios::noreplace", "noreplace", std::ios::noreplace },

#else   // if defined (_RWSTD_NO_EXTENSIONS)

        { "__rw:::__rw_nocreate", "__rw_nocreate", _RW::__rw_nocreate },
        { "__rw::__rw_noreplace", "__rw_noreplace", _RW::__rw_noreplace },

#endif   // _RWSTD_NO_EXTENSIONS

#ifndef _RWSTD_NO_EXT_STDIO

        { "std::ios::stdio", "stdio", std::ios::stdio },
        { "std::ios::native", "native", std::ios::native },

#else   // if defined (_RWSTD_NO_EXT_STDIO)

        { "__rw::__rw_stdio", "__rw_stdio", _RW::__rw_stdio },
        { "__rw::__rw_native", "__rw_native", _RW::__rw_native },

#endif   // _RWSTD_NO_EXT_STDIO

        BITNAME (std::ios, app),
        BITNAME (std::ios, binary),
        BITNAME (std::ios, in),
        BITNAME (std::ios, out),
        BITNAME (std::ios, trunc),
        BITNAME (std::ios, ate),

        { "std::ios::openmode(0)", "openmode(0)", std::ios::openmode () }
    };

    static const size_t count = sizeof names / sizeof *names;

    return _rw_bmpfmt (spec, buf, names, count, bits);
}

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

/* extern */ int
_rw_fmtseekdir (const FmtSpec &spec, Buffer &buf, int bits)
{
    static const Bitnames names [] = {

        BITNAME (std::ios, beg),
        BITNAME (std::ios, cur),
        BITNAME (std::ios, end)
    };

    static const size_t count = sizeof names / sizeof *names;

    return _rw_bmpfmt (spec, buf, names, count, bits);
}

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

/* extern */ int
_rw_fmtevent (const FmtSpec& spec, Buffer &buf, int event)
{
    const char* const str =
          std::ios::copyfmt_event == event ? "copyfmt_event"
        : std::ios::imbue_event   == event ? "imbue_event"
        : std::ios::erase_event   == event ? "erase_event"
        : 0;

    // NUL-terminate before appending below
    FmtSpec newspec (spec);
    newspec.fl_pound = 0;

    int len = _rw_fmtstr (newspec, buf, "", 1);

    if (1 == len) {
        // back up before the terminating NUL
        buf.endoff -= 1;

        // append name of event
        len = rw_asnprintf (buf.pbuf, buf.pbufsize,
                            "%{+}%{?}std::ios::%{;}%{?}%s%{:}event(%d)%{;}",
                            spec.fl_pound, 0 != str, str, event);

        if (0 < len)
            buf.endoff += len;
    }

    return len;
}

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

/* extern */ int
_rw_fmtlc (const FmtSpec &spec, Buffer &buf, int val)
{
    const char *str = 0;

    switch (val) {
    case LC_ALL:      str = "LC_ALL"; break;
    case LC_COLLATE:  str = "LC_COLLATE"; break;
    case LC_CTYPE:    str = "LC_CTYPE"; break;
    case LC_MONETARY: str = "LC_MONETARY"; break;
    case LC_NUMERIC:  str = "LC_NUMERIC"; break;
    case LC_TIME:     str = "LC_TIME"; break;

#ifdef LC_MESSAGES
    case LC_MESSAGES: str = "LC_MESSAGES"; break;
#endif   // LC_MESSAGES

    }

    if (str) {
        // NUL-terminate before appending below
        FmtSpec newspec (spec);
        newspec.fl_pound = 0;

        int len = _rw_fmtstr (newspec, buf, "", 1);

        if (1 == len) {
            // back up before the terminating NUL
            buf.endoff -= 1;

            len = rw_asnprintf (buf.pbuf, buf.pbufsize, "%{+}%s", str);

            if (0 < len)
                buf.endoff += len;
        }

        return len;
    }

    static const Bitnames names [] = {
        BITNAME (std::locale, all),
        BITNAME (std::locale, none),
        BITNAME (std::locale, collate),
        BITNAME (std::locale, ctype),
        BITNAME (std::locale, monetary),
        BITNAME (std::locale, numeric),
        BITNAME (std::locale, messages),
        BITNAME (std::locale, time)
    };

    static const size_t count = sizeof names / sizeof *names;

    return _rw_bmpfmt (spec, buf, names, count, val);
}

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

/* extern */ int
_rw_fmtmonpat (const FmtSpec &spec, Buffer &buf, const char pat [4])
{
    static const char qual[] = "std::money_base::";

    char buffer [256];

    buffer [0] = '\0';

    for (int i = 0; i != 4; ++i) {
        switch (pat [i]) {
        case std::money_base::symbol:
            if (spec.fl_pound)
                strcat (buffer, qual);
            strcat (buffer, "symbol ");
            break;

        case std::money_base::sign:
            if (spec.fl_pound)
                strcat (buffer, qual);
            strcat (buffer, "sign ");
            break;

        case std::money_base::none:
            if (spec.fl_pound)
                strcat (buffer, qual);
            strcat (buffer, "none ");
            break;

        case std::money_base::value:
            if (spec.fl_pound)
                strcat (buffer, qual);
            strcat (buffer, "value ");
            break;

        case std::money_base::space:
            if (spec.fl_pound)
                strcat (buffer, qual);
            strcat (buffer, "space ");
            break;

        default:
            sprintf (buffer + strlen (buffer), "\\%03o", pat [i]);
            break;
        }
    }

    FmtSpec newspec (spec);
    newspec.fl_pound = 0;

    return _rw_fmtstr (newspec, buf, buffer, _RWSTD_SIZE_MAX);
}

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

/* extern */ int
_rw_fmtsignal (const FmtSpec &spec, Buffer &buf, int val)
{
    static const struct {
        int         val;
        const char* str;
    } names[] = {

#undef SIGNAL
#define SIGNAL(val)   { val, #val }

#ifdef SIGABRT
        SIGNAL (SIGABRT),
#endif   // SIGABRT
#ifdef SIGALRM
        SIGNAL (SIGALRM),
#endif   // SIGALRM
#ifdef SIGBUS
        SIGNAL (SIGBUS),
#endif   // SIGBUS
#ifdef SIGCANCEL
        SIGNAL (SIGCANCEL),
#endif   // SIGCANCEL
#ifdef SIGCHLD
        SIGNAL (SIGCHLD),
#endif   // SIGCHLD
#ifdef SIGCKPT
        SIGNAL (SIGCKPT),
#endif   // SIGCKPT
#ifdef SIGCLD
        SIGNAL (SIGCLD),
#endif   // SIGCLD
#ifdef SIGCONT
        SIGNAL (SIGCONT),
#endif   // SIGCONT
#ifdef SIGDIL
        SIGNAL (SIGDIL),
#endif   // SIGDIL
#ifdef SIGEMT
        SIGNAL (SIGEMT),
#endif   // SIGEMT
#ifdef SIGFPE
        SIGNAL (SIGFPE),
#endif   // SIGFPE
#ifdef SIGFREEZE
        SIGNAL (SIGFREEZE),
#endif   // SIGFREEZE
#ifdef SIGGFAULT
        SIGNAL (SIGGFAULT),
#endif   // SIGGFAULT
#ifdef SIGHUP
        SIGNAL (SIGHUP),
#endif   // SIGHUP
#ifdef SIGILL
        SIGNAL (SIGILL),
#endif   // SIGILL
#ifdef SIGINFO
        SIGNAL (SIGINFO),
#endif   // SIGINFO
#ifdef SIGINT
        SIGNAL (SIGINT),
#endif   // SIGINT
#ifdef SIGIO
        SIGNAL (SIGIO),
#endif   // SIGIO
#ifdef SIGIOT
        SIGNAL (SIGIOT),
#endif   // SIGIOT
#ifdef SIGK32
        SIGNAL (SIGK32),
#endif   // SIGK32
#ifdef SIGKILL
        SIGNAL (SIGKILL),
#endif   // SIGKILL
#ifdef SIGLOST
        SIGNAL (SIGLOST),
#endif   // SIGLOST
#ifdef SIGLWP
        SIGNAL (SIGLWP),
#endif   // SIGLWP
#ifdef SIGPIPE
        SIGNAL (SIGPIPE),
#endif   // SIGPIPE
#ifdef SIGPOLL
        SIGNAL (SIGPOLL),
#endif   // SIGPOLL
#ifdef SIGPROF
        SIGNAL (SIGPROF),
#endif   // SIGPROF
#ifdef SIGPTINTR
        SIGNAL (SIGPTINTR),
#endif   // SIGPTINTR
#ifdef SIGPTRESCHED
        SIGNAL (SIGPTRESCHED),
#endif   // SIGPTRESCHED
#ifdef SIGPWR
        SIGNAL (SIGPWR),
#endif   // SIGPWR
#ifdef SIGQUIT
        SIGNAL (SIGQUIT),
#endif   // SIGQUIT
#ifdef SIGRESTART
        SIGNAL (SIGRESTART),
#endif   // SIGRESTART
#ifdef SIGRESV
        SIGNAL (SIGRESV),
#endif   // SIGRESV
#ifdef SIGSEGV
        SIGNAL (SIGSEGV),
#endif   // SIGSEGV
#ifdef SIGSTKFLT
        SIGNAL (SIGSTKFLT),
#endif   // SIGSTKFLT
#ifdef SIGSTOP
        SIGNAL (SIGSTOP),
#endif   // SIGSTOP
#ifdef SIGSYS
        SIGNAL (SIGSYS),
#endif   // SIGSYS
#ifdef SIGTERM
        SIGNAL (SIGTERM),
#endif   // SIGTERM
#ifdef SIGTHAW
        SIGNAL (SIGTHAW),
#endif   // SIGTHAW
#ifdef SIGTRAP
        SIGNAL (SIGTRAP),
#endif   // SIGTRAP
#ifdef SIGTSTP
        SIGNAL (SIGTSTP),
#endif   // SIGTSTP
#ifdef SIGTTIN
        SIGNAL (SIGTTIN),
#endif   // SIGTTIN
#ifdef SIGTTOU
        SIGNAL (SIGTTOU),
#endif   // SIGTTOU
#ifdef SIGUNUSED
        SIGNAL (SIGUNUSED),
#endif   // SIGUNUSED
#ifdef SIGURG
        SIGNAL (SIGURG),
#endif   // SIGURG
#ifdef SIGUSR1
        SIGNAL (SIGUSR1),
#endif   // SIGUSR1
#ifdef SIGUSR2
        SIGNAL (SIGUSR2),
#endif   // SIGUSR2
#ifdef SIGVTALRM
        SIGNAL (SIGVTALRM),
#endif   // SIGVTALRM
#ifdef SIGWAITING
        SIGNAL (SIGWAITING),
#endif   // SIGWAITING
#ifdef SIGWINCH
        SIGNAL (SIGWINCH),
#endif   // SIGWINCH
#ifdef SIGWINDOW
        SIGNAL (SIGWINDOW),
#endif   // SIGWINDOW
#ifdef SIGXCPU
        SIGNAL (SIGXCPU),
#endif   // SIGXCPU
#ifdef SIGXFSZ
        SIGNAL (SIGXFSZ),
#endif   // SIGXFSZ
#ifdef SIGXRES
        SIGNAL (SIGXRES),
#endif   // SIGXRES
        { -1, 0 }
    };

    const char *name = 0;

    for (size_t i = 0; i != sizeof names / sizeof *names; ++i) {
        if (names [i].val == val) {
            name = names [i].str;
            break;
        }
    }

    char smallbuf [32];
    if (0 == name) {
        sprintf (smallbuf, "SIG#%d", val);
        name = smallbuf;
    }

    FmtSpec newspec (spec);
    newspec.fl_pound = 0;

    return _rw_fmtstr (newspec, buf, name, _RWSTD_SIZE_MAX);
}

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

/* extern */ int
_rw_fmterrno (const FmtSpec &spec, Buffer &buf, int val)
{
    static const struct {
        int         val;
        const char* str;
    } names[] = {

#undef ERRNO
#define ERRNO(val)   { val, #val }

#ifdef EPERM
        ERRNO (EPERM),
#endif   // EPERM
#ifdef ENOENT
        ERRNO (ENOENT),
#endif   // ENOENT
#ifdef ESRCH
        ERRNO (ESRCH),
#endif   // ESRCH
#ifdef EINTR
        ERRNO (EINTR),
#endif   // EINTR
#ifdef EIO
        ERRNO (EIO),
#endif   // EIO
#ifdef ENXIO
        ERRNO (ENXIO),
#endif   // ENXIO
#ifdef E2BIG
        ERRNO (E2BIG),
#endif   // E2BIG
#ifdef ENOEXEC
        ERRNO (ENOEXEC),
#endif   // ENOEXEC
#ifdef EBADF
        ERRNO (EBADF),
#endif   // EBADF
#ifdef ECHILD
        ERRNO (ECHILD),
#endif   // ECHILD
#ifdef EAGAIN
        ERRNO (EAGAIN),
#endif   // EAGAIN
#ifdef ENOMEM
        ERRNO (ENOMEM),
#endif   // ENOMEM
#ifdef EACCES
        ERRNO (EACCES),
#endif   // EACCES
#ifdef EFAULT
        ERRNO (EFAULT),
#endif   // EFAULT
#ifdef ENOTBLK
        ERRNO (ENOTBLK),
#endif   // ENOTBLK
#ifdef EBUSY
        ERRNO (EBUSY),
#endif   // EBUSY
#ifdef EEXIST
        ERRNO (EEXIST),
#endif   // EEXIST
#ifdef EXDEV
        ERRNO (EXDEV),
#endif   // EXDEV
#ifdef ENODEV
        ERRNO (ENODEV),
#endif   // ENODEV
#ifdef ENOTDIR
        ERRNO (ENOTDIR),
#endif   // ENOTDIR
#ifdef EISDIR
        ERRNO (EISDIR),
#endif   // EISDIR
#ifdef EINVAL
        ERRNO (EINVAL),
#endif   // EINVAL
#ifdef ENFILE
        ERRNO (ENFILE),
#endif   // ENFILE
#ifdef EMFILE
        ERRNO (EMFILE),
#endif   // EMFILE
#ifdef ENOTTY
        ERRNO (ENOTTY),
#endif   // ENOTTY
#ifdef ETXTBSY
        ERRNO (ETXTBSY),
#endif   // ETXTBSY
#ifdef EFBIG
        ERRNO (EFBIG),
#endif   // EFBIG
#ifdef ENOSPC
        ERRNO (ENOSPC),
#endif   // ENOSPC
#ifdef ESPIPE
        ERRNO (ESPIPE),
#endif   // ESPIPE
#ifdef EROFS
        ERRNO (EROFS),
#endif   // EROFS
#ifdef EMLINK
        ERRNO (EMLINK),
#endif   // EMLINK
#ifdef EPIPE
        ERRNO (EPIPE),
#endif   // EPIPE
#ifdef EDOM
        ERRNO (EDOM),
#endif   // EDOM
#ifdef ERANGE
        ERRNO (ERANGE),
#endif   // ERANGE
#ifdef ENOMSG
        ERRNO (ENOMSG),
#endif   // ENOMSG
#ifdef EIDRM
        ERRNO (EIDRM),
#endif   // EIDRM
#ifdef ECHRNG
        ERRNO (ECHRNG),
#endif   // ECHRNG
#ifdef EL2NSYNC
        ERRNO (EL2NSYNC),
#endif   // EL2NSYNC
#ifdef EL3HLT
        ERRNO (EL3HLT),
#endif   // EL3HLT
#ifdef EL3RST
        ERRNO (EL3RST),
#endif   // EL3RST
#ifdef ELNRNG
        ERRNO (ELNRNG),
#endif   // ELNRNG
#ifdef EUNATCH
        ERRNO (EUNATCH),
#endif   // EUNATCH
#ifdef ENOCSI
        ERRNO (ENOCSI),
#endif   // ENOCSI
#ifdef EL2HLT
        ERRNO (EL2HLT),
#endif   // EL2HLT
#ifdef EDEADLK
        ERRNO (EDEADLK),
#endif   // EDEADLK
#ifdef ENOLCK
        ERRNO (ENOLCK),
#endif   // ENOLCK
#ifdef ECANCELED
        ERRNO (ECANCELED),
#endif   // ECANCELED
#ifdef ENOTSUP
        ERRNO (ENOTSUP),
#endif   // ENOTSUP
#ifdef EDQUOT
        ERRNO (EDQUOT),
#endif   // EDQUOT
#ifdef EBADE
        ERRNO (EBADE),
#endif   // EBADE
#ifdef EBADR
        ERRNO (EBADR),
#endif   // EBADR
#ifdef EXFULL
        ERRNO (EXFULL),
#endif   // EXFULL
#ifdef ENOANO
        ERRNO (ENOANO),
#endif   // ENOANO
#ifdef EBADRQC
        ERRNO (EBADRQC),
#endif   // EBADRQC
#ifdef EBADSLT
        ERRNO (EBADSLT),
#endif   // EBADSLT
#ifdef EDEADLOCK
        ERRNO (EDEADLOCK),
#endif   // EDEADLOCK
#ifdef EBFONT
        ERRNO (EBFONT),
#endif   // EBFONT
#ifdef EOWNERDEAD
        ERRNO (EOWNERDEAD),
#endif   // EOWNERDEAD
#ifdef ENOTRECOVERABLE
        ERRNO (ENOTRECOVERABLE),
#endif   // ENOTRECOVERABLE
#ifdef ENOSTR
        ERRNO (ENOSTR),
#endif   // ENOSTR
#ifdef ENODATA
        ERRNO (ENODATA),
#endif   // ENODATA
#ifdef ETIME
        ERRNO (ETIME),
#endif   // ETIME
#ifdef ENOSR
        ERRNO (ENOSR),
#endif   // ENOSR
#ifdef ENONET
        ERRNO (ENONET),
#endif   // ENONET
#ifdef ENOPKG
        ERRNO (ENOPKG),
#endif   // ENOPKG
#ifdef EREMOTE
        ERRNO (EREMOTE),
#endif   // EREMOTE
#ifdef ENOLINK
        ERRNO (ENOLINK),
#endif   // ENOLINK
#ifdef EADV
        ERRNO (EADV),
#endif   // EADV
#ifdef ESRMNT
        ERRNO (ESRMNT),
#endif   // ESRMNT
#ifdef ECOMM
        ERRNO (ECOMM),
#endif   // ECOMM
#ifdef ELOCKUNMAPPED
        ERRNO (ELOCKUNMAPPED),
#endif   // ELOCKUNMAPPED
#ifdef ENOTACTIVE
        ERRNO (ENOTACTIVE),
#endif   // ENOTACTIVE
#ifdef EMULTIHOP
        ERRNO (EMULTIHOP),
#endif   // EMULTIHOP
#ifdef EBADMSG
        ERRNO (EBADMSG),
#endif   // EBADMSG
#ifdef ENAMETOOLONG
        ERRNO (ENAMETOOLONG),
#endif   // ENAMETOOLONG
#ifdef EOVERFLOW
        ERRNO (EOVERFLOW),
#endif   // EOVERFLOW
#ifdef ENOTUNIQ
        ERRNO (ENOTUNIQ),
#endif   // ENOTUNIQ
#ifdef EBADFD
        ERRNO (EBADFD),
#endif   // EBADFD
#ifdef EREMCHG
        ERRNO (EREMCHG),
#endif   // EREMCHG
#ifdef ELIBACC
        ERRNO (ELIBACC),
#endif   // ELIBACC
#ifdef ELIBBAD
        ERRNO (ELIBBAD),
#endif   // ELIBBAD
#ifdef ELIBSCN
        ERRNO (ELIBSCN),
#endif   // ELIBSCN
#ifdef ELIBMAX
        ERRNO (ELIBMAX),
#endif   // ELIBMAX
#ifdef ELIBEXEC
        ERRNO (ELIBEXEC),
#endif   // ELIBEXEC
#ifdef EILSEQ
        ERRNO (EILSEQ),
#endif   // EILSEQ
#ifdef ENOSYS
        ERRNO (ENOSYS),
#endif   // ENOSYS
#ifdef ELOOP
        ERRNO (ELOOP),
#endif   // ELOOP
#ifdef ERESTART
        ERRNO (ERESTART),
#endif   // ERESTART
#ifdef ESTRPIPE
        ERRNO (ESTRPIPE),
#endif   // ESTRPIPE
#ifdef ENOTEMPTY
        ERRNO (ENOTEMPTY),
#endif   // ENOTEMPTY
#ifdef EUSERS
        ERRNO (EUSERS),
#endif   // EUSERS
#ifdef ENOTSOCK
        ERRNO (ENOTSOCK),
#endif   // ENOTSOCK
#ifdef EDESTADDRREQ
        ERRNO (EDESTADDRREQ),
#endif   // EDESTADDRREQ
#ifdef EMSGSIZE
        ERRNO (EMSGSIZE),
#endif   // EMSGSIZE
#ifdef EPROTOTYPE
        ERRNO (EPROTOTYPE),
#endif   // EPROTOTYPE
#ifdef ENOPROTOOPT
        ERRNO (ENOPROTOOPT),
#endif   // ENOPROTOOPT
#ifdef EPROTONOSUPPORT
        ERRNO (EPROTONOSUPPORT),
#endif   // EPROTONOSUPPORT
#ifdef ESOCKTNOSUPPORT
        ERRNO (ESOCKTNOSUPPORT),
#endif   // ESOCKTNOSUPPORT
#ifdef EOPNOTSUPP
        ERRNO (EOPNOTSUPP),
#endif   // EOPNOTSUPP
#ifdef EPFNOSUPPORT
        ERRNO (EPFNOSUPPORT),
#endif   // EPFNOSUPPORT
#ifdef EAFNOSUPPORT
        ERRNO (EAFNOSUPPORT),
#endif   // EAFNOSUPPORT
#ifdef EADDRINUSE
        ERRNO (EADDRINUSE),
#endif   // EADDRINUSE
#ifdef EADDRNOTAVAIL
        ERRNO (EADDRNOTAVAIL),
#endif   // EADDRNOTAVAIL
#ifdef ENETDOWN
        ERRNO (ENETDOWN),
#endif   // ENETDOWN
#ifdef ENETUNREACH
        ERRNO (ENETUNREACH),
#endif   // ENETUNREACH
#ifdef ENETRESET
        ERRNO (ENETRESET),
#endif   // ENETRESET
#ifdef ECONNABORTED
        ERRNO (ECONNABORTED),
#endif   // ECONNABORTED
#ifdef ECONNRESET
        ERRNO (ECONNRESET),
#endif   // ECONNRESET
#ifdef ENOBUFS
        ERRNO (ENOBUFS),
#endif   // ENOBUFS
#ifdef EISCONN
        ERRNO (EISCONN),
#endif   // EISCONN
#ifdef ENOTCONN
        ERRNO (ENOTCONN),
#endif   // ENOTCONN
#ifdef ESHUTDOWN
        ERRNO (ESHUTDOWN),
#endif   // ESHUTDOWN
#ifdef ETOOMANYREFS
        ERRNO (ETOOMANYREFS),
#endif   // ETOOMANYREFS
#ifdef ETIMEDOUT
        ERRNO (ETIMEDOUT),
#endif   // ETIMEDOUT
#ifdef ECONNREFUSED
        ERRNO (ECONNREFUSED),
#endif   // ECONNREFUSED
#ifdef EHOSTDOWN
        ERRNO (EHOSTDOWN),
#endif   // EHOSTDOWN
#ifdef EHOSTUNREACH
        ERRNO (EHOSTUNREACH),
#endif   // EHOSTUNREACH
#ifdef EWOULDBLOCK
        ERRNO (EWOULDBLOCK),
#endif   // EWOULDBLOCK
#ifdef EALREADY
        ERRNO (EALREADY),
#endif   // EALREADY
#ifdef EINPROGRESS
        ERRNO (EINPROGRESS),
#endif   // EINPROGRESS
#ifdef ESTALE
        ERRNO (ESTALE),
#endif   // ESTALE
        { -1, 0 }
    };

    const char* str = strerror (val);

    char smallbuf [32];

    if (spec.fl_pound || 0 == str) {

        const char *name = 0;

        for (size_t i = 0; i != sizeof names / sizeof *names; ++i) {
            if (names [i].val == val) {
                name = names [i].str;
                break;
            }
        }

        if (0 == name) {
            sprintf (smallbuf, "E#%d", val);
            str = smallbuf;
        }
        else
            str = name;
    }

    FmtSpec newspec (spec);
    newspec.width    = 0;
    newspec.fl_pound = 0;

    return _rw_fmtstr (newspec, buf, str, _RWSTD_SIZE_MAX);
}

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

/* extern */ int
_rw_fmtlasterror (const FmtSpec &spec, Buffer &buf, int val)
{
#ifdef _WIN32

    LPVOID pmsg;
    FormatMessage (  FORMAT_MESSAGE_ALLOCATE_BUFFER
                   | FORMAT_MESSAGE_FROM_SYSTEM
                   | FORMAT_MESSAGE_IGNORE_INSERTS,
                   0, (DWORD)val,
                   MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
                   (LPTSTR)&pmsg,
                   0, 0);

    FmtSpec newspec (spec);
    newspec.width    = 0;
    newspec.fl_pound = 0;

    const int result = _rw_fmtstr (newspec, buf,
                                   _RWSTD_STATIC_CAST (const char*, pmsg),
                                   _RWSTD_SIZE_MAX);

    LocalFree (pmsg);

    return result;

#else   // if !defined (_WIN32)

    return _rw_fmterrno (spec, buf, val);

#endif   // _WIN32

}

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

/* extern */ int
_rw_fmtmask (const FmtSpec &spec, Buffer &buf, int bits)
{
    static const Bitnames names [] = {
        BITNAME (std::ctype_base, alnum),
        BITNAME (std::ctype_base, alpha),
        BITNAME (std::ctype_base, cntrl),
        BITNAME (std::ctype_base, digit),
        BITNAME (std::ctype_base, graph),
        BITNAME (std::ctype_base, lower),
        BITNAME (std::ctype_base, print),
        BITNAME (std::ctype_base, punct),
        BITNAME (std::ctype_base, space),
        BITNAME (std::ctype_base, upper),
        BITNAME (std::ctype_base, xdigit)
    };

    static const size_t count = sizeof names / sizeof *names;

    return _rw_bmpfmt (spec, buf, names, count, bits);
}

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

/* extern */ int
_rw_fmtcharmask (const FmtSpec &spec, Buffer &buf, int c)
{
    enum {
        bit_alnum  = 1,
        bit_alpha  = 1 << 1,
        bit_cntrl  = 1 << 2,
        bit_digit  = 1 << 3,
        bit_graph  = 1 << 4,
        bit_lower  = 1 << 5,
        bit_print  = 1 << 6,
        bit_punct  = 1 << 7,
        bit_space  = 1 << 8,
        bit_upper  = 1 << 9,
        bit_xdigit = 1 << 10
    };

    int mask = 0;

    if (spec.fl_pound) {

#ifndef _RWSTD_NO_WCHAR_H

        mask |= iswalnum (c) ? bit_alnum : 0;
        mask |= iswalpha (c) ? bit_alpha : 0;
        mask |= iswcntrl (c) ? bit_cntrl : 0;
        mask |= iswdigit (c) ? bit_digit : 0;
        mask |= iswgraph (c) ? bit_graph : 0;
        mask |= iswlower (c) ? bit_lower : 0;
        mask |= iswprint (c) ? bit_print : 0;
        mask |= iswpunct (c) ? bit_punct : 0;
        mask |= iswspace (c) ? bit_space : 0;
        mask |= iswupper (c) ? bit_upper : 0;
        mask |= iswxdigit (c) ? bit_xdigit : 0;

#endif   // _RWSTD_NO_WCHAR_H

    }
    else {
        const unsigned char uc = c;

        mask |= isalnum (uc) ? bit_alnum : 0;
        mask |= isalpha (uc) ? bit_alpha : 0;
        mask |= iscntrl (uc) ? bit_cntrl : 0;
        mask |= isdigit (uc) ? bit_digit : 0;
        mask |= isgraph (uc) ? bit_graph : 0;
        mask |= islower (uc) ? bit_lower : 0;
        mask |= isprint (uc) ? bit_print : 0;
        mask |= ispunct (uc) ? bit_punct : 0;
        mask |= isspace (uc) ? bit_space : 0;
        mask |= isupper (uc) ? bit_upper : 0;
        mask |= isxdigit (uc) ? bit_xdigit : 0;
    }

    char mask_str [80];
    char *str = mask_str;

    str [0] = '\0';

#define APPEND(bit)                             \
    if (mask & bit_ ## bit)                     \
        strcat (strcat (str, #bit), "|");       \
    else (void)0

    APPEND (alnum);
    APPEND (alpha);
    APPEND (cntrl);
    APPEND (digit);
    APPEND (graph);
    APPEND (lower);
    APPEND (print);
    APPEND (punct);
    APPEND (space);
    APPEND (upper);
    APPEND (xdigit);

    if (str == mask_str)
        *str = '\0';
    else
        str [-1] = '\0';

    FmtSpec newspec (spec);
    newspec.fl_pound = 0;

    return _rw_fmtstr (newspec, buf, str, _RWSTD_SIZE_MAX);
}

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

/* extern */ int
_rw_fmtbits (const FmtSpec &spec, Buffer &buf,
             const void *pelems, size_t elemsize)
{
    const size_t nbits = spec.prec;

    char bitbuf [256];
    char *pbits = nbits < sizeof bitbuf ? bitbuf : new char [nbits + 1];

    for (size_t bitno = 0; bitno != nbits; ++bitno) {

        if (bitno && 0 == (bitno % (elemsize * _RWSTD_CHAR_BIT)))
            pelems = _RWSTD_STATIC_CAST (const UChar*, pelems) + elemsize;

        size_t bit = 1 << (bitno & (_RWSTD_CHAR_BIT * elemsize - 1));

        switch (elemsize) {
        case _RWSTD_CHAR_SIZE:
            bit = *_RWSTD_STATIC_CAST (const UChar*, pelems) & bit;
            break;

#if _RWSTD_CHAR_SIZE < _RWSTD_SHRT_SIZE
        case _RWSTD_SHRT_SIZE:
            bit = *_RWSTD_STATIC_CAST (const UShrt*, pelems) & bit;
            break;
#endif   // sizeof (char) < sizeof (short)

#if _RWSTD_SHRT_SIZE < _RWSTD_INT_SIZE
        case _RWSTD_INT_SIZE:
            bit = *_RWSTD_STATIC_CAST (const UInt*, pelems) & bit;
            break;
#endif   // sizeof (short) < sizeof (int)

#if _RWSTD_INT_SIZE < _RWSTD_LONG_SIZE
        case _RWSTD_LONG_SIZE:
            bit = *_RWSTD_STATIC_CAST (const ULong*, pelems) & bit;
            break;
#endif   // sizeof (int) < sizeof (long)

#if _RWSTD_LONG_SIZE < _RWSTD_LLONG_SIZE
        case _RWSTD_LLONG_SIZE:
            bit = *_RWSTD_STATIC_CAST (const ULLong*, pelems) & bit;
            break;
#endif   // sizeof (long) < sizeof (long long)

        default:
            RW_ASSERT (!"logic error: bad element size");
        }

        pbits [bitno] = bit ? '1' : '0';
    }

    const int res = _rw_fmtstr (spec, buf, pbits, nbits);

    if (pbits != bitbuf)
        delete[] pbits;

    return res;
}