###############################################################################
#
# Makefile
#
# Make program to build various tools under Unix* for the AXIOM-XL compiler
#
# Copyright (c) 1990-2007 Aldor Software Organization Ltd (Aldor.org).
#
###############################################################################
#
# Targets: all, junk, clean
#
#    make all   -- make the various tools for the AXIOM-XL compiler
#    make junk  -- list files which are not part of the tools
#    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
CFLAGS = -O -ansi
EXE	= 
OBJ	= o
LEX	= lex
# ANSI compatible.
CC 	= gcc
DOCC	= docc
OUTFLAG	= -o
# $(ALDORROOT) is retrieved from the environment
ALDORSTEM   = ../../../..
ALDORBUGS   = $(ALDORSTEM)/bugs
ALDORBIN    = $(ALDORROOT)/bin
ALDORMABIN  = $(ALDORROOT)/mabin
ALDORTOOLS  = $(ALDORROOT)/toolbin

NAMEFILE     = ../../Current
MAFILTER     = $(ALDORTOOLS)/mafilter

OBSOLETE= \
	axlbug maxiomxl.c maxiomxl.sh doaxiomxl \
	mafilter manew madiff maget maput makill \
	suru.c realuser.c older24h.c

OKFILES = Makefile \
	aldorbug msgcat.c \
	doas \
	recvbug.c recvbug.sh \
	forwbug.c forwbug.sh \
	getbug \
	maclean \
	includes.c makemake.c domkmk \
	skimenum.c cenum.h cenum.c \
	exclude.c strarray.c dirname.c atinlay.c \
	undent buildarg doaldor dolatex doranlib dog++ docc krcc \
	mksrctex cprt.awk \
	zcport.h zacc.h zacc.c zaccscan.l zaccgram.y \
	cscan.c cscan.h ccode.h cparse.y cparse.h \
	oldc.c badzeros.c cids cwords.c collide.c shorten.c \
	dosfile.c memlay.c fixbug fixreply mkasys diskchek.c \
	extract.c flags.h flags.c aldoc2html.c mklib.sh $(OBSOLETE)

SRC=$(shell pwd)

#Portability
ifeq ($(MACHINE), win32gcc)
	EXE	= .exe
	LEX	= flex
endif

ifeq ($(MACHINE), win32msvc)
	#CC 	= cc
	#CFLAGS	= /Ox
	EXE	= .exe
	OBJ	= obj
	P	= $(shell pwd)
	SRC	= $(shell cygpath -m $(P))
	DOCC	= cl /nologo
	LEX	= flex
	OUTFLAG	= /Fe
endif

all: \
  $(ALDORBIN)/aldorbug       $(ALDORBIN)/msgcat$(EXE) \
  \
  $(ALDORBUGS)/recvbug     $(ALDORBUGS)/recvbug.sh \
  $(ALDORBUGS)/forwbug     $(ALDORBUGS)/forwbug.sh \
  \
  $(ALDORTOOLS)/maclean \
  $(ALDORTOOLS)/makemake$(EXE)   $(ALDORTOOLS)/domkmk \
  $(ALDORTOOLS)/skimenum$(EXE)   $(ALDORTOOLS)/exclude$(EXE) \
  $(ALDORTOOLS)/strarray$(EXE)   $(ALDORTOOLS)/dirname$(EXE) \
  $(ALDORTOOLS)/atinlay$(EXE)    $(ALDORTOOLS)/memlay$(EXE) \
  $(ALDORTOOLS)/diskchek$(EXE) \
  $(ALDORTOOLS)/dosfile$(EXE)    $(ALDORTOOLS)/mkasys \
  $(ALDORTOOLS)/undent     $(ALDORTOOLS)/badzeros$(EXE) \
  $(ALDORTOOLS)/doaldor   $(ALDORBIN)/doaldor    $(ALDORTOOLS)/dolatex \
  $(ALDORTOOLS)/buildarg   $(ALDORTOOLS)/params \
  $(ALDORTOOLS)/doranlib   $(ALDORTOOLS)/docc \
  $(ALDORTOOLS)/dog++ \
  $(ALDORTOOLS)/krcc       $(ALDORTOOLS)/mksrctex \
  $(ALDORTOOLS)/cprt.awk   $(ALDORTOOLS)/zacc$(EXE) \
  $(ALDORTOOLS)/cids       $(ALDORTOOLS)/cwords$(EXE) \
  $(ALDORTOOLS)/collide$(EXE)    $(ALDORTOOLS)/shorten$(EXE) \
  $(ALDORTOOLS)/fixbug     $(ALDORTOOLS)/fixreply \
  $(ALDORTOOLS)/getbug     \
  $(ALDORBIN)/mklib	   $(ALDORBIN)/extract$(EXE) \
  $(ALDORBIN)/aldoc2html$(EXE)

# add this to all if you need it
#  $(ALDORTOOLS)/oldc       \

clean::
	@ if [ -d $(ALDORTOOLS) ] ; then ( \
		cd $(ALDORTOOLS) ; \
		rm -f y.tab.h y.tab.c lex.yy.c *.o *~ ) ; \
	fi

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


##############################################################################
#
# :: Tools delivered to end-user [bin directory]
#
##############################################################################

# msgcat: Construct an X/Open message catalog together with .c and .h files
#$(ALDORBIN)/msgcat$(EXE): msgcat.c $(ALDORTOOLS)/docc $(ALDORTOOLS)/oldc
$(ALDORBIN)/msgcat$(EXE): msgcat.c $(ALDORTOOLS)/docc 
	@ (cd $(ALDORBIN) ; \
		echo "$(DOCC) $(CFLAGS) $(SRC)/msgcat.c $(OUTFLAG)msgcat$(EXE)" ; \
		$(DOCC) $(CFLAGS) $(SRC)/msgcat.c $(OUTFLAG)msgcat$(EXE) \
	)

# msgcat: Construct an X/Open message catalog together with .c and .h files
$(ALDORBIN)/mklib: mklib.sh
	rm -f $@
	cp mklib.sh $@
	chmod 755 $@

# aldorbug: Mail an AXIOM-XL bug report
$(ALDORBIN)/aldorbug: aldorbug
	rm -f $@
	cp aldorbug $@
	chmod 755 $@

# extract: extracts tests from source files
$(ALDORBIN)/extract$(EXE): flags.c extract.c
	$(DOCC) -c flags.c
	$(DOCC) $(OUTFLAG)extract$(EXE) extract.c flags.$(OBJ)
	mv extract$(EXE) $@
	rm -f flags.$(OBJ)

# aldoc2html: take aldoc comments and create an html file
$(ALDORBIN)/aldoc2html$(EXE): flags.c aldoc2html.c
	$(DOCC) -c flags.c
	$(DOCC) $(OUTFLAG)aldoc2html$(EXE) aldoc2html.c flags.$(OBJ)
	mv aldoc2html$(EXE) $@
	rm -f flags.$(OBJ)

##############################################################################
#
# :: Bug delivery programs [bugs directory on server]
#
##############################################################################

# recvbug: accept delivery of bug files by mail
$(ALDORBUGS)/recvbug: recvbug.c
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		echon "Making recvbug..." ; \
		cd $(ALDORBUGS) ; \
		$(CC) $(CFLAGS) -o Nrecvbug$(EXE) $(SRC)/recvbug.c ; \
		chmod 755 Nrecvbug$(EXE) ; \
		chmod u+s Nrecvbug$(EXE) ; \
		mv Nrecvbug$(EXE) recvbug ; \
		echo "done" ; \
	fi

# called by recvbug
$(ALDORBUGS)/recvbug.sh: recvbug.sh
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		echon "Making recvbug.sh..." ; \
		cd $(ALDORBUGS) ; \
		cp $(SRC)/recvbug.sh Nrecvbug.sh ; \
		chmod 755 Nrecvbug.sh ; \
		chmod u+s Nrecvbug.sh ; \
		mv Nrecvbug.sh recvbug.sh ; \
		echo "done" ; \
	fi
# forwbug: forward delivery of bug files by mail
$(ALDORBUGS)/forwbug: forwbug.c
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		echon "Making forwbug..." ; \
		cd $(ALDORBUGS) ; \
		$(CC) $(CFLAGS) -o Nforwbug$(EXE) $(SRC)/forwbug.c ; \
		chmod 755 Nforwbug$(EXE) ; \
		chmod u+s Nforwbug$(EXE) ; \
		mv Nforwbug forwbug$(EXE) ; \
		echo "done" ; \
		fi

# called by forwbug
$(ALDORBUGS)/forwbug.sh: forwbug.sh
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		echon "Making forwbug.sh..." ; \
		cd $(ALDORBUGS) ; \
		cp $(SRC)/forwbug.sh Nforwbug.sh ; \
		chmod 755 Nforwbug.sh ; \
		chmod u+s Nforwbug.sh ; \
		mv Nforwbug.sh forwbug.sh ; \
		echo "done" ; \
	fi


##############################################################################
#
# :: Source control tools [mabin directory on server]
#
##############################################################################

# maxiomxl: server file locking and updating tool
$(ALDORMABIN)/maxiomxl: maxiomxl.c
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		cd $(ALDORMABIN) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/maxiomxl.c -o maxiomxl$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/maxiomxl.c -o maxiomxl$(EXE) ; \
		chmod u+s maxiomxl$(EXE) ; \
	fi

# maxiomxl.sh: part of maxiomxl
$(ALDORMABIN)/maxiomxl.sh: maxiomxl.sh
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		rm -f $@ ; \
		echo Copying maxiomxl.sh to $@ ; \
		cp maxiomxl.sh $@ ; \
		chmod 755 $@ ; \
		chmod u+s $@ ; \
	fi

# older24h: part of maxiomxl
$(ALDORMABIN)/older24h: older24h.c
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		cd $(ALDORMABIN) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/older24h.c -o older24h$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/older24h.c -o older24h$(EXE) ; \
	fi

# realuser: part of maxiomxl
$(ALDORMABIN)/realuser: realuser.c
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		cd $(ALDORMABIN) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/realuser.c -o realuser$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/realuser.c -o realuser$(EXE) ; \
	fi

# suru: part of maxiomxl
$(ALDORMABIN)/suru: suru.c
	@ if [ -f $(ALDORSTEM)/Server ] ; then \
		cd $(ALDORMABIN) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/suru.c -o suru$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/suru.c -o suru$(EXE) ; \
	fi

##############################################################################
#
# :: Other tools [toolbin directory]
#
##############################################################################

# mafilter:  Customize a maintain script for product or development.
$(ALDORTOOLS)/mafilter: mafilter
	rm -f $@
	cp mafilter $@
	chmod 755 $@

# manew:  Add a file to the server
$(ALDORTOOLS)/manew: manew $(MAFILTER) $(NAMEFILE)
	rm -f $@
	@ $(MAFILTER) $(NAMEFILE) manew $@
	chmod 755 $@

# maclean: Clean output directories
$(ALDORTOOLS)/maclean: maclean
	rm -f $@
	cp maclean $@
	chmod 755 $@

# madiff: Compare against a file on the server
$(ALDORTOOLS)/madiff: madiff $(MAFILTER) $(NAMEFILE)
	rm -f $@
	@ $(MAFILTER) $(NAMEFILE) madiff $@
	chmod 755 $@

# maget: Retrieve a file from the server
$(ALDORTOOLS)/maget: maget $(MAFILTER) $(NAMEFILE)
	rm -f $@
	@ $(MAFILTER) $(NAMEFILE) maget $@
	chmod 755 $@

# maput: Replace a file on the server
$(ALDORTOOLS)/maput: maput $(MAFILTER) $(NAMEFILE)
	rm -f $@
	@ $(MAFILTER) $(NAMEFILE) maput $@
	chmod 755 $@

# makill: Delete a file on the server
$(ALDORTOOLS)/makill: makill $(MAFILTER) $(NAMEFILE)
	rm -f $@
	@ $(MAFILTER) $(NAMEFILE) makill $@
	chmod 755 $@


# makemake: Construct a make file based on include commands.
$(ALDORTOOLS)/makemake$(EXE): makemake.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/makemake.c -o makemake$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/makemake.c -o makemake$(EXE) \
	)

# domkmk: platform-dependent interface to makemake
$(ALDORTOOLS)/domkmk: domkmk
	rm -f $@
	cp domkmk $@
	chmod 755 $@

# skimenum: Extract enumeration values from a C source file.
$(ALDORTOOLS)/skimenum$(EXE): skimenum.c cenum.h cenum.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/skimenum.c $(SRC)/cenum.c -o skimenum$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/skimenum.c $(SRC)/cenum.c -o skimenum$(EXE) \
	)

# exclude: Undo cpp includes.
$(ALDORTOOLS)/exclude$(EXE): exclude.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/exclude.c -o exclude$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/exclude.c -o exclude$(EXE) \
	)

# strarray: Construct .c and .h files for an array of the file lines.
$(ALDORTOOLS)/strarray$(EXE): strarray.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/strarray.c -o strarray$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/strarray.c -o strarray$(EXE) \
	)

# dirname: Form the directory part of a file name, for portable shell scripts.
$(ALDORTOOLS)/dirname$(EXE): dirname.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/dirname.c -o dirname$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/dirname.c -o dirname$(EXE) \
	)

# atinlay: Translate a file to pig latin.
$(ALDORTOOLS)/atinlay$(EXE): atinlay.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/atinlay.c -o atinlay$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/atinlay.c -o atinlay$(EXE) \
	)

# memlay: Explore machine's memory layout
$(ALDORTOOLS)/memlay$(EXE): memlay.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/memlay.c -o memlay$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/memlay.c -o memlay$(EXE) \
	)

# diskchek: Check that distribution disk images fit on real diskettes.
$(ALDORTOOLS)/diskchek$(EXE): diskchek.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/diskchek.c -o diskchek$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/diskchek.c -o diskchek$(EXE) \
	)

# dosfile: Convert between dos and unix file formats.
$(ALDORTOOLS)/dosfile$(EXE): dosfile.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/dosfile.c -o dosfile$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/dosfile.c -o dosfile$(EXE) \
	)

# undent: Convert file to standard indentation.  User must finish by hand.
$(ALDORTOOLS)/undent: undent
	rm -f $@
	cp undent $@
	chmod 755 $@

# badzeros: Locate suspicious zeros in a C source file.
$(ALDORTOOLS)/badzeros$(EXE): badzeros.c cscan.c cscan.h
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) -I$(SRC) $(SRC)/badzeros.c $(SRC)/cscan.c \
			-o badzeros$(EXE)" ; \
		$(CC) $(CFLAGS) -I$(SRC) $(SRC)/badzeros.c $(SRC)/cscan.c \
			-o badzeros$(EXE) \
	)

# doaldor: Helper script for compiling axiomxl library files.
$(ALDORBIN)/doaldor: doaldor
	rm -f $@
	cp doaldor $@
	chmod 755 $@

$(ALDORTOOLS)/doaldor: doaldor
	rm -f $@
	cp doaldor $@
	chmod 755 $@

# dolatex: Platform customization for "latex".
$(ALDORTOOLS)/dolatex: dolatex
	rm -f $@
	cp dolatex $@
	chmod 755 $@

# doranlib: Platform customization for "ranlib".
$(ALDORTOOLS)/doranlib: doranlib
	rm -f $@
	cp doranlib $@
	chmod 755 $@

# Arg file for buildarg
$(ALDORTOOLS)/params: $(NAMEFILE) buildarg Makefile
	(H=`hostname| awk -F. '{print $$1}'` ; \
	echo "$$H" ;  \
	grep "$$H" < $(NAMEFILE) | \
	  sed -e "s/^$$H://" > $(ALDORTOOLS)/params \
	)

# buildarg
$(ALDORTOOLS)/buildarg: buildarg $(ALDORTOOLS)/params
	rm -f $@
	cp buildarg $@
	chmod 755 $@

# docc: Platform customization for "cc".
$(ALDORTOOLS)/docc: docc $(ALDORTOOLS)/buildarg $(ALDORTOOLS)/krcc
	rm -f $@
	cp docc $@
	chmod 755 $@

# dog++: Platform customization for "g++".
$(ALDORTOOLS)/dog++: dog++
	rm -f $@
	cp dog++ $@
	chmod 755 $@

# krcc: Convert a program to K+R C, then compile.
$(ALDORTOOLS)/krcc: krcc
	rm -f $@
	cp krcc $@
	chmod 755 $@

# mksrctex: Latex axiomxl compiler source with index.
$(ALDORTOOLS)/mksrctex: mksrctex
	rm -f $@
	cp mksrctex $@
	chmod 755 $@

# called by mksrctex
$(ALDORTOOLS)/cprt.awk: cprt.awk
	rm -f $@
	cp cprt.awk $@
	chmod 755 $@

# cids: Produce the set without duplication of ids in a collection of C files.
$(ALDORTOOLS)/cids: cids
	rm -f $@
	cp cids $@
	chmod 755 $@

# cwords: Extract all identifiers from a C source file.
$(ALDORTOOLS)/cwords$(EXE): cwords.c cscan.c cscan.h
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) -I$(SRC) $(SRC)/cwords.c $(SRC)/cscan.c \
			-o cwords$(EXE)" ; \
		$(CC) $(CFLAGS) -I$(SRC) $(SRC)/cwords.c $(SRC)/cscan.c \
			-o cwords$(EXE) \
	)

# oldc: Convert ANSI C-file to K+R C.
$(ALDORTOOLS)/oldc$(EXE): oldc.c cscan.c cparse.y ccode.h cscan.h $(ALDORTOOLS)/zacc$(EXE)
	@ (cd $(ALDORTOOLS) ; \
		echo "$(ALDORTOOLS)/zacc$(EXE) -p -c cparse.c $(SRC)/cparse.y" ; \
		$(ALDORTOOLS)/zacc$(EXE) -p -c cparse.c $(SRC)/cparse.y ; \
		echo "$(CC) $(CFLAGS) -DYYMAXDEPTH=500 -I$(SRC) \
			$(SRC)/oldc.c $(SRC)/cscan.c cparse.c -o oldc$(EXE)" ; \
		$(CC) $(CFLAGS) -DYYMAXDEPTH=500 -I$(SRC) \
			$(SRC)/oldc.c $(SRC)/cscan.c cparse.c -o oldc$(EXE) ; \
		rm cparse.c \
	)

# collide: Find words which are the same up to a given length.
$(ALDORTOOLS)/collide$(EXE): collide.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/collide.c -o collide$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/collide.c -o collide$(EXE) \
	)

# shorten: Produce a file of #define statements to rename identifiers.
$(ALDORTOOLS)/shorten$(EXE): shorten.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(CC) $(CFLAGS) $(SRC)/shorten.c -o shorten$(EXE)" ; \
		$(CC) $(CFLAGS) $(SRC)/shorten.c -o shorten$(EXE) \
	)

# zacc: Parser generator with parameterized rules. Based on Yacc.
$(ALDORTOOLS)/zacc$(EXE): zaccgram.y zaccscan.l zacc.c zacc.h zcport.h cenum.h cenum.c
	@ (cd $(ALDORTOOLS) ; \
		echo "$(LEX) $(SRC)/zaccscan.l" ; \
		      $(LEX) $(SRC)/zaccscan.l ; \
		echo "yacc -d $(SRC)/zaccgram.y" ; \
		      yacc -d $(SRC)/zaccgram.y ; \
		echo "mv y.tab.h zaccgram.h" ; \
		      mv y.tab.h zaccgram.h ; \
		echo "$(CC) $(CFLAGS) -I. -I$(SRC) \
		   $(SRC)/zacc.c lex.yy.c y.tab.c $(SRC)/cenum.c -o zacc$(EXE)" ; \
		      $(CC) $(CFLAGS) -I. -I$(SRC) \
		   $(SRC)/zacc.c lex.yy.c y.tab.c $(SRC)/cenum.c -o zacc$(EXE) ; \
		rm lex.yy.c y.tab.c zaccgram.h \
	)

# getbug: Request a reported bug
$(ALDORTOOLS)/getbug: getbug
	rm -f $@
	cp getbug $@
	chmod 755 $@

# fixbug: Save a bug fix
$(ALDORTOOLS)/fixbug: fixbug
	rm -f $@
	cp fixbug $@
	chmod 755 $@

# fixreply: Report bug fix to bug reporter
$(ALDORTOOLS)/fixreply: fixreply
	rm -f $@
	cp fixreply $@
	chmod 755 $@

# mkasys: dump .asy files from all .ao's in libaxllib.al
$(ALDORTOOLS)/mkasys: mkasys
	rm -f $@
	cp mkasys $@
	chmod 755 $@
