value.cpp

Go to the documentation of this file.

 
// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC
 
#include <ctype.h>      // for isdigit()
#include <stdarg.h>     // for va_arg, va_list, ...
#include <stdlib.h>     // for strtol()
#include <string.h>     // for size_t, strlen()
#include <wchar.h>      // for wint_t
 
 
#include <rw_value.h>
#include <rw_char.h>    // for rw_expand()
#include <rw_printf.h>
 
 
/* static */ size_t UserClass::count_;
/* static */ int    UserClass::id_gen_;   // generates unique non-zero ids
/* static */ int  (*UserClass::gen_)();   // extern "C++" int (*)()
 
/* static */ size_t UserClass::n_total_def_ctor_;
/* static */ size_t UserClass::n_total_copy_ctor_;
/* static */ size_t UserClass::n_total_dtor_;
/* static */ size_t UserClass::n_total_op_assign_;
/* static */ size_t UserClass::n_total_op_plus_assign_;
/* static */ size_t UserClass::n_total_op_minus_assign_;
/* static */ size_t UserClass::n_total_op_times_assign_;
/* static */ size_t UserClass::n_total_op_div_assign_;
/* static */ size_t UserClass::n_total_op_eq_;
/* static */ size_t UserClass::n_total_op_lt_;
 
// default values of pointers
/* static */ size_t* UserClass::def_ctor_throw_ptr_ =
    &UserClass::def_ctor_throw_count_;
/* static */ size_t* UserClass::copy_ctor_throw_ptr_ =
    &UserClass::copy_ctor_throw_count_;
/* static */ size_t* UserClass::dtor_throw_ptr_ =
    &UserClass::dtor_throw_count_;
/* static */ size_t* UserClass::op_assign_throw_ptr_ =
    &UserClass::op_assign_throw_count_;
/* static */ size_t* UserClass::op_plus_assign_throw_ptr_ =
    &UserClass::op_plus_assign_throw_count_;
/* static */ size_t* UserClass::op_minus_assign_throw_ptr_ =
    &UserClass::op_minus_assign_throw_count_;
/* static */ size_t* UserClass::op_times_assign_throw_ptr_ =
    &UserClass::op_times_assign_throw_count_;
/* static */ size_t* UserClass::op_div_assign_throw_ptr_ =
    &UserClass::op_div_assign_throw_count_;
/* static */ size_t* UserClass::op_eq_throw_ptr_ =
    &UserClass::op_eq_throw_count_;
/* static */ size_t* UserClass::op_lt_throw_ptr_ =
    &UserClass::op_lt_throw_count_;
 
// exception throwing initially disabled
/* static */ size_t UserClass::def_ctor_throw_count_        = size_t (-1);
/* static */ size_t UserClass::copy_ctor_throw_count_       = size_t (-1);
/* static */ size_t UserClass::dtor_throw_count_            = size_t (-1);
/* static */ size_t UserClass::op_assign_throw_count_       = size_t (-1);
/* static */ size_t UserClass::op_plus_assign_throw_count_  = size_t (-1);
/* static */ size_t UserClass::op_minus_assign_throw_count_ = size_t (-1);
/* static */ size_t UserClass::op_times_assign_throw_count_ = size_t (-1);
/* static */ size_t UserClass::op_div_assign_throw_count_   = size_t (-1);
/* static */ size_t UserClass::op_eq_throw_count_           = size_t (-1);
/* static */ size_t UserClass::op_lt_throw_count_           = size_t (-1);
 
 
UserClass::UserClass ()
    : data_ (), id_ (++id_gen_), origin_ (id_), src_id_ (id_),
      n_copy_ctor_ (0), n_op_assign_ (0), n_op_eq_ (0), n_op_lt_ (0)
{
    // increment the total number of invocations of the default ctor
    // (do so even if the function throws an exception below)
    ++n_total_def_ctor_;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    if (def_ctor_throw_ptr_ && n_total_def_ctor_ == *def_ctor_throw_ptr_) {
        DefCtor ex;
        ex.id_ = id_;
        throw ex;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    // initialize the object's value
    if (gen_)
        data_.val_ = gen_ ();
 
    // increment the number of successfully constructed objects
    ++count_;
}
 
 
UserClass::UserClass (const UserClass &rhs)
    : data_ (rhs.data_), id_ (++id_gen_), origin_ (rhs.origin_),
      src_id_ (rhs.id_),
      n_copy_ctor_ (0), n_op_assign_ (0), n_op_eq_ (0), n_op_lt_ (0)
{
    // verify id validity
    RW_ASSERT (rhs.id_ && rhs.id_ < id_gen_);
 
    // increment the number of times `rhs' has been copied
    // (do so even if the function throws an exception below)
    ++_RWSTD_CONST_CAST (UserClass*, &rhs)->n_copy_ctor_;
 
    // increment the total number of invocations of the copy ctor
    // (do so even if the function throws an exception below)
    ++n_total_copy_ctor_;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    // throw an exception if the number of calls
    // to the copy ctor reaches the given value
    if (copy_ctor_throw_ptr_ && n_total_copy_ctor_ == *copy_ctor_throw_ptr_) {
        CopyCtor ex;
        ex.id_ = id_;
        throw ex;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    // increment the number of successfully constructed objects
    ++count_;
}
 
 
UserClass::~UserClass ()
{
    // verify id validity
    RW_ASSERT (id_ && id_ <= id_gen_);
 
    // increment the total number of invocations of the dtor
    // (do so even if the function throws an exception below)
    ++n_total_dtor_;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    // throw an exception if the number of calls
    // to the class dtor reaches the given value
    if (dtor_throw_ptr_ && n_total_dtor_ == *dtor_throw_ptr_) {
        Dtor ex;
        ex.id_ = id_;
        throw ex;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    // decrement the number of objects in existence
    --count_;
 
    // invalidate id
    _RWSTD_CONST_CAST (int&, this->id_) = 0;
}
 
 
void UserClass::
assign (assign_op which, const UserClass &rhs)
{
    // verify id validity and uniqueness:
    // a valid id is non-zero (dtor resets)
    RW_ASSERT (id_ && id_ <= id_gen_);
    RW_ASSERT (rhs.id_ && rhs.id_ <= id_gen_);
 
    // no two id's have the same value
    RW_ASSERT (this == &rhs || id_ != rhs.id_);
 
    size_t *p_total_op = 0;
    size_t *p_op       = 0;
    size_t *p_throw    = 0;
 
    Exception *pex = 0; 
 
    OpAssign      ex_assign;
    OpPlusAssign  ex_plus_assign;
    OpMinusAssign ex_minus_assign;
    OpTimesAssign ex_times_assign;
    OpDivAssign   ex_div_assign;
 
    int new_val;
 
    switch (which) {
    case op_assign:
        p_total_op = &n_total_op_assign_;
        p_op       = &n_op_assign_;
        p_throw    = op_assign_throw_ptr_;
        pex        = &ex_assign;
        new_val    = rhs.data_.val_;
        break;
 
    case op_plus_assign:
        p_total_op = &n_total_op_plus_assign_;
        p_op       = &n_op_plus_assign_;
        p_throw    = op_plus_assign_throw_ptr_;
        pex        = &ex_plus_assign;
        new_val    = data_.val_ + rhs.data_.val_;
        break;
 
    case op_minus_assign:
        p_total_op = &n_total_op_minus_assign_;
        p_op       = &n_op_minus_assign_;
        p_throw    = op_minus_assign_throw_ptr_;
        pex        = &ex_minus_assign;
        new_val    = data_.val_ - rhs.data_.val_;
        break;
 
    case op_times_assign:
        p_total_op = &n_total_op_times_assign_;
        p_op       = &n_op_times_assign_;
        p_throw    = op_times_assign_throw_ptr_;
        pex        = &ex_times_assign;
        new_val    = data_.val_ * rhs.data_.val_;
        break;
 
    case op_div_assign:
        p_total_op = &n_total_op_div_assign_;
        p_op       = &n_op_div_assign_;
        p_throw    = op_div_assign_throw_ptr_;
        pex        = &ex_div_assign;
        new_val    = data_.val_ / rhs.data_.val_;
        break;
 
    default:
        // should never get here (silences bogus HP aCC/cadvise
        // warning #20200-D: Potential null pointer dereference)
        RW_ASSERT (!"unhandled case");
        return;
    }
 
    // increment the number of invocations of the operator
    // (do so even if the function throws an exception below)
 
    ++*p_total_op;
    ++*p_op;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    // throw an exception if the number of calls to
    // the assignment operator reaches the given value
 
    if (p_throw && *p_throw == *p_total_op) {
        pex->id_ = id_;
        throw *pex;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    // overwrite value and source id only when the operation
    // is successful (i.e., only when it doesn't throw)
 
    origin_ = rhs.origin_;
    src_id_ = rhs.id_;
    data_.val_    = new_val;
}
 
 
UserClass& UserClass::
operator= (const UserClass &rhs)
{
    assign (op_assign, rhs);
 
    return *this;
}
 
 
UserClass& UserClass::
operator+= (const UserClass &rhs)
{
    assign (op_plus_assign, rhs);
 
    return *this;
}
 
 
UserClass& UserClass::
operator-= (const UserClass &rhs)
{
    assign (op_minus_assign, rhs);
 
    return *this;
}
 
 
UserClass& UserClass::
operator*= (const UserClass &rhs)
{
    assign (op_times_assign, rhs);
 
    return *this;
}
 
 
UserClass& UserClass::
operator/= (const UserClass &rhs)
{
    assign (op_div_assign, rhs);
 
    return *this;
}
 
 
bool
UserClass::operator== (const UserClass &rhs) const
{
    // verify id validity and uniqueness
    RW_ASSERT (id_ && id_ <= id_gen_);
    RW_ASSERT (rhs.id_ && rhs.id_ <= id_gen_);
    RW_ASSERT (this == &rhs || id_ != rhs.id_);
 
    // increment the number of times each distinct object
    // has been used as the argument to operator==
    // (do so even if the function throws an exception below)
    ++_RWSTD_CONST_CAST (UserClass*, this)->n_op_eq_;
 
    if (this != &rhs)
        ++_RWSTD_CONST_CAST (UserClass*, &rhs)->n_op_eq_;
 
    // increment the total number of invocations of the operator
    // (do so even if the function throws an exception below)
    ++n_total_op_eq_;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    // throw an exception if the number of calls
    // to operator== reaches the given value
 
    if (op_eq_throw_ptr_ && n_total_op_eq_ == *op_eq_throw_ptr_) {
        OpEq ex;
        ex.id_ = id_;
        throw ex;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    return data_.val_ == rhs.data_.val_;
}
 
 
bool
UserClass::operator< (const UserClass &rhs) const
{
    // verify id validity and uniqueness
    RW_ASSERT (id_ && id_ <= id_gen_);
    RW_ASSERT (rhs.id_ && rhs.id_ <= id_gen_);
    RW_ASSERT (this == &rhs || id_ != rhs.id_);
 
    // increment the number of times each distinct object
    // has been used as the argument to operator<
    // (do so even if the function throws an exception below)
    ++_RWSTD_CONST_CAST (UserClass*, this)->n_op_lt_;
 
    if (this != &rhs)
        ++_RWSTD_CONST_CAST (UserClass*, &rhs)->n_op_lt_;
 
    // increment the total number of invocations of the operator
    // (do so even if the function throws an exception below)
    ++n_total_op_lt_;
 
#ifndef _RWSTD_NO_EXCEPTIONS
 
    // throw an exception if the number of calls
    // to operator== reaches the given value
 
    if (op_lt_throw_ptr_ && n_total_op_lt_ == *op_lt_throw_ptr_) {
        OpLt ex;
        ex.id_ = id_;
        throw ex;
    }
 
#endif   // _RWSTD_NO_EXCEPTIONS
 
    return data_.val_ < rhs.data_.val_;
}
 
 
bool UserClass::
is_count (size_t n_copy_ctor,
          size_t n_op_assign,
          size_t n_op_eq,
          size_t n_op_lt) const
{
    // verify id validity
    RW_ASSERT (id_ && id_ <= id_gen_);
 
    return    (size_t (-1) == n_copy_ctor || n_copy_ctor_ == n_copy_ctor)
           && (size_t (-1) == n_op_assign || n_op_assign_ == n_op_assign)
           && (size_t (-1) == n_op_eq     || n_op_eq_     == n_op_eq)
           && (size_t (-1) == n_op_lt     || n_op_lt_     == n_op_lt);
}
 
 
/* static */ bool UserClass::
is_total (size_t cnt,
          size_t n_def_ctor,
          size_t n_copy_ctor,
          size_t n_op_assign,
          size_t n_op_eq,
          size_t n_op_lt)
{
    return    (size_t (-1) == cnt         || count_             == cnt)
           && (size_t (-1) == n_def_ctor  || n_total_def_ctor_  == n_def_ctor)
           && (size_t (-1) == n_copy_ctor || n_total_copy_ctor_ == n_copy_ctor)
           && (size_t (-1) == n_op_assign || n_total_op_assign_ == n_op_assign)
           && (size_t (-1) == n_op_eq     || n_total_op_eq_     == n_op_eq)
           && (size_t (-1) == n_op_lt     || n_total_op_lt_     == n_op_lt);
}
 
 
/* static */ const UserClass*
UserClass::first_less (const UserClass *xarray, size_t nelems)
{
    size_t inx = nelems;
 
    if (1 < nelems) {
        for (inx = 1; inx != nelems; ++inx) {
            if (xarray [inx] < xarray [inx - 1])
                break;
        }
    }
    
    return inx < nelems ? xarray + inx : 0;
}
 
 
/* static */ void
UserClass::reset_totals ()
{
    n_total_def_ctor_  =
    n_total_copy_ctor_ =
    n_total_dtor_      =
    n_total_op_assign_ =
    n_total_op_eq_     =
    n_total_op_lt_     = 0;
}
 
 
typedef unsigned char UChar;
 
template <class T>
static T*
__rw_from_char (T*, const char *str, size_t len, bool sorted)
{
    // handle null pointers
    if (!str)
        return 0;
 
    // expand source string
    char str_buf_ [256];
    size_t strlen_ = sizeof (str_buf_);
    const char* const str_ = rw_expand (str_buf_, str, len, &strlen_);
 
    if (sorted) {
        // verify that the sequence is sorted
        for (size_t i = 1; i < strlen_; ++i) {
            if (str_ [i] < str_ [i - 1]) {
                if (str_buf_ != str_)
                    delete[] str_;
                return 0;
            }
        }
    }
 
    T*array = 0;
 
    _TRY {
        array = new T [strlen_];
    }
    _CATCH (...) {
 
        if (str_buf_ != str_)
            delete[] str_;
 
        _RETHROW;
    }
 
    typedef unsigned char UChar;
 
    // this should trivially hold given the above but the assert
    // silences bogus HP aCC/cadvise warning #20200-D: Potential
    // null pointer dereference
    RW_ASSERT (0 != array);
 
    for (size_t i = 0; i < strlen_; ++i)
        array [i].data_.val_ = UChar (str_ [i]);
 
    if (str_buf_ != str_)
        delete[] str_;
 
    return array;
}
 
 
template <class T>
static const T*
__rw_mismatch (const T *xarray, const char *str, size_t len)
{
    if (!str)
        return xarray;
 
    if (size_t (-1) == len)
        len = strlen (str);
 
    for (size_t i = 0; i != len; ++i) {
 
        const int val = UChar (str [i]);
 
        if (val != xarray [i].data_.val_)
            return xarray + i;
    }
 
    return 0;
}
 
 
/* static */ UserClass*
UserClass::from_char (const char *str, size_t len /* = -1 */,
                      bool sorted /* = false */)
{
    return __rw_from_char ((UserClass*)0, str, len, sorted);
}
 
 
/* static */ const UserClass*
UserClass::mismatch (const UserClass *xarray, const char *str,
                     size_t len /* = -1 */)
{
    return __rw_mismatch (xarray, str, len);
}
 
 
/* static */ int
UserClass::compare (const UserClass *xarray, const char *str,
                    size_t len /* = -1 */)
{
    const UserClass* const px = mismatch (xarray, str, len);
 
    if (px) {
        RW_ASSERT (size_t (px - xarray) < len);
 
        return px->data_.val_ - int (UChar (str [px - xarray]));
    }
 
    return 0;
}
 
 
/* static */ int
UserClass::compare (const char *str, const UserClass *xarray,
                    size_t len /* = -1 */)
{
    return -UserClass::compare (xarray, str, len);
}
 
 
/* static */ int
UserClass::compare (const UserClass *x, const UserClass *y, size_t count)
{
    for (size_t i = 0; i != count; ++i) {
        if (x [i].data_.val_ != y [i].data_.val_)
            return x [i].data_.val_ - y [i].data_.val_;
    }
 
    return 0;
}
 
 
/* static */ UserPOD*
UserPOD::from_char (const char *str, size_t len /* = -1 */,
                    bool sorted /* = false */)
{
    return __rw_from_char ((UserPOD*)0, str, len, sorted);
}
 
 
/* static */ const UserPOD*
UserPOD::mismatch (const UserPOD *xarray, const char *str,
                   size_t len /* = -1 */)
{
    return __rw_mismatch (xarray, str, len);
}
 
 
/* static */ size_t UnaryPredicate::n_total_op_fcall_;
 
 
UnaryPredicate::
UnaryPredicate ()
{
    // no-op
}
 
 
UnaryPredicate::
UnaryPredicate (const UnaryPredicate&)
{
    // no-op
}
 
 
UnaryPredicate& UnaryPredicate::
operator= (const UnaryPredicate&)
{
    return *this;
}
 
 
/* virtual */ UnaryPredicate::~UnaryPredicate ()
{
    // no-op
}
 
 
/* virtual */ conv_to_bool UnaryPredicate::
operator()(const UserClass&) const
{
    ++n_total_op_fcall_;
 
    return conv_to_bool::make (true);
}
 
 
/* static */ size_t BinaryPredicate::n_total_op_fcall_;
 
 
BinaryPredicate::
BinaryPredicate (binary_op op): op_ (op)
{
    // no-op
}
 
 
/* virtual */ BinaryPredicate::~BinaryPredicate ()
{
    // no-op
}
 
 
/* virtual */ conv_to_bool BinaryPredicate::
operator()(const UserClass &lhs, const UserClass &rhs) /* non-const */
{
    ++n_total_op_fcall_;
 
    bool result;
 
    switch (op_) {
    case op_equals:        result = lhs.data_.val_ == rhs.data_.val_; break;
    case op_not_equals:    result = !(lhs.data_.val_ == rhs.data_.val_); break;
    case op_less:          result = lhs.data_.val_ < rhs.data_.val_; break;
    case op_less_equal:    result = !(rhs.data_.val_ < lhs.data_.val_); break;
    case op_greater:       result = rhs.data_.val_ < lhs.data_.val_; break;
    case op_greater_equal: result = !(rhs.data_.val_ < lhs.data_.val_); break;
    }
 
    return conv_to_bool::make (result);
}
 
 
static inline void
_rw_advance (const void*& parray, int idx, bool is_class)
{
    if (is_class)
        parray = _RWSTD_STATIC_CAST (const UserClass*, parray) + idx;
    else
        parray = _RWSTD_STATIC_CAST (const UserPOD*, parray) + idx;
}
 
static int
_rw_fmtxarrayv (char **pbuf, size_t *pbufsize, const char *fmt, va_list va)
{
    RW_ASSERT (0 != pbuf);
    RW_ASSERT (0 != pbufsize);
    RW_ASSERT (0 != fmt);
 
    bool     fl_plus  =  false;
    bool     fl_pound =  false;
    int      nelems   = -1;
    int      cursor   = -1;
 
    const void* pelem = 0;
 
    // directive syntax:
    // "X=" [ '#' ] [ '+' ] [ '*' | <n> ] [ '.' [ '*' | '@' | <n> ] ]
    // where
    // '#' causes UserClass::id_ to be included in output
    //     ignored for UserPOD
    // '+' forces UserClass::data_.val_ or UserPOD::data_.val to be
    //     formatted as an integer (otherwise it is formatted as an
    //     (optionally escaped) character '*' or <n> is the number
    //     of elements in the sequence (the first occurrence)
    // '*', <n> is the offset of the cursor within the sequence
    //          (where the cursor is a pair of pointy brackets
    //          surrounding the element, e.g., >123<)
    // '@' is the pointer to the element to be surrended by the
    //     pair of pointy brackets
    // first rw_snprintfa's variable argument of int type should be
    // sizeof(UserClass) or sizeof(UserPOD)
 
    if ('X' != fmt [0] || '=' != fmt [1])
        return _RWSTD_INT_MIN;
 
    // extract the address of the caller's variable argument list
    va_list* const pva = va_arg (va, va_list*);
    RW_ASSERT (0 != pva);
 
    // process element width
    const int cwidth = va_arg (*pva, int);
    RW_ASSERT (sizeof (UserClass) == cwidth || sizeof (UserPOD) == cwidth);
 
    const bool is_class = (sizeof (UserClass) == cwidth);
 
    fmt += 2;
 
    if ('+' == *fmt) {
        // use numerical formatting for data_.val_
        fl_plus = true;
        ++fmt;
    }
 
    if ('#' == *fmt) {
        // include UserClass::id_ in output
        fl_pound = is_class;
        ++fmt;
    }
 
    if ('*' == *fmt) {
        // process width
        // extract the width from rw_snprintfa's variable argument
        // list pass through to us by the caller
        nelems = va_arg (*pva, int);
        ++fmt;
    }
    else if (isdigit (*fmt)) {
        // process positional parameter or width
        char* end = 0;
        const int arg = int (strtol (fmt, &end, 10));
        if ('$' != *end)
            nelems = arg;
 
        fmt = end;
    }
 
    if ('.' == *fmt) {
        // process precision (cursor)
        if ('*' == *++fmt) {
            // extract the cursor index from rw_snprintfa's variable
            // argument list passed through to us by the caller
            cursor = va_arg (*pva, int);
            ++fmt;
        }
        else if ('@' == *fmt) {
            // extract the pointer from rw_snprintfa's variable argument
            // list passed through to us by the caller
            pelem = va_arg (*pva, void*);
            ++fmt;
        }
        else if (isdigit (*fmt)) {
            char* end = 0;
            cursor = int (strtol (fmt, &end, 10));
            fmt = end;
        }
    }
 
    RW_ASSERT ('\0' == *fmt);
 
    // extract a pointer to UserClass or UserPOD from rw_snprintfa's
    // variable argument list pass through to us by the caller 
    const void* const xbeg = va_arg (*pva, const void*);
 
    if (-1 != cursor) {
        RW_ASSERT (-1 < cursor);
        RW_ASSERT (0 == pelem);
 
        pelem = xbeg;
        _rw_advance (pelem, cursor, is_class);
    }
 
    // extract the address where to store the extracted argument
    // for use by any subsequent positional paramaters
    const void** const pparam = va_arg (va, const void**);
    RW_ASSERT (0 != pparam);
 
    // store the extracted argument
    *pparam = xbeg;
 
    // compute the length of the buffer formatted so far
    const size_t buflen_0 = *pbuf ? strlen (*pbuf) : 0;
 
    int nbytes = 0;
 
    // invoke rw_asnprintf() recursively to format our arguments
    // and append the result to the end of the buffer; pass the
    // value returned from rw_asnprintf() (i.e., the number of
    // bytes appended) back to the caller
 
    const char* pointer [2];
    const void* px = xbeg;
 
    for (int i = 0; i != nelems; ++i) {
 
        if (px == pelem) {
            pointer [0] = ">";
            pointer [1] = "<";
        }
        else {
            pointer [0] = "";
            pointer [1] = "";
        }
 
        int id;
        int val;
 
        if (is_class) {
            const UserClass* const pclass =
                _RWSTD_STATIC_CAST (const UserClass*, px);
            val = pclass->data_.val_;
            id = pclass->id_;
        }
        else {
            const UserPOD* const ppod =
                _RWSTD_STATIC_CAST (const UserPOD*, px);
            val = ppod->data_.val_;
            id = 0;
        }
 
        const int n =
            rw_asnprintf (pbuf, pbufsize,
                          "%{+}%s"                        // '>'
                          "%{?}%d:%{;}"
                          "%{?}%d%s%{?},%{;}%{:}%{lc}%s%{;}",
                          pointer [0],                    // ">" or ""
                          fl_pound, id,                   // "<id>:"
                          fl_plus, val,                   // <val>
                          pointer [1],                    // "<" or ""
                          i + 1 < nelems,                 // ','
                          wint_t (val),                   // <val>
                          pointer [1]);                   // "<" or ""
        if (n < 0)
            return n;
 
        nbytes += n;
 
        _rw_advance (px, 1, is_class);
    }
 
 
    // compute the new length of the buffer
    const size_t buflen_1 = *pbuf ? strlen (*pbuf) : 0;
 
    // assert that the function really appended as many characters
    // as it said it did (assumes no NULs embedded in the output)
    // and that it didn't write past the end of the buffer
    RW_ASSERT (buflen_1 == buflen_0 + nbytes);
    RW_ASSERT (buflen_1 < *pbufsize);
 
    return nbytes;
}
 
 
static int
_rw_fmtxarray (char **pbuf, size_t *pbufsize, const char *fmt, ...)
{
    va_list va;
    va_start (va, fmt);
 
    const int nbytes = _rw_fmtxarrayv (pbuf, pbufsize, fmt, va);
 
    va_end (va);
 
    return nbytes;
}
 
 
UserClassFmatInit::
UserClassFmatInit ()
{
    // push a new formatter function on top of the stack
    // of user-defined formatting callbacks invoked by
    // rw_printf() at al to process extended directives
    static int format_init = rw_printf ("%{+!}", _rw_fmtxarray);
 
    _RWSTD_UNUSED (format_init);
}