On this tape you will find the sources  for  Lisp,  all  the
on-line  documentation  for  Lisp,  and the library functions for
Lisp.  You will also find a macro (that knows  about  half-kills)
and 3 linkr's (see below).

     There  are  some modifications that you will have to make to
Lisp to run it on your system.  These are the pathnames that  the
system knows about and the switches that make the particular Lisp
configuration that you desire.

To get the Lisp you want, set the switches in sparm.m11 and  play
with linkr and linkr.v6 as follows:

        standard combined space Lisp (Bell 410):

                multiseg = Bell411 = 0;
                rm support/linkr.v6
                mv support/linkr source/linkr

        Version 5 Harvard format (5-space I&D):
		(Not supported since V5 UNIX, 1976)

                multiseg = 1;
                Bell411 = 0;
                rm support/linkr.v6
                mv support/linkr source/linkr

        Bell I&D format (V6 or V7 411)

                multiseg = 1;
                Bell411 = 1;
                rm support/linkr

                mv support/linkr.v6 source/linkr
		OR
		mv support/linkr.v7 source/linkr
		(macro and linkr on V7 systems use I/D space)
		(file "sysmac.sml" should reside in /lib/maclnk)

     There  are  also other switches that you should be concerned
with:

	version7
		0=> V6/PWB system using old (2-word-inline) seek
		1=> V7 system using long seeks
		(note that version7=1 has only been tested with I/D
		 and hardware FPP -- s. dyer 3/8/81)

        fpsim   0=> hardware fpp on 11/45
                1=> 11/40 or no hardware fpp

        gcrec   0=> when Lisp has gc stack overflow, die.
                1=> when gc stack overflow occurs, recover

        brksig  0=> take no special action when out of dotted pairs
                ?=> use this signal(interupt) to return to top level when
                    there are no dotted pairs. At Harvard,  break (13) is used,
                    but there is no reason that that quit  or the
                    like couldn't be used.

        onepage (data space only users (410))
                1=> Arrange things so that the text size is about
                    4k words.  Do this by making some of the
                    "pure" text code live in the data segment.
                    provides about 1800 extra dtpr's at expense
                    of system overhead.

                0=> put all text in sharable segments.












     The pathnames that need attention are located in  dstuf.m11.
Errorfile  is  the  path of the errorfile, which is accessed each
screw-up. This path should be kept short, in  order  that  system
overhead will be relatively low.  Secondarly, fix the path of the
Lisp library directory, if necessary.  The third path (which  has
to  be  fixed  only if you make an I&D Lisp) is lispbin, which is
where the saveme function gets its instructions (note  that  mfpi
doesn't  work  here).  One may also wish to give attention to the
paths in the shrlisp command file, and to the paths in  the  file
svlisp.


     One is now ready to make a Lisp.  To do this utter:

% shrlisp

which  will  eventually  (about  5-10 minutes) produce a ../l1100
file (assuming that you didn't change shrlisp).  Then type:

% ../l1100 -

which will run Lisp, and write out the error file (that's why the
"-").  If the errorfile is ok, the system should respond

AM110 Lisp
->

If not, something like:

#nnnnnn ->

where nnnnnn is an integer  indicating  the  message  number  re-
quested.  After you have convinced yourself that Lisp is OK, do a

->(load '"../lib/svlisp")
nil
->(sv1)

->

a sequence which will 1) load the saux file and the hacks file 2)
purge the binding of saveme and 3) leave a file  on  the  current
directory called code, which is executable and has the pre-loaded
auxfns contained.  Place this in bin, and you are done.  (You may
also  wish  to  produce  ed110, which is obtained by loading edit
before doing the (sv1)).

     In the lib directory, there is the file saux ( which has the
auxillary  functions,  such  as  pp,  get,  put, etc.) and auxfns
(which is similar to aux, but has some functions defined that that
are  now  hand-coded in subr.m11).  The file edit is the L110 in-
core editor.  The functions of trace and bt  should  be  obvious.
The  file hack has the teco and tecf stuff, as well as update and
shell.  If you do not have teco, prehaps this could  be  made  to










work with ed, but I make no promises.

     In the directory doc, there is an lman (lisp user documenta-
tion), and ed110 manuals.  There is also the description  of  the
innards  that  we  give our am110 students when they add stuff to
the interpreter.  There is also a list insertion teco  macro  and
documentation that is useful if you have teco.

     As  far as I'm aware, Lisp is solid, and has survived over a
year of use.  Recently, full core allocation overflow  protection
has  been added, and hopefully is throughly debugged.  However, I
would appreciate knowing of any problems with the system.

     Good luck, and feel free to contact  me  if  there  are  any
problems.


                                Forrest Howard
                                95 Baker St
                                Belmont, MA 02178
                                617-489-0395
				(1975 address; presently at
				 XEROX PARC-MAXC, CA)

(ps  auxfns no longer fits on the tape, so it is not included
 use saux)