Re: Loops (was Re: do { quit; } else { })

On 23/04/2025 16:31, David Brown wrote:

On 22/04/2025 22:03, bart wrote:

Too few levels of functions and/or macros (there is no semantic difference between macros and functions in this matter)

There is a great deal of difference. Functions tend to be well-formed in their inputs and outputs.
Macros take some abitrary blocks of syntax and return another arbitrary block of syntax:
     #define INDEX(a, b, y) a y b
     INDEX(a, i, [) ];

I did ask at one point whether anybody could link to some truly terrible C code; nobody has so far.

 There are probably two reasons for that.  One is that everyone, except perhaps you, understands that this is very subjective.  I've seen plenty of code posted in this group, written by regulars whose programming skill and knowledge I highly respect, and yet which I would classify as "truly terrible" and reject it immediately if it were presented to me for code review in my work.  The other reason is that nobody else is particularly interested in seeing bad code, or going out of their way to look for it.
 

>
I just want to find out the threshold at which some will actually agree that macros have been abused or their use is over the top and unjustified.
>

 Why?
 We are all going to have different first-glance opinions on different bits of code.

What's your initial opinion of this 500-line example:
   https://github.com/sal55/langs/blob/master/lisp.c
Here's one of the functions from it:
   lval rest(lval *h, lval *g) { lval *f = h-1; lval r = 0; for (; f>=g; f--)
     r = cons(h, *f, r); return r; }
Here's what my visualisation tool produces:
     global function rest(ref i32 h, g)i64 =
         ref i32 f
         i32 r
         f := h-1
         r := 0
         while f >= g do
             r := cons(h,f^,r)
             f--
         od
         return r
     end
Yes, you might apply a C formatter too, and keep it in C, it won't fix that for-loop though.

  But to form a solid, justifiable opinion I would want to see a lot more of the code in question.

Suppose this is a class of program which you have extensive experience of writing, but you see extra layers of complications that you'd never needed in yours, and the other program doesn't work any better either.
In fact it is poorer, and looks worse.
Would you still be as tolerant?

 > but you're not considering how
 > bizarre and crippling restriction it would be to put a cap on it.
>
There WILL be a cap.

 No.

OK. I haven't been able to find a limit for nested, non-recursive macros. And I don't know how to set up a test for recursive macros (I'm not even sure they exist in C).
(I can do that my language, and that needs a cap since there are no conditional elements that would stop recursion. So this fails:
    macro M = M + 1
But the same in C works, sort of, in that the second M here:
    #define M M + 1
is not expanded.)

Very few things in this world are black-or-white.
 

Some deep nesting might be justified in special cases, for example some recursive macro that builds a string a character at a time.
>
But this was not such a case; it was simply decided to make it work using macros instead of functions.

 How do you know that?

By the 500 such macro definitions, and the EXTENSIVE use of such macro invocations instead of functions, in a class of application I'm very familiar with.

 

>
As for being crippling: I've written all sorts of language apps, including interpreters like this, without ever using more than one level, and for several decades, zero levels.
>

 And how do you know that is a good choice, or would be better in this case?

Near 40 years' experience of implementing interpreters? On some very resource-limited systems too. Ones that have always run rings around other products, until more recently when people are trying harder.
But those efforts are now centred on JIT-based products. This Lua product however is not JIT-based. (There is a separate LuaJIT project.)
(My latest interpreter does use macros. But there are only 25 across the project, which is for a bigger and richer language than Lua, and for an interpreter that runs faster. None of those are nested.
That product can be transpiled to C, and then it uses 0 C macros.)

A language like C provides all these odd-ball features, people are going to use them.

 Macros are hardly odd-ball.

C ones are.