🚀 go-pugleaf

In article ... jwil1@cs.aukuni.ac.nz (TMOTA) writes:

   torbenm@diku.dk (Torben AEgidius Mogensen) writes:

   >Afeature I have sorely missed in compilers for C etc. is a cheap
   >tail-call: if the last thing you do in a procedure or function is to
   >call a procedure or function, this can be implemented as a goto rather
   >than a general procedure/function call. Also, the local variables of

   What do you mean? What if the tail-called function then tries to call
   another function or (even worse) recurses? This could only work if
   the tail-called function expected to recieve *exactly* the stack frame
   that the tail-caller has had set up when it was called.

Urk? You clean up the stack before you call the tail-called function, of
course. It's a standard optimisation, at least in the Lisp world. [The only
objection to it is that it can make debugging harder -- you lose the functions
that tail-called when you get the stack backtrace.]

   And remember that Acorn's C compiler (the ARM proc. call std.?) is clever
   enough to notice when you call a function that does not call another (a
   leaf function), and does not bother with most of the context-storing
   operations involved in normal function calls.

I'm not sure you said what you meant. There's no cleverness involved in calling
a leaf function (after all, who's to know that it *is* a leaf function?), it's
just that leaf functions don't need to carry all the baggage of a full function
call -- it's the code of the leaf that ``does not bother with most of the
context-storing operations''. [They don't carry the baggage because there's
very little that can go wrong inside them, so they don't need to record who
they are in case something does.]


--

Regards,    | It's strange how you suddenly discover bizarre and dangerous
Kers.       | holes in your knowledge.  I fell down one today. - Steve Knight