##############################################################################
#
# NMakefile
#
# Make program to compile the Foam runtime (frisco) files
#
# Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
#
#
##############################################################################
#
# Targets: all, junk, clean, quick
#
#    make all	-- make the runtime files for the Aldor compiler
#    make junk	-- list files which are not part of the Aldor compiler
#    make clean -- remove generated files  (e.g. foo.c~)
#
# Parameters:  ALDORROOT
#
#    To override defaults do, e.g.,
#	 make -e ALDORROOT=/spad/local/aldor/rs all
#    or
#	 setenv ALDORROOT /spad/local/aldor/rs; setenv MAKEFLAGS e; make all
#
##############################################################################
#
# We do not use the compiler archive since these files may be compiled
# with different options, or different compilers.
#
##############################################################################

SHELL	= /bin/sh
AR	= uniar
CP	= copy 
LN	= copy
RM	= -del /q
ALDOR   = aldor

#SYS      = `echo $(MACHINE) | awk -F- '{print $$1}'`
SYS     = Windows


#ifeq "$(findstring sun4os57g,$(MACHINE))" "sun4os57g"
#  CCPROG=docc
#else
#  CCPROG=unicl $(UNICLARGS) -Wstdc -Wsys=$(SYS)
#endif 
CCPROG=unicl $(UNICLARGS)

#ifeq "$(findstring rs,$(MACHINE))" "rs"
#  GMPSCRIPT=aldor.gmp.bsh
#else
#  GMPSCRIPT=aldor.gmp.sh
#endif 
GMPSCRIPT=aldor-gmp.bat

#GMP2 = gmp-2.lib
GMP3 = cyggmp-3.lib

CPPPROG  = unicl $(CPPARGS)
CPPFLAGS = -DNDEBUG -DFOAM_RTS  -O3 
# CFLAGS	 =  -DNDEBUG -DFOAM_RTS -O # -DSTO_CAN_BLACKLIST
DFLAGS	 =  # -DSTO_DEBUG_DISPLAY -DSTO_CENSUS # -DSTO_SHOW
OFLAGS	 =  -O -DNDEBUG #-Wopts=-pg # -g
CFLAGS	 =  -DFOAM_RTS $(DFLAGS) $(OFLAGS)
#CFLAGS	 =  -DFOAM_RTS -g

#
# Environment
#

IncDir	= $(ALDORROOT)\include
LibDir	= $(ALDORROOT)\lib
BinDir  = $(ALDORROOT)\bin

#SRC     =..\..\src
SRC     =$(ALDORROOT)\..\..\version\current\src
#CmmDir  =..\cmm
CmmDir  =$(ALDORROOT)\..\..\version\current\contrib\cmm
CRTDIR  =$(MAKEDIR)

BUILDARG = $(ALDORROOT)\toolbin\buildarg
MACH	 = `echo $(MACHINE) | awk -F- '{print $$1}'`

#GmpDir	= $(LibDir)
GmpDir	= U:\gmp-41\dynamic
#GmpDir	= /usr/packages/gmp-3.0
#GmpDir	= /usr/packages/gmp-2.0.2

LIBFOAMAL= $(LibDir)\libfoam.al
LIBFOAM	= $(LibDir)\libfoam-gmp.lib
BUILDARG = $(ALDORROOT)\toolbin\buildarg
ALDOR	 = $(ALDORROOT)\bin\aldor -fo -Csmax=0 -Y$(GmpDir)
AXLCDB = # -Cargs=-Wopts=-pg # -O
ALDORARGS = -Q3 -Qinline-all -M no-ALDOR_W_OverRideLibraryFile $(AXLCDB) # -O

LIB=lib /out:$(LIBFOAM)

#
# Files from compiler sources
#

PORTH0        = axlport.h  platform.h cconfig.h optcfg.h foamopt.h compopt.h 
STDCH0        = assert.h0 ctype.h0 errno.h0  float.h0  limits.h0 \
		locale.h0 math.h0  setjmp.h0 signal.h0 stdarg.h0 \
		stddef.h0 stdio.h0 stdlib.h0 string.h0 time.h0 unistd.h0
OPSYSH0       = os_cms.c os_dos.c os_os2.c os_unix.c os_vms.c \
		os_macs7.c os_win32.c
FOAMHX        =	axlgen.h axlgen0.h editlevels.h debug.h fluid.h format.h test.h

FOAMC	      = stdc.c   cport.c   	\
		opsys.c  btree.c 	\
		util.c   foam_c.c 	\
		output.c table.c 	\
		xfloat.c foamopt.c 	\
		dword.c  compopt.c 	\
		store.c  bigint.c	\
		timer.c  foam_cfp.c

FOAMCC 	      =	fm_gmp.c
LOCALH	      = 

FOAMH         = $(PORTH0) $(STDCH0) $(OPSYSH0)  \
		$(FOAMC:.c=.h) $(FOAMHX) 

COMMONFILES   = $(FOAMH) $(FOAMC)
OKFILES       = Makefile aldor-gmp.bat $(FOAMC) $(FOAMCC) $(LOCALH) $(FOAMH)

OBJECTS       = $(LIBFOAM)(stdc.obj)   $(LIBFOAM)(cport.obj)   \
		$(LIBFOAM)(opsys.obj)  $(LIBFOAM)(btree.obj)   \
		$(LIBFOAM)(util.obj)   $(LIBFOAM)(foam_c.obj)  \
		$(LIBFOAM)(output.obj) $(LIBFOAM)(table.obj)   \
		$(LIBFOAM)(xfloat.obj) $(LIBFOAM)(foamopt.obj) \
		$(LIBFOAM)(dword.obj)  $(LIBFOAM)(compopt.obj) \
		$(LIBFOAM)(store.obj)  $(LIBFOAM)(bigint.obj)  \
		$(LIBFOAM)(timer.obj)  $(LIBFOAM)(foam_cfp.obj) \
		$(LIBFOAM)(runtime.obj)			   \
		$(LIBFOAM)(fm_gmp.obj)

# General Rules

all: .cvsignore lib extlibs script

clean: 
	@ $(RM) *~
	@ $(RM) $(FOAMH) $(FOAMC)

#not done
junk:
	@ ls -d $(OKFILES) * | sort | grep -v CVS | uniq -u

#not done
extlibs:
	@rem for x in `$(BUILDARG) extra-libdirs` ; do 		\
		lib=$(ALDORROOT)/lib/$(MACH)$$x;		\
		$(MAKE) lib LibDir=$$lib SYS=$(MACH)$$x ;	\
	done

$(LibDir): 
	mkdir $(LibDir)

lib: $(LibDir) $(COMMONFILES) $(LIBFOAM)
	$(LIB) *.obj
	$(RM) *.obj	

script: $(ALDORROOT)\bin\aldor-gmp.bat

$(ALDORROOT)\bin\aldor-gmp.bat: $(CRTDIR)\aldor-gmp.bat
	$(CP) $(CRTDIR)\$(GMPSCRIPT) $@
	rem chmod 0777 $@

# not done
# The following can be used to obtain a system on which both GMP-2 and
# GMP-3 can be used together. After building libfoam-gmp.lib with GmpDir
# set to the GMP-2 installation, rename it to libfoam-gmp2.a. Change
# GmpDir here to point to the GMP-3 installation, recompile and copy
# to libfoam-gmp3.a (all in $AXIOMXROOT/lib of course).
#
# Then `make extras' to finish off: you may need to change the
# path names for GMP-2 and GMP-3 below for your system.
extras:
	/bin/rm -f $(ALDORROOT)/lib/lib$(GMP2)
	/bin/rm -f $(ALDORROOT)/lib/lib$(GMP3)
	/bin/rm -f $(ALDORROOT)/bin/aldor.gmp2
	/bin/rm -f $(ALDORROOT)/bin/aldor.gmp3
	ln -s /usr/local/lib/libgmp-2.0.2.a $(ALDORROOT)/lib/lib$(GMP2)
	ln -s /usr/local/lib/libgmp-3.0.a $(ALDORROOT)/lib/lib$(GMP3)
	cp aldor.gmp2 $(ALDORROOT)/bin
	cp aldor.gmp3 $(ALDORROOT)/bin
	chmod 755 $(ALDORROOT)/bin/aldor.gmp2
	chmod 755 $(ALDORROOT)/bin/aldor.gmp3

.cvsignore: Makefile
	echo .cvsignore $(COMMONFILES) > .cvsignore

samples:

#
# Rules to get the common source files (as links or copies)
#
axlport.h:	$(SRC)\axlport.h 
	$(RM) $@
	echo $(SRC)
	$(LN) $? $@

platform.h:	$(SRC)\platform.h 
	$(RM) $@
	$(LN) $? $@

cconfig.h:	$(SRC)\cconfig.h 
	$(RM) $@
	$(LN) $? $@


assert.h0:	$(SRC)\assert.h0 
	$(RM) $@
	$(LN) $? $@

ctype.h0:	$(SRC)\ctype.h0 
	$(RM) $@
	$(LN) $? $@

errno.h0:	$(SRC)\errno.h0 
	$(RM) $@
	$(LN) $? $@

float.h0:	$(SRC)\float.h0 
	$(RM) $@
	$(LN) $? $@

limits.h0:	$(SRC)\limits.h0 
	$(RM) $@
	$(LN) $? $@

locale.h0:	$(SRC)\locale.h0 
	$(RM) $@
	$(LN) $? $@

math.h0:	$(SRC)\math.h0 
	$(RM) $@
	$(LN) $? $@

setjmp.h0:	$(SRC)\setjmp.h0 
	$(RM) $@
	$(LN) $? $@

signal.h0:	$(SRC)\signal.h0 
	$(RM) $@
	$(LN) $? $@

stdarg.h0:	$(SRC)\stdarg.h0 
	$(RM) $@
	$(LN) $? $@

stddef.h0:	$(SRC)\stddef.h0 
	$(RM) $@
	$(LN) $? $@

stdio.h0:	$(SRC)\stdio.h0 
	$(RM) $@
	$(LN) $? $@

stdlib.h0:	$(SRC)\stdlib.h0 
	$(RM) $@
	$(LN) $? $@

string.h0:	$(SRC)\string.h0 
	$(RM) $@
	$(LN) $? $@

time.h0:	$(SRC)\time.h0 
	$(RM) $@
	$(LN) $? $@

unistd.h0:	$(SRC)\unistd.h0 
	$(RM) $@
	$(LN) $? $@


os_cms.c:	$(SRC)\os_cms.c 
	$(RM) $@
	$(LN) $? $@

os_dos.c:	$(SRC)\os_dos.c 
	$(RM) $@
	$(LN) $? $@

os_os2.c:	$(SRC)\os_os2.c 
	$(RM) $@
	$(LN) $? $@

os_unix.c:	$(SRC)\os_unix.c 
	$(RM) $@
	$(LN) $? $@

os_vms.c:	$(SRC)\os_vms.c 
	$(RM) $@
	$(LN) $? $@

os_macs7.c:	$(SRC)\os_macs7.c 
	$(RM) $@
	$(LN) $? $@

os_win32.c:	$(SRC)\os_win32.c 
	$(RM) $@
	$(LN) $? $@


axlgen.h:	$(SRC)\axlgen.h 
	$(RM) $@
	$(LN) $? $@

axlgen0.h:	$(SRC)\axlgen0.h 
	$(RM) $@
	$(LN) $? $@

editlevels.h:	$(SRC)\editlevels.h 
	$(RM) $@
	$(LN) $? $@

debug.h:	$(SRC)\debug.h 
	$(RM) $@
	$(LN) $? $@

fluid.h:	$(SRC)\fluid.h 
	$(RM) $@
	$(LN) $? $@

format.h:	$(SRC)\format.h 
	$(RM) $@
	$(LN) $? $@

test.h: 	$(SRC)\test.h 
	$(RM) $@
	$(LN) $? $@


stdc.h: 	$(SRC)\stdc.h 
	$(RM) $@
	$(LN) $? $@

cport.h:	$(SRC)\cport.h 
	$(RM) $@
	$(LN) $? $@

opsys.h:	$(SRC)\opsys.h 
	$(RM) $@
	$(LN) $? $@

btree.h:	$(SRC)\btree.h 
	$(RM) $@
	$(LN) $? $@

bigint.h:	$(SRC)\bigint.h 
	$(RM) $@
	$(LN) $? $@

dword.h:	$(SRC)\dword.h 
	$(RM) $@
	$(LN) $? $@

util.h: 	$(SRC)\util.h 
	$(RM) $@
	$(LN) $? $@

table.h: 	$(SRC)\table.h 
	$(RM) $@
	$(LN) $? $@

store.h: 	$(SRC)\store.h 
	$(RM) $@
	$(LN) $? $@

xfloat.h: 	$(SRC)\xfloat.h 
	$(RM) $@
	$(LN) $? $@

timer.h: 	$(SRC)\timer.h 
	$(RM) $@
	$(LN) $? $@


stdc.c: 	$(SRC)\stdc.c 
	$(RM) $@
	$(LN) $? $@

cport.c:	$(SRC)\cport.c 
	$(RM) $@
	$(LN) $? $@

opsys.c:	$(SRC)\opsys.c 
	$(RM) $@
	$(LN) $? $@

btree.c:	$(SRC)\btree.c 
	$(RM) $@
	$(LN) $? $@

bigint.c:	$(SRC)\bigint.c 
	$(RM) $@
	$(LN) $? $@

dword.c:	$(SRC)\dword.c 
	$(RM) $@
	$(LN) $? $@

util.c: 	$(SRC)\util.c 
	$(RM) $@
	$(LN) $? $@

table.c: 	$(SRC)\table.c 
	$(RM) $@
	$(LN) $? $@

xfloat.c: 	$(SRC)\xfloat.c 
	$(RM) $@
	$(LN) $? $@

timer.c: 	$(SRC)\timer.c 
	$(RM) $@
	$(LN) $? $@


foam_c.h: 	$(SRC)\foam_c.h 
	$(RM) $@
	$(LN) $? $@

foam_cfp.h: 	$(SRC)\foam_cfp.h 
	$(RM) $@
	$(LN) $? $@

foamopt.h: 	$(SRC)\foamopt.h 
	$(RM) $@
	$(LN) $? $@

compopt.h: 	$(SRC)\compopt.h 
	$(RM) $@
	$(LN) $? $@

optcfg.h: 	$(SRC)\optcfg.h 
	$(RM) $@
	$(LN) $? $@

output.h: 	$(SRC)\output.h 
	$(RM) $@
	$(LN) $? $@


foam_c.c: 	$(SRC)\foam_c.c 
	$(RM) $@
	$(LN) $? $@

foam_cfp.c: 	$(SRC)\foam_cfp.c 
	$(RM) $@
	$(LN) $? $@

foamopt.c: 	$(SRC)\foamopt.c 
	$(RM) $@
	$(LN) $? $@

compopt.c: 	$(SRC)\compopt.c 
	$(RM) $@
	$(LN) $? $@

output.c: 	$(SRC)\output.c 
	$(RM) $@
	$(LN) $? $@

store.c: 	$(SRC)\store.c 
	$(RM) $@
	$(LN) $? $@

fm_gmp.c:	$(CRTDIR)\fm_gmp.c


#
# Rules to compile the common files
#

# The doranlib dependency ensures that doranlib gets called.
$(LIBFOAM): $(OBJECTS) 
	@rem doranlib $@

$(LIBFOAM)(runtime.obj): $(LIBFOAMAL)
	cd $(LibDir)
	$(AR) x $(LIBFOAMAL) runtime.ao
	$(ALDOR) $(ALDORARGS) runtime.ao
	rem $(LIB) runtime.obj
	$(RM) runtime.ao

$(LIBFOAM)(stdc.obj):   stdc.c   $(PORTH0) $(STDCH0)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\stdc.c 
	rem $(LIB) stdc.obj 
	rem $(RM) stdc.obj

$(LIBFOAM)(cport.obj):  cport.c  $(PORTH0) $(STDCH0)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\cport.c 
	rem $(LIB) cport.obj 
	rem $(RM) cport.obj

$(LIBFOAM)(opsys.obj):  opsys.c  $(PORTH0) $(STDCH0) $(OPSYSH0)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\opsys.c 
	rem $(LIB) opsys.obj 
	rem $(RM) opsys.obj

$(LIBFOAM)(btree.obj):  btree.c  $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\btree.c 
	rem $(LIB) btree.obj 
	rem $(RM) btree.obj

store $(LIBFOAM)(store.obj):  store.c  $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\store.c 
	rem $(LIB) store.obj 
	rem $(RM) store.obj

$(LIBFOAM)(bigint.obj): bigint.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\bigint.c 
	rem $(LIB) bigint.obj 
	rem $(RM) bigint.obj

$(LIBFOAM)(dword.obj): dword.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\dword.c 
	rem $(LIB) dword.obj 
	rem $(RM) dword.obj

$(LIBFOAM)(util.obj):   util.c   $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\dword.c 
	rem $(LIB) dword.obj 
	rem $(RM) dword.obj

$(LIBFOAM)(table.obj):   table.c   $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\table.c 
	rem $(LIB) table.obj 
	rem $(RM) table.obj

$(LIBFOAM)(xfloat.obj):   xfloat.c   $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\xfloat.c 
	rem $(LIB) xfloat.obj 
	rem $(RM) xfloat.obj

$(LIBFOAM)(timer.obj):   timer.c   $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\timer.c 
	rem $(LIB) timer.obj 
	rem $(RM) timer.obj

foam_c $(LIBFOAM)(foam_c.obj): foam_c.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(CRTDIR)  $(CRTDIR)\foam_c.c 
	rem $(LIB) foam_c.obj 
	rem $(RM) foam_c.obj

foam_cfp $(LIBFOAM)(foam_cfp.obj): foam_cfp.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(CRTDIR)  $(CRTDIR)\foam_cfp.c 
	rem $(LIB) foam_cfp.obj 
	rem $(RM) foam_cfp.obj

output $(LIBFOAM)(output.obj): output.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\output.c 
	rem $(LIB) output.obj 
	rem $(RM) output.obj

foamopt $(LIBFOAM)(foamopt.obj): foamopt.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\foamopt.c 
	rem $(LIB) foamopt.obj 
	rem $(RM) foamopt.obj

compopt $(LIBFOAM)(compopt.obj): compopt.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) $(CRTDIR)\compopt.c 
	rem $(LIB) compopt.obj 
	rem $(RM) compopt.obj

fm_gmp $(LIBFOAM)(fm_gmp.obj): fm_gmp.c $(FOAMH)
	cd $(LibDir) 
	$(CCPROG) $(CFLAGS) -c -I$(IncDir) -I$(GmpDir) $(CRTDIR)\fm_gmp.c 
	rem $(LIB) fm_gmp.obj 
	rem $(RM) fm_gmp.obj

