##############################################################################
#
# NMakefile
#
# NMAKE compatible make program to build the Axiom interface.
#
# Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
#
##############################################################################
#
# Targets: all, junk, clean, quick
#
#    make all	-- make the Axiom interface for the AXIOM-XL compiler
#    make junk	-- list files which are not part of the AXIOM-XL compiler
#    make clean -- remove generated files  (e.g. foo.c~)
#
# Parameters:  AXIOMXLROOT
#
#    To override defaults do, e.g.,
#	 make -e AXIOMXLROOT=\spad\local\axiomxl\rs all
#    or
#	 setenv AXIOMXLROOT \spad\local\axiomxl\rs; setenv MAKEFLAGS e; make all
#
##############################################################################

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

AXIOMXL	= $(BinDir)\aldor
LAXLLIB	= $(LibDir)\libaxllib.al
LAXIOM	= $(LibDir)\libax0.al
LAXKEY	= ax0

AXLCDB	= -W check -M no-ALDOR_W_WillObsolete
AXLFLAGS= -lAxiomLib:$(LAXKEY) $(AXLCDB)
AXFLAGS	= -Wname:axiom -Wnhash -M no-ALDOR_W_OverRideLibraryFile -R $(LibDir) -Y $(LibDir) $(AXLFLAGS)

# $(AXIOM) is retrieved from the environment
OBJ		= $(AXIOM)\..\..\obj
INTERPSYS	= $(OBJ)\rios\bin\interpsys
DAASE		= $(OBJ)\rios

CFLAGS	= -g
RM	= del
CP	= copy

AR	= uniar
ARFLAGS	= rv
ARXFLAGS= x
ARR	= $(AR) $(ARFLAGS)
ARX	= $(AR) $(ARXFLAGS)

MAKE	= nmake -f NMakefile /nologo /x -

#
# Source lists
#
Samples	= axlit.as axiom.as
Sources	= attrib.as stub.as axlit.as minimach.as axextend.as \
	  axext_l.lsp axiom.as ax0.as mkax.lsp
Lists	= axiom.lst ax.lst

#
# Object lists
#
Aos	= $(LAXIOM)(lang.ao)		\
	  $(LAXIOM)(attrib.ao)		\
	  $(LAXIOM)(stub.ao)		\
	  $(LAXIOM)(axlit.ao)		\
	  $(LAXIOM)(minimach.ao)	\
	  $(LAXIOM)(axextend.ao)

#
# Target lists
#
IncTargs = $(IncDir)\axiom.as $(IncDir)\ax0.as
LibTargs = $(LAXIOM)
AoTargs  = lang0 attrib stub mkaso axlit minimach axextend axext
AuxTargs = $(LibDir)\lang.lsp		\
	   $(LibDir)\attrib.asy		\
	   $(LibDir)\attrib.lsp		\
	   $(LibDir)\axlit.asy		\
	   $(LibDir)\axlit.lsp		\
	   $(LibDir)\minimach.asy	\
	   $(LibDir)\minimach.lsp	\
	   $(LibDir)\axextend.asy	\
	   $(LibDir)\axextend.lsp	\
	   $(LibDir)\axext_l.lsp

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

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

#all:	$(Lists) $(IncTargs) $(AoTargs)
all:	$(IncTargs) $(AoTargs)

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

clean:
	@ $(RM) *~

libclean:
	@ $(RM) $(IncTargs) $(LibTargs) $(AuxTargs)

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

lists:		$(Lists)
include:	$(IncTargs)
lib:		$(LibTargs)

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

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

#
# Specific dependencies and rules
#

# The doranlib dependency ensures that doranlib gets called.
$(LAXIOM):  $(Aos) doranlib
	@ echo doranlib $@

doranlib:
	@ echon

#
# Ax0
#
lang0:
	@ $(MAKE) lang

lang $(LAXIOM)(lang.ao): # $(LAXLLIB)(lang.ao)
	@ cd $(LibDir)
	@ $(ARX) $(LAXLLIB) lang.ao
	@ $(ARR) $(LAXIOM)  lang.ao
	@ echo Generating $(LibDir)\lang.lsp
	@ $(AXIOMXL) -F lsp $(AXLFLAGS) lang.ao
	@ $(RM) lang.ao
	@ cd $(MAKEDIR)

attrib $(LAXIOM)(attrib.ao): attrib.as
	@doaldor.bat attrib $(LAXKEY) as $(AXLFLAGS) -Fasy -Flsp

stub $(LAXIOM)(stub.ao): stub.as
	doaldor.bat stub $(LAXKEY) as $(AXLFLAGS)

axlit $(LAXIOM)(axlit.ao): axlit.as
	@doaldor.bat axlit $(LAXKEY) as $(AXLFLAGS) -Fasy -Flsp

minimach $(LAXIOM)(minimach.ao): minimach.as
	@doaldor.bat minimach $(LAXKEY) as $(AXLFLAGS) -Fasy -Flsp

axextend $(LAXIOM)(axextend.ao): axextend.as
	@doaldor.bat axextend $(LAXKEY) as $(AXLFLAGS) -Fasy -Flsp -X

axext $(LibDir)\axext_l.lsp:: axext_l.lsp
	@echo Copying axext_l.lsp into $(LibDir)
	@$(CP) axext_l.lsp $(LibDir)\axext_l.lsp

$(IncDir)\axiom.as: axiom.as
	@echo Copying axiom.as into $(IncDir)
	@$(CP) axiom.as $(IncDir)\axiom.as

$(IncDir)\ax0.as: ax0.as
	@echo Copying ax0.as into $(IncDir)
	@$(CP) ax0.as $(IncDir)\ax0.as

#
# basecliq
#

mkax:
	@if [ ! -x ax ] ; then mkdir ax ; fi
	@(DAASE="$(DAASE)"; export DAASE; $(INTERPSYS)) < mkax.lsp
	@if [ -x nax ] ; then cp nax\* ax; fi

mkaso:
	for /f %%i in (ax.lst) do doax0 %%i ax0 $(AXFLAGS)

#	 @ doax0 basecliq	ax0 $(AXFLAGS)
#	 @ doax0 aggcat		ax0 $(AXFLAGS)
#	 @ doax0 stream		ax0 $(AXFLAGS)
#	 @ doax0 seg		ax0 $(AXFLAGS)
#	 @ doax0 list		ax0 $(AXFLAGS)
#	 @ doax0 array1		ax0 $(AXFLAGS)
#	 @ doax0 array2		ax0 $(AXFLAGS)
#	 @ doax0 sex		ax0 $(AXFLAGS)
#	 @ doax0 any		ax0 $(AXFLAGS)
#	 @ doax0 mkfunc		ax0 $(AXFLAGS)
#	 @ doax0 indexedp	ax0 $(AXFLAGS)
#	 @ doax0 misc		ax0 $(AXFLAGS)
#	 @ doax0 op		ax0 $(AXFLAGS)
#	 @ doax0 pattern		ax0 $(AXFLAGS)
#	 @ doax0 kl		ax0 $(AXFLAGS)
#	 @ doax0 variable	ax0 $(AXFLAGS)
#	 @ doax0 patmatch1	ax0 $(AXFLAGS)
#	 @ doax0 sf		ax0 $(AXFLAGS)
#	 @ doax0 si		ax0 $(AXFLAGS)
#	 @ doax0 float		ax0 $(AXFLAGS)
#	 @ doax0 symbol		ax0 $(AXFLAGS)
#	 @ doax0 integer		ax0 $(AXFLAGS)
#	 @ doax0 vector		ax0 $(AXFLAGS)
#	 @ doax0 matcat		ax0 $(AXFLAGS)
#	 @ doax0 matrix		ax0 $(AXFLAGS)
#	 @ doax0 evalable	ax0 $(AXFLAGS)
#	 @ doax0 polycat		ax0 $(AXFLAGS)
#	 @ doax0 multpoly	ax0 $(AXFLAGS)
#	 @ doax0 fspace		ax0 $(AXFLAGS)
#	 @ doax0 poly		ax0 $(AXFLAGS)
#	 @ doax0 equation	ax0 $(AXFLAGS)
#	 @ doax0 fr		ax0 $(AXFLAGS)
#	 @ doax0 fraction	ax0 $(AXFLAGS)
#	 @ doax0 patmatch2	ax0 $(AXFLAGS)
