.fo 0 25vg
.fo 2 25vgi
.sr list_left_margin 0
.sr list_right_margin 0
.so r/r.macros
.tr @ 
Instructions for transport to PDP10 via CMAC macros.
.sp 2
.fi
The following files are provided:
.ilist 4 0
1.	The source of two versions of the C compiler, one that produces
CMAC code and one that produces MIDAS PDP10 code.
.next
2.	The source of GT, the program that processes machine
descriptions and produces compiler tables.
.next
3.	Two test programs.
.next
4.	The compiled CMAC code for the CMAC version of the compiler
and the test program TESTC.
.next
5.	A set of MIDAS macro definitions that implement the CMAC 
macros on the PDP-10 and a small support package that allows the
TESTC program to run on the ITS operating system.
.next
6.	The source of a simple control routine that calls the
compiler phases.  This program is provided primarily to show the algorithm.
.next
7.	Some of the basic support routines for the ITS PDP-10 implementation.
.next
8.	Some documentation.  All recipients should first obtain MAC
TR-149 (A Portable Compiler for the Language C -- the major documentation
of the compiler, although slightly obsolete) and Bell Laboratories
Computing Science Technical Report No. 31 (The C Programming Language
-- defines C and a "standard" portable I/O library, which is somewhat
different than the one I use).
.end_list
.ne 10
The following procedure is used to construct a compiler on a PDP10:
.ilist 4 0
1.	Modify the provided macro definitions (cmac.insert) and the
support routines (cmac.supprt) for your assembler and operating system.
.next
2.	Test the macro definitions and the support routines by
assembling and running the test program TESTC.
.next
3.	Implement the small set of I/O routines used by the compiler
(described in ccdoc.text).  It is best to keep these as simple as
possible (i.e. don't buffer), as the run-time implementation given for
the CMAC macros is much different than the PDP10 implementation,
so you will have to rewrite them for the PDP10 implementation
eventually.
.next
4.	Assemble the CMAC code of the CMAC version of the compiler.
Load the phases together with the I/O routines.  Devise some way
of calling the compiler phases in the right sequence and with the
right parameters (use cc.c as guidance).  It is not necessary
that this be done by a program.
.next
5.	You now have (hopefully) a running C compiler that produces
CMAC object code.  Try it out on the test program TESTC and compare
the output with the CMAC file provided.
.next
6.	The next step is to construct a compiler that produces PDP-10
code directly.  You may wish to bring up the provided PDP-10 version
to see what the output looks like.  Assuming that this output is
not satisfactory, decide how it must be changed and make the
appropriate changes to the machine description (pdp10.gt) and the
macro file (c42-10.c).  Note that I separate the output into
4 object segments.  This kludgery can be ignored; it is necessary only
to support optional things like "compiling" UUOs into PUSHJs and
stack tracing.
.next
7.	Compile the GT program using your CMAC compiler.
Assemble and load the GT program and use it to process your new
machine description.  Break up the output file into new compiler
source files (use install.teco or the existing files for guidance).
Using your CMAC compiler, compile these new files and assemble them.
Then, load up the new compiler.
.next
8.	Test this new compiler on the test program, to see if it
produces reasonable output.
.next
9.	Now you must re-implement the I/O stuff for the PDP-10
implementation.  You should use the provided support stuff as
guidance, but note that it is far, far more fancy than necessary
and you don't have to even understand all of it.  It is best to
start simple (still no buffering); wait until it works before you
try to speed things up and add extra features.  You will need
the UUO handler, however (in uuoh.midas).
.next
10.	After implementing the I/O stuff for the PDP-10 implementation,
try out the TESTC program.  If that works, compile and test the
compiler, itself.
.end_list