# File:  Makefile

#
# Builds a executable target in the platform specific bin directory...
#
#----------------------------------------------------------------------------
# Project specific path defintions.
#----------------------------------------------------------------------------
INSTALLDIR  = ../lib
LIBINCLDIR  = ../include

PROJDIR    = .

SRC        = $(PROJDIR)/src
INCL       = $(PROJDIR)/include
OBJ        = $(PROJDIR)/obj
BIN        = $(PROJDIR)/bin
LIB        = $(PROJDIR)/lib
TESTDIR    = $(PROJDIR)/test
#----------------------------------------------------------------------------
# LINCLUDES and LDEFINES are appended to CFLAGS and C++FLAGS
#----------------------------------------------------------------------------
LDEFINES    = -DNO_RANGE_CHECK  
LINCLUDES      =  -I$(INCL) -I$(LIBINCLDIR) 

#----------------------------------------------------------------------------
# Include the appropriate compiler/platform definitions ...
#----------------------------------------------------------------------------
include ../etc/Makefile.platform

YACCFLAGS1     = $(YACCFLAGS) -p cifparser_
LEXFLAGS1      = $(LEXFLAGS) -Pcifparser_ 

YACCFLAGS2     = $(YACCFLAGS) -p ddlparser_
LEXFLAGS2      = $(LEXFLAGS) -Pddlparser_ 

YACCFLAGS3     = $(YACCFLAGS) -p dicparser_
LEXFLAGS3      = $(LEXFLAGS) -Pdicparser_ 
#----------------------------------------------------------------------------
#  Target definitions.
#----------------------------------------------------------------------------

TARGET1       = $(BIN)/FOtest1
TARGET2       = $(BIN)/FOtest2
TARGET3       = $(BIN)/FOtest3
TARGET4       = $(BIN)/FOtest4
TARGET5       = $(BIN)/FOtest5
TARGET6       = $(BIN)/FOtest6
TARGET7       = $(BIN)/FOtest7
TARGET8       = $(BIN)/FOtest8
TARGET9       = $(BIN)/FOtest9
TARGET10      = $(BIN)/FOtest10
TARGET11       = $(BIN)/FOtest11
TARGET12       = $(BIN)/FOtest12
TARGET13       = $(BIN)/FOtest13
TARGET14       = $(BIN)/FOtest14
TARGET15       = $(BIN)/FOtest15
TARGET16       = $(BIN)/DataChecking
TARGET17       = $(BIN)/checkdictionary
TARGET18       = $(BIN)/selective-reading
TARGET19       = $(BIN)/BigCifTest


FILEOBJLIB = $(LIB)/libciffileobj.a
LIBCIFBUILD= $(INSTALLDIR)/libcifobj.a

ALLTARGETS =  $(OBJS) $(FILEOBJLIB)  $(TARGET1) $(TARGET2)\
	$(TARGET3) $(TARGET4) $(TARGET5) $(TARGET6) \
	$(TARGET7) $(TARGET8) $(TARGET9) $(TARGET10) \
        $(TARGET11) $(TARGET12) $(TARGET13) $(TARGET14) \
        $(TARGET15) $(TARGET16)  $(TARGET17) $(TARGET18) \
	$(TARGET19)


#
#      List of source files
#

SRCFILES = $(SRC)/TblFileObj.C\
         $(SRC)/CifFileObjBase.C \
         $(SRC)/CifFileReadDef.C \
         $(SRC)/CifScanner.l \
         $(SRC)/CifScanner.C \
         $(SRC)/CifScannerBase.C \
         $(SRC)/CifParser.y \
         $(SRC)/CifParser.C \
         $(SRC)/CifParserBase.C \
         $(SRC)/CifFileObj.C \
         $(SRC)/DDLScanner.l \
         $(SRC)/DDLScanner.C \
         $(SRC)/DDLScannerBase.C \
         $(SRC)/DDLFileObj.C \
         $(SRC)/DDLParser.y \
         $(SRC)/DDLParser.C \
         $(SRC)/DDLParserBase.C \
         $(SRC)/DICScanner.l \
         $(SRC)/DICScanner.C \
         $(SRC)/DICScannerBase.C \
         $(SRC)/DICFileObj.C \
         $(SRC)/DICParser.y \
         $(SRC)/DICParser.C \
         $(SRC)/DICParserBase.C

TARGETSRC = $(SRC)/FOtest1.C \
				$(SRC)/FOtest2.C \
				$(SRC)/FOtest3.C \
				$(SRC)/FOtest4.C \
				$(SRC)/FOtest5.C \
				$(SRC)/FOtest6.C \
				$(SRC)/FOtest7.C \
				$(SRC)/FOtest8.C \
				$(SRC)/FOtest9.C \
				$(SRC)/FOtest10.C \
				$(SRC)/FOtest11.C \
				$(SRC)/FOtest12.C \
				$(SRC)/FOtest13.C \
				$(SRC)/FOtest14.C \
				$(SRC)/FOtest15.C \
				$(SRC)/DataChecking.C \
				$(SRC)/checkdictionary.C \
				$(SRC)/selective-reading.C \
				$(SRC)/BigCifTest.C


TESTFILES = $(TESTDIR)/ADH041.cif \
				$(TESTDIR)/ddl-mm \
				$(TESTDIR)/dictionary.dic \
				$(TESTDIR)/ndb_ddl \
				$(TESTDIR)/ndb_dictionary.dic \
				$(TESTDIR)/infile01.db \
				$(TESTDIR)/infile02.db \
				$(TESTDIR)/Test1.cif \
				$(TESTDIR)/Test2.cif \
				$(TESTDIR)/Test3.cif \
				$(TESTDIR)/Test14.cif \
				$(TESTDIR)/view1.cif

#
#      List of header and object files
#

HFILES = $(INCL)/TblFileObj.h \
         $(INCL)/CifFileObjBase.h \
         $(INCL)/CifFileReadDef.h \
         $(INCL)/CifScannerBase.h \
         $(INCL)/CifScannerInt.h \
         $(INCL)/CifParserBase.h \
         $(INCL)/CifParserInt.h \
         $(INCL)/CifFileObj.h \
         $(INCL)/DDLScannerBase.h \
         $(INCL)/DDLScannerInt.h \
         $(INCL)/DDLFileObj.h \
         $(INCL)/DDLParserBase.h \
         $(INCL)/DDLParserInt.h \
         $(INCL)/DICScannerBase.h \
         $(INCL)/DICScannerInt.h \
         $(INCL)/DICFileObj.h \
         $(INCL)/DICParserBase.h \
         $(INCL)/DICParserInt.h

OBJS  = $(OBJ)/TblFileObj.o \
	$(OBJ)/CifFileObjBase.o \
	$(OBJ)/CifFileReadDef.o \
	$(OBJ)/CifParser.o \
	$(OBJ)/CifParserBase.o \
        $(OBJ)/CifScanner.o \
	$(OBJ)/CifScannerBase.o \
	$(OBJ)/DDLParser.o \
	$(OBJ)/DDLParserBase.o \
        $(OBJ)/DDLScanner.o \
	$(OBJ)/DDLScannerBase.o \
	$(OBJ)/DICParser.o \
	$(OBJ)/DICParserBase.o \
        $(OBJ)/DICScanner.o \
	$(OBJ)/DICScannerBase.o \
	$(OBJ)/CifFileObj.o \
        $(OBJ)/DDLFileObj.o \
        $(OBJ)/DICFileObj.o 

OBJ1 = $(OBJ)/FOtest1.o
OBJ2 = $(OBJ)/FOtest2.o
OBJ3 = $(OBJ)/FOtest3.o
OBJ4 = $(OBJ)/FOtest4.o
OBJ5 = $(OBJ)/FOtest5.o
OBJ6 = $(OBJ)/FOtest6.o
OBJ7 = $(OBJ)/FOtest7.o
OBJ8 = $(OBJ)/FOtest8.o
OBJ9 = $(OBJ)/FOtest9.o
OBJ10 = $(OBJ)/FOtest10.o
OBJ11 = $(OBJ)/FOtest11.o
OBJ12 = $(OBJ)/FOtest12.o
OBJ13 = $(OBJ)/FOtest13.o
OBJ14 = $(OBJ)/FOtest14.o
OBJ15 = $(OBJ)/FOtest15.o
OBJ16 = $(OBJ)/DataChecking.o
OBJ17 = $(OBJ)/checkdictionary.o
OBJ18 = $(OBJ)/selective-reading.o
OBJ19 = $(OBJ)/BigCifTest.o

CIFLIB = $(INSTALLDIR)/libcifstr.a
CIFOBJCLIB = $(INSTALLDIR)/libcifobj.a $(INSTALLDIR)/libistable.a \
             $(INSTALLDIR)/libregex.a  $(INSTALLDIR)/libtblindex.a \
	     $(INSTALLDIR)/libndbmisc.a
#
#      targets
#

all: $(FILEOBJLIB) $(ALLTARGETS) $(CIFLIB) $(CIFOBJCLIB)
#

$(FILEOBJLIB): $(OBJS) 
	$(AR) $(AR_PUTFLAGS) $(FILEOBJLIB) $(OBJS)
	$(RANLIB) $(FILEOBJLIB)
	@echo $(FILEOBJLIB) " is up to date."

$(TARGET1): $(OBJ1) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ1) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET2): $(OBJ2) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ2) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET3): $(OBJ3) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ3) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LIBCIFBUILD) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET4): $(OBJ4) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ4) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LIBCIFBUILD) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET5): $(OBJ5) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ5) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LIBCIFBUILD) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET6): $(OBJ6) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ6) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET7): $(OBJ7) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ7) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET8): $(OBJ8) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ8) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET9): $(OBJ9) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ9) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET10): $(OBJ10) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(FILEOBJLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ10) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET11): $(OBJ11) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ11) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET12): $(OBJ12) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ12) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET13): $(OBJ13) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ13) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET14): $(OBJ14) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ14) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET15): $(OBJ15) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ15) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET16): $(OBJ16) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ16) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET17): $(OBJ17) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ17) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET18): $(OBJ18) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ18) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)

$(TARGET19): $(OBJ19) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(HFILES)
	$(CCC) $(C++FLAGS) -o $@  $(OBJ19) $(OBJS) $(CIFLIB) $(CIFOBJCLIB) $(LDFLAGS) -lm $(MALLOCLIB)


#
#      making object files
#

$(OBJ)/FOtest1.o: $(SRC)/FOtest1.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest1.C -o $@

$(OBJ)/FOtest2.o: $(SRC)/FOtest2.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest2.C -o $@

$(OBJ)/FOtest3.o: $(SRC)/FOtest3.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest3.C -o $@

$(OBJ)/FOtest4.o: $(SRC)/FOtest4.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest4.C -o $@

$(OBJ)/FOtest5.o: $(SRC)/FOtest5.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest5.C -o $@

$(OBJ)/FOtest6.o: $(SRC)/FOtest6.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest6.C -o $@

$(OBJ)/FOtest7.o: $(SRC)/FOtest7.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest7.C -o $@

$(OBJ)/FOtest8.o: $(SRC)/FOtest8.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest8.C -o $@

$(OBJ)/FOtest9.o: $(SRC)/FOtest9.C $(HFILES)
	$(CCC) -g $(C++FLAGS) -c $(SRC)/FOtest9.C -o $@

$(OBJ)/FOtest10.o: $(SRC)/FOtest10.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest10.C -o $@

$(OBJ)/FOtest11.o: $(SRC)/FOtest11.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest11.C -o $@

$(OBJ)/FOtest12.o: $(SRC)/FOtest12.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest12.C -o $@

$(OBJ)/FOtest13.o: $(SRC)/FOtest13.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest13.C -o $@

$(OBJ)/FOtest14.o: $(SRC)/FOtest14.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest14.C -o $@

$(OBJ)/FOtest15.o: $(SRC)/FOtest15.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/FOtest15.C -o $@

$(OBJ)/DataChecking.o: $(SRC)/DataChecking.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/DataChecking.C -o $@

$(OBJ)/checkdictionary.o: $(SRC)/checkdictionary.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/checkdictionary.C -o $@

$(OBJ)/selective-reading.o: $(SRC)/selective-reading.C $(HFILES)
	$(CCC) $(C++FLAGS) -c $(SRC)/selective-reading.C -o $@

$(OBJ)/BigCifTest.o: $(SRC)/BigCifTest.C $(HFILES)
	$(CCC) -g $(C++FLAGS) -c $(SRC)/BigCifTest.C -o $@


$(OBJ)/TblFileObj.o: $(SRC)/TblFileObj.C $(INCL)/TblFileObj.h
	$(CCC) $(C++FLAGS) -c $(SRC)/TblFileObj.C -o $@

$(OBJ)/CifFileObjBase.o: $(SRC)/CifFileObjBase.C $(INCL)/CifFileObjBase.h
	$(CCC) $(C++FLAGS) -c $(SRC)/CifFileObjBase.C -o $@

$(OBJ)/CifFileReadDef.o: $(SRC)/CifFileReadDef.C $(INCL)/CifFileReadDef.h
	$(CCC) $(C++FLAGS) -c $(SRC)/CifFileReadDef.C -o $@

$(OBJ)/CifFileObj.o: $(SRC)/CifFileObj.C $(INCL)/CifFileObj.h
	$(CCC) $(C++FLAGS) -c $(SRC)/CifFileObj.C -o $@

$(OBJ)/DDLFileObj.o: $(SRC)/DDLFileObj.C $(INCL)/DDLFileObj.h
	$(CCC) $(C++FLAGS) -c $(SRC)/DDLFileObj.C -o $@

$(OBJ)/DICFileObj.o: $(SRC)/DICFileObj.C $(INCL)/DICFileObj.h
	$(CCC) $(C++FLAGS) -c $(SRC)/DICFileObj.C -o $@

# parsers

$(OBJ)/CifParser.o : $(SRC)/CifParser.y
	@sh -c 'cd $(SRC); $(YACC) $(YACCFLAGS1) ./CifParser.y'
	mv $(SRC)/CifParser.tab.c $(SRC)/CifParser.C
	mv $(SRC)/CifParser.tab.h $(SRC)/CifParser.h
	$(CCC) $(C++FLAGS_RELAXED)  -c $(SRC)/CifParser.C  -o $@ 

$(OBJ)/CifScanner.C :  $(SRC)/CifScanner.l
	$(LEX) $(LEXFLAGS1) -t  $(SRC)/CifScanner.l > $(SRC)/CifScanner.C

$(OBJ)/CifScanner.o :  $(SRC)/CifScanner.l
	$(LEX) $(LEXFLAGS1) -t  $(SRC)/CifScanner.l > $(SRC)/CifScanner.C
	$(CCC) $(C++FLAGS_RELAXED) -c $(SRC)/CifScanner.C -o $@ 

$(OBJ)/CifParserBase.o: $(SRC)/CifParserBase.C
	$(CCC) $(C++FLAGS) -c $(SRC)/CifParserBase.C -o $@

$(OBJ)/CifScannerBase.o: $(SRC)/CifScannerBase.C
	$(CCC) $(C++FLAGS) -c $(SRC)/CifScannerBase.C -o $@

$(OBJ)/DDLParser.o : $(SRC)/DDLParser.y
	@sh -c 'cd $(SRC); $(YACC) $(YACCFLAGS2) ./DDLParser.y'
	mv $(SRC)/DDLParser.tab.c $(SRC)/DDLParser.C
	mv $(SRC)/DDLParser.tab.h $(SRC)/DDLParser.h
	$(CCC) $(C++FLAGS_RELAXED)  -c $(SRC)/DDLParser.C  -o $@ 

$(OBJ)/DDLScanner.C :  $(SRC)/DDLScanner.l
	$(LEX) $(LEXFLAGS2) -t  $(SRC)/DDLScanner.l > $(SRC)/DDLScanner.C

$(OBJ)/DDLScanner.o :  $(SRC)/DDLScanner.l
	$(LEX) $(LEXFLAGS2) -t  $(SRC)/DDLScanner.l > $(SRC)/DDLScanner.C
	$(CCC) $(C++FLAGS_RELAXED) -c $(SRC)/DDLScanner.C -o $@ 

$(OBJ)/DDLParserBase.o: $(SRC)/DDLParserBase.C
	$(CCC) $(C++FLAGS) -c $(SRC)/DDLParserBase.C -o $@

$(OBJ)/DDLScannerBase.o: $(SRC)/DDLScannerBase.C
	$(CCC) $(C++FLAGS) -c $(SRC)/DDLScannerBase.C -o $@

$(OBJ)/DICParser.o : $(SRC)/DICParser.y
	@sh -c 'cd $(SRC); $(YACC) $(YACCFLAGS3) ./DICParser.y'
	mv $(SRC)/DICParser.tab.c $(SRC)/DICParser.C
	mv $(SRC)/DICParser.tab.h $(SRC)/DICParser.h
	$(CCC) $(C++FLAGS_RELAXED)  -c $(SRC)/DICParser.C  -o $@ 

$(OBJ)/DICScanner.C :  $(SRC)/DICScanner.l
	$(LEX) $(LEXFLAGS3) -t  $(SRC)/DICScanner.l > $(SRC)/DICScanner.C

$(OBJ)/DICScanner.o :  $(SRC)/DICScanner.l
	$(LEX) $(LEXFLAGS3) -t  $(SRC)/DICScanner.l > $(SRC)/DICScanner.C
	$(CCC) $(C++FLAGS_RELAXED) -c $(SRC)/DICScanner.C -o $@ 

$(OBJ)/DICParserBase.o: $(SRC)/DICParserBase.C
	$(CCC) $(C++FLAGS) -c $(SRC)/DICParserBase.C -o $@

$(OBJ)/DICScannerBase.o: $(SRC)/DICScannerBase.C
	$(CCC) $(C++FLAGS) -c $(SRC)/DICScannerBase.C -o $@

test:	all $(FILEOBJLIB) $(ALLTARGETS)
	@echo 'Running Test 1 ** Results stored in $(TESTDIR)' 
	@$(TARGET1) 2>&1 | tee $(TESTDIR)/test1.out
#
	@echo 'Running Test 2 ** Results stored in $(TESTDIR)' 
	@$(TARGET2) 2>&1 | tee $(TESTDIR)/test2.out
#
	@echo 'Running Test 3 ** Results stored in $(TESTDIR)' 
	@$(TARGET3) 2>&1 | tee $(TESTDIR)/test3.out
#
	@echo 'Running Test 4 ** Results stored in $(TESTDIR)' 
	@$(TARGET4) 2>&1 | tee $(TESTDIR)/test4.out
#
	@echo 'Running Test 5 ** Results stored in $(TESTDIR)' 
	@$(TARGET5) -f test/ADH041.cif -o test/Test5.ocif 2>&1 | tee $(TESTDIR)/test5.out
#
	@echo 'Running Test 6 ** Results stored in $(TESTDIR)' 
	@$(TARGET6) 2>&1 | tee $(TESTDIR)/test6.out
#
	@echo 'Running Test 7 ** Results stored in $(TESTDIR)' 
	@$(TARGET7) 2>&1 | tee $(TESTDIR)/test7.out
#
	@echo 'Running Test 8 ** Results stored in $(TESTDIR)' 
	@$(TARGET8) 2>&1 | tee $(TESTDIR)/test8.out
#
	@echo 'Running Test 9 ** Results stored in $(TESTDIR)' 
	@$(TARGET9) 2>&1 | tee $(TESTDIR)/test9.out
#
	@echo 'Running Test 10 ** Results stored in $(TESTDIR)' 
	@$(TARGET10) 2>&1 | tee $(TESTDIR)/test10.out
#
	@echo 'Running Test 11 ** Results stored in $(TESTDIR)' 
	@$(TARGET11) 2>&1 | tee $(TESTDIR)/test11.out
#
	@echo 'Running Test 12 ** Results stored in $(TESTDIR)' 
	@$(TARGET12) 2>&1 | tee $(TESTDIR)/test12.out
#
	@echo 'Running Test 13 ** Results stored in $(TESTDIR)' 
	@$(TARGET13) 2>&1 | tee $(TESTDIR)/test13.out
#
	@echo 'Running Test 14 ** Results stored in $(TESTDIR)' 
	@$(TARGET14) 2>&1 | tee $(TESTDIR)/test14.out
#
	@echo 'Running Test 15 ** Results stored in $(TESTDIR)' 
	@$(TARGET15) 2>&1 | tee $(TESTDIR)/test15.out
#
	@echo 'Running Test 16 ** Results stored in $(TESTDIR)' 
	@$(TARGET16) test/ADH041.cif 2>&1 | tee $(TESTDIR)/test16.out

	@mv -f *.log $(TESTDIR)

install: $(FILEOBJLIB)
	$(INSTALL) $(INSTALLOPTS) $(HFILES)     $(LIBINCLDIR)/.
	$(INSTALL) $(INSTALLOPTS) $(FILEOBJLIB) $(INSTALLDIR)/.

clean :
	@rm -f core $(OBJS)
	@rm -f $(OBJ)/*.o
	@rm -rf $(OBJ)/ii_files
	@rm -f CifParser.log 
	@rm -f $(ALLTARGETS)
	@rm -f $(FILEOBJLIB)
	@rm -f $(TESTDIR)/TESTFILE* $(TESTDIR)/*.ocif
#	@cd $(INSTALLDIR); rm -f $(FILEOBJLIB)
#	@cd $(LIBINCLDIR); rm -f $(HFILES)
	@cd ..; rm -f $(FILEOBJLIB)
	@cd ..; rm -f $(HFILES)
	@rm -rf Template.DB
	@rm -f $(SRC)/CifParser.C
	@rm -f $(SRC)/CifParser.h
	@rm -f $(SRC)/CifParser.output
	@rm -f $(SRC)/CifScanner.C
	@rm -f $(SRC)/DDLParser.C
	@rm -f $(SRC)/DDLParser.h
	@rm -f $(SRC)/DDLParser.output
	@rm -f $(SRC)/DDLScanner.C
	@rm -f $(SRC)/DICParser.C
	@rm -f $(SRC)/DICParser.h
	@rm -f $(SRC)/DICParser.output
	@rm -f $(SRC)/DICScanner.C


spotless: clean
#
export:
	mkdir -p $(EXPORT_DIR)
	@cd $(EXPORT_DIR); mkdir -p $(INCL)
	$(EXPORT) $(EXPORT_LIST) $(HFILES) $(EXPORT_DIR)/$(INCL)
	@cd $(EXPORT_DIR); mkdir -p $(SRC)
	$(EXPORT) $(EXPORT_LIST) $(SRCFILES) $(EXPORT_DIR)/$(SRC)
	$(EXPORT) $(EXPORT_LIST) $(TARGETSRC) $(EXPORT_DIR)/$(SRC)
	@cd $(EXPORT_DIR); mkdir -p $(TESTDIR)
	@cp $(TESTFILES) $(EXPORT_DIR)/$(TESTDIR)
	@cd $(EXPORT_DIR); mkdir -p $(BIN)
	@cd $(EXPORT_DIR); mkdir -p $(LIB)
	@cd $(EXPORT_DIR); mkdir -p $(OBJ)
	@cp Makefile $(EXPORT_DIR)