
First, make sure that the C compiler that you're using has been installed
	as directed. The preferred C compiler is the IBM C/2 version 1.1
	compiler, but the Microsoft C 5.0 and C 5.1 have both been used.
	The older IBM C 1.0 compiler hasn't been used recently, but will
	probably still work with minor code changes.

	IBM C/2 version 1.0 differs from version 1.1 in the libraries used
	in the link step. The DOS (REAL-mode) library for version 1.0 is
	SLIBC3.LIB, and the OS/2 (PROTECTED-mode) library for version 1.0
	is SLIBC5.LIB.

	In any case the following line in makefile will need to be 
	changed or overridden for the compiler used if it isn't C/2.

	C=IBM_C_2

	Note that in addition to the space required for the compiler
	and other compiler tools and libraries you will need about 
	2 megabytes for the pc_code source and objects.

	One final note, the MAKE.EXE on all these compilers prior to
	C/2 version 1.1 have a weird syntax (make <filename>, where
	filename is the name of the makefile, not the target program).
	If you are using a compiler other than C/2 version 1.1, you
	need to set the environment variable "DOSTARGET" to "makefile".

In order to compile code on the PS/2 there are two choices:

1. use the makefile and associated files to copy files down to DOS
	and build a new unix.exe. This can be done quite simply by
	issuing the command (you will need to be root for this):
		make
	You can specify the disk that contains the appropriate 
	DOS filesytem by setting the environment variable DOSDEVICE (it
	defaults to /dev/rhd0h in make.dos). This will edit autoexec.bat
	and reboot the machine, provided that a line exists in autoexec.bat
	to automatically start unix.

	When the system is rebooted it will invoke 'autocomp.bat' (after
	renaming it in case of problems), which will create \pc_code and
	copy the source files into it. If the compile and link work 
	properly the old unix.exe is copied to unix.old and the new 
	unix.exe is used to boot 4.3 again.

2. use the makefile to build a Makefile compatible with DOS and
	the particular compiler you are using, by following
	these instructions

	- build Makefile from makefile

		e.g.
			make Makefile C=IBM_C_2

	-	build a version.c (by hand) or by:

		make.dos -n

	-	write this directory (pc_code) out onto a 1.4MB or 720K diskette
		e.g.
			doswrite -i -v -a *.* Makefile

	-	then build the boot program and copy it out too
			cd ../standatr
			make boot.out
			ln boot.out boot
			doswrite -v boot

	-	install the IBM C compiler and IBM macro assembler onto
		the system according the their instructions (version 1.0
		of C and 2.0 of MASM are known to work).
		be sure to create the TMP directory, and to put a 
		FILES=20 (at a minimum) into config.sys.

	-	create a source directory (pc_code is fine) and copy the 
		contents of the diskette onto it
		e.g.
			mkdir pc_code
			cd pc_code
			copy a:*.* 


	-	build the unix.exe program
		e.g.

			make unix.exe
		NOTE: For the make that comes with compilers other than
		C/2 version 1.1, type make makefile.

	-	copy unix.exe to the root directory
			copy unix.exe \
		or to the diskette:
			copy unix.exe a:

	-	go to the root directory of disk or diskette:
			cd \
		or
			a:

	-	now you can reboot 4.3 from either the disk or diskette
		by means of the command:
			unix go

Building OS/2 code:

The same two choices apply to building the OS/2 code as the PC code with the
following exceptions:

a) The OS/2 code lives in two directories, /sys/os2code and /sys/os2pcif. Each
directory is used to build a different program.

b) The program build in /sys/os2pcif is pcif.sys, not unix.exe.

c) There is a binary file in /sys/os2code that must be written with the 
following command AFTER the rest of the files are written (see "write this
directory" in the instructions above).

	doswrite -v fci.obj

d) The PC code must have build copied down and build before you start to build
the OS/2 code. The OS/2 code depends on some of the same utility files and 
include files as DOS. The OS/2 code also instructs the linker to load the 
PC code version of unix.exe, making a single binary that can run under DOS
and OS/2

e) OS/2 code can only be build by IBM C/2 version 1.0 or 1.1.

