#*=====================================================================*/
#*    serrano/prgm/project/bigloo/Makefile                             */
#*    -------------------------------------------------------------    */
#*    Author      :  Manuel Serrano                                    */
#*    Creation    :  Wed Jan 14 13:40:15 1998                          */
#*    Last change :  Fri Feb 12 07:23:37 1999 (serrano)                */
#*    -------------------------------------------------------------    */
#*    This Makefile is as portable as possible. That is, it can be     */
#*    processed by any make program.                                   */
#*    -------------------------------------------------------------    */
#*    The main Bigloo Makefile. This makefile can be used to:          */
#*       - Compile a new Bigloo an on host (default entry point)       */
#*       - Install a new compiled version                              */
#*       - Check a version (recette)                                   */
#*       - Bootstrap an already compiled Bigloo (bootstrap)            */
#*       - ...                                                         */
#*=====================================================================*/

#*---------------------------------------------------------------------*/
#*    Compilers, Tools and Destinations                                */
#*---------------------------------------------------------------------*/
# which C compiler to be used
CC              = gcc
# the assembler
AS		= as
# The library builder
AR		= ar
# The flags of the library builder
ARFLAGS		= qcv
# the directory to write executable
BIN             = bin
# the Bigloo root directory
ROOT		= $$HOME/prgm/project/bigloo
# my personal Bigloo bin directory
ROOTBIN		= $(ROOT)/bin
# the executable used to bootstrap
BIGLOO          = bigloo
# the cigloo binary file
CIGLOO		= cigloo
# the tools that writes copyright
COPYRIGHT	= $(ROOTBIN)/copyright
# the tools that gives a shared library version
GETLIBCVERSION	= $(ROOTBIN)/libcversion
# the libc we are testing for version
LIBC		= /usr/lib/libc.so
# the library C version
LIBCVERSION	= 6
# how to produce a gentle beep
BEEP            = echo -n ""
# the shell to be used
SHELL           = /bin/sh
# The distribution number
BROOTVERSION	= `$(ROOTBIN)/bigloo-revision`
# the version is used to save executable when boostrapping
BVERSION	= `$(MAKE) -s -f comptime/Dmakefile getversion`
# the cigloo version
CVERSION	= `$(BIN)/cigloo -revision`
# the rpm architecture (for now only i386 is supported)
RPMARCH		= i386
# the root directory where to remove directory after the rpm contruction
RPMSOURCEDIR	= /usr/src/redhat/BUILD
# ranlib
RANLIB		= ranlib
# shared libraries builder
LD		= ld
# Mask for installed files
BMASK		= 755
# How to clean when building a distribution
CLEAN		= clean
# The directory where to build a distribution
DISTRIBTMPDIR	= $$HOME/trashcan
# The rpm source directory
RPMSOURCESDIR	= /usr/src/redhat/SOURCES
# The Bigloohtml page directory
HTMLPAGEDIR	= $$HOME/public_html/bigloo
# The ftp host and location where to store Bigloo
FTPHOSTNAME	= tahoe
FTPHOST		= $(FTPHOSTNAME).unice.fr
FTPDIR		= $$HOME/public_ftp

#*---------------------------------------------------------------------*/
#*    Installation directories                                         */
#*---------------------------------------------------------------------*/
MANDIR		= manuals
DOCDIR		= manuals
INFODIR		= manuals
BINDIR		= bin
LIBDIR		= lib
DISTRIBDIR	= $$HOME/prgm/distrib

#*---------------------------------------------------------------------*/
#*    The directory that compose a version                             */
#*---------------------------------------------------------------------*/
DIRECTORIES	= cigloo     \
                  bench      \
	          autoconf   \
                  contrib    \
                  etc        \
                  examples   \
                  gc-forward \
                  recette    \
                  tools      \
                  xlib       \
                  runtime    \
	          comptime   \
                  html       \
		  bdb        \
                  bde        \
                  bmacs      \
                  manuals    \
                  www

#*---------------------------------------------------------------------*/
#*    The file that have to be removed when building a distrib.        */
#*---------------------------------------------------------------------*/
NO_DIST_FILES	= .bigloo.prc_aux bigloo.lsm doc

#*---------------------------------------------------------------------*/
#*    Booting Bigloo (compiling the first Bigloo on a new host).       */
#*---------------------------------------------------------------------*/
boot:
	@ $(MAKE) -f Dmakefile.cfg boot

compile-bee: compile-cigloo compile-bde compile-bdb compile-bmacs

compile-cigloo:
	@ $(MAKE) -f Dmakefile.cfg compile-cigloo

compile-bde:
	@ $(MAKE) -f Dmakefile.cfg compile-bde

compile-bdb:
	@- $(MAKE) -f Dmakefile.cfg compile-bdb

compile-bmacs:
	@- $(MAKE) -f Dmakefile.cfg compile-bmacs

Dmakefile.cfg:
	@ echo "***ERROR: Bigloo has to be configured before compiled!" 1>&2
	@ exit -1

Dboot:
	@ (cd runtime;                                             \
           $(MAKE) -f Dmakefile libs CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     AS="$(AS)"                    \
                                     AR="$(AR)"                    \
                                     ARFLAGS="$(ARFLAGS)"          \
                                     RANLIB="$(RANLIB)"            \
                                     LIBRARYNAME="$(LIBRARYNAME)"  \
                                     LD="$(LD)")
	@ (cd comptime; $(MAKE) -f Dmakefile                       \
                                     CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     EXTRA_LD_OPT="$(EXTRA_LD_OPT)"\
                                     SHRD_COMP="$(SHRD_COMP)"      \
                                     EXTRALIBS="$(EXTRALIBS)"      \
                                     AS="$(AS)")
	@ (cd runtime;                                             \
           $(MAKE) -f Dmakefile heap CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     AS="$(AS)"                    \
                                     AR="$(AR)"                    \
                                     ARFLAGS="$(ARFLAGS)"          \
                                     RANLIB="$(RANLIB)"            \
                                     LIBRARYNAME="$(LIBRARYNAME)"  \
                                     LD="$(LD)")
	@ if [ $(INFOPS) = "yes" ]; then                           \
          (cd manuals; $(MAKE) info ps INFOOPTION="$(INFOOPTION)") \
          else                                                     \
          (cd manuals; $(MAKE) info INFOOPTION="$(INFOOPTION)")    \
          fi
	@ echo "Boot Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

Dcigloo:
	@ (cd cigloo; $(MAKE) -f Dmakefile                         \
                                     BIGLOO="$(BIGLOO)"            \
                                     CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     AS="$(AS)"                    \
                                     AR="$(AR)"                    \
                                     ARFLAGS="$(ARFLAGS)"          \
                                     RANLIB="$(RANLIB)"            \
                                     LIBRARYNAME="$(LIBRARYNAME)"  \
                                     LD="$(LD)")

Dbde:
	@ (cd bde; $(MAKE) -f Dmakefile                            \
                                     BIGLOO="$(BIGLOO)"            \
                                     CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     AS="$(AS)"                    \
                                     AR="$(AR)"                    \
                                     ARFLAGS="$(ARFLAGS)"          \
                                     RANLIB="$(RANLIB)"            \
                                     LIBRARYNAME="$(LIBRARYNAME)"  \
                                     LD="$(LD)")

Dbdb:
	@ if [ "$(READLINE)" != "no" ]; then                       \
             (cd bdb; $(MAKE) -f Dmakefile                         \
                                     BIGLOO="$(BIGLOO)"            \
                                     CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     AS="$(AS)"                    \
                                     AR="$(AR)"                    \
                                     ARFLAGS="$(ARFLAGS)"          \
                                     RANLIB="$(RANLIB)"            \
                                     READLINE="$(READLINE)"        \
                                     LD="$(LD)")                   \
           else                                                    \
              echo "Can't compile bdb because can't find readline";\
           fi

Dbmacs:
	@ if [ "$(EMACSDIR) " != " " ]; then                       \
              (cd bmacs; $(MAKE) -f Dmakefile)                     \
           else                                                    \
              echo "Can't compile bmacs because can't find xemacs";\
           fi

#*---------------------------------------------------------------------*/
#*    recette                                                          */
#*---------------------------------------------------------------------*/
recette:
	@ (cd recette; $(MAKE) touchall; $(MAKE) -f Dmakefile; recette)
	@ echo "Recette Done..."
	@ $(BEEP)
	@ echo "-------------------------------"
	  
#*---------------------------------------------------------------------*/
#*    distrib                                                          */
#*    -------------------------------------------------------------    */
#*    This entry build a distribution (biglooXXX.tar.gz file).         */
#*    This rule uses dependencies that cannot be satisfied by this     */
#*    current makefile. The dependencies are here present just to      */
#*    check that everything is ready for a distribution.               */
#*    -------------------------------------------------------------    */
#*    The fast-distrib is just here for debug. It does not build       */
#*    a real bigloo distribution. It builds a non bootstrapped, light  */
#*    one.                                                             */
#*---------------------------------------------------------------------*/
distrib:
	@ (cd $(DISTRIBTMPDIR);                                       \
	   rm -rf $(BIGLOO)$(BROOTVERSION);                           \
           rm -rf $(BIGLOO); mkdir $(BIGLOO); cd $(BIGLOO);           \
           prcs checkout -r$(BROOTVERSION).@ $(BIGLOO);               \
           $(MAKE) -s true-distrib)

fast-distrib: 
	@ rm -rf $(DISTRIBTMPDIR)/$(BIGLOO);
	@ mkdir $(DISTRIBTMPDIR)/$(BIGLOO);
	@ for d in $(DIRECTORIES); do                                 \
             echo "copying $$d ...";                                  \
	     tar cf - $$d |                                           \
                (cd $(DISTRIBTMPDIR)/$(BIGLOO);                       \
                 tar xf -);                                           \
          done
	@ cp Makefile $(DISTRIBTMPDIR)/$(BIGLOO)
	@ cp configure $(DISTRIBTMPDIR)/$(BIGLOO)
	@ cp LICENSE $(DISTRIBTMPDIR)/$(BIGLOO)
	@ cp COPYING $(DISTRIBTMPDIR)/$(BIGLOO)
	@ $(MAKE) -s extra-fast-distrib

extra-fast-distrib:
	@ (cd $(DISTRIBTMPDIR)/$(BIGLOO);                             \
           $(MAKE) -s true-distrib CLEAN=fast-clean)

true-distrib: $(COPYRIGHT) $(DISTRIBDIR)/bigloo$(BROOTVERSION).tar.gz

$(DISTRIBDIR)/bigloo$(BROOTVERSION).tar.gz: $(DISTRIBDIR)/bigloo.tar
	@ gzip $(DISTRIBDIR)/bigloo.tar
	@ mv $(DISTRIBDIR)/bigloo.tar.gz $(DISTRIBDIR)/bigloo$(BROOTVERSION).tar.gz
	@ echo "$(DISTRIBDIR)/bigloo$(BROOTVERSION).tar.gz Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

$(DISTRIBDIR)/bigloo.tar:
	@ for p in $(NO_DIST_FILES); do                               \
             rm -rf $$p;                                              \
          done
	@ for d in $(DIRECTORIES); do                                 \
             if [ -d $$d ]; then                                      \
               echo "distribution $$d ...";                           \
	       (cd $$d;                                               \
                $(MAKE) -s distrib BIN=$$HOME/prgm/project/bigloo/bin \
                                   LIB=../lib                         \
                                   CLEAN=$(CLEAN));                   \
                if [ $$? != "0" ]; then                               \
                   exit 1;                                            \
                fi;                                                   \
             fi                                                       \
          done
	@ echo "bigloo.tar"
	@ (pwd=`pwd`;                                                 \
           bpwd=`basename $$pwd`;                                     \
           cd ..;                                                     \
           mv $$bpwd $$bpwd$(BROOTVERSION);                           \
           tar cf $(DISTRIBDIR)/bigloo.tar $$bpwd$(BROOTVERSION))
	@ echo "$(DISTRIBDIR)/bigloo.tar Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    rpm                                                              */
#*---------------------------------------------------------------------*/
rpm: $(GETLIBCVERSION) bigloo$(BROOTVERSION).$(RPMARCH).rpm

bigloo$(BROOTVERSION).$(RPMARCH).rpm:                                  \
                         $(RPMSOURCESDIR)/bigloo$(BROOTVERSION).tar.gz \
                         bigloo.spec 
	@ ssh rpm -bb bigloo.spec
	@ ssh cp /usr/src/redhat/RPMS/$(RPMARCH)/bigloo-$(BROOTVERSION)-$(LIBCVERSION).$(RPMARCH).rpm $(DISTRIBDIR)
	@ ssh chown $$LOGNAME $(DISTRIBDIR)/bigloo-$(BROOTVERSION)-$(LIBCVERSION).$(RPMARCH).rpm
	@ ssh rm /usr/src/redhat/RPMS/$(RPMARCH)/bigloo-$(BROOTVERSION)-$(LIBCVERSION).$(RPMARCH).rpm
	@ echo "Removing $(RPMSOURCEDIR)/bigloo$(BROOTVERSION)"
	@ ssh /bin/rm -rf $(RPMSOURCEDIR)/bigloo$(BROOTVERSION)

.PHONY: $(RPMSOURCESDIR)/bigloo$(BROOTVERSION).tar.gz
$(RPMSOURCESDIR)/bigloo$(BROOTVERSION).tar.gz:
	@ echo "building bigloo.spec for libc version: $(LIBCVERSION)"
	@ echo "Copying bigloo.tar.gz into $(RPMSOURCESDIR)/bigloo$(BROOTVERSION).tar.gz"
	@ ssh cp $(DISTRIBDIR)/bigloo$(BROOTVERSION).tar.gz $(RPMSOURCESDIR)/bigloo$(BROOTVERSION).tar.gz

#*---------------------------------------------------------------------*/
#*    www                                                              */
#*    -------------------------------------------------------------    */
#*    Make a complete www installation (install both html and          */
#*    ftp files).                                                      */
#*---------------------------------------------------------------------*/
www: html ftp

#*---------------------------------------------------------------------*/
#*    html                                                             */
#*    -------------------------------------------------------------    */
#*    Set the html page up                                             */
#*---------------------------------------------------------------------*/
.PHONY: html
html: doc/bigloo.ps.gz
	@ if [ ! -d $(HTMLPAGEDIR) ]; then                    \
             mkdir $(HTMLPAGEDIR);                            \
             chmod a+rx $(HTMLPAGEDIR);                       \
          fi
	@ cat html/bigloo.html                                \
            | sed -e s,"<the-ftp-host>","$(FTPHOST)",g        \
            | sed -e s,"<the-ftp-dir>",`echo $(FTPDIR)`,g     \
            > $(HTMLPAGEDIR)/bigloo.html
	@ chmod 644 $(HTMLPAGEDIR)/bigloo.html
	@ install -m 644 doc/bigloo.ps.gz $(HTMLPAGEDIR)/bigloo.ps.gz
	@ install -m 644 ChangeLog $(HTMLPAGEDIR)/ChangeLog
	@ install -m 644 examples/Process/process.scm         \
                         $(HTMLPAGEDIR)/process
	@ install -m 644 examples/Runtime/runtime.scm         \
                         $(HTMLPAGEDIR)/runtime
	@ install -m 644 examples/Object/object.scm           \
                         $(HTMLPAGEDIR)/object
	@ install -m 644 examples/Roman/roman.scm             \
                         $(HTMLPAGEDIR)/roman
	@ install -m 644 examples/Yacc2bigloo/yacc2bigloo.scm \
                         $(HTMLPAGEDIR)/yacc2bigloo
	@ install -m 644 contrib/apropos.tar.gz               \
                         $(HTMLPAGEDIR)/apropos.tar.gz
	@ install -m 644 contrib/dload-0.1.tar.gz             \
                         $(HTMLPAGEDIR)/dload-0.1.tar.gz
	@ install -m 644 contrib/scmdoc.tar.gz                \
                         $(HTMLPAGEDIR)/scmdoc.tar.gz
	@ install -m 644 contrib/scmsockets.tar.gz            \
                         $(HTMLPAGEDIR)/scmsockets.tar.gz
	@ install -m 644 contrib/slibinit.tar.gz              \
                         $(HTMLPAGEDIR)/slibinit.tar.gz
	@ install -m 644 contrib/stepper-0.1.tar.gz           \
                         $(HTMLPAGEDIR)/stepper-0.1.tar.gz

#*---------------------------------------------------------------------*/
#*    ftp                                                              */
#*    -------------------------------------------------------------    */
#*    Set up the ftp file for the Bigloo distribution                  */
#*---------------------------------------------------------------------*/
ftp:
	@ rcp $(DISTRIBDIR)/bigloo-$(BROOTVERSION)-$(LIBCVERSION).$(RPMARCH).rpm \
              $(FTPHOSTNAME):$(FTPDIR)/bigloo-$(BROOTVERSION)-$(LIBCVERSION).$(RPMARCH).rpm
	@ rcp $(DISTRIBDIR)/bigloo$(BROOTVERSION).tar.gz         \
              $(FTPHOSTNAME):$(FTPDIR)/bigloo$(BROOTVERSION).tar.gz
	@ (rsh $(FTPHOSTNAME) chmod a+rx -R $(FTPDIR))

#*---------------------------------------------------------------------*/
#*    doc/bigloo.ps.gz                                                 */
#*---------------------------------------------------------------------*/
doc/bigloo.ps.gz:
	@ (cd doc; make bigloo.ps; gzip bigloo.ps)

#*---------------------------------------------------------------------*/
#*    $(COPYRIGHT)                                                     */
#*---------------------------------------------------------------------*/
$(COPYRIGHT):
	@ (cd $(ROOT)/tools; $(MAKE) $(ROOTBIN)/copyright BIN=$(ROOTBIN))

#*---------------------------------------------------------------------*/
#*    $(GETLIBCVERSION)                                                */
#*---------------------------------------------------------------------*/
$(GETLIBCVERSION):
	(cd $(ROOT)/tools; $(MAKE) $(ROOTBIN)/libcversion BIN=$(ROOTBIN))

#*---------------------------------------------------------------------*/
#*    fullbootstrap                                                    */
#*---------------------------------------------------------------------*/
fullbootstrap:
	@ (cp $(ROOTBIN)/$(BIGLOO)                            \
              $(ROOTBIN)/$(BIGLOO).ante;                      \
           echo "$(ROOTBIN)/$(BIGLOO).ante.gz:";              \
	   /bin/rm -f $(ROOTBIN)/$(BIGLOO).ante.gz >&2;       \
           gzip $(ROOTBIN)/$(BIGLOO).ante)
	@ (cd comptime; $(MAKE) -i touchall; $(MAKE))
	@ (cd runtime; $(MAKE) -i touchall; $(MAKE) heap libs)
	@ (cd comptime; $(MAKE) -i touchall; $(MAKE))
	@ (cd comptime; $(MAKE) -i touchall; $(MAKE))
	@ (cd recette; $(MAKE) -i touchall; $(MAKE) recette)
	@ (cd recette; recette)
	@ $(MAKE) revision
	@ echo "Bigloo Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    install                                                          */
#*---------------------------------------------------------------------*/
install: 
	@ $(MAKE) -f Dmakefile.cfg install BVERSION="$(BVERSION)"

install-cigloo:
	@ $(MAKE) -f Dmakefile.cfg install-cigloo CVERSION="$(CVERSION)"

install-bde:
	@ $(MAKE) -f Dmakefile.cfg install-bde

install-bdb:
	@- $(MAKE) -f Dmakefile.cfg install-bdb

install-bmacs:
	@- $(MAKE) -f Dmakefile.cfg install-bmacs

install-bee: install-cigloo install-bde install-bdb install-bmacs

Dinstall: checkdirs
	if [ $(MANDIR) != manuals ]; then                     \
	   cp manuals/bigloo.man $(MANDIR)/bigloo.1;          \
           if [ -f $(MANDIR)/bigloo.1 ]; then                 \
	      chmod $(BMASK) $(MANDIR)/bigloo.1;              \
           fi;                                                \
        fi
	if [ $(DOCDIR) != manuals ]; then                     \
           if [ -f manuals/bigloo.ps ]; then                  \
	     cp manuals/bigloo.ps $(DOCDIR)/bigloo.ps;        \
             if [ -f $(DOCDIR)/bigloo.ps ]; then              \
	        chmod $(BMASK) $(DOCDIR)/bigloo.ps;           \
             fi                                               \
           fi                                                 \
        fi
	if [ $(INFODIR) != manuals ]; then                    \
           if [ -f manuals/bigloo.info ]; then                \
	     cp manuals/bigloo.info* $(INFODIR);              \
             if [ -f $(INFODIR)/bigloo.info ]; then           \
	        chmod $(BMASK) $(INFODIR)/bigloo.info*;       \
             fi                                               \
           fi                                                 \
        fi
	if [ ! -f $(INFODIR)/dir ]; then                      \
          echo "$(INFODIR)/dir file does not exist";          \
        else                                                  \
          if [ "`grep "bigloo.info" $(INFODIR)/dir` " = " " ]; then      \
            echo "* bigloo: (bigloo.info). The Bigloo documentation." >> \
              $(INFODIR)/dir;                                            \
            fi                                                           \
        fi
	if [ $(BINDIR) != bin ]; then                         \
	   cp bin/$(BIGLOO)$(BVERSION) $(BINDIR);             \
	   chmod $(BMASK) $(BINDIR)/$(BIGLOO)$(BVERSION);     \
           (cd $(BINDIR);                                     \
             rm -f $(BIGLOO);                                 \
             ln -s $(BIGLOO)$(BVERSION) $(BIGLOO));           \
        else                                                  \
            ver=$(BVERSION);                                  \
            rm -f bin/bigloo$$ver;                            \
            (cd bin; ln -s bigloo bigloo$$ver);               \
        fi
	if [ $(LIBDIR) != lib ]; then                         \
	   cp lib/bigloo$(BVERSION).h                         \
              $(LIBDIR)/bigloo$(BVERSION).h;                  \
           chmod $(BMASK) $(LIBDIR)/bigloo$(BVERSION).h;      \
	   cp lib/bigloo_cfg$(BVERSION).h                     \
              $(LIBDIR)/bigloo_cfg$(BVERSION).h;              \
           chmod $(BMASK) $(LIBDIR)/bigloo_cfg$(BVERSION).h;  \
	   cp lib/bigloo$(BVERSION).heap                      \
              $(LIBDIR)/bigloo$(BVERSION).heap;               \
           chmod $(BMASK) $(LIBDIR)/bigloo$(BVERSION).heap;   \
	   cp lib/libbigloo$(BVERSION).a                      \
              $(LIBDIR)/libbigloo$(BVERSION).a;               \
           chmod $(BMASK) $(LIBDIR)/libbigloo$(BVERSION).a;   \
	   $(RANLIB) $(LIBDIR)/libbigloo$(BVERSION).a;        \
	   cp lib/libbigloo$(BVERSION)_u.a                    \
              $(LIBDIR)/libbigloo$(BVERSION)_u.a;             \
           chmod $(BMASK) $(LIBDIR)/libbigloo$(BVERSION)_u.a; \
	   $(RANLIB) $(LIBDIR)/libbigloo$(BVERSION)_u.a;      \
           if [ -f lib/libbigloo$(BVERSION).so ]; then        \
	      chmod $(BMASK) lib/libbigloo$(BVERSION).so;     \
	      cp lib/libbigloo$(BVERSION).so                  \
                 $(LIBDIR)/libbigloo$(BVERSION).so;           \
           fi;                                                \
           if [ -f lib/libbigloo$(BVERSION)_u.so ]; then      \
	      chmod $(BMASK) lib/libbigloo$(BVERSION)_u.so;   \
	      cp lib/libbigloo$(BVERSION)_u.so                \
                 $(LIBDIR)/libbigloo$(BVERSION)_u.so;         \
           fi;                                                \
	   cp lib/libgc.a $(LIBDIR)/libgc.a;                  \
	   chmod $(BMASK) $(LIBDIR)/libgc.a;                  \
	   $(RANLIB) $(LIBDIR)/libgc.a;                       \
           if [ -f lib/libgc.so ]; then                       \
	      chmod $(BMASK) lib/libgc.so;                    \
	      cp lib/libgc.so $(LIBDIR)/libgc.so;             \
           fi;                                                \
	fi

Dinstall-cigloo: checkdirs
	if [ $(BINDIR) != bin ]; then                         \
	   cp bin/$(CIGLOO) $(BINDIR)/$(CIGLOO)$(CVERSION);   \
	   chmod $(BMASK) $(BINDIR)/$(CIGLOO)$(CVERSION);     \
           (cd $(BINDIR);                                     \
             rm -f $(CIGLOO);                                 \
             ln -s $(CIGLOO)$(CVERSION) $(CIGLOO));           \
        else                                                  \
            ver=$(CVERSION);                                  \
            rm -f bin/cigloo$$ver;                            \
            (cd bin; ln -s cigloo cigloo$$ver);               \
	fi

Dinstall-bde: checkdirs
	if [ $(MANDIR) != manuals ]; then                     \
	   cp manuals/afile.man $(MANDIR)/afile.1;            \
           if [ -f $(MANDIR)/afile.1 ]; then                  \
	      chmod $(BMASK) $(MANDIR)/afile.1;               \
           fi;                                                \
	   cp manuals/afile.man $(MANDIR)/afile.1;            \
           if [ -f $(MANDIR)/afile.1 ]; then                  \
	      chmod $(BMASK) $(MANDIR)/afile.1;               \
           fi;                                                \
	   cp manuals/bdepend.man $(MANDIR)/bdepend.1;        \
           if [ -f $(MANDIR)/bdepend.1 ]; then                \
	      chmod $(BMASK) $(MANDIR)/bdepend.1;             \
           fi;                                                \
	   cp manuals/bmake.man $(MANDIR)/bmake.1;            \
           if [ -f $(MANDIR)/bmake.1 ]; then                  \
	      chmod $(BMASK) $(MANDIR)/bmake.1;               \
           fi;                                                \
	   cp manuals/bpp.man $(MANDIR)/bpp.1;                \
           if [ -f $(MANDIR)/bpp.1 ]; then                    \
	      chmod $(BMASK) $(MANDIR)/bpp.1;                 \
           fi;                                                \
	   cp manuals/bprof.man $(MANDIR)/bprof.1;            \
           if [ -f $(MANDIR)/bprof.1 ]; then                  \
	      chmod $(BMASK) $(MANDIR)/bprof.1;               \
           fi;                                                \
	   cp manuals/btags.man $(MANDIR)/btags.1;            \
           if [ -f $(MANDIR)/btags.1 ]; then                  \
	      chmod $(BMASK) $(MANDIR)/btags.1;               \
           fi;                                                \
       fi
	if [ $(BINDIR) != bin ]; then                         \
	   cp bin/afile $(BINDIR)/afile;                      \
	   cp bin/bdepend $(BINDIR)/bdepend;                  \
	   cp bin/bmake $(BINDIR)/bmake;                      \
	   cp bin/bprof $(BINDIR)/bprof;                      \
	   cp bin/bpp $(BINDIR)/bpp;                          \
	   cp bin/btags $(BINDIR)/btags;                      \
	   chmod $(BMASK) $(BINDIR)/afile;                    \
	   chmod $(BMASK) $(BINDIR)/bdepend;                  \
	   chmod $(BMASK) $(BINDIR)/bmake;                    \
	   chmod $(BMASK) $(BINDIR)/bprof;                    \
	   chmod $(BMASK) $(BINDIR)/bpp;                      \
	   chmod $(BMASK) $(BINDIR)/btags;                    \
	fi

Dinstall-bdb: checkdirs
	if [ $(INFODIR) != manuals ]; then                    \
           if [ -f manuals/bdb.info ]; then                   \
	     cp manuals/bdb.info* $(INFODIR);                 \
             if [ -f $(INFODIR)/bdb.info ]; then              \
	        chmod $(BMASK) $(INFODIR)/bdb.info*;          \
             fi                                               \
           fi                                                 \
        fi
	if [ ! -f $(INFODIR)/dir ]; then                      \
          echo "$(INFODIR)/dir file does not exist";          \
        else                                                  \
          if [ "`grep '(bdb.info)' $(INFODIR)/dir` " = " " ]; then\
            echo "* bdb: (bdb.info). The Bdb documentation." >>   \
              $(INFODIR)/dir;                                 \
            fi                                                \
        fi
	if [ -f bin/bdb ]; then                               \
	  if [ $(BINDIR) != bin ]; then                       \
	     cp bin/bdb $(BINDIR)/bdb;                        \
	     chmod $(BMASK) $(BINDIR)/bdb;                    \
	  fi;                                                 \
	  if [ $(LIBDIR) != lib ]; then                       \
	     cp lib/bdb.heap $(LIBDIR)/bdb.heap;              \
             chmod $(BMASK) $(LIBDIR)/bdb.heap;               \
	     cp lib/libbdb.a $(LIBDIR)/libbdb.a;              \
             chmod $(BMASK) $(LIBDIR)/libbdb.a;               \
	     $(RANLIB) $(LIBDIR)/libbdb.a;                    \
	  fi                                                  \
        fi

Dinstall-bmacs:
	@ if [ "$(EMACSDIR) " != " " ]; then                  \
	  if [ ! -d $(EMACSDIR) ]; then                       \
            echo "Can't find $(EMACSDIR) directory";          \
            exit -1;                                          \
          fi;                                                 \
	  if [ "$(EMACSDIR)" != "bmacs" ]; then               \
	   cp bmacs/*/*.elc $(EMACSDIR);                      \
          fi;                                                 \
	fi

checkdirs:
	@ if [ ! -d $(MANDIR) ]; then                         \
           echo "Can't find $(MANDIR) directory";             \
           exit -1;                                           \
        fi
	@ if [ ! -d $(DOCDIR) ]; then                         \
           echo "Can't find $(DOCDIR) directory";             \
           exit -1;                                           \
        fi
	@ if [ ! -d $(INFODIR) ]; then                        \
           echo "Can't find $(INFODIR) directory";            \
           exit -1;                                           \
        fi
	@ if [ ! -d $(BINDIR) ]; then                         \
           echo "Can't find $(BINDIR) directory";             \
           exit -1;                                           \
        fi
	@ if [ ! -d $(LIBDIR) ]; then                         \
           mkdir $(LIBDIR);                                   \
           chmod $(BMASK) $(LIBDIR);                          \
           if [ ! -d $(LIBDIR) ]; then                        \
              echo "Can't find nor create $(LIBDIR) dir";     \
              exit -1;                                        \
           fi                                                 \
        fi

#*---------------------------------------------------------------------*/
#*    uninstall                                                        */
#*---------------------------------------------------------------------*/
uninstall:
	@ $(MAKE) -f Dmakefile.cfg uninstall

Duninstall:
	-rm -f $(MANDIR)/bigloo.1
	-rm -f $(DOCDIR)/bigloo.ps
	-rm -f $(INFODIR)/bigloo.info*
	-rm -f $(INFODIR)/bdb.info*
	-rm -f $(BINDIR)/$(BIGLOO)$(BVERSION)
	-rm -f $(BINDIR)/$(BIGLOO)
	-rm -f $(BINDIR)/$(CIGLOO)$(CVERSION)
	-rm -f $(BINDIR)/$(CIGLOO)
	-rm -f $(BINDIR)/bdb
	-rm -f $(BINDIR)/afile
	-rm -f $(BINDIR)/bdepend
	-rm -f $(BINDIR)/bmake
	-rm -f $(BINDIR)/bprof
	-rm -f $(BINDIR)/bpp
	-rm -f $(BINDIR)/btags
	-rm -f $(LIBDIR)/bigloo$(BVERSION).h
	-rm -f $(LIBDIR)/bigloo_cfg$(BVERSION).h
	-rm -f $(LIBDIR)/bigloo$(BVERSION).heap
	-rm -f $(LIBDIR)/libbigloo$(BVERSION).a
	-rm -f $(LIBDIR)/libbigloo$(BVERSION)_u.a
	-rm -f $(LIBDIR)/libbigloo$(BVERSION).so
	-rm -f $(LIBDIR)/libbigloo$(BVERSION)_u.so
	-rm -f $(LIBDIR)/libgc.a
	-rm -f $(LIBDIR)/libgc.so
	-rm -f $(LIBDIR)/bdb.heap
	-rm -f $(LIBDIR)/libbdb.a
	@ (cd bmacs; $(MAKE) -f Dmakefile uninstall)

#*---------------------------------------------------------------------*/
#*    clean                                                            */
#*---------------------------------------------------------------------*/
clean:
	@ $(MAKE) -f Dmakefile.cfg clean

Dclean:
	@ for d in $(DIRECTORIES); do                                 \
             echo "cleaning $$d ...";                                 \
             if [ -d $$d ]; then                                      \
	        (cd $$d;                                              \
                 if [ -f Dmakefile ]; then                            \
                    $(MAKE) -s -f Dmakefile                           \
                                  -i clean                            \
                                  BIGLOO=$(BIGLOO)                    \
                                  > /dev/null 2> /dev/null;           \
                 else                                                 \
                    $(MAKE) -s -i DClean clean                        \
                                  BIGLOO=$(BIGLOO)                    \
                                  > /dev/null 2> /dev/null;           \
                 fi)                                                  \
             fi;                                                      \
          done
	@ (cd gc-boehm; $(MAKE) -s clean)
	@- rm -f Dmakefile.cfg
	@- rm -f *[~%] .??*[~%] \#*\# ?*\# 2> /dev/null
	@- rm -f bin/*

#*---------------------------------------------------------------------*/
#*    xv                                                               */
#*    -------------------------------------------------------------    */
#*    On recherche tous les fichiers de plus de 15 caracteres          */
#*    (a cause de la version linux).                                   */
#*---------------------------------------------------------------------*/
xv:
	@ find . -name '???????????????*' -print

#*---------------------------------------------------------------------*/
#*    viii ...                                                         */
#*    -------------------------------------------------------------    */
#*    On recherche tous les fichiers de plus de 8 caracteres           */
#*    (pour ms-dos)                                                    */
#*---------------------------------------------------------------------*/
viii:
	@ find . \( -name '?????????*.*' -o -name '*.????*' \) -print

#*---------------------------------------------------------------------*/
#*    revision control (by the means of prcs) ...                      */
#*---------------------------------------------------------------------*/
version:
	@ echo $(BROOTVERSION)

revision: populate checkin

populate: $(BIGLOO).prj
	@ for d in $(DIRECTORIES); do                          \
             echo "populating from $$d ...";                   \
             prcs populate $(BIGLOO) `cd $$d; $(MAKE) -s pop`; \
          done;
	prcs populate $(BIGLOO) gc-boehm      \
             LICENSE COPYING ChangeLog        \
             INSTALL README                   \
             README.ppc README.sgi            \
             Makefile configure bigloo.lsm    \
             tutorial

checkin:
	prcs checkin -r$(BROOTVERSION).@ $(BIGLOO)
	@ (major=`$(BIN)/bigloo -revision`;                            \
           revision=`prcs info -r $$major.@ | awk '{ print $$2 }'`;    \
           cp $(ROOTBIN)/$(BIGLOO)                                     \
              $(ROOTBIN)/"$(BIGLOO).$$revision";                       \
           echo "$(ROOTBIN)/$(BIGLOO).$$revision.gz:";                 \
           gzip "$(ROOTBIN)/$(BIGLOO).$$revision")

checkout:
	@ echo "prcs checkout -r$(BROOTVERSION).@ $(BIGLOO)"

$(BIGLOO).prj:
	@ prcs checkout $(BIGLOO)
	@ cat $(BIGLOO).prj | sed -e s,"(Populate-Ignore ())","(Populate-Ignore (\"\\\\\\\\\\.o\\$$\" \"\\\\\\\\\\~$$\" \"\\\\\\\\\\.log\\$$\" \"\\\\\\\\\\.ps\\$$\" \"\\\\\\\\\\.aux\\$$\" \"\\\\\\\\\\.date_of_backup\\$$\" \"\\\\\\\\\\.so\\$$\" \"\\\\\\\\\\.a\\$$\" \"if_not_there\\$$\" \"if_mach\\$$\" \"threadlibs\\$$\"))", > $(BIGLOO).dprj; rm -f $(BIGLOO).prj; mv $(BIGLOO).dprj $(BIGLOO).prj

#*---------------------------------------------------------------------*/
#*    RPM construction                                                 */
#*---------------------------------------------------------------------*/
.PHONY: bigloo.spec
bigloo.spec:
	@ echo $@:
	@- rm -f bigloo.spec
	@ echo "Summary: Bigloo is a compiler and an interpreter for Scheme." > $@
	@ echo "Name: $(BIGLOO)" > $@
	@ echo "Version: $(BROOTVERSION)" >> $@
	@ echo "Release: $(LIBCVERSION)" >> $@
	@ echo "Copyright: see README file" >> $@
	@ echo "Group: Development/Languages" >> $@
	@ echo "Source: ftp:/kaolin.unice.fr/pub/bigloo$(BROOTVERSION).tar.gz" >> $@
	@ echo "Summary: Bigloo is compiler for the Scheme programming language" >> $@
	@ echo "%description" >> $@
	@ echo "Bigloo is a compiler and interpreter for an extended version of the" >> $@
	@ echo "Scheme programming language. Bigloo allows a full connection between" >> $@
	@ echo "Scheme and C programs. It delivers fast and small executables." >> $@
	@ echo "" >> $@
	@ echo "%prep" >> $@
	@ echo "" >> $@
	@ echo "%setup -n $(BIGLOO)$(BROOTVERSION)" >> $@
	@ echo "" >> $@
	@ echo "%build" >> $@
	@ echo "configure --bindir=/usr/bin --libdir=/usr/lib/bigloo --mandir=/usr/man/man1 --docdir=/usr/doc --lispdir=/usr/share/xemacs/lisp-site" >> $@
	@ echo "make BVERSION=$(BROOTVERSION) boot install compile-bee" >> $@
	@ echo "" >> $@
	@ echo "%install" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/$(BIGLOO)$(BROOTVERSION) /usr/bin/$(BIGLOO)$(BROOTVERSION)" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/$(CIGLOO) /usr/bin/$(CIGLOO)" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/afile /usr/bin/afile" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/bdepend /usr/bin/bdepend" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/bmake /usr/bin/bmake" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/bprof /usr/bin/bprof" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/bpp /usr/bin/bpp" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/btags /usr/bin/btags" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/bdb /usr/bin/bdb" >> $@
	@ echo "if [ ! -d /usr/lib/bigloo ]; then " >> $@
	@ echo "   mkdir /usr/lib/bigloo" >> $@
	@ echo "fi" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/$(BIGLOO)$(BROOTVERSION).h /usr/lib/bigloo/$(BIGLOO)$(BROOTVERSION).h" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/$(BIGLOO)_cfg$(BROOTVERSION).h /usr/lib/bigloo/$(BIGLOO)_cfg$(BROOTVERSION).h" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/$(BIGLOO)$(BROOTVERSION).heap /usr/lib/bigloo/$(BIGLOO)$(BROOTVERSION).heap" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/lib$(BIGLOO)$(BROOTVERSION).a /usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION).a" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/lib$(BIGLOO)$(BROOTVERSION)_u.a /usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION)_u.a" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/lib$(BIGLOO)$(BROOTVERSION).so /usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION).so" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/lib$(BIGLOO)$(BROOTVERSION)_u.so /usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION)_u.so" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/libgc.a /usr/lib/bigloo/libgc.a" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/libgc.so /usr/lib/bigloo/libgc.so" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/libbdb.a /usr/lib/bigloo/libbdb.a" >> $@
	@ echo "install -m 644 -o 0 -g 0 lib/bdb.heap /usr/lib/bigloo/bdb.heap" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/$(BIGLOO).man /usr/man/man1/$(BIGLOO).1" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/afile.man /usr/man/man1/afile.1" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/bdepend.man /usr/man/man1/bdepend.1" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/bmake.man /usr/man/man1/bmake.1" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/bpp.man /usr/man/man1/bpp.1" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/bprof.man /usr/man/man1/bprof.1" >> $@
	@ echo "install -m 644 -o 0 -g 0 manuals/btags.man /usr/man/man1/btags.1" >> $@
	@ echo "chown root.root README ChangeLog manuals/$(BIGLOO).ps" >> $@
	@ echo "if [ ! -d /usr/share/xemacs ]; then " >> $@
	@ echo "   mkdir /usr/share/xemacs" >> $@
	@ echo "fi" >> $@
	@ echo "if [ ! -d /usr/share/xemacs/site-lisp ]; then " >> $@
	@ echo "   mkdir /usr/share/xemacs/site-lisp" >> $@
	@ echo "fi" >> $@
	@ echo "if [ ! -d /usr/share/xemacs/site-lisp/bee ]; then " >> $@
	@ echo "   mkdir /usr/share/xemacs/site-lisp/bee" >> $@
	@ echo "fi" >> $@
	@ echo "if [ ! -d /usr/share/xemacs/site-lisp/ude ]; then " >> $@
	@ echo "   mkdir /usr/share/xemacs/site-lisp/ude" >> $@
	@ echo "fi" >> $@
	@ echo "if [ ! -d /usr/share/xemacs/site-lisp/dbg ]; then " >> $@
	@ echo "   mkdir /usr/share/xemacs/site-lisp/dbg" >> $@
	@ echo "fi" >> $@
	@ echo "(cd bmacs; for p in */*.el*; do" >> $@
	@ echo "   install -m 644 -o 0 -g 0 $$""p /usr/share/xemacs/site-lisp/$$""p;" >> $@
	@ echo " done)" >> $@
	@ echo "(cd manuals; for p in bigloo.info*; do" >> $@
	@ echo "   install -m 644 -o 0 -g 0 $$""p /usr/info/$$""p;" >> $@
	@ echo " done)" >> $@
	@ echo "(cd /usr/info;" >> $@
	@ echo " if [ -f dir ]; then" >> $@
	@ echo "   if [ \"\`grep '(bigloo.info)' dir\` \" = \" \" ]; then" >> $@
	@ echo "     echo \"* bigloo: (bigloo.info). The Bigloo documentation.\" >> dir" >> $@
	@ echo "   fi" >> $@
	@ echo " fi)" >> $@
	@ echo "" >> $@
	@ echo "%files" >> $@
	@ echo "%doc README ChangeLog manuals/$(BIGLOO).ps" >> $@
	@ echo "%dir /usr/lib/bigloo" >> $@
	@ echo "" >> $@
	@ echo "/usr/bin/$(BIGLOO)$(BROOTVERSION)" >> $@
	@ echo "/usr/bin/$(CIGLOO)" >> $@
	@ echo "/usr/bin/afile" >> $@
	@ echo "/usr/bin/bdepend" >> $@
	@ echo "/usr/bin/bmake" >> $@
	@ echo "/usr/bin/bprof" >> $@
	@ echo "/usr/bin/bpp" >> $@
	@ echo "/usr/bin/btags" >> $@
	@ echo "/usr/bin/bdb" >> $@
	@ echo "/usr/lib/bigloo/$(BIGLOO)$(BROOTVERSION).h" >> $@
	@ echo "/usr/lib/bigloo/$(BIGLOO)_cfg$(BROOTVERSION).h" >> $@
	@ echo "/usr/lib/bigloo/$(BIGLOO)$(BROOTVERSION).heap" >> $@
	@ echo "/usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION).a" >> $@
	@ echo "/usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION)_u.a" >> $@
	@ echo "/usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION).so" >> $@
	@ echo "/usr/lib/bigloo/lib$(BIGLOO)$(BROOTVERSION)_u.so" >> $@
	@ echo "/usr/lib/bigloo/libgc.a" >> $@
	@ echo "/usr/lib/bigloo/libgc.so" >> $@
	@ echo "/usr/lib/bigloo/bdb.heap" >> $@
	@ echo "/usr/lib/bigloo/libbdb.a" >> $@
	@ echo "/usr/man/man1/$(BIGLOO).1" >> $@
	@ echo "/usr/man/man1/afile.1" >> $@
	@ echo "/usr/man/man1/bdepend.1" >> $@
	@ echo "/usr/man/man1/bmake.1" >> $@
	@ echo "/usr/man/man1/bpp.1" >> $@
	@ echo "/usr/man/man1/bprof.1" >> $@
	@ echo "/usr/man/man1/btags.1" >> $@
	@ echo "/usr/info/bigloo.info*" >> $@
	@ echo "/usr/share/xemacs/site-lisp/bdb*.el*" >> $@
	@ echo "/usr/share/xemacs/site-lisp/bee*.el*" >> $@
