Re: How to implement lexical closures?

On May 7, 12:22 am, grom <grom...@gmail.com> wrote:
> I'm working on a toy interpreter (http://code.google.com/p/zemscript/)
> and trying to implement lexical closures (http://code.google.com/p/
> zemscript/source/browse/#svn/branches/lexical_scope) ....


> However since it copies the symbol table the following does *not*
> work:
> create = function() {
> x = 0;
> return {
> "get" : function() { return x; },
> "set" : function(v) { x = v; }
> };
>
> };
>
> o = create();
> o["set"](42);
> println(o["get"]()); // Should print 42
>
> What I can't work out is how I can get the second example to work
> without breaking the first example.


A closure is a pair consisting of code and an activation record. The
activation record is an array of slots for values of parameters (and
local variables if your language has them). In lanuages like yours
with lexical nesting, there will also be a frame pointer to the
activation record of the lexically enclosing scope. The code must
refer to activation record slots. If you even minimally compile
(rewrite) the input program, you can convert identifiers into
activation record offsets. In some contexts this is called Boehm
numbering. Alternately, you can - as has been said - keep runtime
symbol tables for each function that map identifiers to offsets. In a
stack-oriented language, the activation records are what go on the
stack. In languages where functions are first class values, they are
generally allocated on the heap and therefore must be garbage
collected. In many cases, optimizers for such languages look for
opportunities to use a stack in lieu of heap wherever possible to
reduce garbage.

Return to the comp.compilers page.
Search the comp.compilers archives again.