#*=====================================================================*/
#*    serrano/prgm/project/bigloo1.9c/Makefile                         */
#*    -------------------------------------------------------------    */
#*    Author      :  Manuel Serrano                                    */
#*    Creation    :  Wed Jan 14 13:40:15 1998                          */
#*    Last change :  Thu Mar 26 16:26:24 1998 (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 tools that writes copyright
COPYRIGHT	= $(ROOTBIN)/copyright
# the tools that gives a shared library version
LIBCVERSION	= $(ROOTBIN)/libcversion
# the libc we are testing for version
LIBC		= /usr/lib/libc.so
# 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	= `$(BIN)/bigloo -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
# copy shared libraries
CPSHARE		= cp
# 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		= doc
DOCDIR		= doc
BINDIR		= bin
LIBDIR		= lib
DISTRIBDIR	= $$HOME/prgm/distrib

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

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

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)"            \
                                     AS="$(AS)")
	@ (cd runtime;                                             \
           $(MAKE) -f Dmakefile heap CC="$(CC)"                    \
                                     CFLAGS="$(CFLAGS)"            \
                                     AS="$(AS)"                    \
                                     AR="$(AR)"                    \
                                     ARFLAGS="$(ARFLAGS)"          \
                                     RANLIB="$(RANLIB)"            \
                                     LD="$(LD)")
	@ echo "Boot Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    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); mkdir $(BIGLOO); cd $(BIGLOO);           \
           prcs checkout -r$(BROOTVERSION).@ $(BIGLOO);               \
           $(MAKE) -s true-distrib)

fast-distrib: 
	@ $(MAKE) -s true-distrib                                     \
                  CLEAN=fast-clean                                    \
                  DIRECTORIES="$(filter-out cigloo examples xlib,     \
                               $(DIRECTORIES)")

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 d in $(DIRECTORIES); do                                 \
             echo "distribution $$d ...";                             \
	     (cd $$d;                                                 \
              $(MAKE) -s distrib BIN=$$HOME/prgm/project/bigloo/bin   \
                                 LIB=../lib                           \
                                 CLEAN=$(CLEAN));                     \
              if [ $$? != "0" ]; then                                 \
                 exit 1;                                              \
              fi;                                                     \
          done
	@ (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: $(LIBCVERSION) 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) $(LIBC)`.$(RPMARCH).rpm $(DISTRIBDIR)
	@ ssh chown $$LOGNAME $(DISTRIBDIR)/bigloo-$(BROOTVERSION)-`$(LIBCVERSION) $(LIBC)`.$(RPMARCH).rpm
	@ ssh rm /usr/src/redhat/RPMS/$(RPMARCH)/bigloo-$(BROOTVERSION)-`$(LIBCVERSION) $(LIBC)`.$(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) $(LIBC)`"
	@ 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) $(LIBC)`.$(RPMARCH).rpm \
              $(FTPHOSTNAME):$(FTPDIR)/bigloo-$(BROOTVERSION)-`$(LIBCVERSION) $(LIBC)`.$(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))

#*---------------------------------------------------------------------*/
#*    $(LIBCVERSION)                                                   */
#*---------------------------------------------------------------------*/
$(LIBCVERSION):
	(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))
	@ (cd recette; recette)
	@ $(MAKE) revision
	@ echo "Bigloo Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

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

Dinstall: checkdirs
	if [ $(MANDIR) != doc ]; then                         \
	   cp doc/bigloo.1 $(MANDIR)/bigloo.1;                \
           if [ -f  $(MANDIR)/bigloo.1 ]; then                \
	      chmod $(BMASK) $(MANDIR)/bigloo.1;              \
           fi                                                 \
        fi
	if [ $(DOCDIR) != doc ]; then                         \
	   cp doc/bigloo.ps $(DOCDIR)/bigloo.ps;              \
           if [ -f $(DOCDIR)/bigloo.ps ]; then                \
	      chmod $(BMASK) $(DOCDIR)/bigloo.ps;             \
           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;      \
	   chmod $(BMASK) lib/libbigloo$(BVERSION).so;        \
	   $(CPSHARED) lib/libbigloo$(BVERSION).so            \
              $(LIBDIR)/libbigloo$(BVERSION).so;              \
	   chmod $(BMASK) lib/libbigloo$(BVERSION)_u.so;      \
	   $(CPSHARED) lib/libbigloo$(BVERSION)_u.so          \
              $(LIBDIR)/libbigloo$(BVERSION)_u.so;            \
	   cp lib/libgc.a $(LIBDIR)/libgc.a;                  \
	   chmod $(BMASK) $(LIBDIR)/libgc.a;                  \
	   $(RANLIB) $(LIBDIR)/libgc.a;                       \
	   chmod $(BMASK) lib/libgc.so;                       \
	   $(CPSHARED) lib/libgc.so $(LIBDIR)/libgc.so;       \
	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 $(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 $(BINDIR)/$(BIGLOO)$(BVERSION)
	-rm -f $(BINDIR)/$(BIGLOO)
	-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

#*---------------------------------------------------------------------*/
#*    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 dclean                       \
                                  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) ...                      */
#*---------------------------------------------------------------------*/
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 ChangeLog INSTALL README \
             README.ppc README.sgi            \
             Makefile configure               \
             style/index.sty style/manual.sty

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) $(LIBC)`" >> $@
	@ echo "Copyright: see README file" >> $@
	@ echo "Group: Development/Languages" >> $@
	@ echo "Source: ftp:/kaolin.unice.fr/pub/bigloo$(BROOTVERSION).tar.gz" >> $@
	@ 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" >> $@
	@ echo "make" >> $@
	@ echo "" >> $@
	@ echo "%install" >> $@
	@ echo "install -s -m 755 -o 0 -g 0 bin/$(BIGLOO)$(BROOTVERSION) /usr/bin/$(BIGLOO)$(BROOTVERSION)" >> $@
	@ 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 doc/$(BIGLOO).1 /usr/man/man1/$(BIGLOO).1" >> $@
	@ echo "" >> $@
	@ echo "%files" >> $@
	@ echo "%doc README ChangeLog doc/$(BIGLOO).ps" >> $@
	@ echo "%dir /usr/lib/bigloo" >> $@
	@ echo "" >> $@
	@ echo "/usr/bin/$(BIGLOO)$(BROOTVERSION)" >> $@
	@ 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/man/man1/$(BIGLOO).1" >> $@
