##############################################################################
#
# 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, junk, 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
#
##############################################################################
#
#  2006/Dec/22
#
#  On Solaris, the value of PWD does not change when make is invoked
#  recursively.  Consequently, it is necessary to explicitly set it
#  at the start of the makefile.
#
PWD = $(shell pwd)

SHELL	= /bin/sh

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

ALDOR	= $(BinDir)/aldor
LFMLIB	= $(LibDir)/libfoamlib.al
LOBLIB	= $(LibDir)/libfoamlib.a
BUILDARG = $(ALDORROOT)/toolbin/buildarg

AXLCDB	= -Wcheck #-Cargs=-g -Qno-cc -Ffm
AXLFLAGS	= -Z db $(AXLCDB) # -Wgc

CP	= cp
RM	= rm -f

ALDOR	= $(BinDir)/aldor
DOALDOR = doaldor
OBJ	= o

ifeq ($(MACHINE), win32gcc)
	ALDOR	= $(BinDir)/aldor.sh
endif

ifeq ($(MACHINE), win32msvc)
	ALDOR	= $(BinDir)/aldor.sh
	DOALDOR = doaldor
	LOBLIB	= $(LibDir)/libfoamlib.lib
	OBJ	= obj
endif

#
# 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	= $(LFMLIB)(lang.ao)		\
	  $(LFMLIB)(machine.ao)		\
	  $(LFMLIB)(basic.ao)		\
	  $(LFMLIB)(foamcat.ao)		\
	  $(LFMLIB)(tuple.ao)		\
	  $(LFMLIB)(gener.ao)		\
	  $(LFMLIB)(boolean.ao)		\
	  $(LFMLIB)(segment.ao)		\
	  $(LFMLIB)(sinteger.ao)	\
	  $(LFMLIB)(sfloat.ao)		\
	  $(LFMLIB)(pointer.ao)		\
	  $(LFMLIB)(char.ao)		\
	  $(LFMLIB)(parray.ao)		\
	  $(LFMLIB)(array.ao)		\
	  $(LFMLIB)(list.ao)		\
	  $(LFMLIB)(langx.ao)		\
	  $(LFMLIB)(string.ao)


AXL0Objs= $(LOBLIB)(lang.$(OBJ))		\
	  $(LOBLIB)(machine.$(OBJ))		\
	  $(LOBLIB)(basic.$(OBJ))		\
	  $(LOBLIB)(foamcat.$(OBJ))		\
	  $(LOBLIB)(tuple.$(OBJ))		\
	  $(LOBLIB)(gener.$(OBJ))		\
	  $(LOBLIB)(boolean.$(OBJ))		\
	  $(LOBLIB)(segment.$(OBJ))		\
	  $(LOBLIB)(sinteger.$(OBJ))		\
	  $(LOBLIB)(sfloat.$(OBJ))		\
	  $(LOBLIB)(pointer.$(OBJ))		\
	  $(LOBLIB)(char.$(OBJ))		\
	  $(LOBLIB)(parray.$(OBJ))		\
	  $(LOBLIB)(array.$(OBJ))		\
	  $(LOBLIB)(list.$(OBJ))		\
	  $(LOBLIB)(langx.$(OBJ))		\
	  $(LOBLIB)(string.$(OBJ))


AXL1Aos	= $(LFMLIB)(format.ao)		\
	  $(LFMLIB)(oslow.ao)		\
	  $(LFMLIB)(fname.ao)		\
	  $(LFMLIB)(file.ao)		\
	  $(LFMLIB)(opsys.ao)		\
	  $(LFMLIB)(textwrit.ao)


AXL1Objs= $(LOBLIB)(format.$(OBJ))		\
	  $(LOBLIB)(oslow.$(OBJ))		\
	  $(LOBLIB)(fname.$(OBJ))		\
	  $(LOBLIB)(file.$(OBJ))		\
	  $(LOBLIB)(opsys.$(OBJ))		\
	  $(LOBLIB)(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) 

ext:	otherlibs

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

clean:
	@ $(RM) *~

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


foaminc.lst:	Makefile
	@echon "Making foaminc.lst..."
	@(for f in $(IncSrcs) ; do echo $$f ; done) | \
		sed -e 's/\.as//' > foaminc.lst
	@echo "done"

foamlib.lst:	Makefile
	@echon "Making foamlib.lst..."
	@(for f in $(AXLSrcs) ; do echo $$f ; done) | \
		sed -e 's/\.as//' > foamlib.lst
	@echo "done"

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

otherlibs:
	for x in "" `$(BUILDARG) extra-libdirs` ; do 		\
		lib=$(ALDORROOT)/lib-$(MACHINE)$$x;		\
		if [ ! -d $$lib ] ; then  mkdir $$lib ; fi;	\
		sys=$(MACHINE)$$x;				\
		echo "mklib $$sys libfoamlib" >> $(ALDORROOT)/lib-$$sys/runme.sh; \
		chmod 755 $(ALDORROOT)/lib-$$sys/runme.sh;	\
	done

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

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

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

#
# Specific dependencies and rules
#
incfoamlib    $(IncDir)/foamlib.as:	   foamlib.as
	$(CP) foamlib.as	$(IncDir)/foamlib.as


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

doranlib:
	@echon

#
# AXL0Srcs
#
lang    $(LFMLIB)(lang.ao): lang.as
	@$(DOALDOR) lang foamlib $(AXLFLAGS) -M no-ALDOR_W_WillObsolete

machine $(LFMLIB)(machine.ao): machine.as
	@$(DOALDOR) machine foamlib $(AXLFLAGS) -lfoamlib

basic   $(LOBLIB)(basic.$(OBJ)) $(LFMLIB)(basic.ao): basic.as
	@$(DOALDOR) basic foamlib $(AXLFLAGS) -lfoamlib -Q inline-limit:18

foamcat   $(LFMLIB)(foamcat.ao): foamcat.as
	@$(DOALDOR) foamcat foamlib $(AXLFLAGS) -lfoamlib

langx    $(LFMLIB)(langx.ao): langx.as
	@$(DOALDOR) langx foamlib $(AXLFLAGS)

rtexns  $(LFMLIB)(rtexns.ao): rtexns.as
	@$(DOALDOR) rtexns foamlib $(AXLFLAGS)

tuple   $(LFMLIB)(tuple.ao): tuple.as
	@$(DOALDOR) tuple foamlib $(AXLFLAGS)

gener   $(LFMLIB)(gener.ao): gener.as
	@$(DOALDOR) gener foamlib $(AXLFLAGS)

except   $(LFMLIB)(except.ao): except.as
	@$(DOALDOR) except foamlib $(AXLFLAGS)

boolean $(LFMLIB)(boolean.ao): boolean.as
	@$(DOALDOR) boolean foamlib $(AXLFLAGS)

segment $(LFMLIB)(segment.ao): segment.as
	@$(DOALDOR) segment foamlib $(AXLFLAGS)

byte    $(LFMLIB)(byte.ao): byte.as
	@$(DOALDOR) byte foamlib $(AXLFLAGS)

hinteger $(LFMLIB)(hinteger.ao): hinteger.as
	@$(DOALDOR) hinteger foamlib $(AXLFLAGS)

sinteger $(LFMLIB)(sinteger.ao): sinteger.as
	@$(DOALDOR) sinteger foamlib $(AXLFLAGS)

sfloat $(LFMLIB)(sfloat.ao): sfloat.as
	@$(DOALDOR) sfloat foamlib $(AXLFLAGS)

bpower $(LFMLIB)(bpower.ao): bpower.as
	@$(DOALDOR) bpower foamlib $(AXLFLAGS)

integer $(LFMLIB)(integer.ao): integer.as
	@$(DOALDOR) integer foamlib $(AXLFLAGS)

pointer $(LFMLIB)(pointer.ao): pointer.as
	@$(DOALDOR) pointer foamlib $(AXLFLAGS)

char    $(LFMLIB)(char.ao): char.as
	@$(DOALDOR) char foamlib $(AXLFLAGS)

string  $(LFMLIB)(string.ao): string.as
	@$(DOALDOR) string foamlib $(AXLFLAGS)

imod  $(LFMLIB)(imod.ao): imod.as
	@$(DOALDOR) imod foamlib $(AXLFLAGS)

#
# AXL1Srcs
#
format $(LFMLIB)(format.ao): format.as
	@$(DOALDOR) format foamlib $(AXLFLAGS)

ratio $(LFMLIB)(ratio.ao): ratio.as
	@$(DOALDOR) ratio foamlib $(AXLFLAGS)

list $(LFMLIB)(list.ao): list.as
	@$(DOALDOR) list foamlib $(AXLFLAGS)

parray $(LFMLIB)(parray.ao): parray.as
	@$(DOALDOR) parray foamlib $(AXLFLAGS)

array $(LFMLIB)(array.ao): array.as
	@$(DOALDOR) array foamlib $(AXLFLAGS)

partial $(LFMLIB)(partial.ao): partial.as
	@$(DOALDOR) partial foamlib $(AXLFLAGS)

sort $(LFMLIB)(sort.ao): sort.as
	@$(DOALDOR) sort foamlib $(AXLFLAGS)

fname $(LFMLIB)(fname.ao): fname.as
	@$(DOALDOR) fname foamlib $(AXLFLAGS)

file $(LFMLIB)(file.ao): file.as
	@$(DOALDOR) file foamlib $(AXLFLAGS)

opsys $(LFMLIB)(opsys.ao): opsys.as
	@$(DOALDOR) opsys  foamlib $(AXLFLAGS)

oslow $(LFMLIB)(oslow.ao): oslow.as
	@$(DOALDOR) oslow foamlib $(AXLFLAGS)

textwrit $(LFMLIB)(textwrit.ao): textwrit.as 
	@$(DOALDOR) textwrit foamlib $(AXLFLAGS)

textread $(LFMLIB)(textread.ao): textread.as 
	@$(DOALDOR) textread  foamlib $(AXLFLAGS)

fmtout $(LFMLIB)(fmtout.ao): fmtout.as
	@$(DOALDOR) fmtout  foamlib $(AXLFLAGS)

fprint $(LFMLIB)(fprint.ao): fprint.as
	@$(DOALDOR) fprint foamlib $(AXLFLAGS) -Q inline-limit:2.4

object $(LFMLIB)(object.ao): object.as
	@$(DOALDOR) object foamlib $(AXLFLAGS)

debug $(LFMLIB)(debug.ao): debug.as
	@$(DOALDOR) debug foamlib $(AXLFLAGS)

table $(LFMLIB)(table.ao): table.as
	@$(DOALDOR) table foamlib $(AXLFLAGS)

