Re: Command Languages Versus Programming Languages

In article <87cyinthjk.fsf@doppelsaurus.mobileactivedefense.com>,
Rainer Weikusat  <rweikusat@talktalk.net> wrote:

cross@spitfire.i.gajendra.net (Dan Cross) writes:

In article <87o728qzbc.fsf@doppelsaurus.mobileactivedefense.com>,
Rainer Weikusat  <rweikusat@talktalk.net> wrote:

mas@a4.home writes:

On 2024-11-20, Rainer Weikusat <rweikusat@talktalk.net> wrote:

Janis Papanagnou <janis_papanagnou+ng@hotmail.com> writes:
>
Assuming that p is a pointer to the current position in a string, e is a
pointer to the end of it (ie, point just past the last byte) and -
that's important - both are pointers to unsigned quantities, the 'bulky'
C equivalent of [0-9]+ is
>
while (p < e && *p - '0' < 10) ++p;
>
That's not too bad. And it's really a hell lot faster than a
general-purpose automaton programmed to recognize the same pattern
(which might not matter most of the time, but sometimes, it does).

>
int
main(int argc, char **argv) {
unsigned char *p, *e;
unsigned char mystr[] = "12#45XY ";
>
    p = mystr;
    e = mystr + sizeof(mystr);
    while (p < e && *p - '0' < 10) ++p;

>
The code I'm actually using is
>
while (p < e && (unsigned)*p - '0' < 10)
       ++p;
>
I just omitted that when posting this beause I mistakenly assumed that
it probably wasn't needed, ;-). You could have pointed this out instead
of trying to dress it up as some sort of mystery problem¹. Especially as
I did mention that using unsigned arithmetic was necessary (should
really be self-evident).

>
Well, no, not exactly.  You said that it was important that the
pointers point to unsigned quantities, but that wasn't the
issue.

>
The issue here is that I mistakenly assumed the (unsigned) in the code
was a left-over from before the time when I had changed to pointers to
unsigned char to fix a different issue.

That you "changed to pointers to unsigned char" is completely
irrelevant.  That's not how C works: C will promote those
`unsigned char` values to `signed int` before it does the
subtraction.  It does this because `unsigned char` has _rank_
lower than _int_ and the entire range of values is expressible
in a signed int.  These are called, "the usual arithmetic
conversions."

I pointed you to the section of the standard that explains this.

As C tries really hard to force
signed arithmetic onto people despite this basically never makes any
sense,

It actually makes a lot of sense in a lot of contexts, and is
usually what people actually want.

You've shown that you, personally, don't have a great command of
the language, so perhaps you shouldn't opine quite so
forcefully.

the type of '0' is int *p gets promoted to int and hence, the
result of the subtraction will also be an int and the '< 10' condition
will be true for every codepoint numerically less than '9' which
obviously won't work as intended.

Yes, that's how it works.

That's a mistake I made which would have warranted being pointed out and
possibly explained instead of posting some broken code together with
some output the broken code certainly never generated due it being
broken.

Perhaps if you stopped being so unbearably smug and pretentious
in your judgements people would give you that grace.  As it is,
you come across as thin-skinned and terribly insecure, and your
code shows a lack of competence.

- Dan C.