##############################################################################
#
# Makefile
#
# Make program to build the most basic library just for runtime.as
#
# Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
#
##############################################################################
#
# Targets: all, clean, quick
#
#    make all	-- make the basic library for libfoam\runtime.as
#    make junk	-- list files which are not part of the library
#    make clean -- remove generated files  (e.g. foo.c~)
#
# Parameters:  ALDORROOT
#
#    To override defaults do, e.g.,
#	 make -e ALDORROOT=\spad\local\axiomxl\rs all
#    or
#	 setenv ALDORROOT \spad\local\axiomxl\rs; setenv MAKEFLAGS e; make all
#
##############################################################################

PWD=$(MAKEDIR)

#
# Environment
#
# $(ALDORROOT) is retrieved from the environment
IncDir	= $(ALDORROOT)\include
LibDir	= $(ALDORROOT)\lib
BinDir	= $(ALDORROOT)\bin
SamDir	= $(ALDORROOT)\share\samples\libfoamlib

LFMLIB	= $(LibDir)\libfoamlib.al
LOBLIB	= $(LibDir)\libfoamlib.lib

#AXLCDB	= -Wcheck -Cargs=-g -Qno-cc -Ffm
AXLFLAGS	= -q3 -qinline-all -Wcheck # -Wgc

CP	= copy
RM	= del

ALDOR	= $(BinDir)\aldor.exe
AR      = $(BinDir)\uniar.exe
LIB     = lib -nologo
OBJ	= obj
SRC=$(PWD)\..\..\src

#
# Source lists
#
# AXL<i>... depends on AXL<i-1>...

IncSrcs	= foamlib.as
AXL0Srcs= lang.as machine.as basic.as foamcat.as tuple.as gener.as boolean.as \
	  segment.as sinteger.as sfloat.as pointer.as char.as parray.as	\
	  array.as list.as langx.as string.as		

AXL1Srcs= format.as partial.as oslow.as fname.as file.as opsys.as textwrit.as


AXLSrcs	= $(AXL0Srcs) $(AXL1Srcs)

Sources	= $(IncSrcs) $(AXLSrcs)
Lists	= foaminc.lst foamlib.lst

#
# Object lists
#

AXL0Aos	= lang.ao machine.ao basic.ao foamcat.ao tuple.ao gener.ao boolean.ao \
	  segment.ao sinteger.ao sfloat.ao pointer.ao char.ao parray.ao \
	  array.ao list.ao langx.ao string.ao

AXL0Objs= lang.obj machine.obj basic.obj foamcat.obj tuple.obj gener.obj \
	  boolean.obj segment.obj sinteger.obj sfloat.obj pointer.obj char.obj \
	  parray.obj array.obj list.obj langx.obj string.obj

AXL1Aos	= format.ao oslow.ao fname.ao file.ao opsys.ao textwrit.ao

AXL1Objs= format.obj oslow.obj fname.obj file.obj opsys.obj textwrit.obj

Objects	= $(AXL0Objs) $(AXL1Objs) 
Aos	= $(AXL0Aos) $(AXL1Aos)

#
# Target lists
#
IncTargs = $(IncDir)\foamlib.as
LibTargs = $(LFMLIB) $(LOBLIB)

# Don't delete the libraries if a compilation fails.
.PRECIOUS: $(LibTargs)

#
# Generic targets
#
OKFILES	 = Makefile NMakefile $(Lists) $(Sources)

all: $(Lists) $(IncTargs) $(LibTargs) 

clean:
	@ $(RM) *~

libclean:
	@ $(RM) $(IncTargs) $(LFMLIB) $(LOBLIB)


foaminc.lst:	Makefile
	@echon "Making foaminc.lst..."
	@for %%f in ($(IncSrcs)) do echo %%~nf > foaminc.lst
	@echo "done"

foamlib.lst:	Makefile
	@echon "Making foamlib.lst..."
	@for %%f in ($(AXLSrcs)) do echo %%~nf > foamlib.lst
	@echo "done"

lists:		$(Lists)
include:	$(IncTargs)
libfoamlib:	$(LFMLIB) $(LOBLIB)

#
# Samples
#
samples:	$(SamDir) $(Sources)
	@echon "Copying samples..."
	@for %%f in $(Sources) do $(CP) %%~nf $(SamDir)
	@echo "done"

$(SamDir):
	@echo "Making directory $(SamDir)."
	@mkdir $(SamDir)

#
# General dependencies
#
$(Objects) $(Aos):	$(ALDOR) $(IncTargs)
$(AXL1Objs) $(AXL1Aos):	$(AXL0Aos)

#
# Specific dependencies and rules
#
$(IncDir)\foamlib.as: foamlib.as
	copy foamlib.as	$(IncDir)\foamlib.as


# The doranlib dependency ensures that doranlib gets called.
$(LFMLIB):  $(AXL0Aos) $(AXL1Aos) doranlib	; @echo ranlib $@

doranlib:
	@echon

#
# AXL0Srcs
#
lang.ao: lang.as
	aldor -fo -fao $(AXLFLAGS) -M no-ALDOR_W_WillObsolete lang.as
	@uniar r $(LFMLIB) lang.ao
	@$(LIB) /out:$(LOBLIB) lang.obj
	@del lang.ao lang.obj

machine.ao: machine.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib machine.as
	@uniar r $(LFMLIB) machine.ao
	@$(LIB) $(LOBLIB) machine.obj
	@del machine.ao machine.obj

basic.ao: basic.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib basic.as
	@uniar r $(LFMLIB) basic.ao
	@$(LIB) $(LOBLIB) basic.obj
	@del basic.ao basic.obj

foamcat.ao: foamcat.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib foamcat.as
	@uniar r $(LFMLIB) foamcat.ao
	@$(LIB) $(LOBLIB) foamcat.obj
	@del foamcat.ao foamcat.obj

langx.ao: langx.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib langx.as
	@uniar r $(LFMLIB) langx.ao
	@$(LIB) $(LOBLIB) langx.obj
	@del langx.ao langx.obj

rtexns.ao: rtexns.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib rtexns.as
	@uniar r $(LFMLIB) rtexns.ao
	@$(LIB) $(LOBLIB) rtexns.obj
	@del rtexns.ao rtexns.obj

tuple.ao: tuple.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib tuple.as
	@uniar r $(LFMLIB) tuple.ao
	@$(LIB) $(LOBLIB) tuple.obj
	@del tuple.ao tuple.obj

gener.ao: gener.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib gener.as
	@uniar r $(LFMLIB) gener.ao
	@$(LIB) $(LOBLIB) gener.obj
	@del gener.ao gener.obj

except.ao: except.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib except.as
	@uniar r $(LFMLIB) except.ao
	@$(LIB) $(LOBLIB) except.obj
	@del except.ao except.obj

boolean.ao: boolean.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib boolean.as
	@uniar r $(LFMLIB) boolean.ao
	@$(LIB) $(LOBLIB) boolean.obj
	@del boolean.ao boolean.obj

segment.ao: segment.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib segment.as
	@uniar r $(LFMLIB) segment.ao
	@$(LIB) $(LOBLIB) segment.obj
	@del segment.ao segment.obj

byte.ao: byte.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib byte.as
	@uniar r $(LFMLIB) byte.ao
	@$(LIB) $(LOBLIB) byte.obj
	@del byte.ao byte.obj

hinteger.ao: hinteger.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib hinteger.as
	@uniar r $(LFMLIB) hinteger.ao
	@$(LIB) $(LOBLIB) hinteger.obj
	@del hinteger.ao hinteger.obj

sinteger.ao: sinteger.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib sinteger.as
	@uniar r $(LFMLIB) sinteger.ao
	@$(LIB) $(LOBLIB) sinteger.obj
	@del sinteger.ao sinteger.obj

sfloat.ao: sfloat.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib sfloat.as
	@uniar r $(LFMLIB) sfloat.ao
	@$(LIB) $(LOBLIB) sfloat.obj
	@del sfloat.ao sfloat.obj

bpower.ao: bpower.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib bpower.as
	@uniar r $(LFMLIB) bpower.ao
	@$(LIB) $(LOBLIB) bpower.obj
	@del bpower.ao bpower.obj

integer.ao: integer.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib integer.as
	@uniar r $(LFMLIB) integer.ao
	@$(LIB) $(LOBLIB) integer.obj
	@del integer.ao integer.obj

pointer.ao: pointer.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib pointer.as
	@uniar r $(LFMLIB) pointer.ao
	@$(LIB) $(LOBLIB) pointer.obj
	@del pointer.ao pointer.obj

char.ao: char.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib char.as
	@uniar r $(LFMLIB) char.ao
	@$(LIB) $(LOBLIB) char.obj
	@del char.ao char.obj

string.ao: string.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib string.as
	@uniar r $(LFMLIB) string.ao
	@$(LIB) $(LOBLIB) string.obj
	@del string.ao string.obj

imod.ao: imod.as
	aldor -fo -fao $(AXLFLAGS) -lfoamlib imod.as
	@uniar r $(LFMLIB) imod.ao
	@$(LIB) $(LOBLIB) imod.obj
	@del imod.ao imod.obj

#
# AXL1Srcs
#
format.ao: format.as
	aldor -fo -fao $(AXLFLAGS) format.as
	@uniar r $(LFMLIB) format.ao
	@$(LIB) $(LOBLIB) format.obj
	@del format.ao format.obj

ratio.ao: ratio.as
	aldor -fo -fao $(AXLFLAGS) ratio.as
	@uniar r $(LFMLIB) ratio.ao
	@$(LIB) $(LOBLIB) ratio.obj
	@del ratio.ao ratio.obj

list.ao: list.as
	aldor -fo -fao $(AXLFLAGS) list.as
	@uniar r $(LFMLIB) list.ao
	@$(LIB) $(LOBLIB) list.obj
	@del list.ao list.obj

parray.ao: parray.as
	aldor -fo -fao $(AXLFLAGS) parray.as
	@uniar r $(LFMLIB) parray.ao
	@$(LIB) $(LOBLIB) parray.obj
	@del parray.ao parray.obj

array.ao: array.as
	aldor -fo -fao $(AXLFLAGS) array.as
	@uniar r $(LFMLIB) array.ao
	@$(LIB) $(LOBLIB) array.obj
	@del array.ao array.obj

partial.ao: partial.as
	aldor -fo -fao $(AXLFLAGS) partial.as
	@uniar r $(LFMLIB) partial.ao
	@$(LIB) $(LOBLIB) partial.obj
	@del partial.ao partial.obj

sort.ao: sort.as
	aldor -fo -fao $(AXLFLAGS) sort.as
	@uniar r $(LFMLIB) sort.ao
	@$(LIB) $(LOBLIB) sort.obj
	@del sort.ao sort.obj

fname.ao: fname.as
	aldor -fo -fao $(AXLFLAGS) fname.as
	@uniar r $(LFMLIB) fname.ao
	@$(LIB) $(LOBLIB) fname.obj
	@del fname.ao fname.obj

file.ao: file.as
	aldor -fo -fao $(AXLFLAGS) file.as
	@uniar r $(LFMLIB) file.ao
	@$(LIB) $(LOBLIB) file.obj
	@del file.ao file.obj

opsys.ao: opsys.as
	aldor -fo -fao $(AXLFLAGS) opsys.as
	@uniar r $(LFMLIB) opsys.ao
	@$(LIB) $(LOBLIB) opsys.obj
	@del opsys.ao opsys.obj

oslow.ao: oslow.as
	aldor -fo -fao $(AXLFLAGS) oslow.as
	@uniar r $(LFMLIB) oslow.ao
	@$(LIB) $(LOBLIB) oslow.obj
	@del oslow.ao oslow.obj

textwrit.ao: textwrit.as 
	aldor -fo -fao $(AXLFLAGS) textwrit.as
	@uniar r $(LFMLIB) textwrit.ao
	@$(LIB) $(LOBLIB) textwrit.obj
	@del textwrit.ao textwrit.obj

textread.ao: textread.as 
	aldor -fo -fao $(AXLFLAGS) textread.as
	@uniar r $(LFMLIB) textread.ao
	@$(LIB) $(LOBLIB) textread.obj
	@del textread.ao textread.obj

fmtout.ao: fmtout.as
	aldor -fo -fao $(AXLFLAGS) fmtout.as
	@uniar r $(LFMLIB) fmtout.ao
	@$(LIB) $(LOBLIB) fmtout.obj
	@del fmtout.ao fmtout.obj

fprint.ao: fprint.as
	aldor -fo -fao $(AXLFLAGS) -Q inline-limit:2.4 fprint.as
	@uniar r $(LFMLIB) fprint.ao
	@$(LIB) $(LOBLIB) fprint.obj
	@del fprint.ao fprint.obj

object.ao: object.as
	aldor -fo -fao $(AXLFLAGS) object.as
	@uniar r $(LFMLIB) object.ao
	@$(LIB) $(LOBLIB) object.obj
	@del object.ao object.obj

debug.ao: debug.as
	aldor -fo -fao $(AXLFLAGS) debug.as
	@uniar r $(LFMLIB) debug.ao
	@$(LIB) $(LOBLIB) debug.obj
	@del debug.ao debug.obj

table.ao: table.as
	aldor -fo -fao $(AXLFLAGS) table.as
	@uniar r $(LFMLIB) table.ao
	@$(LIB) $(LOBLIB) table.obj
	@del table.ao table.obj

