----------------------------------
	EiC BUILD INSTRUCTIONS 
	
		by

	     Ed Breen

 ---------TABLE-of-CONTENTS--------- 

1. INTRODUCTION:
2. INSTALLING EIC FROM THE SOURCE DISTRIBUTION:
        Step 1
        Step 2 
        Step 3
        Step 4
        Step 5 
	Step 6
3  BUILDING A TOY VERSION OF EiC
4. EXPLANATION OF NON-PORTABLE MACROS USED:
        $(addprefix PREFIX,NAMES...)    (from GNU info Make)
5. TROUBLE SHOOTING:
6. PORTING EiC TO OTHER PLATFORMS

 --END-of-TABLE-of-CONTENTS---------

 ------------------------------------
- INTRODUCTION:

	EiC's distribution plus binaries require approximately 4
	Mbytes of disk space. To build EiC, you will need GNU make and
	gcc 2.6.3 or later. However, if you don't have GNU make then
	the section on 'explanation of non-portable macros' may help
	you over come this limitation.


 -------------------------------------------
- INSTALLING EiC FORM THE SOURCE DISTRIBUTION:

	There are just six easy steps to installing EiC.  Please read
	all six steps before starting at step 1.

-- Step 1

	Untar the distribution. It will automatically unpack itself
	into a subdirectory off the current directory. This
	subdirectory will be named EiC and will be referred to as the
	top EiC directory or the HOMEofEiC.
	
	If you use GNU tar, then:
		% tar -xvzf EiC.tar.gz
	else
		% gunzip EiC.tar.gz 
		% tar -xvf EiC.tar.gz

-- Step 2 

	If you haven't already done so, then:

		% cd EiC
-- Step 3

	This step looks worse than it really is. You shouldn't have to
	do anything, other than setting the directory where EiC will
	be installed.
	
	In the project parameter file:

		/EiC/project.params

	you will need to set EiC's installation directory; this is
	where the EiC binary will be placed, via:
	
		INSTALL_DIR = $(HOME)/bin

	By default, it points to 'bin', which is assumed to be just
	off your home directory and within your search path. If you
	don't have a bin directory, make it or just change the
	assignment to point to any other directory that is in your
	search PATH, and that you have write access to.

	The rest of this step can now be skipped over and only if things
	fail, after step 4, will you need to refer to the rest of step
	3.
 
	Now, you will need to:

		a) set the EiC project parameters,  and
		b) check the appropriate platform parameters are
		   set according to your site.

	Hopefully, the default settings will do.  However, if you are
	uncertain about what to do, with respect to what the various
	parameters mean or platform types, then consult the DATA
	DICTIONARY section in the file:
	
		EiC/config/GuideLines.make.

	Now check the parameter settings in the file:

		EiC/config/$(PLATFORM)/make.params

	where $(PLATFORM) is the platform type that you are going
	to compile EiC for. Check the directory EiC/config
	for the platforms supported. They are indicated by
	directories with names starting with '_'; for example,
        _LINUX, _SOLARIS, _SUNOS, etc. 

	If you find any parameter setting in the platform make.params
	file that are not to your liking, then you have can override
	these settings by placing a corresponding  parameter in
	the file: 

		EiC/override.params

	The main purpose of the override.params file is to
	allow for any peculiarities that are unique
	to any particular site. More information on this
	file can be found in the file itself.
	

-- Step 4

	From EiC's top directory type the following command:
		
		% config/makeconfig

	makeconfig will use its default procedures to determine your
	operating system, and other configuration settings. It will
	attempt to produce the file:
		
		 EiC/make.proj

	that will contain the correct configuration setup for the EiC
	project Makefiles within your environment. To get more
	infomation about makeconfig type:
		
		% config/makeconfig -h

-- Step 5 

	If makeconfig was successful, then from the EiC top directory,
	type:
 
		% make install
		% make clean
		% rehash
		% cd test
		% test.sh       // run EiC's test procedures


	You will have to also set the environmental variable
	HOMEofEiC to point to directory where EiC is
	installed. See README.BIN for further information on
	HOMEofEiC.

	Hopefully everythings goes to plan -- if not, see the section
	on trouble shooting below.


-- Step 6
	 To make the documentation then
		
		% cd EiC/doc
		% make install


- BUILDING A TOY VERSION OF EiC

	To build a version of the EiC interpreter
	that does not include EiC's runtime library
	then change to EiC's src directory

		% cd EiC/src
		% make -f makefile.seic 
		% rm *.o

	This will produce the binary `seic'. It
	is the starting point for experimenting
	with EiC.
	
- EXPLANATION OF NON-PORTABLE MACROS USED:

-- $(addprefix PREFIX,NAMES...)    (from GNU info Make)
		
	The argument NAMES is regarded as a series of names, separated
        by whitespace; PREFIX is used as a unit.  The value of PREFIX
        is prepended to the front of each individual name and the
        resulting larger names are concatenated with single spaces
        between them.  For example,

          	$(addprefix src/,foo bar)

     	produces the result `src/foo src/bar'.

- TROUBLE SHOOTING:

	If the compiler complains about duplicate definitions
	of standard C funtions, then make sure you are using
	gcc 2.6.3 or later, via:

		% gcc -v
	
	If the installation procedure completely fails, then
	check that make is being initiated correctly in each
	subdirectly. You may need to set the SHELL variable in the
	top level make file (../EiC/Makefile):

		SHELL = /bin/ksh


	If you don't have a ksh shell, then you may have to 
	do most things by hand:

		% cd EiC
		% config/makeconfig
		% make install    // let it fail
		% cd module/stdClib/src
		% make headers
		% cd ../../../src 
		% make headers
		% cd ../module/stdClib/src
		% make install
		% cd ../../../src
		% make install
		% cd ../main
		% make install
	
	Check that you aren't installing EiC for a platform it
	doesn't know about (see porting EiC to other platforms below).
	
	If everything compiles, without errors, and your system reports
	after typing:

		% eic
		eic: Command not found
	
	Then check your search path and the directory where EiC
	was installed. Or maybe just enter
	
		% rehash


	Read all of step 3.


-------------------------------------------------
- PORTING EiC TO OTHER PLATFORMS

This part of the documentation explains how to port EiC to a new
platform. It is also assumed that the following steps will be
performed on the new platform.  The following outlines the steps I
took to port EiC to a Dec Alpha.

-- Porting the EiC interpreter

	First get the platform name 
	via `uname'.

	At the system prompt:

	% uname
	OSF1

	Therefore, the DEC alpha platform name is:
	
		OSF1

	Now change to the directory EiC/config and
	create the appropriate platform directory.

		% cd EiC/config
		% mkdir _OSF1 

	Note the leading underscore. Now pick one of the existing
	platforms that you feel is compatible with the new
	platform and copy over its `make.params' file.
	For example:

		% cp _LINUX/make.params _OSF1
	
	Now edit the copy of make.params, to reflect to the new OS, in
	particular change the PLATFORM designation.

	Next, check for data alignment, pointer size and
	byte ordering, by compiling and running 
        `alignment' in EiC/config:

		% gcc alignment.c
		% a.out
		#define EIC_LITTLE_ENDIAN 1
		{1, 1}, /* char */
		{2, 2}, /* short */
		{4, 4}, /* int */
		{8, 8}, /* long */
		{4, 4}, /* float */
		{8, 8}, /* double */
		{8, 8}, /* pointer */
		{0, 1}, /* struct*/

		% rm a.out

	Now you need to inform EiC about this by
	adding the following structure to the 
	EiC source file `EiC/src/metric.h': 

	/* Dec Alpha */
	#ifdef _OSF1
	#define EIC_LITTLE_ENDIAN  1
	short metric[8][2] = { /* size, alignment pairs */
       		{1, 1}, /* char */
		{2, 2}, /* short */
		{4, 4}, /* int */
		{8, 8}, /* long */
		{4, 4}, /* float */
		{8, 8}, /* double */
		{8, 8}, /* pointer */
		{0, 1}, /* struct*/
	};
	#endif
	
	Now inform the makefile system of the new platform.
	In the directory EiC type:

	<EiC> % config/makeconfig
	TOP_DIR = /home/edb/compilers/EiC
	CONFIG_DIR = /home/edb/compilers/EiC/config
	platform = _OSF1

	This completes the porting of the EiC
	interpeter and the Makefile system to the new
	platform. Now the fun begins -- we have to
	port EiC's runtime library.

-- Porting the runtime library.

	Change to the directory EiC/module/stdClib/src and
	add  the appropriate patform directory:

	<EiC/.../src> mkdir _OSF1

	Copy the contents of an already established
	platform to this directory:

	<EiC/.../src> cp -r _LINUX/* _OSF1

	Now each header file in this directory must be
	made compatible with the platform header files in
	`/usr/include'. Also the file "fcntl.h" needs to be
	addressed. However, you don't have to worry about

		stdio.h
		stdlib.h
		errno.h
		stdtypes.h
                limits.h
	        float.h
                signal.h
                termdefs.h

	As these files get automaticly constructed by EiC's build
	process during installation, by the EiC/config/genstdio.c
	program. As this document is usually as not as up todate as
	the gentstdio.c file you should also check it for any other .h
	files it may now be generating. To do this, just look at the
	contents of the main() function.
		
	 To help with this process of generating header files, I used
         gcc and grep; for example, when inspecting termios.h:
	
	</usr/include> gcc -D_POSIX_SOURCE -E termios.h | less