Look at this solution in C++:

#include <string_view>
#include <compare>
#include <type_traits>
#include <cctype>
#include <stdexcept>
#include <cstdint>
#include <cassert>

template<typename CharType, typename Traits>
requires
std::is_same_v<std::make_unsigned_t<CharType>, unsigned char> ||
std::is_same_v<CharType, wchar_t>
&&
requires( CharType const *str, size_t n ) { { Traits::compare( str,
str, n ) } -> std::same_as<int>; }
int numberedStrCmp( std::basic_string_view<CharType, Traits> const
&left, std::basic_string_view<CharType, Traits> const &right )
{ using str_cit = typename std::basic_string_view<CharType,
Traits>::const_iterator;
auto parseDigits = []( str_cit &it, str_cit end ) -> uint64_t
{
assert(!isdigit( *it ));
uint64_t value = 0;
do
{
if( value * 10 / 10 != value )
throw std::out_of_range( "numberedStrCmp() - number too big" );
value *= 10;
unsigned digit = *it - '0';
if( value + digit < value )
throw std::out_of_range( "numberedStrCmp() - number too big" );
value += digit;
} while( ++it != end && isdigit( *it ) );
return value;
};
auto skipDigits = []( str_cit &it )
{
while( isdigit( *++it ) );
};
str_cit itLeft = left.cbegin(), itRight = right.cbegin();
auto compareCurChar = [&]() -> int
{
bool
leftDigit = isdigit( *itLeft ),
rightDigit = isdigit( *itRight );
if( leftDigit && rightDigit )
{
uint64_t
leftNumber = parseDigits( itLeft, left.cend() ),
rightNumber = parseDigits( itRight, right.cend() );
return leftNumber == rightNumber ? 0 : leftNumber < rightNumber ? -1
: +1;
}
else if( leftDigit || rightDigit )
{
auto cmpDigitChar = []( CharType chr ) -> int
{
CharType cmpDigit = '0';
return Traits::compare( &cmpDigit, &chr, 1 );
};
if( leftDigit )
{
skipDigits( itLeft );
return cmpDigitChar( *itRight++ );
}
else
{
skipDigits( itRight );
return -cmpDigitChar( *itLeft++ );
}
}
return Traits::compare( &*itLeft++, &*itRight++, 1 );
};
for( ; ; )
{
auto zeroCmp = []( CharType chr )
{
CharType zero = '\0';
return Traits::compare( &zero, &chr, 1 );
};
if( itLeft == left.cend() )
return itRight != right.cend() ? zeroCmp( *itRight ) : 0;
if( itRight == right.cend() )
return -zeroCmp( *itLeft );
int cmp = compareCurChar();
if( cmp != 0 )
return cmp;
}
}

using namespace std;

#if !defined(NDEBUG)
template
int numberedStrCmp( basic_string_view<char, char_traits<char>> const
&left, basic_string_view<char, char_traits<char>> const &right );
#endif

Two advantages of this solution:
* It works with normal chars as well as wide-characters
* It honors customized collation-orders implemented in the Traits type

The only disadvantage is that it currently doesn't support multibyte
-characters.

On 2022-02-24, Bonita Montero <Bonita.Montero@gmail.com> wrote:
> Look at this solution in C++:

Dog's breakfast.

> auto parseDigits = []( str_cit &it, str_cit end ) -> uint64_t
> {
> assert(!isdigit( *it ));
> uint64_t value = 0;
> do
> {
> if( value * 10 / 10 != value )
> throw std::out_of_range( "numberedStrCmp() - number too big" );
> value *= 10;
> unsigned digit = *it - '0';
> if( value + digit < value )
> throw std::out_of_range( "numberedStrCmp() - number too big" );
> value += digit;
> } while( ++it != end && isdigit( *it ) );
> return value;

All those C++ libraries, and you have to write your own loop to
scan digits and produce an unsigned integer???

You are incompetent beyond belief.

Am 24.02.2022 um 23:16 schrieb Kaz Kylheku:
> On 2022-02-24, Bonita Montero <Bonita.Montero@gmail.com> wrote:
>> Look at this solution in C++:
>
> Dog's breakfast.
>
>> auto parseDigits = []( str_cit &it, str_cit end ) -> uint64_t
>> {
>> assert(!isdigit( *it ));
>> uint64_t value = 0;
>> do
>> {
>> if( value * 10 / 10 != value )
>> throw std::out_of_range( "numberedStrCmp() - number too big" );
>> value *= 10;
>> unsigned digit = *it - '0';
>> if( value + digit < value )
>> throw std::out_of_range( "numberedStrCmp() - number too big" );
>> value += digit;
>> } while( ++it != end && isdigit( *it ) );
>> return value;
>
> All those C++ libraries, and you have to write your own loop to
> scan digits and produce an unsigned integer???

Yes, because there is no universal function that fits for wide
characters also. from_chars has a nice api-design but it is is
char only.

On 2022-02-24, Bonita Montero <Bonita.Montero@gmail.com> wrote:
> Am 24.02.2022 um 23:16 schrieb Kaz Kylheku:
>> On 2022-02-24, Bonita Montero <Bonita.Montero@gmail.com> wrote:
>>> Look at this solution in C++:
>>
>> Dog's breakfast.
>>
>>> auto parseDigits = []( str_cit &it, str_cit end ) -> uint64_t
>>> {
>>> assert(!isdigit( *it ));

You don't want to pass wide characters or other junk into isdigit!

It has undefined behavior for values other than EOF and 0 to
UCHAR_MAX!

Even char is not safe, because it can be signed and exhibit negative
values that are not EOF.

Since the code is supposed to be generic between char and wchar_t,
what you can do is use iswdigit function for both cases. But that is tricky.

You have to be careful how you convert a char to a wchar. If a char value is,
say, -128, you don't want to just be casting that to wchar_t because you will
get some huge value. Rather, you want something like
(wchar_t) (unsigned char) c.

Now iswdigit takes a wint_t, not a wchar_t. wint_t is capable of holding the value
WEOF. (WEOF is not required to have the same value as EOF, and need not be
negative.)

The wide character classification functions don't have the same pitfall
as the classic ones; there is no statement saying that the functions are
only required to work for some restricted subrange of their wint_t argument,

>>> uint64_t value = 0;
>>> do
>>> {
>>> if( value * 10 / 10 != value )
>>> throw std::out_of_range( "numberedStrCmp() - number too big" );

Someone just wanted a nicer sort for displaying file names; now
you're killing the program with a surprise exception when someone has
a file name with too many consecutive digits somewhere in it.

>> All those C++ libraries, and you have to write your own loop to
>> scan digits and produce an unsigned integer???
>
> Yes, because there is no universal function that fits for wide
> characters also.

wcstoul, wcstoull, since ISO C99, declared in <wchar.h>.

For uintmax_t, there is wcstoumax, in <inttypes.h>, also requiring
<stddef.h>.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:

> You don't want to pass wide characters or other junk into isdigit!

isdigit takes an int.

> Even char is not safe, because it can be signed and exhibit negative
> values that are not EOF.

As the boundary between signed and and unsigned ints doesn't fall
within >= '0' and <= '9' it isn't a problem that isdgit takes an int.

> You have to be careful how you convert a char to a wchar. If a char value is,
> say, -128, you don't want to just be casting that to wchar_t because you will
> get some huge value. Rather, you want something like
> (wchar_t) (unsigned char) c.

You're stupid.

>>>> uint64_t value = 0;
>>>> do
>>>> {
>>>> if( value * 10 / 10 != value )
>>>> throw std::out_of_range( "numberedStrCmp() - number too big" );
>
> Someone just wanted a nicer sort for displaying file names; now
> you're killing the program with a surprise exception when someone has
> a file name with too many consecutive digits somewhere in it.

Then you need additional handling inside an exception-handler.

> wcstoul, wcstoull, since ISO C99, declared in <wchar.h>.

I'd have to use a if constexpr then and wcstoul and wcstoull don't
honor any collation orders implemented in Traits.

Here's a better version that allows arbitraty number lengths:

#include <string_view>
#include <compare>
#include <type_traits>
#include <cctype>
#include <stdexcept>
#include <cstdint>
#include <cassert>

template<typename CharType, typename Traits>
requires
std::is_same_v<std::make_unsigned_t<CharType>, unsigned char> ||
std::is_same_v<CharType, wchar_t>
&&
requires( CharType const *str, size_t n ) { { Traits::compare( str,
str, n ) } -> std::same_as<int>; }
int numberedStrCmp( std::basic_string_view<CharType, Traits> const
&left, std::basic_string_view<CharType, Traits> const &right )
{ using str_cit = typename std::basic_string_view<CharType,
Traits>::const_iterator;
str_cit itLeft = left.cbegin(), itRight = right.cbegin();
auto digitsCmp = [&]() -> int
{
auto nDigits = []( str_cit &it, str_cit end ) -> ptrdiff_t
{
assert(isdigit( *it ));
str_cit begin = it;
while( ++it != end && isdigit( *it ) );
return it - begin;
};
ptrdiff_t
nLeftDigits = nDigits( itLeft, left.cend() ),
nRightDigits = nDigits( itRight, right.cend() );
if( nLeftDigits != nRightDigits )
return nLeftDigits < nRightDigits ? -1 : 1;
nLeftDigits = -nLeftDigits;
do
if( itLeft[nLeftDigits] != itRight[nLeftDigits] )
return itLeft[nLeftDigits] < itRight[nLeftDigits] ? -1 : 1;
while( ++nLeftDigits );
return 0;
};
auto skipDigits = []( str_cit &it )
{
while( isdigit( *++it ) );
};
auto compareCurChar = [&]() -> int
{
bool
leftDigit = isdigit( *itLeft ),
rightDigit = isdigit( *itRight );
if( leftDigit && rightDigit )
return digitsCmp();
else if( leftDigit || rightDigit )
{
auto cmpDigitChar = []( CharType chr ) -> int
{
CharType cmpDigit = '0';
return Traits::compare( &cmpDigit, &chr, 1 );
};
if( leftDigit )
{
skipDigits( itLeft );
return cmpDigitChar( *itRight++ );
}
else
{
skipDigits( itRight );
return -cmpDigitChar( *itLeft++ );
}
}
return Traits::compare( &*itLeft++, &*itRight++, 1 );
};
for( ; ; )
{
auto zeroCmp = []( CharType chr )
{
CharType zero = '\0';
return Traits::compare( &zero, &chr, 1 );
};
if( itLeft == left.cend() )
return itRight != right.cend() ? zeroCmp( *itRight ) : 0;
if( itRight == right.cend() )
return -zeroCmp( *itLeft );
int cmp = compareCurChar();
if( cmp != 0 )
return cmp;
}
}

using namespace std;

#if !defined(NDEBUG)
template
int numberedStrCmp( basic_string_view<char, char_traits<char>> const
&left, basic_string_view<char, char_traits<char>> const &right );
#endif

In article <sv9qfh$kec$1@dont-email.me>,
Bonita Montero <Bonita.Montero@gmail.com> wrote:
....
>You're stupid.

That's rich. Someone posting C++ garbage in a C newsgroup, calling someone
else "stupid". If you keep at it, I may have to start posting my PL/I
solutions on these threads.

That said, gotta give ya credit for spelling "You're" correctly. Most
folks of your general IQ level would have misspelled it.

--
[Donald] Trump didn't have it all handed to him by his parents,
like Hillary Clinton did.

- Some dumb cluck in Ohio; featured in Michael Moore's "Trumpland" -

Am 25.02.2022 um 08:45 schrieb Kenny McCormack:
> In article <sv9qfh$kec$1@dont-email.me>,
> Bonita Montero <Bonita.Montero@gmail.com> wrote:
> ...
>> You're stupid.
>
> That's rich. Someone posting C++ garbage in a C newsgroup, calling someone
> else "stupid". If you keep at it, I may have to start posting my PL/I
> solutions on these threads.

C++ isn't garbage but just the more suitable langauage.

The below solution compares numbers with leading zeroes not correctly.
I'll fix this.

Am 25.02.2022 um 07:58 schrieb Bonita Montero:
>
>> wcstoul, wcstoull, since ISO C99, declared in <wchar.h>.
>
> I'd have to use a if constexpr then and wcstoul and wcstoull don't
> honor any collation orders implemented in Traits.
>
>
> Here's a better version that allows arbitraty number lengths:
>
> #include <string_view>
> #include <compare>
> #include <type_traits>
> #include <cctype>
> #include <stdexcept>
> #include <cstdint>
> #include <cassert>
>
> template<typename CharType, typename Traits>
>     requires
>     std::is_same_v<std::make_unsigned_t<CharType>, unsigned char> ||
> std::is_same_v<CharType, wchar_t>
>     &&
>     requires( CharType const *str, size_t n ) { { Traits::compare( str,
> str, n ) } -> std::same_as<int>; }
> int numberedStrCmp( std::basic_string_view<CharType, Traits> const
> &left, std::basic_string_view<CharType, Traits> const &right )
> {
>     using str_cit = typename std::basic_string_view<CharType,
> Traits>::const_iterator;
>     str_cit itLeft = left.cbegin(), itRight = right.cbegin();
>     auto digitsCmp = [&]() -> int
>     {
>         auto nDigits = []( str_cit &it, str_cit end ) -> ptrdiff_t
>         {
>             assert(isdigit( *it ));
>             str_cit begin = it;
>             while( ++it != end && isdigit( *it ) );
>             return it - begin;
>         };
>         ptrdiff_t
>             nLeftDigits = nDigits( itLeft, left.cend() ),
>             nRightDigits = nDigits( itRight, right.cend() );
>         if( nLeftDigits != nRightDigits )
>             return nLeftDigits < nRightDigits ? -1 : 1;
>         nLeftDigits = -nLeftDigits;
>         do
>             if( itLeft[nLeftDigits] != itRight[nLeftDigits] )
>                 return itLeft[nLeftDigits] < itRight[nLeftDigits] ? -1
> : 1;
>         while( ++nLeftDigits );
>         return 0;
>     };
>     auto skipDigits = []( str_cit &it )
>     {
>         while( isdigit( *++it ) );
>     };
>     auto compareCurChar = [&]() -> int
>     {
>         bool
>             leftDigit = isdigit( *itLeft ),
>             rightDigit = isdigit( *itRight );
>         if( leftDigit && rightDigit )
>             return digitsCmp();
>         else if( leftDigit || rightDigit )
>         {
>             auto cmpDigitChar = []( CharType chr ) -> int
>             {
>                 CharType cmpDigit = '0';
>                 return Traits::compare( &cmpDigit, &chr, 1 );
>             };
>             if( leftDigit )
>             {
>                 skipDigits( itLeft );
>                 return cmpDigitChar( *itRight++ );
>             }
>             else
>             {
>                 skipDigits( itRight );
>                 return -cmpDigitChar( *itLeft++ );
>             }
>         }
>         return Traits::compare( &*itLeft++, &*itRight++, 1 );
>     };
>     for( ; ; )
>     {
>         auto zeroCmp = []( CharType chr )
>         {
>             CharType zero = '\0';
>             return Traits::compare( &zero, &chr, 1 );
>         };
>         if( itLeft == left.cend() )
>             return itRight != right.cend() ? zeroCmp( *itRight ) : 0;
>         if( itRight == right.cend() )
>             return -zeroCmp( *itLeft );
>         int cmp = compareCurChar();
>         if( cmp != 0 )
>             return cmp;
>     }
> }
>
> using namespace std;
>
> #if !defined(NDEBUG)
> template
> int numberedStrCmp( basic_string_view<char, char_traits<char>> const
> &left, basic_string_view<char, char_traits<char>> const &right );
> #endif

So this is it:

#include <string_view>
#include <compare>
#include <type_traits>
#include <cctype>
#include <stdexcept>
#include <cstdint>
#include <cassert>

template<typename CharType, typename Traits>
requires
std::is_same_v<std::make_unsigned_t<CharType>, unsigned char> ||
std::is_same_v<CharType, wchar_t>
&&
requires( CharType const *str, size_t n ) { { Traits::compare( str,
str, n ) } -> std::same_as<int>; }
int numberedStrCmp( std::basic_string_view<CharType, Traits> const
&left, std::basic_string_view<CharType, Traits> const &right )
{ using str_cit = typename std::basic_string_view<CharType,
Traits>::const_iterator;
str_cit itLeft = left.cbegin(), itRight = right.cbegin();
auto digitsCmp = [&]() -> int
{
auto skipLeadingZeroes = []( str_cit &it, str_cit end )
{
assert(isdigit( *it ));
for( ; *it == '0' && it + 1 != end && isdigit( it[1] ); ++it );
};
skipLeadingZeroes( itLeft, left.cend() );
skipLeadingZeroes( itRight, right.cend() );
auto countDigits = []( str_cit &it, str_cit end ) -> ptrdiff_t
{
assert(isdigit( *it ));
str_cit begin = it;
while( ++it != end && isdigit( *it ) );
return it - begin;
};
ptrdiff_t
nLeftDigits = countDigits( itLeft, left.cend() ),
nRightDigits = countDigits( itRight, right.cend() );
if( nLeftDigits != nRightDigits )
return nLeftDigits < nRightDigits ? -1 : 1;
ptrdiff_t nDigits = -nLeftDigits;
do
if( itLeft[nDigits] != itRight[nDigits] )
return itLeft[nDigits] < itRight[nDigits] ? -1 : 1;
while( ++nLeftDigits );
return 0;
};
auto skipDigits = []( str_cit &it )
{
assert(isdigit( *it ));
while( isdigit( *++it ) );
};
auto compareCurChar = [&]() -> int
{
bool
leftDigit = isdigit( *itLeft ),
rightDigit = isdigit( *itRight );
if( leftDigit && rightDigit )
return digitsCmp();
else if( leftDigit || rightDigit )
{
auto cmpDigitChar = []( CharType chr ) -> int
{
CharType cmpDigit = '0';
return Traits::compare( &cmpDigit, &chr, 1 );
};
if( leftDigit )
{
skipDigits( itLeft );
return cmpDigitChar( *itRight++ );
}
else
{
skipDigits( itRight );
return -cmpDigitChar( *itLeft++ );
}
}
return Traits::compare( &*itLeft++, &*itRight++, 1 );
};
for( ; ; )
{
auto zeroCmp = []( CharType chr )
{
CharType zero = '\0';
return Traits::compare( &zero, &chr, 1 );
};
if( itLeft == left.cend() )
return itRight != right.cend() ? zeroCmp( *itRight ) : 0;
if( itRight == right.cend() )
return -zeroCmp( *itLeft );
int cmp = compareCurChar();
if( cmp != 0 )
return cmp;
}
}

using namespace std;

#if !defined(NDEBUG)
template
int numberedStrCmp( basic_string_view<char, char_traits<char>> const
&left, basic_string_view<char, char_traits<char>> const &right );
#endif

In article <sva62c$ktu$1@dont-email.me>,
Bonita Montero <Bonita.Montero@gmail.com> wrote:
>Am 25.02.2022 um 08:45 schrieb Kenny McCormack:
>> In article <sv9qfh$kec$1@dont-email.me>,
>> Bonita Montero <Bonita.Montero@gmail.com> wrote:
>> ...
>>> You're stupid.
>>
>> That's rich. Someone posting C++ garbage in a C newsgroup, calling someone
>> else "stupid". If you keep at it, I may have to start posting my PL/I
>> solutions on these threads.
>
>C++ isn't garbage but just the more suitable langauage.
>

Like I said, you get credit for spelling "You're" correctly.

That's about it.

--
Conservatives want smaller government for the same reason criminals want fewer cops.

On Friday, 25 February 2022 at 05:46:53 UTC, Bonita Montero wrote:
> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>
> > You don't want to pass wide characters or other junk into isdigit!
> isdigit takes an int.
> > Even char is not safe, because it can be signed and exhibit negative
> > values that are not EOF.
> As the boundary between signed and and unsigned ints doesn't fall
> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.
>
If isdigit() expands to ((ch) >= '0' && (ch) <= '9') then isdigit(c++) has
funny results.
If it expands to (__internaltable[ch+1]) then ch outside the range -1 to
255 will have funny results.

I think the standard says that the second option is to be preferred.

Bonita Montero <Bonita.Montero@gmail.com> writes:

> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>
>> You don't want to pass wide characters or other junk into isdigit!
>
> isdigit takes an int.
>
>> Even char is not safe, because it can be signed and exhibit negative
>> values that are not EOF.
>
> As the boundary between signed and and unsigned ints doesn't fall
> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.

You are missing the point. It's undefined. Anyway, as an advocate for
C++ you should be using the simple C++ way to do this test:

std::use_facet<std::ctype<char>>(std::locale()).is(std::ctype_base::digit, c)

;-)

--
Ben.

Am 25.02.2022 um 11:03 schrieb Malcolm McLean:
> On Friday, 25 February 2022 at 05:46:53 UTC, Bonita Montero wrote:
>> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>>
>>> You don't want to pass wide characters or other junk into isdigit!
>> isdigit takes an int.
>>> Even char is not safe, because it can be signed and exhibit negative
>>> values that are not EOF.
>> As the boundary between signed and and unsigned ints doesn't fall
>> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.
>>
> If isdigit() expands to ((ch) >= '0' && (ch) <= '9') then isdigit(c++) has
> funny results.

It doesn't matter if the digits I handle to isdigit are sign-expanded
or not because '0' ... '9' falls into the unsigned range.

> If it expands to (__internaltable[ch+1]) then ch outside the range -1 to
> 255 will have funny results.
>
> I think the standard says that the second option is to be preferred.

Am 25.02.2022 um 12:46 schrieb Ben Bacarisse:
> Bonita Montero <Bonita.Montero@gmail.com> writes:
>
>> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>>
>>> You don't want to pass wide characters or other junk into isdigit!
>>
>> isdigit takes an int.
>>
>>> Even char is not safe, because it can be signed and exhibit negative
>>> values that are not EOF.
>>
>> As the boundary between signed and and unsigned ints doesn't fall
>> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.
>
> You are missing the point. It's undefined. Anyway, as an advocate for
> C++ you should be using the simple C++ way to do this test:

There's nothing undefined here. It doesn't matter if the digits I
handle to isdigit are sign-expanded or not because '0' ... '9'
falls into the unsigned range.

Am 25.02.2022 um 12:46 schrieb Ben Bacarisse:
> Bonita Montero <Bonita.Montero@gmail.com> writes:
>
>> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>>
>>> You don't want to pass wide characters or other junk into isdigit!
>>
>> isdigit takes an int.
>>
>>> Even char is not safe, because it can be signed and exhibit negative
>>> values that are not EOF.
>>
>> As the boundary between signed and and unsigned ints doesn't fall
>> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.
>
> You are missing the point. It's undefined. Anyway, as an advocate for
> C++ you should be using the simple C++ way to do this test:
>
> std::use_facet<std::ctype<char>>(std::locale()).is(std::ctype_base::digit, c)

And _digit_-checking needs no locales for sure.

gazelle@shell.xmission.com (Kenny McCormack) writes:
>In article <sv9qfh$kec$1@dont-email.me>,
>Bonita Montero <Bonita.Montero@gmail.com> wrote:
>...
>>You're stupid.
>

>That said, gotta give ya credit for spelling "You're" correctly. Most
>folks of your general IQ level would have misspelled it.

That's more due to ESL (English as a Second Language) than to IQ, I suspect.

On Friday, 25 February 2022 at 12:02:56 UTC, Bonita Montero wrote:
> Am 25.02.2022 um 12:46 schrieb Ben Bacarisse:
>
> > std::use_facet<std::ctype<char>>(std::locale()).is(std::ctype_base::digit, c)
> And _digit_-checking needs no locales for sure.
>
In Arabic, whilst they use Arabic numerals (of course), the glyphs are very
different from the ones used in the West.

On 2022-02-25, Bonita Montero <Bonita.Montero@gmail.com> wrote:
> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>
>> You don't want to pass wide characters or other junk into isdigit!
>
> isdigit takes an int.

Good, you can read manuals. It takes an int, which ISO C says must
either represent the value EOF, or else a value in the range of the
unsigned char type (0 to UCHAR_MAX).

Passing any other value is undefined behavior. That's exactly what will
happen when you feed it wchar_t values containing character code points
whose values lie beyond UCHAR_MAX, or that are negative values not equal
to EOF after conversion to int.

>> Even char is not safe, because it can be signed and exhibit negative
>> values that are not EOF.
>
> As the boundary between signed and and unsigned ints doesn't fall
> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.

What???

If you know that the datum is between '0' and '9', why would you be
calling isdigit?

you're calling isdigit because you don't know what.

What I mean is that if you have a C string str made up of char elements,
which is often the case, then isdigit(str[i]) is not necessary
well-defined behavior. While all the positive valuews of char will be
within the 0 to UCHAR_MAX range, char may be signed, and so str[i] could
produce a value that is negative and not EOF. Then isdigit's behavior is
no longer defined.

>> You have to be careful how you convert a char to a wchar. If a char value is,
>> say, -128, you don't want to just be casting that to wchar_t because you will
>> get some huge value. Rather, you want something like
>> (wchar_t) (unsigned char) c.
>
> You're stupid.

It may seem like that to you, but the situation is more like that
I might not be very good at explaining things to people who don't have
anywhere near the right comprehension level.

What I mean in the above paragraph is that, suppose we have some
ISO-Latin character value that maps to a negative value of char.
For instance, the 0xA0 space character. In signed char (on 8 bit, two's
complement platforms) that will have the value -96.

What happens if we call iswdigit(-96)? Internally, this function cuold
treat that as, say, an unsigned 32 bit value: i.e. 0xFFFFFFA0 which
doesn't correspond to the character. (That garbage could well somehow be
misinterpreted as a digit, resulting in a false positive.)

What my "stupid" cast is doing is this:

(wchar_t) (unsigned char) -96.
^^^^^^^^^^^^^^^^^^^^
the underlined part goes to 160, and so now if we pass that to iswdigit,
it will be operating on the 160 value that we intend.

But in the wchar_t expansion of all the C++ template-ology, we don't
want that (unsigned char) cast, of ourse; it will be truncating the wide
characters.

>> Someone just wanted a nicer sort for displaying file names; now
>> you're killing the program with a surprise exception when someone has
>> a file name with too many consecutive digits somewhere in it.
>
> Then you need additional handling inside an exception-handler.

If you don't document that, it won't get written, and it won't get
tested. The first person to step on that case could be an end user
who creates a filename with many digits in it.

Furthermore, a comparison function for sorting strings must handle all
strings you can throw at it without crashing, aborting or throwing.

It's not reasonable for any filename handling code to throw when it is
given a valid filename.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

On 2022-02-25, Bonita Montero <Bonita.Montero@gmail.com> wrote:
> Am 25.02.2022 um 08:45 schrieb Kenny McCormack:
>> In article <sv9qfh$kec$1@dont-email.me>,
>> Bonita Montero <Bonita.Montero@gmail.com> wrote:
>> ...
>>> You're stupid.
>>
>> That's rich. Someone posting C++ garbage in a C newsgroup, calling someone
>> else "stupid". If you keep at it, I may have to start posting my PL/I
>> solutions on these threads.
>
> C++ isn't garbage but just the more suitable langauage.

Not in your hands, though.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

On 2022-02-25, Malcolm McLean <malcolm.arthur.mclean@gmail.com> wrote:
> On Friday, 25 February 2022 at 12:02:56 UTC, Bonita Montero wrote:
>> Am 25.02.2022 um 12:46 schrieb Ben Bacarisse:
>>
>> > std::use_facet<std::ctype<char>>(std::locale()).is(std::ctype_base::digit, c)
>> And _digit_-checking needs no locales for sure.
>>
> In Arabic, whilst they use Arabic numerals (of course), the glyphs are very
> different from the ones used in the West.

Is't not clear, however, whether the ISO C isdigit and iswdigit
functions are allowed to detect those.

The requirement is that they only report true for the ten decimal digits
of the basic execution character set.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
> On Friday, 25 February 2022 at 05:46:53 UTC, Bonita Montero wrote:
>> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>>
>> > You don't want to pass wide characters or other junk into isdigit!
>> isdigit takes an int.
>> > Even char is not safe, because it can be signed and exhibit negative
>> > values that are not EOF.
>> As the boundary between signed and and unsigned ints doesn't fall
>> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.
>>
> If isdigit() expands to ((ch) >= '0' && (ch) <= '9') then isdigit(c++) has
> funny results.
> If it expands to (__internaltable[ch+1]) then ch outside the range -1 to
> 255 will have funny results.
>
> I think the standard says that the second option is to be preferred.

Not just preferred, required. N1570 7.1.4p1:

Any invocation of a library function that is implemented as a
macro shall expand to code that evaluates each of its arguments
exactly once, fully protected by parentheses where necessary, so
it is generally safe to use arbitrary expressions as arguments.

But calling isdigit with a value that is not either EOF or within the
range of unsigned char has undefined behavior, which is why you need to
do something like:

char c = ...;
isdigit((unsigned char)c);

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

On 2/25/22 2:12 PM, Kaz Kylheku wrote:
> On 2022-02-25, Malcolm McLean <malcolm.arthur.mclean@gmail.com> wrote:
>> On Friday, 25 February 2022 at 12:02:56 UTC, Bonita Montero wrote:
>>> Am 25.02.2022 um 12:46 schrieb Ben Bacarisse:
>>>
>>>> std::use_facet<std::ctype<char>>(std::locale()).is(std::ctype_base::digit, c)
>>> And _digit_-checking needs no locales for sure.
>>>
>> In Arabic, whilst they use Arabic numerals (of course), the glyphs are very
>> different from the ones used in the West.
>
> Is't not clear, however, whether the ISO C isdigit and iswdigit
> functions are allowed to detect those.
>
> The requirement is that they only report true for the ten decimal digits
> of the basic execution character set.
>

While the character classification routines allow for locale specific
letters and such, it doesn't have similar wording for digits.

This would imply that isdigit is supposed to ONLY detect for the
characters '0' ... '9' and not other 'digits' from other locales.

Since the rules for character sets are written to allow the use of the
expression c - '0' to convert a character in c that passes an isdigit
test to its decimal value, I strongly suspect that limitation is
intentional and not just an omission.

Am 25.02.2022 um 19:58 schrieb Kaz Kylheku:
> On 2022-02-25, Bonita Montero <Bonita.Montero@gmail.com> wrote:
>> Am 25.02.2022 um 08:45 schrieb Kenny McCormack:
>>> In article <sv9qfh$kec$1@dont-email.me>,
>>> Bonita Montero <Bonita.Montero@gmail.com> wrote:
>>> ...
>>>> You're stupid.
>>>
>>> That's rich. Someone posting C++ garbage in a C newsgroup, calling someone
>>> else "stupid". If you keep at it, I may have to start posting my PL/I
>>> solutions on these threads.
>>
>> C++ isn't garbage but just the more suitable langauage.
>
> Not in your hands, though.

You're simply stupid.

Am 25.02.2022 um 20:17 schrieb Keith Thompson:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>> On Friday, 25 February 2022 at 05:46:53 UTC, Bonita Montero wrote:
>>> Am 24.02.2022 um 23:46 schrieb Kaz Kylheku:
>>>
>>>> You don't want to pass wide characters or other junk into isdigit!
>>> isdigit takes an int.
>>>> Even char is not safe, because it can be signed and exhibit negative
>>>> values that are not EOF.
>>> As the boundary between signed and and unsigned ints doesn't fall
>>> within >= '0' and <= '9' it isn't a problem that isdgit takes an int.
>>>
>> If isdigit() expands to ((ch) >= '0' && (ch) <= '9') then isdigit(c++) has
>> funny results.
>> If it expands to (__internaltable[ch+1]) then ch outside the range -1 to
>> 255 will have funny results.
>>
>> I think the standard says that the second option is to be preferred.
>
> Not just preferred, required. N1570 7.1.4p1:
>
> Any invocation of a library function that is implemented as a
> macro shall expand to code that evaluates each of its arguments
> exactly once, fully protected by parentheses where necessary, so
> it is generally safe to use arbitrary expressions as arguments.
>
> But calling isdigit with a value that is not either EOF or within the
> range of unsigned char has undefined behavior, which is why you need to
> do something like:

My code is C++ and C++ specifies isdigit as a normal function.