Super Pascal; Dynamic Symbol Table Control

A long time ago (1987 I think) I read an article about a language
called "Super Pascal." It had two big tricks that I boggled at at
the time, but am now beginning to comprehend.


The first big trick was that Var and Type statements were handled
directly as part of the code, with variable arguments, subject to
looping and branching control and all the rest of it.; in principle,
you could write a program that designed, declared, and allocated a
new record type on finding need, or which extended the types it
started with.


The second big trick was that functions and procedures were also
variables like everything else; There was an execute(Q) call that
would call whatever executable routine you had assigned to the
variable Q, which had to be of type routine, and which, given the
string-manipulation and dynamic compilation capabilities, could be
composed, declared, compiled, assigned, and executed all during
run-time.


There were a number of small tricks, including arbitrary-length
numerics and a capability to dynamically link and use external
libraries that had been compiled from C code. The memory map was
very simple; everything lived on the heap, including all dynamically
allocated executable code, stack frames (in a linked list rather
than a pure stack), and you name it other. Any dynamically
allocated code would be swapped into the code segment for an
execution.


The reviewer who wrote that article panned the compiler for
producing bloated code and not optimizing for speed very much.
But some of the issues it addressed - playing its symbol table
like a xylophone mainly - are pretty fascinating to me now that
I have done a little compiler construction and know what goes
into them.


If anyone knows what became of this compiler, or who made it, I
would love to have a copy of it to tinker and play with and run
tests on. I'd be cheerfully willing to pay good money for it;
I just can't *FIND* the darn thing.


Also, If you have any insight into how the compile-a-routine-
composed-at-run-time-and-link-it-into-the-code construct works,
I'd be fascinated to hear about it. Routines-as-variables I
can handle, in fact it's nice. Type and Var statements with
variable arguments evaluated at run-time is a bit of a boggle,
but I can comprehend it. But run-time partial compiles boggle
my mind, unless you link in flatly every possible routine that
it might possibly want. -- in which case, what's the point?


Ray Dillinger
[Sounds like they indirect all code and variable references through the
symbol table. This is an old technique that Lisp has been using since about
1960. -John]
--

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