Re: [Axiom-developer] bootstrap Meta/Boot

[Bill Page]

On 8/11/07, M. Edward (Ed) Borasky <address@hidden> wrote:
> Bill Page wrote:
> > The first Lisp I ever used was written in Fortran and ran on a PDP 11. :-)
> The assembly language of the original PDP 11 (before all the ugly
> extensions, etc., got tacked onto it) was so simple, logical, rational
> and elegant that I can't imagine a Lisp interpreter for it written in
> anything other than assembler. The only architecture I've ever seen that
> even came close IMHO was the Texas Instruments 9900.
>
> But the *real* Lispniks of the day used PDP 6/10 "mainframes" -- how
> were those implemented?
>

You can find (almost) anything on the Web, so I took a quick look to
see if I could locate the version of Lisp written in Fortran that I
compiled and installed on a PDP 11 so many years ago. As I recall it
came from a PDP 11 contributed library. (No one actually wanted to
*buy* a licensed copy of Lisp, even then :). I didn't find what I was
looking for but just to prove that what I said has some credibility
let me quote:

Twisted Documentation: Lisp in Python

Chris Meyers

http://www.ibiblio.org/obp/py4fun/lisp/lisp.html

"So when I came across "Lisp in Lisp" taking up most of page 13 of the
Lisp 1.5 Users Manual I had a stronger motivation than just esthetics
to do something with it. I figured that if I could translate just that
much Lisp into Fortran, then I would have the means to run other Lisp
programs. It was much easier said than done. Fortran did not support
recursion and this was an example of true "functional programming".
There was not a single GOTO or variable assignment. Each function call
and return had to done in Fortran with computed GOTO's, first pushing
or popping information on stacks implemented with Fortran arrays. It
was very messy. Later I did a version in PDP-11 Assembler and, still
later, one in Pascal which was pretty clean."

http://www.springerlink.com/content/g653169260k53444/

acques Cohen1 and Carl Zuckerman1
(1)     Brandeis University, 02154 Waltham, Massachusetts, USA

Received: 7 March 1972  Revised: 10 May 1972
Abstract  This paper describes the implementation of a pedagogical
version of Evalquote with a set of Fortran subroutines. Their study
enables the user to understand the programming machinery needed to
interpret Lisp programs; the implementation of the subroutines allows
him to run pure Lisp in machines for which only Fortran is available.
The approach used in this paper is to define a stack-machine capable
of executing a sequence of pseudo-instructions which represent a Lisp
program in post-fixed notation. These instructions are easily
simulated by Fortran subroutines. Once the subroutines are implemented
in a computer it is a simple matter to manually transcribe Evalquote
into a sequence of these pseudo-instructions and thus obtain a Lisp
interpreter with a minimum of programming effort. The paper does not
attempt to describe a complete and efficient Lisp interpreter;
instead, it concentrates on the description of a minimal set of
pseudo-instructions and their actions.

------

Regards,
Bill Page.