From: Alan M. Carroll
Subject: Binding Implementation Technique References
Date: 
Message-ID: <1992Mar17.014856.17039@m.cs.uiuc.edu>
Hi, all. I haven't bugged you in a while, so I thought I'd get back in
shape. Currently, I'm mucking around inside XLisp, particularly in the
area of symbol dereference. I've looked around in a couple libraries, but
I can't seem to find any good references on techniques used to do
variable binding in Lisp. Because of Epoch, I'm very familiar with how
Emacs does it, but of course that's dynamic binding only. CLtL2, while
an excellent book, doesn't say anything about the internals that I can
find, and the journal papers I've found are far too esoteric. I guess
what I want is the Dragon Book for Lisp systems. Any hints would be
appreciated. Thanks!

-- 
Alan M. Carroll          "Weren't there yams involved, too?" - J. Ockerbloom
Epoch Development Team   
Urbana Il.               "I hate shopping with the reality-impaired" - Susan

From: Brent W. Benson Jr.
Subject: Re: Binding Implementation Technique References
Date: 
Message-ID: <1992Mar17.031319.16053@nic.unh.edu>
·······@cs.uiuc.edu (Alan M. Carroll) writes:

carroll> ... I can't seem to find any good references on techniques
carroll> used to do [lexical] variable binding in Lisp...  I guess
carroll> what I want is the Dragon Book for Lisp systems...

Check out "Structure and Interpretation of Computer Programs" by
Abelson and Sussman (MIT Press/McGraw Hill).  It talks about
implementing the lexically scoped environments used in modern dialects
of Lisp like Scheme and Common Lisp.  Also, a great new book called
"Essentials of Programming Languages" by Friedman, Wand and Haynes
(MIT Press/McGraw Hill) deals with this and many other language
implementation issues.

The basic idea is to use some sort of structure where new bindings
hide existing bindings.  For example, you could use a list of
association lists (frames):  (((a . 1) (b . 2)) ((a . 0) (b . 1)) ...).
In this example the bindings of a to 1 and b to 2 hide the previous
bindings of 0 and 1.  This might occur in code like:

(let ((a 0) (b 1))
 (let ((a 1) (b 2))
  ...))	

;Brent
-- 
Brent Benson				···@cs.unh.edu	
Department of Computer Science  	(603) 862-3786
University of New Hampshire 
Durham, NH 03824
From: John B Chase
Subject: Re: Binding Implementation Technique References
Date: 
Message-ID: <1992Mar17.192417.5985@cunixf.cc.columbia.edu>
Newsgroups: comp.lang.lisp
Subject: AKCL on SCO Unix 386 V3.2.2 recipes
Summary: Recipe for Installing AKCL on SCO Unix V3.2.2
Expires:
References: <······················@m.cs.uiuc.edu>
Sender:
Reply-To: ···@cunixa.cc.columbia.edu (John B Chase)
Followup-To:
Distribution: 
Organization: Columbia University
Keywords: SCO, AKCL, 386/V3.2.2

Where might I find a recipe for installing KCL and AKCL on my 386
machine running SCO Unix System V/386, Release 3.2.2?  Where might
binaries be available?  Has this even been accomplished?  First looks
were daunting.

Many thanks,  John

···@cunixa.cc.columbia.edu
Newsgroups: comp.lang.lisp
Subject: Re: Binding Implementation Technique References
Summary:
Expires:
References: <······················@m.cs.uiuc.edu>
Sender:
Reply-To: ···@cunixa.cc.columbia.edu (John B Chase)
Followup-To:
Distribution: 
Organization: Columbia University
Keywords: 
From: Barry Margolin
Subject: Re: Binding Implementation Technique References
Date: 
Message-ID: <ksd3t1INNsa1@early-bird.think.com>
In article <······················@nic.unh.edu> ···@kepler.unh.edu (Brent W. Benson Jr.) writes:
>The basic idea is to use some sort of structure where new bindings
>hide existing bindings.  For example, you could use a list of
>association lists (frames):  (((a . 1) (b . 2)) ((a . 0) (b . 1)) ...).

This is common in interpreters.  But most compiled Lisps tend to use stack
frame techniques similar to those in conventional languages, i.e. local
variable references are compiled into stack frame offsets.  Lexical
variables add a complication to this, since the variables don't live in the
current stack frame; upward closures generally receive an extra parameter,
which is a pointer to a captured lexical frame, and lexical variables are
accessed by indexing into this.

I'm pretty sure these kinds of techniques are discussed in the references
that Brent suggested.  You can also look in the regular dragon book for
its discussion of variable references.  When upward closures aren't
involved, most of the same techniques can be used.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

······@think.com          {uunet,harvard}!think!barmar
From: John B Chase
Subject: AKCL on SCO Unix 386 V3.2.2 recipes
Date: 
Message-ID: <1992Mar17.190451.29560@cunixf.cc.columbia.edu>
Where might I find a recipe for installing KCL and AKCL on my 386
machine running SCO Unix System V/386, Release 3.2.2?  Where might
binaries be available?  Has this even been accomplished?  First looks
were daunting.

Many thanks,  John

···@cunixa.cc.columbia.edu
From: Rick Farris
Subject: Re: AKCL on SCO Unix 386 V3.2.2 recipes
Date: 
Message-ID: <1992Mar18.202823.6609@rfengr.com>
In article <······················@cunixf.cc.columbia.edu> ···@cunixa.cc.columbia.edu (John B Chase) writes:

> Where might I find a recipe for installing KCL and AKCL on
> my 386 machine running SCO Unix System V/386, Release
> 3.2.2?  Where might binaries be available?  Has this even
> been accomplished?  First looks were daunting.

I used the instructions that came from Austin Code Works and
it worked fine for me.  Where did things begin to go wrong
for you?

--
Rick Farris  RF Engineering POB M Del Mar, CA 92014  voice (619) 259-6793
·······@rfengr.com     ...!ucsd!serene!rfarris      serenity bbs 259-7757
From: John B Chase
Subject: Re: Binding Implementation Technique References
Date: 
Message-ID: <1992Mar17.191627.19879@cunixf.cc.columbia.edu>
From: Stephen J Bevan
Subject: Re: Binding Implementation Technique References
Date: 
Message-ID: <BEVAN.92Mar18183757@panda.cs.man.ac.uk>
In article <······················@m.cs.uiuc.edu> ·······@cs.uiuc.edu (Alan M. Carroll) writes:
   ... I can't seem to find any good references on techniques used to do
   variable binding in Lisp. 
   [deleted]
   I guess what I want is the Dragon Book for Lisp systems. Any hints
   would be appreciated. Thanks!

Anatomy of Lisp
Allen

It is a bit old, but IMHO still the one of the best.