Question

many (may be all?) programming language consist of assembly language

how lisp implemented in assembly language?

is there any good reference, manual, tutorial, or keyword for google?

any official rule/convention for build your own lisp implementation?

such as tail recursion should follow some embodiment rule or something..

thanks

Answer 1

Although the other comments and posts are right, this question is overly vague and maybe a bit confused, I can’t help but share some recommendations. I’ve collected a number of links and books on implementing Lisp as I have recently developed a bit of a fascination with language implementation. It’s a deep topic, of course, but reading the stuff related to Lisp is especially compelling because you can skip a lot of the intense reading on parsing if you implement a Lisp compiler or interpreter in Lisp, and just use read. This allows the authors to get to the meat of compilation or interpretation quickly. These recommendations are books I’ve read or started or am reading, and mostly deal with Scheme, not Common Lisp, but still might be of some interest.

If you’ve got no background in language implementation, and have never had the pleasure of reading about the classic Lisp and Scheme “metacircular evaluators”, I would recommend Structure and Interpretation of Computer Programs. If you’ve seen Lisp-in-Lisp (or Scheme-in-Scheme…) you can skip ahead. In the last two chapters of SICP, the authors present a few different interpreters for Lisp/Scheme and a few variants, as well as a byte-code compiler and a virtual machine. It’s simply a brilliant book, and free.

If you don’t have time to read SICP, or don’t want to slog through it just to get to the interpretation and compilation chapters, I would recommend The Little Schemer. Even though it’s very short and intended for newcomers to Lisp and Scheme, if you’ve never seen a Lisp interpreter written in Lisp, they do present one, and it’s quite a delightful book, but might not be for everyone due to the cute style.

There’s another free book on Scheme similar to SICP, called An Introduction to Scheme and its Implementation, which I haven’t read but used as a reference for a few bits. There are sections on interpreters and compilers in there, and it seems to go a bit deeper than SICP, dealing with hairier things like parsing too. It maybe needed an editor, but it’s an impressive offering nonetheless.

With a decent idea of how to do Lisp in Lisp, you can approach implementing Lisp in something lower level.

Lisp in Small Pieces is frequently recommended. I’ve read most of it, and can say it’s definitely a great book, full of nitty gritty stuff. I’m going back over it with a fine comb, because it’s easy to skim when you don’t understand stuff. I also struggled with getting the code from the author’s site to run; if you get it, I recommend using Gambit Scheme and running the code that relies on Meroonet with Meroon, from this distribution. Lisp in Small Pieces presents a number of interpreters written in Scheme as well as a byte-code compiler and a compiler-to-C.

Lisp in Small Pieces moves fast, and it’s quite dense. If it’s too much for you, perhaps start with The Essentials of Programming Languages. I’ve read some of it and it’s quite good, but it’s more interpreters. Apparently one of the older editions (1st? I’m not sure…) included a compiler. There seems to be a lot of change between the 3 editions, but the first is super cheap on Amazon, so check it out.

As for compilation to C, this is kind of a gross subject with lots of hairy bits. Compilation to C brings up all these weird corner issues, like how to optimize tail-calls and handle closures, first-class continuations and garbage collection, but it’s pretty interesting, and a lot of “real” implementations of Scheme go this route. Marc Feeley’s presentation on this is pretty interesting, titled The 90 Minute Scheme to C compiler.

I have fewer resources on compiling all the way down to assembly, but there is a often recommended paper which introduces compilation of Scheme to x86, called An Incremental Approach to Compiler Construction. It assumes little of the reader, however I found that it simply goes too fast and doesn’t fill in enough details. Maybe you’ll have better luck.

A lot of the above recommendation comes from this monster comment on Hacker News from over a year ago, from mahmud. It references a number of ML resources, and compilation using continuations. I haven’t gotten that far in my study, so I can’t say what’s good or not. But it’s an incredibly valuable comment. The referenced works include Andrew Appel’s “Compiling with Continuations” and Paul Wilson’s “Uniprocessor Garbage Collection Techniques” paper.

Good luck!