#################################################################
###
### Makefile for Singular
###
#################################################################

SHELL		= /bin/sh

##
## version
##
SINGULAR_VERSION	= @SINGULAR_VERSION@
SINGULAR		= @SINGULAR@
SINGUNAME		= @SINGUNAME@
EXEC_EXT		= @EXEC_EXT@
HAVE_PLURAL             = @PLURAL@

##
## Python related stuff
##
HAVE_PYTHON             = @HAVE_PYTHON_VALUE@
PYTHON_CPPFLAGS		= @PYTHON_CPPFLAGS@
PYTHON_MODULE_LIBS 	= @PYTHON_LDFLAGS@ @PYTHON_EXTRA_LIBS@
PYTHON_MODULE_LDFLAGS   = @PYTHON_MODULE_FLAGS@ @PYTHON_EXTRA_LDFLAGS@

MODULE_SUFFIX = so

ifdef LD_STATIC
PYTHON_LIBS = @PYTHON_STATIC_LIBS@
else
PYTHON_LIBS = @PYTHON_EMBED_LIBS@
ifeq (${HAVE_PYTHON},1)
PYOBJECT_MODULE = pyobject.${MODULE_SUFFIX}
endif 

endif

##
## various paths
##
top_srcdir	= @top_srcdir@
srcdir		= @srcdir@
prefix 		= @prefix@
exec_prefix 	= @exec_prefix@
libdir 		= @libdir@
# program executable goes here
bindir		= @bindir@
# includes are taken from here
includedir	= @includedir@
slibdir		= ${prefix}/LIB
install_bindir  = ${install_prefix}/${SINGUNAME}
install_slibdir = ${install_prefix}/LIB

##
## various programs
##
@SET_MAKE@
CC		= @CC@
LD              = @LD@
CXX		= @CXX@
LEX		= sh flexer.sh

PERL		= @PERL@
BISON		= bison
INSTALL		= @INSTALL@
INSTALL_PROGRAM	= @INSTALL_PROGRAM@
INSTALL_DATA	= @INSTALL_DATA@
MKINSTALLDIRS   = ./mkinstalldirs
LN_S		= @LN_S@

##
## compiler and linker options
##
PIPE		= @PIPE@
CFLAGS		= @CFLAGS@ ${PIPE}
CXXFLAGS	= @CXXFLAGS@ -I.. -I@prefix@ ${PIPE}
CXXTEMPLFLAGS	= @CXXTEMPLFLAGS@ -I.. -I@prefix@
ifneq ($(SINGUNAME),ix86-Win)
CPPFLAGS	= -I${srcdir} -I.. -I@prefix@ @CPPFLAGS@ @PYTHON_CPPFLAGS@
else
## Dirs after @CPPFLAGS@ are for PySingular
CPPFLAGS	= -I${srcdir} -I.. -I@prefix@ @CPPFLAGS@ @PYTHON_CPPFLAGS@
## -I/usr/include/python2.4 -I/usr/local/include -I../modules/python
endif
DEFS		= -DNDEBUG -DOM_NDEBUG -D@SING_UNAME@ @DEFS@
LDFLAGS2	= @LDFLAGS@
ifneq ($(SINGUNAME),ix86-Win)
LDFLAGS		= -L@prefix@/kernel -L../kernel -lkernel @LDFLAGS@ 
LDFLAGSG	= -L@prefix@/kernel -L../kernel -lkernel_g @LD_DYN_FLAGS1@ @LDFLAGS@ 
LDFLAGSP	= -L@prefix@/kernel -L../kernel -lkernel_p @LD_DYN_FLAGS1@ @LDFLAGS@ 
else
## -L/usr/local/lib -L@prefix@/modules/python --> PySingular
LDFLAGS		= -L@prefix@/kernel -L/bin -lkernel @LDFLAGS@ -L/usr/local/lib -L../modules/python 
LDFLAGSG	= -L@prefix@/kernel -L/bin -lkernel_g @LDFLAGS@ 
LDFLAGSP	= -L@prefix@/kernel -L/bin -lkernel_p @LDFLAGS@ 
endif
LD_DYN_FLAGS1	= @LD_DYN_FLAGS1@
LD_DYN_FLAGS2	= @LD_DYN_FLAGS2@
SFLAGS		= @SFLAGS@
SLDFLAGS	= @SLDFLAGS@

## For PYSingular
ifneq ($(SINGUNAME),ix86-Win)
WIN_LIBS        =
else
WIN_LIBS        = 
##../modules/python/libpython_module.a
endif

LD_LIBC	        = -lc
STATIC_LDFLAGS	= @STATIC_LDFLAGS@
# under cygwin, do not explicitly link against -lm, for it is the cygwin
# lib -- if you really want to do this, use -lm as the _last_ thing on the
# arguments to link
ifneq ($(SINGUNAME),ix86-Win)
## for cones & fans if not under Win OS:
## put "-lgfan -lcddgmp " behind "-lncurses" in next three lines
LIBS		= -lm @NEED_LIBS@
LIBSG		= -lm @NEED_LIBSG@
LIBSP		= -lm @NEED_LIBSG@
else
## for cones & fans if under Win OS:
## put "-lgfan -lcddgmp " before "-Xlinker" in definition of LIBS and LIBSG
LIBS		= -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -Xlinker -Bdynamic -lgmp -lomalloc_ndebug -lncurses
## -lpython_module -lpython2.4 /usr/local/lib/libboost_python-gcc-d-1_32.dll
LIBSG		= -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -Xlinker -Bdynamic -lgmp -lncurses
## with cdd and gfan: LIBSG		= -lsingfac -lsingcf -lntl  -static -lreadline -lhtmlhelp -lgfan -lcddgmp -Xlinker -Bdynamic -lgmp -lncurses
endif
MP_LIBS		= @MP_LIBS@
HAVE_MPSR       = @HAVE_MPSR@

#
# Handle libSINGULAR stuff
#
LIBSINGULAR_LIBS =-lsingfac -lsingcf -lntl -lreadline -lgmp -lomalloc

SO_SUFFIX = so

#LIBSINGULAR_FLAGS = -export-dynamic 
LIBSINGULAR_LD = $(CXX)

# correct suffix for dynamic linking
ifeq ($(SINGUNAME),ix86Mac-darwin)
SO_SUFFIX        = dylib
MODULE_SUFFIX    = bundle
LIBSINGULAR_FLAGS = -single_module
LIBSINGULAR_LD = $(LD)
endif

ifeq ($(SINGUNAME),x86_64Mac-darwin)
SO_SUFFIX        = dylib
MODULE_SUFFIX    = bundle
LIBSINGULAR_FLAGS = -single_module
LIBSINGULAR_LD = $(LD)
endif

ifeq ($(SINGUNAME),ppcMac-darwin)
MACOSX_DEPLOYMENT_TARGET=10.4
SO_SUFFIX        = dylib
MODULE_SUFFIX    = bundle
LIBSINGULAR_FLAGS = -single_module
LIBSINGULAR_LD = $(LD)
endif

ifeq ($(SINGUNAME),ix86-Win)
SO_SUFFIX = dll
MODULE_SUFFIX    = dll
LIBSINGULAR_FLAGS = -shared
LIBSINGULAR_LIBS = -lsingfac -lsingcf -lntl -lreadline -lgmp -lomalloc  -lhtmlhelp
endif

ifeq ($(SINGUNAME),ix86-SunOS)
SO_SUFFIX  = so
MODULE_SUFFIX    = so
LIBSINGULAR_FLAGS = -shared
LIBSINGULAR_LIBS = -lsingfac -lsingcf -lntl -lreadline -lgmp -lomalloc
endif

#
# End libSINGULAR
#

ifdef LD_STATIC
LDFLAGS  := ${STATIC_LDFLAGS} ${LDFLAGS}
SING_EXEC = Singular-static
LIBS := ${MP_LIBS} ${LIBS} ${PYTHON_LIBS}
LIBSG := ${MP_LIBS} ${LIBSG} ${PYTHON_LIBS}
DL_KERNEL =
GLIBC_DYN_FIX=
else
LDFLAGS  := ${LD_DYN_FLAGS1} ${LDFLAGS} ${LD_DYN_FLAGS2}
SING_EXEC = Singular
LIBS := ${LIBS} ${PYTHON_LIBS}
LIBSG := ${LIBSG} ${PYTHON_LIBS}
DL_KERNEL	= @DL_KERNEL@
GLIBC_DYN_FIX= @GLIBC_DYN_FIX@
endif


# CXXFLAGS =  -g -Wall -Wno-unused
# CFLAGS =  -g -Wall -Wno-unused
##
## End configuration dependend stuff
#################################################################

###
### file sets
###

# normal C++ source files
CXXSOURCES=grammar.cc scanner.cc attrib.cc \
    blackbox.cc eigenval_ip.cc\
    extra.cc fehelp.cc feOpt.cc \
    ipassign.cc ipconv.cc ipid.cc iplib.cc \
    ipprint.cc ipshell.cc \
    newstruct.cc lists.cc \
    sdb.cc \
    fglm.cc interpolation.cc\
    silink.cc ssiLink.cc \
    subexpr.cc \
    janet.cc wrapper.cc\
    libparse.cc sing_win.cc\
    gms.cc pcv.cc maps_ip.cc\
    walk.cc walk_ip.cc \
    cntrlc.cc misc_ip.cc \
    calcSVD.cc pipeLink.cc \
    Minor.cc \
    MinorProcessor.cc \
    MinorInterface.cc \
    bigintm.cc pyobject_setup.cc \
    bbcone.cc bbfan.cc denom_list.cc \
    minpoly.cc

# stuff for MP
MPSR_SOURCES = mpsr_Put.cc mpsr_PutPoly.cc mpsr_GetPoly.cc mpsr_sl.cc\
	mpsr_Get.cc mpsr_GetMisc.cc mpsr_Error.cc \


# stuff for dbm
DBMSR_SOURCES =  ndbm.cc sing_dbm.cc

# normal C source files
CSOURCES=

# C++ sources which are used if part of the kernel are dynamically linked
DL_KERNEL_SOURCES=slInit_Dynamic.cc 

# C++ sources which are used for dynamic libraries if part of the kernel is
# dynamically linked
DL_LIB_SOURCES= 

# C++ sources which are used if no parts of the kernel are dynamically linked
STATIC_SOURCES=slInit_Static.cc

# C++ sources for which both, shared and static object files are needed
COMMON_SOURCES = $(MPSR_SOURCES) $(DBMSR_SOURCES)

# special C++ source files (need extra compiling and/or linking), for which
# dependencies should be generated
ESOURCES=iparith.cc $(COMMON_SOURCES) \
	$(DL_KERNEL_SOURCES) $(DL_LIB_SOURCES) $(STATIC_SOURCES) 

SOURCES=${CSOURCES} ${CXXSOURCES} \
	grammar.y scanner.l libparse.l \
	utils.cc utils.h \
	tesths.cc mpsr_Tok.cc claptmpl.cc 

HEADERS=lists.h attrib.h \
	mpsr_Tok.h \
	ipconv.h newstruct.h \
	subexpr.h ipid.h \
	cntrlc.h ipprint.h sdb.h \
	ipshell.h tok.h \
	silink.h ssiLink.h \
	sing_dbm.h maps_ip.h interpolation.h \
	mpsr.h mpsr_sl.h\
	mpsr_Get.h janet.h\
	mpsr_Put.h walk.h\
	dbm_sl.h libparse.h pipeLink.h \
	gms.h pcv.h eigenval_ip.h blackbox.h \
	distrib.h walk.h \
        static.h \
        omSingularConfig.h

DISTFILES=${SOURCES} ${HEADERS} ${ESOURCES} \
        Makefile.in configure.in configure \
	mod2.h.in grammar.h testgh install-sh mkinstalldirs

OBJS := $(CXXSOURCES:.cc=.o) $(CSOURCES:.c=.o)

ifeq ($(SINGUNAME),ix86-Win)
OBJS := $(OBJS) Singular_res.o
endif

P_PROCS_MODULES = FieldZp FieldIndep FieldQ FieldGeneral

ifeq ($(DL_KERNEL),1)
OBJS 	:= $(OBJS) $(DL_KERNEL_SOURCES:.cc=.o)
DBMSR_SO= dbmsr.so
DL_LIBS := $(DBMSR_SO) ${PYOBJECT_MODULE}
ifeq ($(HAVE_MPSR), 1)
MPSR_SO	=	mpsr.so
DL_LIBS := 	$(DL_LIBS) $(MPSR_SO) ${PYOBJECT_MODULE}
endif
else
ifndef LD_STATIC
ifeq ($(HAVE_MPSR), 1)
LIBS := $(MP_LIBS) $(LIBS)
LIBSG := $(MP_LIBS) $(LIBSG)
endif
endif
OBJS := $(OBJS) $(STATIC_SOURCES:.cc=.o) $(COMMON_SOURCES:.cc=.o)
OBJSG := $(OBJSG) $(STATIC_SOURCES:.cc=.og) $(COMMON_SOURCES:.cc=.og)
DL_LIBS=
endif


#
# Singular libraries which go into distribution
# MAKE SURE THAT THIS IS UP_TO_DATE
#
include singular-libs

ifdef HAVE_PLURAL
SLIBS = COPYING ${SLIB0} ${SLIB1} ${PLIBS} all.lib help.cnf
else
SLIBS = COPYING ${SLIB0} ${SLIB1} all.lib help.cnf
endif

SLIBS_FILES = $(addprefix LIB/,${SLIBS})

GFTABLES = $(wildcard LIB/gftables/[1-9]*)

##
## Build Targets
##
.l.cc:
	@if test -r scanner.cc; then \
		touch scanner.cc ;\
	elif test "x${LEX}" = x; then \
		echo Error: no lex given, could not rebuilt scanner.cc;\
                exit 1; \
	fi
	${LEX} -s -I -t $< > scanner.cc.lmp
	cp scanner.cc.lmp scanner.cc

.y.cc:
	@if test -r grammar.cc; then \
		touch grammar.cc ;\
	else \
	if test "x${BISON}" = x; then \
		echo Error: no bison given, could not rebuilt grammar.cc;\
                exit 1; \
	fi;\
	${BISON} -d -t -o grammar.cc $<;\
	chmod +x testgh;\
	./testgh;\
	fi

.cc.o:	
	${CXX} ${CXXFLAGS} ${CXXTEMPLFLAGS} ${CPPFLAGS} ${DEFS} -c $<
.c.o:
	${CC} ${CFLAGS} ${CPPFLAGS} ${DEFS} -c $<

%.dl_o : %.cc
	${CXX} ${CXXFLAGS} ${CXXTEMPLFLAGS} ${CPPFLAGS} ${DEFS} ${SFLAGS} -c $< -o $@

all:	$(SING_EXEC)

Singular-static: version.h
	sleep 1
	echo "#define HAVE_STATIC" > static.h
	(cd ../kernel;rm -f mod_raw.o;${MAKE} LD_STATIC=1 depend install-bindist;cd ../Singular)
	${MAKE} LD_STATIC=1 S_EXT="-static" depend
	${MAKE} LD_STATIC=1 S_EXT="-static" Singular-static
	echo "#undef HAVE_STATIC" > static.h

Singular${S_EXT}: mod2.h Makefile version.h $(WIN_LIBS) scanner.cc  ${OBJS} \
          iparith.o tesths.cc libparse.cc claptmpl.o mpsr_Tok.o $(DL_LIBS) 
	${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} \
	  -o Singular${S_EXT} \
	  tesths.cc iparith.o mpsr_Tok.o claptmpl.o\
	  ${OBJS} ${LDFLAGS} ${LIBS} ../kernel/mmalloc.o 

libsingular: mod2.h Makefile version.h $(WIN_LIBS) scanner.cc  ${OBJS} \
         iparith.o libparse.cc claptmpl.o mpsr_Tok.o $(DL_LIBS) 
	$(LIBSINGULAR_LD) ${SLDFLAGS} ${LIBSINGULAR_FLAGS} -o libsingular.${SO_SUFFIX} \
	iparith.o mpsr_Tok.o claptmpl.o \
	${OBJS} -lkernel -L../kernel -L../factory -L../libfac -L${libdir} ${LIBSINGULAR_LIBS}

libsingular.a: mod2.h Makefile version.h $(WIN_LIBS) scanner.cc  ${OBJS} \
         iparith.o libparse.cc claptmpl.o mpsr_Tok.o
	mkdir libsingular.tmp
	(cd  libsingular.tmp; \
	ar x ../../kernel/libkernel.a; \
	ar x ../../$(SINGUNAME)/lib/libsingfac.a; \
	ar x ../../$(SINGUNAME)/lib/libsingcf.a; \
	ar x ../../$(SINGUNAME)/lib/libntl.a; \
	ar x ../../$(SINGUNAME)/lib/libomalloc.a; \
	cd ..)
	ar cr libsingular.a \
	iparith.o mpsr_Tok.o claptmpl.o \
	${OBJS} libsingular.tmp/* 
	rm -rf libsingular.tmp

../modules/python/libpython_module.a:
	cd ../modules/python; scons

%.static: version.h
	${MAKE} DL_KERNEL=0 S_EXT=".static" $@

iparith.o mpsr_Tok.o : iparith.inc mpsr_Tok.inc

cntrlc.o cntrlc.og : feOptES.inc feOptTS.inc feOpt.inc version.h

misc_ip.o emacs.o tesths.o: version.h

claptmpl.o: claptmpl.cc mod2.h
	${CXX} ${CXXFLAGS}  ${CPPFLAGS} ${DEFS} -c $<

iparith.inc: gentable.cc grammar.h tok.h table.h mod2.h
	 ${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} gentable.cc \
	     -o gentable1
	./gentable1
	/bin/rm -f gentable1 gentable1.exe

mpsr_Tok.inc: gentable2.cc grammar.h tok.h table.h mod2.h
	${CXX} ${CXXFLAGS} ${CPPFLAGS} ${CXXTEMPLFLAGS} ${DEFS} gentable2.cc \
	     -o gentable2
	./gentable2
	/bin/rm -f gentable2 gentable2.exe


svnver: 
	svnversion >svnver

version.h: ${SOURCES} ${HEADERS} Makefile.in mod2.h.in \
           configure.in svnver
	echo "#define feVersionId \""  `cat svnver` "\"" >version.h
	echo "#define CC \"" ${CC} ${CFLAGS} ${DEFS}"\"" >>version.h
	echo "#define CXX \"" ${CXX} ${CXXFLAGS} ${DEFS} "\"" >>version.h

libparse: libparse_main.o utils.o
	${CXX}  ${CPPFLAGS} -DSTANDALONE_PARSER -o libparse libparse_main.o utils.o ../kernel/fegetopt.o ${LDFLAGS2} -lomalloc

libparse_main.o: libparse.cc
	${CXX} ${CPPFLAGS} -c -o libparse_main.o libparse.cc  -DSTANDALONE_PARSER

utils.o: utils.cc
	${CXX} ${CPPFLAGS} -c -o utils.o utils.cc  -DSTANDALONE_PARSER

libparse.cc: libparse.l
	@if test "x${LEX}" = x; then \
		echo Error: no lex given, could not rebuilt libparse.cc;\
                exit 1; \
	fi
	${LEX} -I -Pyylp -t libparse.l >libparse.cc.lmp
	cp libparse.cc.lmp libparse.cc

# Hmm compiling with -fomit-frame-pointer resulted in access violation
# under cygwin
ESingular: mod2.h feOpt.cc version.h emacs.cc \
           feOptES.inc
	${CXX} -O2 ${CPPFLAGS} ${DEFS} -DESINGULAR -DPROTO -o ESingular emacs.cc ../kernel/fegetopt.o \
	${LDFLAGS} ${LIBS} ../kernel/mmalloc.o

TSingular: mod2.h feOpt.cc version.h emacs.cc \
           feOptTS.inc
	${CXX} -O2 ${CPPFLAGS} ${DEFS} -DTSINGULAR -DPROTO -o TSingular emacs.cc ../kernel/fegetopt.o \
	${LDFLAGS} ${LIBS} ../kernel/mmalloc.o

feOpt.o: feOpt.inc feOptES.inc feOptTS.inc
extra.o: feOpt.inc

feOpt.inc: feOpt.cc mod2.h
	$(CXX) $(CXXFLAGS) -DGENERATE_OPTION_INDEX ${CPPFLAGS} feOpt.cc -o feOpt
	./feOpt
	/bin/rm -f feOpt feOpt.exe

feOptES.inc: feOpt.cc mod2.h
	$(CXX) $(CXXFLAGS) -DGENERATE_OPTION_INDEX  -DESINGULAR -I../kernel feOpt.cc -o feOptES
	./feOptES
	rm -f feOptES feOptES.exe

feOptTS.inc: feOpt.cc mod2.h
	$(CXX) $(CXXFLAGS) -DGENERATE_OPTION_INDEX  -DTSINGULAR -I../kernel feOpt.cc -o feOptTS
	./feOptTS
	rm -f feOptTS feOptTS.exe

mpsr.so: $(MPSR_SOURCES:.cc=.dl_o)
	$(LD) ${SLDFLAGS} -o $@ $^ -L${libdir} ${MP_LIBS} ${GLIBC_DYN_FIX}

dbmsr.so: $(DBMSR_SOURCES:.cc=.dl_o)
	$(LD) ${SLDFLAGS} -o $@ $^ ${GLIBC_DYN_FIX}

# dynamic module for python bject support
pyobject.${MODULE_SUFFIX}: pyobject.dl_o
	@echo "build dynamic module pyobject..."
	$(CXX) $^ ${PYTHON_MODULE_LDFLAGS} ${SLDFLAGS} ${PYTHON_MODULE_LIBS} ${LD_LIBC} -o $@

src: scanner.cc grammar.h grammar.cc libparse.cc

mod2.h: stamp-h

stamp-h : config.status mod2.h.in
	CONFIG_FILES= CONFIG_HEADERS="mod2.h" ./config.status

Makefile: Makefile.in config.status
	CONFIG_FILES="Makefile" CONFIG_HEADERS= ./config.status

config.status: configure
	./config.status --recheck

configure: configure.in
	@echo "WARNING: You need to rerun autoconf. I am proceeding, for now."
	@touch configure
#	autoconf

ifeq ($(SINGUNAME),ix86-Win)
##
## windows only targets
##

## resources
Singular.rc: Singular.rc.in config.status
	CONFIG_FILES="Singular.rc" CONFIG_HEADERS= ./config.status

ESingular_res.o: Singular.rc
	windres -DESINGULAR -i Singular.rc -o ESingular_res.o

TSingular_res.o: Singular.rc
	windres -DTSINGULAR -i Singular.rc -o TSingular_res.o

Singular_res.o: Singular.rc
	windres -DSINGULAR -i Singular.rc -o Singular_res.o

## run
run.o: run.c run.h
	gcc -c -I. -O2 run.c -o run.o

runTSingular : run.o TSingular_res.o
	gcc -mwindows run.o TSingular_res.o -o runTSingular.exe
#	gcc -mwindows -e _mainCRTStartup run.o TSingular_res.o -o runTSingular.exe

runESingular : run.o ESingular_res.o
	gcc -mwindows run.o ESingular_res.o -o runESingular.exe
#	gcc -mwindows -e _mainCRTStartup run.o ESingular_res.o -o runESingular.exe

RUN_SINGULARS=runESingular runTSingular

endif

##
## install targets
##
install: all installbin installslib

install_all: install

install-nolns: all installbin-nolns installslib-nolns

installbin: ${SING_EXEC} libparse ESingular TSingular ${RUN_SINGULARS}
	${MKINSTALLDIRS} ${bindir}
	${INSTALL_PROGRAM} ${SING_EXEC} ${SINGULAR}
	-for file in *.so; do \
	  ${INSTALL_PROGRAM} $$file ${bindir}; \
	done
	${INSTALL_PROGRAM} libparse ${RUN_SINGULARS} ${bindir}
	${INSTALL_PROGRAM} ESingular TSingular ${bindir}
	${INSTALL_PROGRAM} surfex ${bindir}
	chmod a+x ${SINGULAR}
	rm -f ${bindir}/${SING_EXEC}${EXEC_EXT}
	cd ${bindir}; ${LN_S} ${SINGULAR} Singular${EXEC_EXT};

installbin-nolns: ${SING_EXEC} libparse ESingular TSingular ${RUN_SINGULARS}
	${MKINSTALLDIRS} ${bindir}
	${INSTALL_PROGRAM} ${SING_EXEC} ${SINGULAR}
	-for file in *.so; do \
	  ${INSTALL_PROGRAM} $$file ${bindir}; \
	done
	${INSTALL_PROGRAM} libparse ${RUN_SINGULARS} ${bindir}
	${INSTALL_PROGRAM} ESingular TSingular ${DL_LIBS} ${bindir}
	chmod a+x ${SINGULAR}
	rm -f ${bindir}/${SING_EXEC}${EXEC_EXT}
	${INSTALL_PROGRAM} ${SINGULAR} ${bindir}/Singular${EXEC_EXT};

installslib: LIB
	test -r ${slibdir} || ${LN_S} `pwd`/LIB ${slibdir}

installslib-nolns: LIB
	${MKINSTALLDIRS} ${slibdir}
	for file in `pwd`/LIB/*.lib; do \
	  ${INSTALL_DATA}  $$file ${slibdir}; \
	done
	${MKINSTALLDIRS} ${slibdir}/gftables
	for file in `pwd`/LIB/gftables/*; do \
	  ${INSTALL_DATA}  $$file ${slibdir}/gftables/; \
	done

install-libsingular: libsingular
	${MKINSTALLDIRS} ${includedir}/singular
	for file in *.$(SO_SUFFIX); do \
	  ${INSTALL_PROGRAM}  $$file ${libdir}; \
	done
	${INSTALL_PROGRAM} libsingular.h ${includedir}
	for file in subexpr.h tok.h grammar.h ipid.h lists.h ipshell.h attrib.h; do \
	sed -e "s:<kernel/:<singular/:" < $$file |sed -e "s:<Singular/:<singular/:"|sed -e "s:<omalloc/:<:"|sed -e "s:<factory/:<:" >${includedir}/singular/$$file ;\
	done

uninstall: uninstallbin

uninstallbin:
	rm -f ${bindir}/Singular${EXEC_EXT} 
	rm -f ${SINGULAR}
	-rmdir ${bindir}

##
## clean targest
##
mostlyclean: 
	-rm -f Singular Singular-static Singularg Singularp libparse feOpt*.inc
	-rm -f *.o *.og core *.op *.so* *.dl_o*
	-rm -f ESingular* TSingular*

clean: mostlyclean
	-rm -f *.bak *.d *.dd depend 
	-rm -f ${slibdir}

distclean: clean
	-rm -f iparith.inc mpsr_Tok.inc stamp.h 
	-rm -f Singular Singular[gp]* *.gprof *~ .\#* version.h
	rm -f plural_cmd.inc
	-rm -f mod2.h Makefile TAGS* tags config.status config.cache config.log

srcclean:
	@echo "This command is intended for maintainers to use;"
	@echo "Rebuilding the deleted files requires flex"
	@echo "bison, perl"
	-rm -f scanner.cc grammar.h grammar.cc libparse.cc

maintainer-clean: distclean srcclean
	@echo "This command is intended for maintainers to use;"
	@echo "Rebuilding the deleted files requires flex"
	@echo "bison, perl and autoconf"
	-rm configure

##
## miscellanous targets
##
fehelp.o fehelp.og fehelp.op: feOpt.inc

LIB/all.lib:	LIB/all.lib.tmpl
	./make_alllib.sh LIB/all.lib.tmpl ${SLIB0} ${PLIBS}

install-bindist: $(HEADERS) $(SOURCES) Makefile depend
	echo "#define MAKE_DISTRIBUTION	" > distrib.h
	sleep 1
	${MAKE} ${SING_EXEC} ESingular TSingular libparse ${RUN_SINGULARS}
	${MKINSTALLDIRS} ${install_bindir} 
	${INSTALL_PROGRAM} ${SING_EXEC} ${install_bindir}/Singular
	-${INSTALL_PROGRAM} *.so ${install_bindir}
	${INSTALL_PROGRAM} -s  libparse ${RUN_SINGULARS} ESingular TSingular ${install_bindir}
	${INSTALL_PROGRAM} surfex ${install_bindir}
	echo "#undef MAKE_DISTRIBUTION " > distrib.h

install-sharedist: ${SLIBS_FILES} LIB/gftables
	${MKINSTALLDIRS} ${install_slibdir}
	cp ${SLIBS_FILES} ${install_slibdir}
	${MKINSTALLDIRS} ${install_slibdir}/gftables
	cp ${GFTABLES} ${install_slibdir}/gftables
	${MKINSTALLDIRS} ${install_slibdir}/surfex
	cp LIB/surfex/surfex.jar ${install_slibdir}/surfex
	chmod -R +rX ${install_slibdir}/*

tar:
	tar cf Singular-${SINGULAR_VERSION}-src.tar ${DISTFILES}
	gzip -f Singular-${SINGULAR_VERSION}-src.tar

backup: tar
	mcopy -o Singular-${SINGULAR_VERSION}-src.tar.gz a:

TAGS:   ${SOURCES} ${ESOURCES} ${HEADERS} 
	etags ${SOURCES} ${ESOURCES} ${HEADERS} ../kernel/*.[ch] ../kernel/*.cc ../kernel/*.inc


tags:   
	ctags *.y *.[lch] *.cc *.inc ../kernel/*.[ch] ../kernel/*.cc ../kernel/*.inc

echoLIBS:
	@echo ${SLIBS}

##
## Below here is stuff for developpers
#################################################################


##
## .og files for having -O and -g object versions available at the same time
##

OBJG1 := $(CXXSOURCES:.cc=.og) 
OBJG2 := $(CSOURCES:.c=.og) 

OBJG=$(OBJG1) $(OBJG2) 

DL_TAILG=\"sog\"


ifeq ($(DL_KERNEL),1)

OBJG := $(OBJG) $(DL_KERNEL_SOURCES:.cc=.og)
DL_LIBSG := $(MPSR_SO:%.so=%.sog) $(DBMSR_SO:%.so=%.sog)

else

OBJG := $(OBJG) $(STATIC_SOURCES:.cc=.og) $(COMMON_SOURCES:.cc=.og)
DL_LIBSG=

endif


##
## compiler and linker options for debug version
##

CCG		= ${CC}
CXXG		= ${CXX}
CXXM		= gcc -MM -MG -DGENERATE_DEPEND
CCM		= gcc -MM -MG -DGENERATE_DEPEND

CFLAGSG		= -g -Wall -Wno-unused ${PIPE}
CXXFLAGSG	= -g -Wall -Wno-unused ${PIPE}
CXXTEMPLFLAGSG	= -fno-implicit-templates
DEFSG		= -D@SING_UNAME@ @DEFS@ -DDL_TAIL=$(DL_TAILG)

##
## Debug Targets
##

%.dl_og: %.cc
	${CXXG} ${CXXFLAGSG} ${CXXTEMPLFLAGSG} ${CPPFLAGS} ${DEFSG} ${SFLAGS} -c $< -o $@

mpsr.sog: $(MPSR_SOURCES:.cc=.dl_og)
	${CXXG} ${CXXFLAGSG} ${SFLAGS} ${SLDFLAGS} ${LDFLAGS} -o $@ $^ ${MP_LIBS} ${GLIBC_DYN_FIX}

dbmsr.sog: $(DBMSR_SOURCES:.cc=.dl_og)
	${CXXG} ${CXXFLAGSG} ${SFLAGS} ${SLDFLAGS} ${LDFLAGS} -o $@ $^ ${MP_LIBS}

claptmpl.og: claptmpl.cc mod2.h
	$(CXXG)  ${CXXFLAGSG} ${CPPFLAGS} ${DEFSG} -c $< -o $@

%.og: %.cc
	$(CXXG) ${CXXFLAGSG} ${CXXTEMPLFLAGSG} ${CPPFLAGS} ${DEFSG} -c $< -o $@

$(OBJG2) : %.og: %.c
	$(CCG)  ${CFLAGSG} ${CPPFLAGS} ${DEFSG} -c $< -o $@

Singularg${S_EXT}: scanner.cc  $(OBJG)  $(DL_LIBSG)\
           iparith.og mpsr_Tok.og claptmpl.og tesths.cc version.h 
	$(CXXG) ${CXXFLAGSG} ${CXXTEMPLFLAGSG} ${CPPFLAGS} ${DEFSG} -o Singularg${S_EXT} \
	tesths.cc iparith.og mpsr_Tok.og claptmpl.og $(OBJG) ${LDFLAGSG} ${LIBSG} -lomalloc ../kernel/mmalloc.og \
	${LD_DYN_FLAGS2} ${LD_LIBC}

iparith.og: iparith.inc iparith.cc
	$(CXXG)  ${CXXFLAGSG} ${CXXTEMPLFLAGSG} ${CPPFLAGS} ${DEFSG} -c iparith.cc -o iparith.og

mpsr_Tok.og: iparith.inc mpsr_Tok.cc
	$(CXXG) ${CXXFLAGSG} ${CPPFLAGS} ${CXXTEMPLFLAGSG} ${DEFSG} -c mpsr_Tok.cc -o mpsr_Tok.og

installg: Singularg
	${MKINSTALLDIRS} ${bindir}
	${INSTALL_PROGRAM} Singularg ${bindir}	

ESingularg: mod2.h feOpt.cc version.h emacs.cc \
           feOptES.inc
	${CXXG} ${CXXFLAGSG} ${CPPFLAGS} -DESINGULAR -g ${DEFSG} -o ESingularg emacs.cc ../kernel/fegetopt.og ${LDFLAGS} ${LIBS} -lomalloc ../kernel/mmalloc.og

##
## .op files for having -O and -g pg object versions available at the same time
##

OBJP1 := $(CXXSOURCES:.cc=.op) 
OBJP2 := $(CSOURCES:.c=.op) 

OBJP=$(OBJP1) $(OBJP2) 

DL_TAILP=\"sop\"


ifeq ($(DL_KERNEL),1)

OBJP := $(OBJP) $(DL_KERNEL_SOURCES:.cc=.op)
DL_LIBSP := $(MPSR_SO:%.so=%.sop) $(DBMSR_SO:%.so=%.sop)

else

OBJP := $(OBJP) $(STATIC_SOURCES:.cc=.op) $(COMMON_SOURCES:.cc=.op)
DL_LIBSP=

endif


##
## compiler and linker options for profiling version
##

CCP		= ${CC}
CXXP		= ${CXX}

CFLAGSP		= -g -pg -O -Wall -Wno-unused ${PIPE}
CXXFLAGSP	= -g -pg -O -Wall -Wno-unused ${PIPE}
CXXTEMPLFLAGSP	= -fno-implicit-templates
DEFSP		= -D@SING_UNAME@ @DEFS@ -DDL_TAIL=$(DL_TAILP)

##
## Profiling Targets
##

%.dl_op: %.cc
	${CXXP} ${CXXFLAGSP} ${CXXTEMPLFLAGSP} ${CPPFLAGS} ${DEFSP} ${SFLAGS} -c $< -o $@

mpsr.sop: $(MPSR_SOURCES:.cc=.dl_op)
	${CXXP} ${CXXFLAGSP} ${SFLAGS} ${SLDFLAGS} ${LDFLAGS} -o $@ $^ ${MP_LIBS} ${GLIBC_DYN_FIX}

dbmsr.sop: $(DBMSR_SOURCES:.cc=.dl_op)
	${CXXP} ${CXXFLAGSP} ${SFLAGS} ${SLDFLAGS} ${LDFLAGS} -o $@ $^ ${MP_LIBS}

claptmpl.op: claptmpl.cc mod2.h
	$(CXXP)  ${CXXFLAGSP} ${CPPFLAGS} ${DEFSP} -c $< -o $@

%.op: %.cc
	$(CXXP) ${CXXFLAGSP} ${CXXTEMPLFLAGSP} ${CPPFLAGS} ${DEFSP} -c $< -o $@

$(OBJP2) : %.op: %.c
	$(CCP)  ${CFLAGSP} ${CPPFLAGS} ${DEFSP} -c $< -o $@

Singularp${S_EXT}: scanner.cc  $(OBJP)  $(DL_LIBSP)\
           iparith.op mpsr_Tok.op claptmpl.op tesths.cc version.h 
	(cd ../kernel;make libkernel_p.a;make install;cd ../Singular)
	$(CXXP) ${CXXFLAGSP} ${CXXTEMPLFLAGSP} ${CPPFLAGS} ${DEFSP} -o Singularp${S_EXT} \
	tesths.cc iparith.op mpsr_Tok.op claptmpl.op $(OBJP) ${LDFLAGSP} ${LIBSP} -lomalloc ../kernel/mmalloc.op \
	${LD_DYN_FLAGS2}

iparith.op: iparith.inc iparith.cc
	$(CXXP)  ${CXXFLAGSP} ${CXXTEMPLFLAGSP} ${CPPFLAGS} ${DEFSP} -c iparith.cc -o iparith.op

mpsr_Tok.op: iparith.inc mpsr_Tok.cc
	$(CXXP) ${CXXFLAGSP} ${CPPFLAGS} ${CXXTEMPLFLAGSP} ${DEFSP} -c mpsr_Tok.cc -o mpsr_Tok.op

installp: Singularp
	${MKINSTALLDIRS} ${bindir}
	${INSTALL_PROGRAM} Singularp ${bindir}	

##
## dependencies
##

%.dd: %.cc mod2.h 
	echo $(@:.dd=.og) $(@:.dd=.op) $(@:.dd=.dl_o) $(@:.dd=.dl_og)  $(@:.dd=.dl_op)" " \\ > $@
	$(CXXM) ${CPPFLAGS} ${DEFSG} $< >> $@

%.d: %.c mod2.h 
	echo $(@:.d=.og) $(@:.d=.op)" " \\ > $@
	$(CCM) ${CPPFLAGS} ${DEFSG} $< >> $@

depend:   $(CXXSOURCES:.cc=.dd) $(ESOURCES:.cc=.dd) $(CSOURCES:.c=.d) mod2.h claptmpl.dd pyobject.dd
	-cat *.dd >depend

ifeq (depend,$(wildcard depend))
include depend
endif