Index: 21.strings.cpp =================================================================== --- 21.strings.cpp (revision 408604) +++ 21.strings.cpp (working copy) @@ -44,6 +44,48 @@ /**************************************************************************/ +enum Signatures +{ + sig_void, + sig_cptr, + sig_cstr, + sig_size, + sig_size_const, + sig_cptr_size, + sig_cstr_size, + sig_cptr_size_size, + sig_cstr_size_size, + sig_size_cptr_size, + sig_size_cstr_size_size, + sig_size_val, + sig_size_cstr, + sig_size_size, + sig_size_size_cptr, + sig_size_size_cstr, + sig_size_size_val, + sig_size_size_cptr_size, + sig_size_size_cstr_size_size, + sig_size_size_size_val, + sig_val, + sig_val_size, + sig_range, + sig_iter, + sig_iter_val, + sig_iter_size_val, + sig_iter_range, + sig_iter_iter, + sig_iter_iter_cptr, + sig_iter_iter_cstr, + sig_iter_iter_cptr_size, + sig_iter_iter_size_val, + sig_iter_iter_range, + + // must be last + sig_last +}; + +/**************************************************************************/ + static const char _rw_this_file[] = __FILE__; @@ -71,7 +113,7 @@ "append", "assign", "erase", "insert", "replace", "operator+=", "find", "rfind", "find_first_of", "find_last_of", "find_first_not_of", "find_last_not_of", "compare", "substr", "operator[]", "at", "copy", - "constructor", "operator=", "swap", "push_back" + "constructor", "operator=", "swap", "push_back", "operator+" }; /**************************************************************************/ @@ -80,10 +122,10 @@ long_string [StringMembers::long_string_len]; static int -_rw_opt_memfun_disabled [StringMembers::sig_last]; +_rw_opt_memfun_disabled [sig_last]; static int -_rw_opt_memfun_enabled [StringMembers::sig_last]; +_rw_opt_memfun_enabled [sig_last]; static int _rw_opt_no_char_types [3]; @@ -140,6 +182,49 @@ /**************************************************************************/ +static void +_rw_append_signature (char **pbuf, size_t *pbufsize, + StringMembers::OverloadId which) +{ + // for convenience + typedef StringMembers Mem; + + int argmap = which >> Mem::mem_bits; + const bool is_const = + Mem::arg_cstr == (argmap & Mem::arg_mask); + + rw_asnprintf (pbuf, pbufsize, "%{+}("); + + for (size_t argno = 0; argmap >>= Mem::arg_bits; ++argno) { + + const int argtype = argmap & Mem::arg_mask; + + const char* type_name = 0; + + switch (argtype) { + case Mem::arg_void: break; + case Mem::arg_size: type_name = "size_type"; break; + case Mem::arg_val: type_name = "value_type"; break; + case Mem::arg_ptr: type_name = "pointer"; break; + case Mem::arg_cptr: type_name = "const_pointer"; break; + case Mem::arg_ref: type_name = "reference"; break; + case Mem::arg_cref: type_name = "const_reference"; break; + case Mem::arg_iter: type_name = "iterator"; break; + case Mem::arg_citer: type_name = "const_iterator"; break; + case Mem::arg_range: type_name = "InputIterator, InputIterator"; break; + case Mem::arg_str: type_name = "basic_string&"; break; + case Mem::arg_cstr: type_name = "const basic_string&"; break; + case Mem::arg_alloc: type_name = "const allocator_type&"; break; + } + + // append the name of the argument type + rw_asnprintf (pbuf, pbufsize, "%{+}%{?}, %{;}%s", + 0 < argno, type_name); + } + + rw_asnprintf (pbuf, pbufsize, "%{+})%{?} const%{;}", is_const); +} + // sets the {CLASS}, {FUNC}, {FUNCSIG}, and optionally {FUNCALL} // environment variables as follows: // CLASS: the name of basic_string specialization @@ -199,7 +284,7 @@ rw_fprintf (0, "%{$CLASS:=*}", buf); // determine the member function name - const size_t funinx = _rw_ilog2 (size_t (fun.which_) >> 6); + const size_t funinx = fun.which_ & StringMembers::mem_mask; const size_t memfuns = sizeof _rw_memfun_names / sizeof *_rw_memfun_names; @@ -218,52 +303,9 @@ rw_putenv ("FUNC="); rw_fprintf (0, "%{$FUNC:=*}", buf); - static const char* const signatures[] = { - "void", - "const value_type*", - "const basic_string&", - "size_type", - "size_type", - "const value_type*, size_type", - "const basic_string&, size_type", - "const value_type*, size_type, size_type", - "const basic_string&, size_type, size_type", - "size_type, const value_type*, size_type", - "size_type, const basic_string&, size_type, size_type", - "size_type, value_type", - "size_type, const basic_string&", - "size_type, size_type", - "size_type, size_type, const value_type*", - "size_type, size_type, const basic_string&", - "size_type, size_type, value_type", - "size_type, size_type, const value_type*, size_type", - "size_type, size_type, const value_type*, size_type, size_type", - "size_type, size_type, size_type, value_type", - "value_type", - "value_type, size_type", - "InputIterator, InputIterator", - "iterator", - "iterator, value_type", - "iterator, size_type, value_type", - "iterator, InputIterator, InputIterator", - "iterator, iterator", - "iterator, iterator, const value_type*", - "iterator, iterator, const basic_string&", - "iterator, iterator, const value_type*, size_type", - "iterator, iterator, size_type, value_type", - "iterator, iterator, InputIterator, InputIterator" - }; + // append the function signature + _rw_append_signature (&buf, &bufsize, fun.which_); - const size_t siginx = - size_t (fun.which_ & ~StringMembers::mem_mask) - 1U; - - RW_ASSERT (siginx < sizeof signatures / sizeof *signatures); - - // append the function signature, - // special processing for at (size_type) const and operator[] const - rw_asnprintf (&buf, &bufsize, "%{+} (%s)%{?} const%{;}", - signatures [siginx], 4 == siginx); - rw_putenv ("FUNCSIG="); rw_fprintf (0, "%{$FUNCSIG:=*}", buf); free (buf); @@ -305,36 +347,36 @@ // format and append member function arguments abbreviating complex // expressions as much as possible to make them easy to understand switch (fun.which_) { - case StringMembers::append_ptr: - case StringMembers::assign_ptr: - case StringMembers::op_plus_eq_ptr: - case StringMembers::find_ptr: - case StringMembers::rfind_ptr: - case StringMembers::find_first_of_ptr: - case StringMembers::find_last_of_ptr: - case StringMembers::find_first_not_of_ptr: - case StringMembers::find_last_not_of_ptr: - case StringMembers::compare_ptr: - case StringMembers::ctor_ptr: - case StringMembers::op_set_ptr: + case StringMembers::append_cptr: + case StringMembers::assign_cptr: + case StringMembers::op_plus_eq_cptr: + case StringMembers::find_const_cptr: + case StringMembers::rfind_const_cptr: + case StringMembers::find_first_of_const_cptr: + case StringMembers::find_last_of_const_cptr: + case StringMembers::find_first_not_of_const_cptr: + case StringMembers::find_last_not_of_const_cptr: + case StringMembers::compare_const_cptr: + case StringMembers::ctor_cptr: + case StringMembers::op_set_cptr: // format self-referential ptr argument without size as c_str() rw_asnprintf (&buf, &bufsize, "%{+}(%{?}c_str()%{:}%{#*s}%{;})", self, int (arg_len), arg); break; - case StringMembers::append_str: - case StringMembers::assign_str: - case StringMembers::op_plus_eq_str: - case StringMembers::find_str: - case StringMembers::rfind_str: - case StringMembers::find_first_of_str: - case StringMembers::find_last_of_str: - case StringMembers::find_first_not_of_str: - case StringMembers::find_last_not_of_str: - case StringMembers::compare_str: - case StringMembers::ctor_str: - case StringMembers::op_set_str: + case StringMembers::append_cstr: + case StringMembers::assign_cstr: + case StringMembers::op_plus_eq_cstr: + case StringMembers::find_const_cstr: + case StringMembers::rfind_const_cstr: + case StringMembers::find_first_of_const_cstr: + case StringMembers::find_last_of_const_cstr: + case StringMembers::find_first_not_of_const_cstr: + case StringMembers::find_last_not_of_const_cstr: + case StringMembers::compare_const_cstr: + case StringMembers::ctor_cstr: + case StringMembers::op_set_cstr: case StringMembers::swap_str: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, @@ -342,47 +384,47 @@ self, int (arg_len), arg); break; - case StringMembers::append_ptr_size: - case StringMembers::assign_ptr_size: - case StringMembers::copy_ptr_size: - case StringMembers::ctor_ptr_size: + case StringMembers::append_cptr_size: + case StringMembers::assign_cptr_size: + case StringMembers::copy_const_ptr_size: + case StringMembers::ctor_cptr_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(" "%{?}data()%{:}%{#*s}%{;}, %zu)", self, int (arg_len), arg, pcase->size); break; - case StringMembers::find_ptr_size: - case StringMembers::rfind_ptr_size: - case StringMembers::find_first_of_ptr_size: - case StringMembers::find_last_of_ptr_size: - case StringMembers::find_first_not_of_ptr_size: - case StringMembers::find_last_not_of_ptr_size: + case StringMembers::find_const_cptr_size: + case StringMembers::rfind_const_cptr_size: + case StringMembers::find_first_of_const_cptr_size: + case StringMembers::find_last_of_const_cptr_size: + case StringMembers::find_first_not_of_const_cptr_size: + case StringMembers::find_last_not_of_const_cptr_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(" "%{?}data()%{:}%{#*s}%{;}, %zu)", self, int (arg_len), arg, pcase->off); break; - case StringMembers::find_str_size: - case StringMembers::rfind_str_size: - case StringMembers::find_first_of_str_size: - case StringMembers::find_last_of_str_size: - case StringMembers::find_first_not_of_str_size: - case StringMembers::find_last_not_of_str_size: - case StringMembers::ctor_str_size: + case StringMembers::find_const_cstr_size: + case StringMembers::rfind_const_cstr_size: + case StringMembers::find_first_of_const_cstr_size: + case StringMembers::find_last_of_const_cstr_size: + case StringMembers::find_first_not_of_const_cstr_size: + case StringMembers::find_last_not_of_const_cstr_size: + case StringMembers::ctor_cstr_size: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(" "%{?}*this%{:}string(%{#*s})%{;}, %zu)", self, int (arg_len), arg, pcase->off); break; - case StringMembers::find_ptr_size_size: - case StringMembers::rfind_ptr_size_size: - case StringMembers::find_first_of_ptr_size_size: - case StringMembers::find_last_of_ptr_size_size: - case StringMembers::find_first_not_of_ptr_size_size: - case StringMembers::find_last_not_of_ptr_size_size: + case StringMembers::find_const_cptr_size_size: + case StringMembers::rfind_const_cptr_size_size: + case StringMembers::find_first_of_const_cptr_size_size: + case StringMembers::find_last_of_const_cptr_size_size: + case StringMembers::find_first_not_of_const_cptr_size_size: + case StringMembers::find_last_not_of_const_cptr_size_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(" "%{?}data()%{:}%{#*s}%{;}, %zu, %zu)", @@ -390,7 +432,7 @@ pcase->off, pcase->size); break; - case StringMembers::copy_ptr_size_size: + case StringMembers::copy_const_ptr_size_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(" "%{?}data()%{:}%{#*s}%{;}, %zu, %zu)", @@ -398,9 +440,9 @@ pcase->size, pcase->off); break; - case StringMembers::append_str_size_size: - case StringMembers::assign_str_size_size: - case StringMembers::ctor_str_size_size: + case StringMembers::append_cstr_size_size: + case StringMembers::assign_cstr_size_size: + case StringMembers::ctor_cstr_size_size: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(" "%{?}*this%{:}string(%{#*s})%{;}, %zu, %zu)", @@ -428,21 +470,21 @@ self, 0 != range1_end, range1_end); break; - case StringMembers::insert_size_ptr: + case StringMembers::insert_size_cptr: // format self-referential ptr argument without size as c_str() rw_asnprintf (&buf, &bufsize, "%{+}(%zu, %{?}c_str()%{:}%{#*s}%{;})", pcase->off, self, int (arg_len), arg); break; - case StringMembers::insert_size_str: + case StringMembers::insert_size_cstr: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(%zu, %{?}*this%{:}string(%{#*s})%{;})", pcase->off, self, int (arg_len), arg); break; - case StringMembers::insert_size_ptr_size: + case StringMembers::insert_size_cptr_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(" "%zu, %{?}data()%{:}%{#*s}%{;}, %zu)", @@ -450,7 +492,7 @@ pcase->size2); break; - case StringMembers::insert_size_str_size_size: + case StringMembers::insert_size_cstr_size_size: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(" "%zu, %{?}*this%{:}string(%{#*s})%{;}, %zu, %zu)", @@ -464,19 +506,7 @@ pcase->off, pcase->size2, pcase->val); break; - case StringMembers::insert_size_val: - rw_asnprintf (&buf, &bufsize, - "%{+}(begin()%{?} + %zu%{;}, %zu, %{#c})", - 0 != pcase->off, pcase->off, pcase->size2, pcase->val); - break; - - case StringMembers::insert_val: - rw_asnprintf (&buf, &bufsize, - "%{+}(begin()%{? + %zu%{;}, %{#c})", - 0 != pcase->off, pcase->off, pcase->val); - break; - - case StringMembers::insert_range: + case StringMembers::insert_iter_range: rw_asnprintf (&buf, &bufsize, "%{+}(begin()%{?} + %zu%{;}, " "%{?}begin()%{:}Iterator(%{#*s})%{;}" "%{?} + %zu%{;}, " @@ -487,8 +517,8 @@ self, 0 != range2_end, range2_end); break; - case StringMembers::replace_size_size_ptr: - case StringMembers::compare_size_size_ptr: + case StringMembers::replace_size_size_cptr: + case StringMembers::compare_const_size_size_cptr: // format self-referential ptr argument without size as c_str() rw_asnprintf (&buf, &bufsize, "%{+}(" "%zu, %zu, %{?}c_str()%{:}%{#*s}%{;})", @@ -496,8 +526,8 @@ int (arg_len), arg); break; - case StringMembers::replace_size_size_str: - case StringMembers::compare_size_size_str: + case StringMembers::replace_size_size_cstr: + case StringMembers::compare_const_size_size_cstr: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(" "%zu, %zu, %{?}*this%{:}string(%{#*s})%{;})", @@ -505,8 +535,8 @@ int (arg_len), arg); break; - case StringMembers::replace_size_size_ptr_size: - case StringMembers::compare_size_size_ptr_size: + case StringMembers::replace_size_size_cptr_size: + case StringMembers::compare_const_size_size_cptr_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(" "%zu, %zu, %{?}data()%{:}%{#*s}%{;}, %zu)", @@ -514,8 +544,8 @@ int (arg_len), arg, pcase->size2); break; - case StringMembers::replace_size_size_str_size_size: - case StringMembers::compare_size_size_str_size_size: + case StringMembers::replace_size_size_cstr_size_size: + case StringMembers::compare_const_size_size_cstr_size_size: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(%zu, %zu, " "%{?}*this%{:}string(%{#*s})%{;}, %zu, %zu)", @@ -530,7 +560,7 @@ pcase->off, pcase->size, pcase->size2, pcase->val); break; - case StringMembers::replace_iter_iter_ptr: + case StringMembers::replace_iter_iter_cptr: // format self-referential ptr argument without size as c_str() rw_asnprintf (&buf, &bufsize, "%{+}(begin()%{?} + %zu%{;}, " "begin()%{?} + %zu%{;}, " @@ -540,7 +570,7 @@ self, int (arg_len), arg); break; - case StringMembers::replace_iter_iter_str: + case StringMembers::replace_iter_iter_cstr: // format self-referential str argument as *this rw_asnprintf (&buf, &bufsize, "%{+}(begin()%{?} + %zu%{;}, " "begin()%{?} + %zu%{;}, " @@ -550,7 +580,7 @@ self, int (arg_len), arg); break; - case StringMembers::replace_iter_iter_ptr_size: + case StringMembers::replace_iter_iter_cptr_size: // format self-referential ptr argument with size as data() rw_asnprintf (&buf, &bufsize, "%{+}(begin()%{?} + %zu%{;}, " "begin()%{?} + %zu%{;}, " @@ -583,51 +613,51 @@ break; case StringMembers::op_plus_eq_val: - case StringMembers::find_val: - case StringMembers::rfind_val: - case StringMembers::find_first_of_val: - case StringMembers::find_last_of_val: - case StringMembers::find_first_not_of_val: - case StringMembers::find_last_not_of_val: + case StringMembers::find_const_val: + case StringMembers::rfind_const_val: + case StringMembers::find_first_of_const_val: + case StringMembers::find_last_of_const_val: + case StringMembers::find_first_not_of_const_val: + case StringMembers::find_last_not_of_const_val: case StringMembers::op_set_val: case StringMembers::push_back_val: rw_asnprintf (&buf, &bufsize, "%{+}(%{#c})", pcase->val); break; - case StringMembers::find_val_size: - case StringMembers::rfind_val_size: - case StringMembers::find_first_of_val_size: - case StringMembers::find_last_of_val_size: - case StringMembers::find_first_not_of_val_size: - case StringMembers::find_last_not_of_val_size: + case StringMembers::find_const_val_size: + case StringMembers::rfind_const_val_size: + case StringMembers::find_first_of_const_val_size: + case StringMembers::find_last_of_const_val_size: + case StringMembers::find_first_not_of_const_val_size: + case StringMembers::find_last_not_of_const_val_size: rw_asnprintf (&buf, &bufsize, "%{+}(%{#c}, %zu)", pcase->val, pcase->off); break; case StringMembers::erase_void: - case StringMembers::substr_void: + case StringMembers::substr_const_void: case StringMembers::ctor_void: rw_asnprintf (&buf, &bufsize, "%{+}()"); break; case StringMembers::erase_size: - case StringMembers::substr_size: + case StringMembers::substr_const_size: case StringMembers::op_index_size: case StringMembers::at_size: rw_asnprintf (&buf, &bufsize, "%{+}(%zu)", pcase->off); break; - case StringMembers::op_index_size_const: - case StringMembers::at_size_const: + case StringMembers::op_index_const_size: + case StringMembers::at_const_size: rw_asnprintf (&buf, &bufsize, "%{+}(%zu) const", pcase->off); break; case StringMembers::erase_size_size: - case StringMembers::substr_size_size: + case StringMembers::substr_const_size_size: rw_asnprintf (&buf, &bufsize, "%{+}(%zu, %zu)", pcase->off, pcase->size); break; @@ -645,6 +675,47 @@ 0 != range1_end, range1_end); break; + case StringMembers::op_plus_cptr_cstr: + // format self-referential ptr argument without size as c_str() + // format self-referential str argument as *this + rw_asnprintf (&buf, &bufsize, + "%{+}(%{?}c_str()%{:}%{#*s}%{;}, " + "%{?}*this%{:}string(%{#*s})%{;})", + self, int (arg_len), arg, self, int (arg_len), arg); + break; + + case StringMembers::op_plus_cstr_cptr: + // format self-referential ptr argument without size as c_str() + // format self-referential str argument as *this + rw_asnprintf (&buf, &bufsize, + "%{+}(%{?}*this%{:}string(%{#*s})%{;}, " + "%{?}c_str()%{:}%{#*s}%{;})", + self, int (arg_len), arg, self, int (arg_len), arg); + break; + + case StringMembers::op_plus_cstr_cstr: + // format self-referential str argument as *this + rw_asnprintf (&buf, &bufsize, + "%{+}(%{?}*this%{:}string(%{#*s})%{;}, " + "%{?}*this%{:}string(%{#*s})%{;})", + self, int (arg_len), arg, self, int (arg_len), arg); + break; + + case StringMembers::op_plus_cstr_val: + // format self-referential str argument as *this + rw_asnprintf (&buf, &bufsize, + "%{+}(%{?}*this%{:}string(%{#*s})%{;}, %{#c})", + self, int (arg_len), arg, pcase->val); + break; + + case StringMembers::op_plus_val_cstr: + // format self-referential str argument as *this + rw_asnprintf (&buf, &bufsize, + "%{+}(%{#c}, %{?}*this%{:}string(%{#*s})%{;})", + pcase->val, self, int (arg_len), arg); + break; + + default: RW_ASSERT (!"test logic error: unknown overload"); } @@ -871,8 +942,8 @@ rw_info (0, 0, 0, "%{$CLASS}::%{$FUNCSIG}"); // compute the function overload's 0-based index - const size_t siginx = - size_t (test.which & ~StringMembers::mem_mask) - 1U; + const size_t siginx = 0; + // size_t (test.which & ~StringMembers::mem_mask) - 1U; // check if tests of the function overload // have been disabled @@ -916,6 +987,8 @@ _rw_string_tests = tests; _rw_string_test_count = test_count; +#define SIGINX ( + return rw_test (argc, argv, file, clause, 0, // comment _rw_run_test, @@ -941,7 +1014,7 @@ "|-no-str_size# " "|-no-ptr_size_size# " "|-no-str_size_size# " - "|-no-size_ptr_size# " + "|-no-size_cptr_size# " "|-no-size_str_size_size# " "|-no-size_val# " "|-no-size_str# " @@ -1018,73 +1091,73 @@ &_rw_opt_no_self_ref, // handlers controlling specific overloads of a function - _rw_opt_memfun_disabled + sig_void - 1, - _rw_opt_memfun_disabled + sig_ptr - 1, - _rw_opt_memfun_disabled + sig_str - 1, - _rw_opt_memfun_disabled + sig_size - 1, - _rw_opt_memfun_disabled + sig_size_const - 1, - _rw_opt_memfun_disabled + sig_ptr_size - 1, - _rw_opt_memfun_disabled + sig_str_size - 1, - _rw_opt_memfun_disabled + sig_ptr_size_size - 1, - _rw_opt_memfun_disabled + sig_str_size_size - 1, - _rw_opt_memfun_disabled + sig_size_ptr_size - 1, - _rw_opt_memfun_disabled + sig_size_str_size_size - 1, - _rw_opt_memfun_disabled + sig_size_val - 1, - _rw_opt_memfun_disabled + sig_size_str - 1, - _rw_opt_memfun_disabled + sig_size_size - 1, - _rw_opt_memfun_disabled + sig_size_size_ptr - 1, - _rw_opt_memfun_disabled + sig_size_size_str - 1, - _rw_opt_memfun_disabled + sig_size_size_val - 1, - _rw_opt_memfun_disabled + sig_size_size_ptr_size - 1, - _rw_opt_memfun_disabled + sig_size_size_str_size_size - 1, - _rw_opt_memfun_disabled + sig_size_size_size_val - 1, - _rw_opt_memfun_disabled + sig_val - 1, - _rw_opt_memfun_disabled + sig_val_size - 1, - _rw_opt_memfun_disabled + sig_range - 1, - _rw_opt_memfun_disabled + sig_iter - 1, - _rw_opt_memfun_disabled + sig_iter_val - 1, - _rw_opt_memfun_disabled + sig_iter_size_val - 1, - _rw_opt_memfun_disabled + sig_iter_range - 1, - _rw_opt_memfun_disabled + sig_iter_iter - 1, - _rw_opt_memfun_disabled + sig_iter_iter_ptr - 1, - _rw_opt_memfun_disabled + sig_iter_iter_str - 1, - _rw_opt_memfun_disabled + sig_iter_iter_ptr_size - 1, - _rw_opt_memfun_disabled + sig_iter_iter_size_val - 1, - _rw_opt_memfun_disabled + sig_iter_iter_range - 1, + _rw_opt_memfun_disabled + sig_void, + _rw_opt_memfun_disabled + sig_cptr, + _rw_opt_memfun_disabled + sig_cstr, + _rw_opt_memfun_disabled + sig_size, + _rw_opt_memfun_disabled + sig_size_const, + _rw_opt_memfun_disabled + sig_cptr_size, + _rw_opt_memfun_disabled + sig_cstr_size, + _rw_opt_memfun_disabled + sig_cptr_size_size, + _rw_opt_memfun_disabled + sig_cstr_size_size, + _rw_opt_memfun_disabled + sig_size_cptr_size, + _rw_opt_memfun_disabled + sig_size_cstr_size_size, + _rw_opt_memfun_disabled + sig_size_val, + _rw_opt_memfun_disabled + sig_size_cstr, + _rw_opt_memfun_disabled + sig_size_size, + _rw_opt_memfun_disabled + sig_size_size_cptr, + _rw_opt_memfun_disabled + sig_size_size_cstr, + _rw_opt_memfun_disabled + sig_size_size_val, + _rw_opt_memfun_disabled + sig_size_size_cptr_size, + _rw_opt_memfun_disabled + sig_size_size_cstr_size_size, + _rw_opt_memfun_disabled + sig_size_size_size_val, + _rw_opt_memfun_disabled + sig_val, + _rw_opt_memfun_disabled + sig_val_size, + _rw_opt_memfun_disabled + sig_range, + _rw_opt_memfun_disabled + sig_iter, + _rw_opt_memfun_disabled + sig_iter_val, + _rw_opt_memfun_disabled + sig_iter_size_val, + _rw_opt_memfun_disabled + sig_iter_range, + _rw_opt_memfun_disabled + sig_iter_iter, + _rw_opt_memfun_disabled + sig_iter_iter_cptr, + _rw_opt_memfun_disabled + sig_iter_iter_cstr, + _rw_opt_memfun_disabled + sig_iter_iter_cptr_size, + _rw_opt_memfun_disabled + sig_iter_iter_size_val, + _rw_opt_memfun_disabled + sig_iter_iter_range, - _rw_opt_memfun_enabled + sig_void - 1, - _rw_opt_memfun_enabled + sig_ptr - 1, - _rw_opt_memfun_enabled + sig_str - 1, - _rw_opt_memfun_enabled + sig_size - 1, - _rw_opt_memfun_enabled + sig_size_const - 1, - _rw_opt_memfun_enabled + sig_ptr_size - 1, - _rw_opt_memfun_enabled + sig_str_size - 1, - _rw_opt_memfun_enabled + sig_ptr_size_size - 1, - _rw_opt_memfun_enabled + sig_str_size_size - 1, - _rw_opt_memfun_enabled + sig_size_ptr_size - 1, - _rw_opt_memfun_enabled + sig_size_str_size_size - 1, - _rw_opt_memfun_enabled + sig_size_val - 1, - _rw_opt_memfun_enabled + sig_size_str - 1, - _rw_opt_memfun_enabled + sig_size_size - 1, - _rw_opt_memfun_enabled + sig_size_size_ptr - 1, - _rw_opt_memfun_enabled + sig_size_size_str - 1, - _rw_opt_memfun_enabled + sig_size_size_val - 1, - _rw_opt_memfun_enabled + sig_size_size_ptr_size - 1, - _rw_opt_memfun_enabled + sig_size_size_str_size_size - 1, - _rw_opt_memfun_enabled + sig_size_size_size_val - 1, - _rw_opt_memfun_enabled + sig_val - 1, - _rw_opt_memfun_enabled + sig_val_size - 1, - _rw_opt_memfun_enabled + sig_range - 1, - _rw_opt_memfun_enabled + sig_iter - 1, - _rw_opt_memfun_enabled + sig_iter_val - 1, - _rw_opt_memfun_enabled + sig_iter_size_val - 1, - _rw_opt_memfun_enabled + sig_iter_range - 1, - _rw_opt_memfun_enabled + sig_iter_iter - 1, - _rw_opt_memfun_enabled + sig_iter_iter_ptr - 1, - _rw_opt_memfun_enabled + sig_iter_iter_str - 1, - _rw_opt_memfun_enabled + sig_iter_iter_ptr_size - 1, - _rw_opt_memfun_enabled + sig_iter_iter_size_val - 1, - _rw_opt_memfun_enabled + sig_iter_iter_range - 1, + _rw_opt_memfun_enabled + sig_void, + _rw_opt_memfun_enabled + sig_cptr, + _rw_opt_memfun_enabled + sig_cstr, + _rw_opt_memfun_enabled + sig_size, + _rw_opt_memfun_enabled + sig_size_const, + _rw_opt_memfun_enabled + sig_cptr_size, + _rw_opt_memfun_enabled + sig_cstr_size, + _rw_opt_memfun_enabled + sig_cptr_size_size, + _rw_opt_memfun_enabled + sig_cstr_size_size, + _rw_opt_memfun_enabled + sig_size_cptr_size, + _rw_opt_memfun_enabled + sig_size_cstr_size_size, + _rw_opt_memfun_enabled + sig_size_val, + _rw_opt_memfun_enabled + sig_size_cstr, + _rw_opt_memfun_enabled + sig_size_size, + _rw_opt_memfun_enabled + sig_size_size_cptr, + _rw_opt_memfun_enabled + sig_size_size_cstr, + _rw_opt_memfun_enabled + sig_size_size_val, + _rw_opt_memfun_enabled + sig_size_size_cptr_size, + _rw_opt_memfun_enabled + sig_size_size_cstr_size_size, + _rw_opt_memfun_enabled + sig_size_size_size_val, + _rw_opt_memfun_enabled + sig_val, + _rw_opt_memfun_enabled + sig_val_size, + _rw_opt_memfun_enabled + sig_range, + _rw_opt_memfun_enabled + sig_iter, + _rw_opt_memfun_enabled + sig_iter_val, + _rw_opt_memfun_enabled + sig_iter_size_val, + _rw_opt_memfun_enabled + sig_iter_range, + _rw_opt_memfun_enabled + sig_iter_iter, + _rw_opt_memfun_enabled + sig_iter_iter_cptr, + _rw_opt_memfun_enabled + sig_iter_iter_cstr, + _rw_opt_memfun_enabled + sig_iter_iter_cptr_size, + _rw_opt_memfun_enabled + sig_iter_iter_size_val, + _rw_opt_memfun_enabled + sig_iter_iter_range, // sentinel (void*)0);