########################################################################
#####                C MeatAxe - Makefile for UNIX                 #####
########################################################################
# Modified by Simon King (2008-12)
# Use:
# > cd LocalDirectory
# > make ROOTDIR=/path/to/package/directory -f /path/to/Makefile
# This results in installing the executables in LocalDirectory/bin/ and the 
# meataxe library in LocalDirectory/lib/
########################################################################
# Configuration section                                            #####
# The following definitions may need some changes                  #####
# depending on your operating system and compiler                  #####
########################################################################

#---------------------------------------------------------------------
# Some Standard Directories (absolute paths)
#---------------------------------------------------------------------

# The directory of Simon King's Sage-package
# This will usually be given to make by ROOTDIR=path/to/package
ROOTDIR=$(PWD)

# Standard path to this makefile
ODIR=$(ROOTDIR)/mtx2.2.4

# The source directory
SRCDIR=$(ODIR)/src

# The library directory (NOT the same as the target directory for libmtx.a!)
MTXLIB=$(ODIR)/lib

# The target directory for executables
TDIR=$(ROOTDIR)/bin

# The target directory for libmtx.a
LDIR=$(ROOTDIR)/lib
LIBMTX=$(LDIR)/libmtx.a

# --------------------------------------------------------------------
# The name and standard options of your C compiler
# --------------------------------------------------------------------

# original: CC=gcc	
# original: COMPFLAGS=-Wall -minline-all-stringops -g $(OO)
# In order to deal with build problems on Intel Mac, we defined
# the variable DARWIN64 in spkg-install
COMPFLAGS=-Wall -DASM_MMX -g $(OO) $(DARWIN64)

# original: COMPFLAGS=-ansi -O -Wall
# respectively: COMPFLAGS=-ansi -g -Wall  -DASM_MMX -DDEBUG # for debugging
# or also: =-ansi -g -Wall -DDEBUG #-DPARANOID

# If you don"t have gcc, use the standard C compiler:
#CC=cc
#COMPFLAGS=-O

# This is for OSF/1's compiler on Dec Alpha (if you want ANSI C)
#CC=cc
#COMPFLAGS=-O -std1

# Use this with HPUX's compiler:
# CC=cc
# COMPFLAGS=-O -Aa
# COMPFLAGS=


# --------------------------------------------------------------------
# Specify your operating system here. If you don't know which system
# you have, try `uname -rs'. If there is no definition for your OS,
# try DEFAULT. If this fails, try the other systems.
# If this fails, too,  edit the file 'meataxe.h' and follow the
# instructions given there...
# --------------------------------------------------------------------

# DEFAULT is known to work with:
#   OSF/1 1.2 and 2.0
#   NetBSD 0.9
#   FreeBSD 1.2
#   Linux 1.0
OS=DEFAULT

#OS=SUNOS_41   # SunOS 4.1 (Tested with 4.1 and 4.1.3)
#OS=ULTRIX     # DEC Ultrix (Tested with 4.2 and 4.3)
#OS=HPUX       # HP/UX (Tested with 9.0)
#OS=IBMVM      # IBM's VM/CMS (not tested, probably broken)
#OS=MSDOS      # MS-DOS + djgpp (not tested, probably broken)

# --------------------------------------------------------------------
# The name and options of the 'ar' command. The following is
# 'standard' on most systems. If you get errors from ar commands,
# try commenting out these lines to use the definitions which are
# (hopefully) built into your make.
# --------------------------------------------------------------------
#AR=ar
ARFLAGS=rv

# --------------------------------------------------------------------
# The ranlib command. The default should work on almost any system.
# --------------------------------------------------------------------
#RANLIB=`if [ -r /bin/ranlib -o -r /usr/bin/ranlib ]; \
#    then echo ranlib; else echo true; fi`

# --------------------------------------------------------------------
# The name of the ZZZ module and the table file generator.
# --------------------------------------------------------------------
# small version, up to GF(256)
ZZZ=zzz
MAKETAB=maketab
# big version, up to GF(2^16)
#ZZZNAME=bigzzz
#MAKETAB=bigmktab


########################################################################
# End of configuration section                                     #####
# There should be no need to change anything below this point      #####
########################################################################

CFLAGS=$(COMPFLAGS) -DOS_$(OS) -fPIC
# SHELL=/bin/sh  # Is it needed to explicitly say that the sage shell is used?


###########################
# C MEATAXE (common part) #
###########################

# Program names
# -------------
MtxH=$(SRCDIR)/meataxe.h
MTXPRG=zad zbl zcf zcl zcp zct zcv zef zev zfr ziv zkd zmo zmu znu \
 zor zpc zpr zpt zqt zsb zsi zsm zsp zsy ztc zte ztm ztr zuk zvp \
 chop pwkond mkcycl mkinc mksub genmod mkdotl mkgraph \
 conv $(MAKETAB) zzztest checksum $(LOCALPRGS)

# Other macros
# ------------
SD=$(SRCDIR)
CCOMP=$(CC) -c $(CFLAGS) -o $@
COMPILE=$(CC) -c $(CFLAGS)
BUILD=$(CC) $(CFLAGS) -o $@ $(SD)/$@.c $(LLIBS)


# Targets
# -------
all:
	( test -d $(TDIR) || $(MKDIR) $(TDIR); cd $(TDIR);  $(MAKE) -j1 ROOTDIR=$(ROOTDIR) TDIR=$(TDIR) LDIR=$(LDIR) -f $(ODIR)/Makefile $(MTXPRG) )

lattice: chop pwkond mkcycl mkinc mksub genmod mkdotl $(MAKETAB)
strip:
	strip $(MTXPRG) $(LOCALPRGS)
clean:
	( cd $(TDIR); $(RM) -f *.o core )
delete:
	( cd $(TDIR); $(RM) -f $(MTXPRG) $(LOCALPRGS) *.o *.a core )


# Auxiliary programs
# ------------------
$(MAKETAB): $(SD)/$(MAKETAB).c $(LIBMTX) $(MtxH)
	$(BUILD) $(LIBMTX)

conv: $(SD)/conv.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zzztest: $(SD)/zzztest.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

checksum: $(SD)/checksum.c
	$(BUILD)

# MeatAxe library
# ---------------
$(LIBMTX):\
	$(LIBMTX)(args.o)\
	$(LIBMTX)(berlekmp.o)\
	$(LIBMTX)(charpol.o)\
	$(LIBMTX)(chbasis.o)\
	$(LIBMTX)(fpoly.o)\
	$(LIBMTX)(gauss.o)\
	$(LIBMTX)(gcd.o)\
	$(LIBMTX)(intstr.o)\
	$(LIBMTX)(matins.o)\
	$(LIBMTX)(message.o)\
	$(LIBMTX)(minpol.o)\
	$(LIBMTX)(mtxobj.o)\
	$(LIBMTX)(os.o)\
	$(LIBMTX)(profile.o)\
	$(LIBMTX)(prtimes.o)\
	$(LIBMTX)(random.o)\
	$(LIBMTX)(sbasis.o)\
	$(LIBMTX)(sequence.o)\
	$(LIBMTX)(spinup.o)\
	$(LIBMTX)(split.o)\
	$(LIBMTX)(words.o)\
	$(LIBMTX)(ycomp.o)\
	$(LIBMTX)(ymatrix.o)\
	$(LIBMTX)(yperm.o)\
	$(LIBMTX)(ypoly.o)\
	$(LIBMTX)(ysets.o)\
	$(LIBMTX)(zbitstr.o)\
	$(LIBMTX)(zfile.o)\
	$(LIBMTX)(zgap.o)\
	$(LIBMTX)(zgauss.o)\
	$(LIBMTX)(zmatinv.o)\
	$(LIBMTX)(znullsp.o)\
	$(LIBMTX)(zpseed.o)\
	$(LIBMTX)(zquot.o)\
	$(LIBMTX)(zsbasis.o)\
	$(LIBMTX)(zspin.o)\
	$(LIBMTX)($(ZZZ).o)\
	$(LIBMTX)(zzz2.o)
	$(RANLIB) $(LIBMTX)

$(LIBMTX)(args.o): $(SD)/args.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o args.o $(SD)/args.c
	$(AR) $(ARFLAGS) $(LIBMTX) args.o
	$(RM) -f args.o

$(LIBMTX)(berlekmp.o): $(SD)/berlekmp.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o berlekmp.o $(SD)/berlekmp.c
	$(AR) $(ARFLAGS) $(LIBMTX) berlekmp.o
	$(RM) -f berlekmp.o

$(LIBMTX)(charpol.o): $(SD)/charpol.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o charpol.o $(SD)/charpol.c
	$(AR) $(ARFLAGS) $(LIBMTX) charpol.o
	$(RM) -f charpol.o

$(LIBMTX)(chbasis.o): $(SD)/chbasis.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o chbasis.o $(SD)/chbasis.c
	$(AR) $(ARFLAGS) $(LIBMTX) chbasis.o
	$(RM) -f chbasis.o

$(LIBMTX)(fpoly.o): $(SD)/fpoly.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o fpoly.o $(SD)/fpoly.c
	$(AR) $(ARFLAGS) $(LIBMTX) fpoly.o
	$(RM) -f fpoly.o

$(LIBMTX)(gauss.o): $(SD)/gauss.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o gauss.o $(SD)/gauss.c
	$(AR) $(ARFLAGS) $(LIBMTX) gauss.o
	$(RM) -f gauss.o

$(LIBMTX)(gcd.o): $(SD)/gcd.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o gcd.o $(SD)/gcd.c
	$(AR) $(ARFLAGS) $(LIBMTX) gcd.o
	$(RM) -f gcd.o

$(LIBMTX)(intstr.o): $(SD)/intstr.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o intstr.o $(SD)/intstr.c
	$(AR) $(ARFLAGS) $(LIBMTX) intstr.o
	$(RM) -f intstr.o

$(LIBMTX)(matins.o): $(SD)/matins.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o matins.o $(SD)/matins.c
	$(AR) $(ARFLAGS) $(LIBMTX) matins.o
	$(RM) -f matins.o

$(LIBMTX)(message.o): $(SD)/message.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o message.o $(SD)/message.c
	$(AR) $(ARFLAGS) $(LIBMTX) message.o
	$(RM) -f message.o

$(LIBMTX)(minpol.o): $(SD)/minpol.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o minpol.o $(SD)/minpol.c
	$(AR) $(ARFLAGS) $(LIBMTX) minpol.o
	$(RM) -f minpol.o

$(LIBMTX)(mtxobj.o): $(SD)/mtxobj.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o mtxobj.o $(SD)/mtxobj.c
	$(AR) $(ARFLAGS) $(LIBMTX) mtxobj.o
	$(RM) -f mtxobj.o

$(LIBMTX)(os.o): $(SD)/os.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) $(OSFLAGS) -DMTXLIB=\"$(MTXLIB)\" -o os.o $(SD)/os.c
	$(AR) $(ARFLAGS) $(LIBMTX) os.o
	$(RM) -f os.o

$(LIBMTX)(sequence.o): $(SD)/sequence.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o sequence.o $(SD)/sequence.c
	$(AR) $(ARFLAGS) $(LIBMTX) sequence.o
	$(RM) -f sequence.o

$(LIBMTX)(words.o): $(SD)/words.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o words.o $(SD)/words.c
	$(AR) $(ARFLAGS) $(LIBMTX) words.o
	$(RM) -f words.o

$(LIBMTX)(ycomp.o): $(SD)/ycomp.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o ycomp.o $(SD)/ycomp.c
	$(AR) $(ARFLAGS) $(LIBMTX) ycomp.o
	$(RM) -f ycomp.o

$(LIBMTX)(ymatrix.o): $(SD)/ymatrix.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o ymatrix.o $(SD)/ymatrix.c
	$(AR) $(ARFLAGS) $(LIBMTX) ymatrix.o
	$(RM) -f ymatrix.o

$(LIBMTX)(yperm.o): $(SD)/yperm.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o yperm.o $(SD)/yperm.c
	$(AR) $(ARFLAGS) $(LIBMTX) yperm.o
	$(RM) -f yperm.o

$(LIBMTX)(ypoly.o): $(SD)/ypoly.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o ypoly.o $(SD)/ypoly.c
	$(AR) $(ARFLAGS) $(LIBMTX) ypoly.o
	$(RM) -f ypoly.o

$(LIBMTX)(ysets.o): $(SD)/ysets.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o ysets.o $(SD)/ysets.c
	$(AR) $(ARFLAGS) $(LIBMTX) ysets.o
	$(RM) -f ysets.o

$(LIBMTX)(zbitstr.o): $(SD)/zbitstr.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zbitstr.o $(SD)/zbitstr.c
	$(AR) $(ARFLAGS) $(LIBMTX) zbitstr.o
	$(RM) -f zbitstr.o

$(LIBMTX)(zfile.o): $(SD)/zfile.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zfile.o $(SD)/zfile.c
	$(AR) $(ARFLAGS) $(LIBMTX) zfile.o
	$(RM) -f zfile.o

$(LIBMTX)(zgap.o): $(SD)/zgap.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zgap.o $(SD)/zgap.c
	$(AR) $(ARFLAGS) $(LIBMTX) zgap.o
	$(RM) -f zgap.o

$(LIBMTX)(zgauss.o): $(SD)/zgauss.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zgauss.o $(SD)/zgauss.c
	$(AR) $(ARFLAGS) $(LIBMTX) zgauss.o
	$(RM) -f zgauss.o

$(LIBMTX)(zmatinv.o): $(SD)/zmatinv.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zmatinv.o $(SD)/zmatinv.c
	$(AR) $(ARFLAGS) $(LIBMTX) zmatinv.o
	$(RM) -f zmatinv.o

$(LIBMTX)(znullsp.o): $(SD)/znullsp.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o znullsp.o $(SD)/znullsp.c
	$(AR) $(ARFLAGS) $(LIBMTX) znullsp.o
	$(RM) -f znullsp.o

$(LIBMTX)(zpseed.o): $(SD)/zpseed.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zpseed.o $(SD)/zpseed.c
	$(AR) $(ARFLAGS) $(LIBMTX) zpseed.o
	$(RM) -f zpseed.o

$(LIBMTX)(zquot.o): $(SD)/zquot.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zquot.o $(SD)/zquot.c
	$(AR) $(ARFLAGS) $(LIBMTX) zquot.o
	$(RM) -f zquot.o

$(LIBMTX)(zsbasis.o): $(SD)/zsbasis.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zsbasis.o $(SD)/zsbasis.c
	$(AR) $(ARFLAGS) $(LIBMTX) zsbasis.o
	$(RM) -f zsbasis.o

$(LIBMTX)(zspin.o): $(SD)/zspin.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zspin.o $(SD)/zspin.c
	$(AR) $(ARFLAGS) $(LIBMTX) zspin.o
	$(RM) -f zspin.o

$(LIBMTX)(profile.o): $(SD)/profile.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o profile.o $(SD)/profile.c
	$(AR) $(ARFLAGS) $(LIBMTX) profile.o
	$(RM) -f profile.o

$(LIBMTX)(prtimes.o): $(SD)/prtimes.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o prtimes.o $(SD)/prtimes.c
	$(AR) $(ARFLAGS) $(LIBMTX) prtimes.o
	$(RM) -f prtimes.o

$(LIBMTX)(random.o): $(SD)/random.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o random.o $(SD)/random.c
	$(AR) $(ARFLAGS) $(LIBMTX) random.o
	$(RM) -f random.o

$(LIBMTX)(sbasis.o): $(SD)/sbasis.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o sbasis.o $(SD)/sbasis.c
	$(AR) $(ARFLAGS) $(LIBMTX) sbasis.o
	$(RM) -f sbasis.o

$(LIBMTX)(spinup.o): $(SD)/spinup.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o spinup.o $(SD)/spinup.c
	$(AR) $(ARFLAGS) $(LIBMTX) spinup.o
	$(RM) -f spinup.o

$(LIBMTX)(split.o): $(SD)/split.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o split.o $(SD)/split.c
	$(AR) $(ARFLAGS) $(LIBMTX) split.o
	$(RM) -f split.o


$(LIBMTX)($(ZZZ).o): $(SD)/$(ZZZ).c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -DZZZ_CC='"$(CC) $(CFLAGS)"' -o $(ZZZ).o $(SD)/$(ZZZ).c
	$(AR) $(ARFLAGS) $(LIBMTX) $(ZZZ).o
	$(RM) -f $(ZZZ).o

$(LIBMTX)(zzz2.o): $(SD)/zzz2.c $(MtxH)
	test -d $(LDIR) || $(MKDIR) $(LDIR)
	$(COMPILE) -o zzz2.o $(SD)/zzz2.c
	$(AR) $(ARFLAGS) $(LIBMTX) zzz2.o
	$(RM) -f zzz2.o




# Objects
# -------
chop.o: $(SD)/chop.c $(SD)/lattice.h $(MtxH) $(SD)/files.h
	$(CCOMP) $(SD)/chop.c

files.o: $(SD)/files.c $(SD)/lattice.h
	$(CCOMP) $(SD)/files.c

genmod.o: $(SD)/genmod.c $(SD)/lattice.h
	$(CCOMP) $(SD)/genmod.c

pwkond.o: $(SD)/pwkond.c $(MtxH) $(SD)/lattice.h
	$(CCOMP) $(SD)/pwkond.c

mkcycl.o: $(SD)/mkcycl.c $(SD)/lattice.h $(MtxH)
	$(CCOMP) $(SD)/mkcycl.c

mkdotl.o: $(SD)/mkdotl.c $(SD)/lattice.h $(MtxH)
	$(CCOMP) $(SD)/mkdotl.c

mkgraph.o: $(SD)/mkgraph.c $(SD)/lattice.h $(MtxH)
	$(CCOMP) $(SD)/mkgraph.c

mkinc.o: $(SD)/mkinc.c $(SD)/lattice.h $(MtxH)
	$(CCOMP) $(SD)/mkinc.c

mksub.o: $(SD)/mksub.c $(SD)/lattice.h $(MtxH)
	$(CCOMP) $(SD)/mksub.c

# Meat-Axe programs
# ----------------- 

zad: $(SD)/zad.c $(LIBMTX)
	echo $(LDIR)
	$(BUILD) $(LIBMTX)

zbl: $(SD)/zbl.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zcf: $(SD)/zcf.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zcl: $(SD)/zcl.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zcp: $(SD)/zcp.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zct: $(SD)/zct.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zcv: $(SD)/zcv.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zef: $(SD)/zef.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zev: $(SD)/zev.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zfr: $(SD)/zfr.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

ziv: $(SD)/ziv.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zkd: $(SD)/zkd.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zmo: $(SD)/zmo.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zmu: $(SD)/zmu.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

znu: $(SD)/znu.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zor: $(SD)/zor.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zpc: $(SD)/zpc.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zpr: $(SD)/zpr.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zpt: $(SD)/zpt.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zqt: $(SD)/zqt.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zsb: $(SD)/zsb.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zsi: $(SD)/zsi.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zsm: $(SD)/zsm.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zsp: $(SD)/zsp.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zsy: $(SD)/zsy.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

ztc: $(SD)/ztc.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zte: $(SD)/zte.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

ztm: $(SD)/ztm.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

ztr: $(SD)/ztr.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zuk: $(SD)/zuk.c $(LIBMTX)
	$(BUILD) $(LIBMTX)

zvp: $(SD)/zvp.c $(LIBMTX)
	$(BUILD) $(LIBMTX)



################################################################
#
#   Lattice package
#
################################################################

OBJ1=files.o chop.o $(LIBMTX)
OBJ3=files.o pwkond.o $(LIBMTX)
OBJ4=files.o mkcycl.o $(LIBMTX)
OBJ5=files.o mkinc.o $(LIBMTX)
OBJ5a=files.o mkdotl.o $(LIBMTX)
OBJ6=mksub.o files.o $(LIBMTX)
OBJ7=genmod.o files.o $(LIBMTX)

# -------------------------------
# Rules for building the programs
# -------------------------------

lattice: $(LPROGS) $(MAKETAB)

chop: $(OBJ1)
	$(CC) $(CFLAGS) -o chop $(OBJ1) $(LLIBS)

pwkond: $(OBJ3)
	$(CC) $(CFLAGS) -o pwkond $(OBJ3) $(LLIBS)

mkcycl: $(OBJ4)
	$(CC) $(CFLAGS) -o mkcycl $(OBJ4) $(LLIBS)

mkdotl: $(OBJ5a)
	$(CC) $(CFLAGS) -o mkdotl $(OBJ5a) $(LLIBS)

mkinc: $(OBJ5)
	$(CC) $(CFLAGS) -o mkinc $(OBJ5) $(LLIBS)

mksub: $(OBJ6)
	$(CC) $(CFLAGS) -o mksub $(OBJ6) $(LLIBS)

genmod: $(OBJ7)
	$(CC) $(CFLAGS) -o genmod $(OBJ7) $(LLIBS)

mkgraph: mkgraph.o files.o $(LIBMTX)
	$(CC) $(CFLAGS) -o mkgraph mkgraph.o files.o $(LIBMTX) $(LLIBS) 

# -------------------------------------------------

