Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: Kaz Kylheku <643-408-1753@kylheku.com>
Newsgroups: comp.lang.c
Subject: Re: Loops (was Re: do { quit; } else { })
Date: Mon, 21 Apr 2025 20:25:58 -0000 (UTC)
Organization: A noiseless patient Spider
Lines: 213
Message-ID: <20250421125957.29@kylheku.com>
References: <vspbjh$8dvd$1@dont-email.me> <20250413072027.219@kylheku.com>
 <vtgpce$39229$1@dont-email.me> <vti2ki$g23v$1@dont-email.me>
 <vtin99$vu24$1@dont-email.me> <vtiuf0$18au8$1@dont-email.me>
 <vtj97r$1i3v3$1@dont-email.me> <vtl166$36p6b$1@dont-email.me>
 <vtlcg0$3f46a$2@dont-email.me> <vtnekn$1fogv$1@dont-email.me>
 <vto2mb$20c4n$1@dont-email.me> <vtu4i5$3hteg$1@dont-email.me>
 <vtujko$3uida$1@dont-email.me> <vtvfop$rf2p$1@dont-email.me>
 <vtvto2$15otp$1@dont-email.me> <vu01k7$1bfv2$1@dont-email.me>
 <vu0720$1dva7$1@dont-email.me> <vu2hmg$3jn88$1@dont-email.me>
 <vu2mkc$3noft$1@dont-email.me> <vu38da$735n$1@dont-email.me>
 <vu3j7s$g755$1@dont-email.me> <87ecxmv4t4.fsf@nosuchdomain.example.com>
 <vu401g$reom$1@dont-email.me> <20250420200823.908@kylheku.com>
 <vu5bqp$230jl$2@dont-email.me> <20250421113640.839@kylheku.com>
 <vu67up$2ubvr$1@dont-email.me>
Injection-Date: Mon, 21 Apr 2025 22:25:59 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="c13f5017c98192b6c07a0b629837b649";
	logging-data="3096052"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1904WuD/2voWrZJNRJLwYhArSujxqaxiRs="
User-Agent: slrn/pre1.0.4-9 (Linux)
Cancel-Lock: sha1:VmKrqJ8eWYu0aMZE8QDYP7FaADg=
Bytes: 9513

On 2025-04-21, bart <bc@freeuk.com> wrote:
> On 21/04/2025 19:43, Kaz Kylheku wrote:
>> On 2025-04-21, bart <bc@freeuk.com> wrote:
>>> On 21/04/2025 04:16, Kaz Kylheku wrote:
>>>> - Because they are not gathered in one place, not only is it less>
>>> readable, but we cannot use while write a macro such as:
>>>>
>>>>        for_sqlite_hash (p, &pSchema->trigHash) {
>>>>          if (some_condition_over(p))
>>>>            continue; // doesn't stupidly repeat for the same p!
>>>>        }
>>>
>>> I can't write such macros at all. I'm not even sure what this does.
>> 
>> Have you never worked with a large codebase written by someone other
>> than you?
>
> How large are we talking about?

Several 100K to millions.

> I've delved into largish apps in the context of getting my C compiler 
> working. I would describe that experience as 'brutal'.

Well, that brutal experience is the job of the career software engineer,
believe it or not. Very few work only on their own original code.

> If you need to 
> debug someone else's codebase, not to find bugs in that program, but to 
> find why your implementation is failing, then you want as conservative a 
> coding style as possible.
>
>
>> When you open a random file in an unfamiliar code base, pretty
>> much any function call that is not in the standard library triggers
>> the "I don't know what this does" response.
>
> Yes, a function call. Macros are in an entirely different, evil category.

No, they aren't. They are just another definition to understand.

They can be misused, and also used to make solutions that are more
complicated than some great ideas that don't involve macros.

So can anything: an open coded function can be misused to make some
complicated solution that can be more nicely done with macros.

> The Lua sources (only a mere 30Kloc), use macros extensively, but also 
> have a habit of giving them ordinary looking names in lower case so that 
> they look like function calls.

So does ISO C; e.g. assert (expr); offsetof (type, member). So what?

Macros that provide syntax should blend into the language.

There is some sense in upper case for preprocessor constants.

Those that have short names can easily clash with variables.

Preprocessor constants are often under-typed.

> Preprocessing such code doesn't help either, since a simple function 
> call can expand into a horrendously complex expression that can be 100s 
> of characters long and have parentheses nested 10 deep.
>
>> You have to learn some of that program's definitions in order to
>> effectively work with that program. At least those which are relevant to
>> your intended task.  You set up your "jump to definition" editor-fu and
>> start reading.
>> 
>> A loop macro like for_sqlite_hash (p, &pSchema->trigHash) is so obvious
>
> Please humour me: What Does It Do?

It is intended to condense an interation that *you* open-coded, in this
example upthread:

       p = sqliteHashFirst(&pSchema->trigHash);
       while (p != NULL)
       {
           sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
           p = sqliteHashNext(p) )
       }

So although I didn't show the definition, I think, of course the intent that it
does this (i.e. is relevant to the discussion thread) and not something else.

  for_sqlite_hash (p, hashptr) stmet

must initialize p using sqliteHashFirst(hashPtr); then
execute stmt if p is not not null, and step to the next entry
using sqliteHashNext(p), assigned back to p:

  #define for_sqlite_hash(P, H) \
   for ((P) = sqliteHashFirst(H); P; (P) = sqliteHashNext(P))

I'm taking it for granted that sqliteHashFirst, which came from your
post,  initiates an iteration, etc. I intuited that without needing it
explained.

>> that the only reason you'd look at its definition is to confirm that
>> it's not doing something stupid (which can be defined as just about
>> anything different from what it *looks* like it is doing).
>> 
>>> I'd call that a win!
>> 
>> Now you're calling the inability of the programmer to implement a
>> nice space-saving notation over something verbose a "win".
>> 
>> If so, why isn't "for (a; b; c)" also a "win" over "do i = x, y".
>
> Your example is just this:
>
>       X(Y, Z)
>
> and you're claiming it is something wonderful. Is it?

You're also claiming that "for X in A, B" (or what have you) is something
wonderful compared to "for (X = A; X <= B; X++)".

If I had to write 17 loops over SQLite hashes, I'd rather type
for_sqlite_hash(p, hash)  than
for (p = sqliteHashFirst(hash); p; p = sqliteHashNext(hash)).

> I don't know. I 
> might guess from its name that it is something to do with loops.

You can guess from its name that it has something to do with loops
over sqlite hashes.

Just like I guessed from sqliteHashBegin that it has something to
with initiating an iteration over a hash, using a pointer-typed
cursor.

> So what do X and Y represent, and what do they expand to?
>
> What I might deduce, is that in C if you have a block of code like this:
>
>     {body}
>
> You can turn that into a loop by putting a for-header to its left:
>
>     for(...) {body}
>
> That for-header can come from a macro, so can be used to apply a loop to 
> such a block, without the code block itself needing to be a macro argument.
>
> I will admit that is a useful side-effect of how a for-loop works, so 
> that it becomes a helpful feature if you ever need to write such macros.

I added a local variable binding extension to GNU Awk (in an Enhanced GNU Awk fork).

I gave it this syntax;

  let (x = 0, y = 1, z) { ... body ...}

guess why! This works with macros. This doesn't:

  { let x = 0, y = 1, z;  ... body ...}

> I can't do that in my language; the macros are too simple, and the loop 
> body would need to be an argument, requiring closures etc. But then, the 
> existing loop features are adequate, and it is also easy to add new ones 
> by changing the language.

It's not easy to add new things by changing the language, when the language is
widely deployed, and implemented by multiple vendors.

Even the users who follow a single implementation might balk;
"Sorry, it has to work with the language that is packaged for Ubuntu 20".

========== REMAINDER OF ARTICLE TRUNCATED ==========