Re: Implementation of control structures

Pascal Bourguignon wrote:
Eli Gottlieb <eligottlieb@xxxxxxxxx> writes:


Frode Vatvedt Fjeld wrote:

Eli Gottlieb <eligottlieb@xxxxxxxxx> writes:


How can I make sure that when return-from is called execution
returns to the correct place?

[...]
This is the general idea. For C etc. I suppose you'd emulate the
catch/throw pattern with setjmp/longjmp. [...]

setjmp() and longjmp()? Hmmm... Rather kludgier than I hoped, but
that should work.


That's a little more complicated than that. You have to unroll a
number of lexical and dynamic bindings when you process RETURN-FROM.
longjmp is a single assembly instruction here.

(block :example
(let ((*print-readably* t)
(a 2)
(potatoe (cons 1 'kg)))
(catch potatoe
(handler-case (let ((a 3))
(unwind-protect (return-from :example 3)
(print :unwound))
(throw potatoe))
(error (err) (format t "~&~A~%~A" a err))))))

; prints:
:|UNWOUND| ; returns:
3

Here, in processing RETURN-FROM:
- the cleanup clauses of UNWIND-PROTECT are executed (:unwound is printed),
- the innermost lexical scope for (a 3) is destroyed,
- the dynamic scope of error handlers is destroyed,
- the dynamic scope of catch is destroyed,
- the lexical scope for (a 2) is destroyed,
- the dynamic scope for *print-readably* is reset,
- and finally the block is exited. (well, here you could use longjmp,
but really you're already here...).

In addition, you may have to process FLET/LABELS lexical scopes too.
Also, if you have an interpreter instead of a compiler, you may have
other scopes to pop, like TAGBODY, MACROLET, and SYMBOL-MACROLET.


For one thing, since it's a lexical construct, you know exactly the
block from which you must return:

(block :name ;1
v
(block :name ;2
x
(return-from :name) ; exits from block 2
y
(return-from :name) ; exits from block 2
z)
(return-from :name) ; exits from block 1
w)

There are two movements to execute RETURN-FROM.

First as described above, you must unwind the scope up to the block
you must exit. In a compiler, you could have a stack offset compiled
in the RETURN-FROM instructions, which would compute the address on
the stack, and the unwinding of the scopes would be complete when the
stack have been poped down to that pointer, or you could keep track of
the number of frames to unwind. Perhaps the later would be easier.

Next, for each block frame you know the address to which the program
must jump to exit from the block. This address could be put on the
stack and returned to, or stored in the RETURN-FROM instructions.
Actually, the later would probably be better, since then you could
avoid stacking block frames altogether. The compiler could choose one
or the other depending on the number of RETURN-FROM in each block.

So you could compile a RETURN-FROM as:

<store-the-result-to-the-multiple-value-registers>
(pop-frames <number-of-frames-to-pop>)
(jump <address-to-jump-to>)

If amongst the frames to be poped there are unwind cleanup forms to
execute, they'll have to save the multiple-value registers.

Actually, I'm not implementing Common Lisp. It's too much of a pain in the ass, and a duplication of effort as well.

Second of all, I'm working in an interpreter. Every Lisp function is run by a single Pascal function, which either runs it (compiled primitive) or evals its function expression (defined Lisp function). It then uses its own return value to return an array of values.

Anyway, I was all set to use setjmp()/longjmp() for the implementation until I realized that under my reference-counting system that would probably result in a memory leak. Blargh.

--
The science of economics is the cleverest proof of free will yet constructed.
.

Relevant Pages

  • Re: How does "new" work in a loop?
    ... compiler can detect the variable's lifetime, ... out the whole lexical scope. ... So you mean that the scope of a variable only last one single iteration ... The variable's lifetime may be smaller ...
    (microsoft.public.dotnet.languages.csharp)
  • Re: How does "new" work in a loop?
    ... out the whole lexical scope. ... So you mean that the scope of a variable only last one single iteration of the loop? ... Does that mean that the compiler adds code to remove the reference from the fs variable? ... As long as the reference is there, the garbage collector won't collect the object. ...
    (microsoft.public.dotnet.languages.csharp)
  • [LogoForum] Re: ucblogo parameter binding peculiarity
    ... think dynamic scope is the right choice. ... instead of Scheme's lexical scope. ... if emptyp:cards ...
    (comp.lang.logo)
  • Re: C# equivalent to a smart pointer???
    ... The basic idea is that the compiler may detect ... It showed up in some sample code in the documentation. ... The issue is that the lifetime of a local variable is NOT determined by ... within the same scope if it's not used in any code past a certain point. ...
    (microsoft.public.dotnet.languages.csharp)
  • Re: VLA and goto -- diagnostic required?
    ... I'm currently working on updating an older compiler up to C99. ... however, just jumps over the actual VLA declaration, within the ... "A goto statement shall not jump from outside the scope of an ...
    (comp.lang.c)