19
9 Arguments and Results are Typed-Pointers
Internally in the LISP interpreter, callable LISP functions and special forms take typed-pointers to
S-expressions as input and return a typed-pointer to an S-expression as output. The only (apparent)
exceptions are those functions and special forms which accept or return functions or special forms,
i.e. conceptually sets of ordered pairs; in fact, typed-pointers will be used in these cases as well. A
final typed-pointer to the result is used to reach the pointed-to data object which is then inspected
in order to print out its complete lexical representation as the final “deliverable.”
We can now describe the workings of some of the functions and special forms defined before.
For (QUOTE x), v[QUOTE] receives as input a typed-pointer to an S-expression x, and the same typed-
pointer is returned as the result.
For (PLUS x y), v[PLUS] receives two typed-pointers as input, one to v[x] and one to v[y] (remember,
by the rules of LISP, v[PLUS] is a function, so x and y get evaluated before v[PLUS] is called). If
the two typed-pointers received by v[PLUS] do not both point to number atoms, PLUS is being
used erroneously. Otherwise the sum value is formed and a number atom with the corresponding
floating-point value is formed. A typed-pointer to this number atom in the number table is the
result.
For (EQ x y), v[EQ] receives two typed-pointers as input, one to v[x] and one to v[y]. If these two
typed-pointers are identical, a typed-pointer to the atom T is returned, otherwise a typed-pointer
to the atom NIL is returned. Thus EQ will correctly report whether or not two atoms are equal, since
atoms are stored uniquely, but it may fail to detect that two dotted-pairs are equal (i.e. consist of
the same atoms within the same tree shape). This failure will occur when two such equal dotted-
pairs occur in different list nodes in memory. On the other hand, if we wish to test for identical,
shared, dotted-pairs, EQ will serve this purpose.
For (CAR x), v[CAR] receives a typed-pointer j to v[x] as input. If v[x] is not a dotted-pair, CAR is
being used erroneously. Otherwise the typed-pointer P
j
.car is returned.
For (CDR x), v[CDR] receives a typed-pointer k to v[x] as input. If v[x] is not a dotted-pair, CDR is
being used erroneously. Otherwise the typed-pointer P
k
.cdr is returned.
For (CONS x y), v[CONS] receives two typed-pointers as input; one typed-pointer j which points to
v[x] and one typed-pointer k which points to v[y]. An unoccupied list node P
h
is obtained and
P
h
.car is set to j and P
h
.cdr is set to k. Strictly, the types of the typed-pointers j and k must each
be either 0 (dotted-pair), 8 (ordinary atom), or 9 (number atom). Then the typed-pointer se(h) is
returned. CONS is one of the few LISP functions which consume memory. CONS requires that a new
list node be allocated at each invocation.
For (SETQ x y), v[SETQ] receives two typed-pointers as input; one typed-pointer j which points to x
and another typed-pointer k which points to y (remember SETQ is a special form). If j is positive
or the value x pointed to by j is a number atom or a function or a special form, there is an error
since x must be an ordinary atom. If j is not positive and the value x pointed to by j is an
ordinary atom, then v[y] is computed by applying EVAL to the S-expression y whose typed-pointer