#* --------------------------------------------------------------------*/
#*    Copyright (c) 1992-1998 by Manuel Serrano. All rights reserved.  */
#*                                                                     */
#*                                     ,--^,                           */
#*                               _ ___/ /|/                            */
#*                           ,;'( )__, ) '                             */
#*                          ;;  //   L__.                              */
#*                          '   \   /  '                               */
#*                               ^   ^                                 */
#*                                                                     */
#*                                                                     */
#*    This program is distributed in the hope that it will be useful.  */
#*    Use and copying of this software and preparation of derivative   */
#*    works based upon this software are permitted, so long as the     */
#*    following conditions are met:                                    */
#*           o credit to the authors is acknowledged following         */
#*             current academic behaviour                              */
#*           o no fees or compensation are charged for use, copies,    */
#*             or access to this software                              */
#*           o this copyright notice is included intact.               */
#*      This software is made available AS IS, and no warranty is made */
#*      about the software or its performance.                         */
#*                                                                     */
#*      Bug descriptions, use reports, comments or suggestions are     */
#*      welcome. Send them to                                          */
#*        Manuel Serrano -- Manuel.Serrano@unice.fr                    */
#*-------------------------------------------------------------------- */
#*=====================================================================*/
#*    serrano/prgm/project/bigloo/runtime/Makefile                     */
#*    -------------------------------------------------------------    */
#*    Author      :  Manuel Serrano                                    */
#*    Creation    :  Tue Mar 21 08:14:18 1995                          */
#*    Last change :  Fri Mar 27 07:30:30 1998 (serrano)                */
#*    -------------------------------------------------------------    */
#*    The (gnu) makefile to build the Bigloo's library.                */
#*=====================================================================*/

#*---------------------------------------------------------------------*/
#*    Compilers, Tools and Destinations                                */
#*---------------------------------------------------------------------*/
# which C compiler to be used
CC              = gcc
# the assembler
AS		= as
# the executable used to bootstrap
BIGLOO          = bigloo
# the Bigloo root directory
ROOT		= $$HOME/prgm/project/bigloo
# the directory to write executable
BIN             = ../bin
# where to store Bigloo libraries and Bigloo heap file
LIB         	= $(ROOT)/lib
# the current Bigloo version
VERSION		= `$(BIN)/bigloo-revision`
# The directory containing the collector
GC_DIR		= ../gc-boehm
# how to produce a beep
BEEP            = echo -n ""
# the shell to be used
SHELL           = /bin/sh
# configure
CONFIGURE	= ../configure
# The heap file
HEAP_FILE	= bigloo$(VERSION).heap
# The bigloo include files
INCLUDE_FILE	= Include/bigloo.h
CONFIG_NAME	= bigloo_cfg
CONFIG_FILE	= Include/$(CONFIG_NAME).h

#*---------------------------------------------------------------------*/
#*    Unix library options                                             */
#*---------------------------------------------------------------------*/
AR		= ar
ARFLAGS		= qcv
RANLIB		= ranlib
LD		= ld -G

#*---------------------------------------------------------------------*/
#*    Backup and versioning                                            */
#*---------------------------------------------------------------------*/
TAR		= tar
TARCOPT         = cf
TARXOPT         = xfp
GZIP		= gzip
BACKUPDIR	= $$HOUSE/backup
BACKUPNAME	= runtime

#*---------------------------------------------------------------------*/
#*    Compilation flags                                                */
#*---------------------------------------------------------------------*/
# verbose compilations ?
VERBOSE		= 
# The C include files
INCLUDE     	= -I$(LIB) -I$(GC_DIR)
# The Bigloo compilation option used the produce an heap file
BHEAPFLAGS	= -unsafe -q -mkheap -mklib $(VERBOSE)
# The option used to produce the _safe_ (and debugged) library
BSAFEFLAGS	= -cg -fno-stack -O3 -mklib -g -cg -cc $(CC) -fsharing  \
                  -q -rm $(VERBOSE) -unsafev -eval '(set! *indent* 4)'
CSAFEFLAGS	= $(INCLUDE) -g -DBIGLOO_DEBUG
# The option used to produce the _unsafe_ (and optimized) library
BUNSAFEFLAGS	= -O4 -fno-stack -mklib -unsafe -cc $(CC) -fsharing -q  \
                  -rm $(VERBOSE)
CUNSAFEFLAGS	= $(INCLUDE) -O2
# The option used to produce the _unsafe_ (and profiled) library
BUNSAFEPFLAGS	= -O3 -fno-stack -mklib -unsafe -pg -cc $(CC) -fsharing \
                  -q $(VERBOSE)
CPFLAGS		= $(INCLUDE) -pg

#*---------------------------------------------------------------------*/
#*    if_XXX tools                                                     */
#*---------------------------------------------------------------------*/
TOOLS_DIR	= ../tools

IF_MACH_SRC	= $(TOOLS_DIR)/if_mach.c
IF_MACH_EXE	= ../bin/if_mach

IF_NOT_THERE_SRC= $(TOOLS_DIR)/if_not_there.c
IF_NOT_THERE_EXE= ../bin/if_not_there

#*---------------------------------------------------------------------*/
#*    Suffixes                                                         */
#*---------------------------------------------------------------------*/
.SUFFIXES:
.SUFFIXES: .scm .c .s .o

#*---------------------------------------------------------------------*/
#*    The assembler objects.                                           */
#*---------------------------------------------------------------------*/
_OBJ_MLIB	= mach_dep 

OBJ_MLIB	= $(_OBJ_MLIB:%=Mlib/%.o)                  
O_OBJ_MLIB      = $(OBJ_MLIB:%=$(O)/%)

#*---------------------------------------------------------------------*/
#*    C objects                                                        */
#*---------------------------------------------------------------------*/
_OBJ_CLIB	= init-obj main cerror cports cstring csymbol cvector   \
                  writer apply cstruct system control ceval hash        \
                  trace callcc cbinary cforeign inline-alloc cdsssl     \
                  cucs2 cunicode cprocess

OBJ_CLIB	= $(_OBJ_CLIB:%=Clib/%.o)                  
O_OBJ_CLIB      = $(OBJ_CLIB:%=$(O)/%)
C_SOURCE_FILES	= $(OBJ_CLIB:%.o=%.c)

#*---------------------------------------------------------------------*/
#*    Scheme IEEE objects                                              */
#*---------------------------------------------------------------------*/
_OBJ_IEEE  	= boolean equiv pair-list char string control number    \
                  fixnum flonum port vector symbol input output control5 

OBJ_IEEE	= $(_OBJ_IEEE:%=Ieee/%.o)  
O_OBJ_IEEE	= $(OBJ_IEEE:%=$(O)/%)                 
C_OBJ_IEEE      = $(OBJ_IEEE:%.o=$(O)/%.c)

#*---------------------------------------------------------------------*/
#*    Scheme R5rs objects                                              */
#*---------------------------------------------------------------------*/
_OBJ_R5RS  	= init5 expand5 misc5 syntaxenv5 usual5 prefs5          \
                  syntaxrules5

OBJ_R5RS	= $(_OBJ_R5RS:%=R5rs/%.o)  
O_OBJ_R5RS	= $(OBJ_R5RS:%=.Olib_u/%)                 
C_OBJ_R5RS      = $(OBJ_R5RS:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    Scheme extended objects                                          */
#*---------------------------------------------------------------------*/
_OBJ_LLIB	= bexit type bigloo error struct os hash                \
                  tvector bit binary intext foreign object dsssl ucs2   \
                  unicode process

OBJ_LLIB	= $(_OBJ_LLIB:%=Llib/%.o)  
O_OBJ_LLIB	= $(OBJ_LLIB:%=$(O)/%)
C_OBJ_LLIB      = $(OBJ_LLIB:%.o=$(O)/%.c)

#*---------------------------------------------------------------------*/
#*    The interpreter objects                                          */
#*---------------------------------------------------------------------*/
_OBJ_EVAL	= eval expand expanders expd-let expd-bool expd-define  \
                  expd-case expd-do expd-try expd-struct evmeaning      \
                  evcompile evenv progn macro expd-quote evprimop

OBJ_EVAL	= $(_OBJ_EVAL:%=Eval/%.o)  
O_OBJ_EVAL	= $(OBJ_EVAL:%=.Olib_u/%)
C_OBJ_EVAL      = $(OBJ_EVAL:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    The Pattern matching compiler objects                            */
#*---------------------------------------------------------------------*/
_OBJ_MATCH	= compiler descr mexpand normalize s2cfun

OBJ_MATCH	= $(_OBJ_MATCH:%=Match/%.o)  
O_OBJ_MATCH	= $(OBJ_MATCH:%=.Olib_u/%)
C_OBJ_MATCH     = $(OBJ_MATCH:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    The Regular grammar generator objects                            */
#*---------------------------------------------------------------------*/
_OBJ_RGC	= runtime rexpand rules tree dfa grammar trap automata  \
                  accept cstate ustate optimize transition

OBJ_RGC		= $(_OBJ_RGC:%=Rgc/%.o)  
O_OBJ_RGC	= $(OBJ_RGC:%=.Olib_u/%)
C_OBJ_RGC       = $(OBJ_RGC:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    The Pretty-printer objects                                       */
#*---------------------------------------------------------------------*/
_OBJ_PP		= pp

OBJ_PP		= $(_OBJ_PP:%=Pp/%.o)  
O_OBJ_PP	= $(OBJ_PP:%=.Olib_u/%)
C_OBJ_PP        = $(OBJ_PP:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    The reader                                                       */
#*---------------------------------------------------------------------*/
_OBJ_READ	= reader

OBJ_READ	= $(_OBJ_READ:%=Read/%.o)  
O_OBJ_READ	= $(OBJ_READ:%=.Olib_u/%)
C_OBJ_READ      = $(OBJ_READ:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    The Lalr compiler objects                                        */
#*---------------------------------------------------------------------*/
_OBJ_LALR	= driver gen global lalr rewrite util

OBJ_LALR	= $(_OBJ_LALR:%=Lalr/%.o)  
O_OBJ_LALR	= $(OBJ_LALR:%=.Olib_u/%)
C_OBJ_LALR      = $(OBJ_LALR:%.o=.Olib_u/%.c)

#*---------------------------------------------------------------------*/
#*    All Scheme objects                                               */
#*---------------------------------------------------------------------*/
OBJ_SCHEME	= $(OBJ_IEEE) $(OBJ_R5RS) $(OBJ_LLIB) $(OBJ_READ)       \
                  $(OBJ_RGC) $(OBJ_PP) $(OBJ_EVAL) $(OBJ_MATCH)         \
                  $(OBJ_LALR)

O_OBJ_SCHEME	= $(O_OBJ_IEEE) $(O_OBJ_R5RS) $(O_OBJ_LLIB)             \
                  $(O_OBJ_READ) $(O_OBJ_RGC) $(O_OBJ_PP) $(O_OBJ_EVAL)  \
                  $(O_OBJ_MATCH) $(O_OBJ_LALR)

C_OBJ_SCHEME	= $(C_OBJ_IEEE) $(C_OBJ_R5RS) $(C_OBJ_LLIB)             \
                  $(C_OBJ_MATCH) $(C_OBJ_RGC) $(C_OBJ_PP) $(C_OBJ_READ) \
                  $(C_OBJ_EVAL) $(C_OBJ_LALR)

SCM_SOURCE_FILES= $(OBJ_SCHEME:%.o=%.scm)

#*---------------------------------------------------------------------*/
#*    Sources                                                          */
#*---------------------------------------------------------------------*/
SOURCE_FILES	= $(SCM_SOURCE_FILES)                \
		  $(C_SOURCE_FILES)                  \
		  Llib/make-lib.scm                  \
		  Lalr/lalr.sch                      \
		  Rgc/tree.sch                       \
		  Eval/byte-code.sch                 \
		  Mlib/mach_dep.c                    \
	   	  Mlib/alpha_osf_inline-alloc.s      \
		  Mlib/sparc_sunos4_mach_dep.s       \
	       	  Mlib/sparc_sunos5_mach_dep.s       \
		  $(INCLUDE_FILE)

POPULATION	= $(SOURCE_FILES) Makefile

#*---------------------------------------------------------------------*/
#*    The heap construction                                            */
#*---------------------------------------------------------------------*/
.PHONY: heap
heap: 
	@ \rm -f $(LIB)/$(HEAP_FILE)
	@ BIGLOOLIB=$(LIB); export BIGLOOLIB; \
          $(BIN)/$(BIGLOO) $(BHEAPFLAGS) Llib/make-lib.scm -heap $(HEAP_FILE)
	@ echo "Heap Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    libs                                                             */
#*---------------------------------------------------------------------*/
.PHONY: libs
libs: 
	@ $(MAKE) lib_u
	@ $(MAKE) lib

#*---------------------------------------------------------------------*/
#*    distrib                                                          */
#*---------------------------------------------------------------------*/
distrib: fixincludeversion
	@ if [ `pwd` = $$HOME/prgm/project/bigloo/runtime ]; then    \
             echo "*** ERROR:Illegal dir to make a distrib `pwd`";   \
             exit 1;                                                 \
          fi
	@ $(MAKE) Clean
	@ $(MAKE) mkdir
	@ $(MAKE) dist-lib_u
	@ $(MAKE) dist-lib
	@ $(MAKE) Dmakefile
	@ $(BIN)/copyright $(POPULATION)

#*---------------------------------------------------------------------*/
#*    The `safe' version.                                              */
#*---------------------------------------------------------------------*/
.PHONY: lib
lib: lib_u lib.so lib.a

lib.a:
	@ $(MAKE) blib.a                         \
             BFLAGS="$(BSAFEFLAGS)"              \
	     CFLAGS="$(CSAFEFLAGS)"              \
             O=".Olib"                           \
             D="libbigloo$(VERSION)$(LEVEL)"

lib.so:
	@ $(MAKE) blib.so                        \
             BFLAGS="$(BSAFEFLAGS)"              \
	     CFLAGS="$(CSAFEFLAGS)"              \
             O=".Olib"                           \
             D="libbigloo$(VERSION)$(LEVEL)"

dist-lib:
	@ $(MAKE) dist-blib.a                    \
             BFLAGS="$(BSAFEFLAGS) -LICENSE"     \
             CFLAGS="$(CUNSAFEFLAGS)"            \
             O=".Olib"                           \
             D="libbigloo$(VERSION)$(LEVEL)"

#*---------------------------------------------------------------------*/
#*    The `unsafe' version                                             */
#*---------------------------------------------------------------------*/
.PHONY: lib_u
lib_u: mkdir                                     \
       includes                                  \
       libgc.a libgc.so lib_u.so lib_u.a 

lib_u.a:
	@ $(MAKE) blib.a                         \
             BFLAGS="$(BUNSAFEFLAGS)"            \
             CFLAGS="$(CUNSAFEFLAGS)"            \
             O=".Olib_u"                         \
	     D="libbigloo$(VERSION)$(LEVEL)_u"

lib_u.so:
	@ $(MAKE) blib.so                        \
             BFLAGS="$(BUNSAFEFLAGS)"            \
             CFLAGS="$(CUNSAFEFLAGS)"            \
             O=".Olib_u"                         \
	     D="libbigloo$(VERSION)$(LEVEL)_u"

dist-lib_u:
	@ $(MAKE) dist-blib.a                    \
             BFLAGS="$(BUNSAFEFLAGS) -LICENSE"   \
             CFLAGS="$(CUNSAFEFLAGS)"            \
             O=".Olib_u"                         \
	     D="libbigloo$(VERSION)$(LEVEL)_u"

#*---------------------------------------------------------------------*/
#*    The profile version                                              */
#*---------------------------------------------------------------------*/
lib_p: lib_p.so lib_p.a

lib_p.a:
	@ $(MAKE) blib.a                         \
             BFLAGS="$(BUNSAFEPFLAGS)"           \
             CFLAGS="$(CPFLAGS)"                 \
	     O=".Olib_p"                         \
	     D="libbigloo$(VERSION)$(LEVEL)_p"
	@ \rm -f gmon.out

lib_p.so:
	@ $(MAKE) blib.so                        \
             BFLAGS="$(BUNSAFEPFLAGS)"           \
             CFLAGS="$(CPFLAGS)"                 \
             O=".Olib_p"                         \
	     D="libbigloo$(VERSION)$(LEVEL)_p"

#*---------------------------------------------------------------------*/
#*    The list of object file that composed the library.               */
#*---------------------------------------------------------------------*/
blibobjects_u:
	@ $(MAKE) blibobjects O=".Olib_u"

blibobjects:
	@ echo $(O_OBJ_CLIB) $(O_OBJ_MLIB) $(O_OBJ_SCHEME)

#*---------------------------------------------------------------------*/
#*    blib.a                                                           */
#*---------------------------------------------------------------------*/
.PHONY: blib.a
blib.a: $(LIB)/$(D).a

$(LIB)/$(D).a: $(O_OBJ_MLIB) $(O_OBJ_CLIB) $(O_OBJ_SCHEME)
	@ \rm -f $(LIB)/$(D).a.old
	@ if [ -f $(LIB)/$(D).a ]; then                \
               mv $(LIB)/$(D).a $(LIB)/$(D).a.old;     \
          fi
	@ $(AR) $(ARFLAGS) $(LIB)/$(D).a               \
               $(O_OBJ_CLIB)                           \
               $(O_OBJ_MLIB)                           \
	       $(O_OBJ_SCHEME)
	@ $(RANLIB) $(LIB)/$(D).a
	@ echo "$(D).a Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    blib.so                                                          */
#*---------------------------------------------------------------------*/
.PHONY: blib.so
blib.so: $(LIB)/$(D).so

$(LIB)/$(D).so: $(O_OBJ_MLIB) $(O_OBJ_CLIB) $(O_OBJ_SCHEME)
	@ $(LD) -o $(LIB)/$(D).so                   \
               $(O_OBJ_CLIB)                        \
               $(O_OBJ_MLIB)                        \
	       $(O_OBJ_SCHEME)                      \
               -lm -lc
	@ echo "$(D).so Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    The C production for the distribution.                           */
#*---------------------------------------------------------------------*/
dist-blib.a: $(C_OBJ_SCHEME)
	@ echo "$(D) (distribution) Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*     clean ...                                                       */
#*---------------------------------------------------------------------*/
.PHONY: Clean clean

Dclean:
	@ $(MAKE) dir-clean O=.Olib
	@ $(MAKE) dir-clean O=.Olib_u
	@ $(MAKE) dir-clean O=.Olib_p
	@ find . \( -name '*[~%]'                   \
                       -o -name '.??*[~%]'          \
                       -o -name '#*#'               \
                       -o -name '?*#'               \
                       -o -name \*core \)           \
                     -type f -exec rm {} \;   
	@ echo "Cleanup done..."
	@ $(BEEP)
	@ echo "-------------------------------"

clean: Dclean
	@- rm -f Dmakefile > /dev/null

dir-clean:
	@- rm -f $(C_OBJ_SCHEME)
	@- rm -f $(O_OBJ_MLIB) $(O_OBJ_CLIB) $(O_OBJ_SCHEME)

DClean:
	@- rm -f $(HEAP_FILE)
	@- rm -f $(LIB)/bigloo$(VERSION).h
	@- rm -f $(LIB)/bigloo_cfg$(VERSION).h
	@- rm -f $(LIB)/libbigloo$(VERSION)*
	@- rm -f $(LIB)/libgc.a
	@- rm -f $(LIB)/libgc.so
	@- rm -f -r .Olib
	@- rm -f -r .Olib_u
	@- rm -f -r .Olib_p

Clean: DClean clean

#*---------------------------------------------------------------------*/
#*     touchall ...                                                    */
#*---------------------------------------------------------------------*/
touchall:
	@ touch $(SOURCE_FILES) 
	@ echo "touchall done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    wc                                                               */
#*---------------------------------------------------------------------*/
wc:
	@ wc Llib/*.{scm,sch} Clib/*.c Include/*.h
	@ echo "wc done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    pop                                                              */
#*    -------------------------------------------------------------    */
#*    This entry is used by the bigloo/Makefile (the main Bigloo       */
#*    makefile) to get the list of file that populate a revision.      */
#*---------------------------------------------------------------------*/
.PHONY: pop
pop: 
	@ echo $(POPULATION:%=runtime/%)

#*---------------------------------------------------------------------*/
#*    backup                                                           */
#*---------------------------------------------------------------------*/
backup:
	@ echo "Backuping $(BACKUPNAME) in $(BACKUPDIR)"
	@ (\rm -f $(BACKUPDIR)/$(BACKUPNAME).tar.gz;        \
	   cleanup;                                         \
           $(TAR) $(TARCOPT) $(BACKUPDIR)/$(BACKUPNAME).tar \
                  $(POPULATION);                            \
           $(GZIP) $(BACKUPDIR)/$(BACKUPNAME).tar)
	@ echo "done..."
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    restore ...                                                      */
#*---------------------------------------------------------------------*/
restore:
	@ echo "Restoring $(BACKUPNAME) from $(BACKUPDIR)"
	@ ($(GZIP) -d --to-stdout $(BACKUPDIR)/$(BACKUPNAME).tar.gz | \
          $(TAR) $(TARXOPT) -)
	@ echo "done..."
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    dirs                                                             */
#*    -------------------------------------------------------------    */
#*    Prepare directories for a compilation.                           */
#*---------------------------------------------------------------------*/
.PHONY: mkdir
mkdir: .Olib_u .Olib .Olib_p                                            \
       .Olib_u/Clib .Olib_u/Eval .Olib_u/Ieee .Olib_u/R5rs .Olib_u/Lalr \
       .Olib_u/Llib .Olib_u/Match .Olib_u/Mlib .Olib_u/Pp .Olib_u/Read  \
       .Olib_u/Rgc .Olib/Clib .Olib/Ieee .Olib/Llib                     \
       .Olib/Mlib .Olib_p .Olib_p/Clib .Olib_p/Ieee .Olib_p/Llib        \
       .Olib_p/Mlib

.Olib_u:
	mkdir .Olib_u
.Olib_u/Clib:
	mkdir .Olib_u/Clib
.Olib_u/Eval:
	mkdir .Olib_u/Eval
.Olib_u/Ieee:
	mkdir .Olib_u/Ieee
.Olib_u/R5rs:
	mkdir .Olib_u/R5rs
.Olib_u/Lalr:
	mkdir .Olib_u/Lalr
.Olib_u/Llib:
	mkdir .Olib_u/Llib
.Olib_u/Match:
	mkdir .Olib_u/Match
.Olib_u/Mlib:
	mkdir .Olib_u/Mlib
.Olib_u/Pp:
	mkdir .Olib_u/Pp
.Olib_u/Read:
	mkdir .Olib_u/Read
.Olib_u/Rgc:
	mkdir .Olib_u/Rgc
.Olib:
	mkdir .Olib
.Olib/Clib:
	mkdir .Olib/Clib
.Olib/Ieee:
	mkdir .Olib/Ieee
.Olib/Llib:
	mkdir .Olib/Llib
.Olib/Mlib:
	mkdir .Olib/Mlib
.Olib_p:
	mkdir .Olib_p
.Olib_p/Clib:
	mkdir .Olib_p/Clib
.Olib_p/Ieee:
	mkdir .Olib_p/Ieee
.Olib_p/Llib:
	mkdir .Olib_p/Llib
.Olib_p/Mlib:
	mkdir .Olib_p/Mlib

#*---------------------------------------------------------------------*/
#*    The implicit `.scm.o' rule                                       */
#*---------------------------------------------------------------------*/
.Olib/%.o: %.scm
	@ $(BIN)/$(BIGLOO) $(BFLAGS) $*.scm -o .Olib/$*.o -c
.Olib_u/%.o: %.scm
	@ $(BIN)/$(BIGLOO) $(BFLAGS) $*.scm -o .Olib_u/$*.o -c
.Olib_p/%.o: %.scm
	@ $(BIN)/$(BIGLOO) $(BFLAGS) $*.scm -o .Olib_p/$*.o -c

#*---------------------------------------------------------------------*/
#*    The implicit `.scm.c' rule                                       */
#*---------------------------------------------------------------------*/
.Olib/%.c: %.scm
	@ $(BIN)/$(BIGLOO) $(BFLAGS) -cgen $*.scm -o .Olib/$*.c
.Olib_u/%.c: %.scm
	@ $(BIN)/$(BIGLOO) $(BFLAGS) -cgen $*.scm -o .Olib_u/$*.c

#*---------------------------------------------------------------------*/
#*    The implicit `.c.o' rule                                         */
#*---------------------------------------------------------------------*/
$(O)/%.o: %.c
	@ echo "$*.c:"
	@ $(CC) $(CFLAGS) $*.c -o $(O)/$*.o -c

#*---------------------------------------------------------------------*/
#*    mach_dep.o                                                       */
#*---------------------------------------------------------------------*/
$(O)/Mlib/mach_dep.o: Mlib/mach_dep.c                 \
                      Mlib/sparc_sunos5_mach_dep.s    \
                      Mlib/sparc_sunos4_mach_dep.s    \
                      $(IF_MACH_EXE)                  \
                      $(IF_NOT_THERE_EXE)
	@ echo "Mlib/mach_dep.c:"
	@ rm -f $(O)/Mlib/mach_dep.o
	@ $(IF_MACH_EXE) sparc sunos5 $(AS) -o $(O)/Mlib/mach_dep.o Mlib/sparc_sunos5_mach_dep.s
	@ $(IF_MACH_EXE) sparc sunos4 $(AS) -o $(O)/Mlib/mach_dep.o Mlib/sparc_sunos4_mach_dep.s
	@ $(IF_NOT_THERE_EXE) $(O)/Mlib/mach_dep.o \
          $(CC) -c $(CFLAGS) Mlib/mach_dep.c -o $(O)/Mlib/mach_dep.o
 
#*---------------------------------------------------------------------*/
#*    inline-alloc.o                                                   */
#*---------------------------------------------------------------------*/
$(O)/Clib/inline-alloc.o: Clib/inline-alloc.c             \
                          Mlib/alpha_osf_inline-alloc.s   \
                         $(IF_MACH_EXE)                  \
                         $(IF_NOT_THERE_EXE)
	@ $(IF_MACH_EXE) alpha osf echo "Mlib/alpha_osf_inline-alloc.s:"
	@ rm -f $(O)/Clib/inline-alloc.o
	@ $(IF_MACH_EXE) alpha osf $(AS) -O -o $(O)/Clib/inline-alloc.o Mlib/alpha_osf_inline-alloc.s
	@ $(IF_NOT_THERE_EXE) $(O)/Clib/inline-alloc.o echo "Clib/inline-alloc.c:"
	@ $(IF_NOT_THERE_EXE) $(O)/Clib/inline-alloc.o \
          $(CC) -c $(CFLAGS) Clib/inline-alloc.c -o $(O)/Clib/inline-alloc.o

#*---------------------------------------------------------------------*/
#*    Tools compilation                                                */
#*---------------------------------------------------------------------*/
$(IF_MACH_EXE): $(IF_MACH_SRC)
	@ $(CC) $(CFLAGS) -o $(IF_MACH_EXE) $(IF_MACH_SRC)

$(IF_NOT_THERE_EXE): $(IF_NOT_THERE_SRC)
	@ $(CC) $(CFLAGS) -o $(IF_NOT_THERE_EXE) $(IF_NOT_THERE_SRC)

#*---------------------------------------------------------------------*/
#*    fixincludeversion ...                                            */
#*    -------------------------------------------------------------    */
#*    We add the Bigloo release number to the #include directive of    */
#*    all hand-written C files.                                        */
#*---------------------------------------------------------------------*/
.PHONY: fixincludeversion
fixincludeversion:
	@ echo "Fixing C source file [with bigloo$(VERSION)$(LEVEL).h]"
	@ if [ `pwd` = $$HOME/prgm/project/bigloo/runtime ]; then    \
             echo "*** ERROR:Illegal dir to make a distrib `pwd`";   \
             exit 1;                                                 \
          fi
	@ for p in $(C_SOURCE_FILES); do     \
             echo $$p;                       \
	     cat $$p | sed -e s,"bigloo.h","bigloo$(VERSION)$(LEVEL).h", > $$p.new; \
	     \rm -rf $$p; mv $$p.new $$p;    \
          done;

#*---------------------------------------------------------------------*/
#*    unfixincludeversion ...                                          */
#*    -------------------------------------------------------------    */
#*    We remove the Bigloo release number to the #include directive of */
#*    all hand-written C files.                                        */
#*---------------------------------------------------------------------*/
.PHONY: unfixincludeversion
unfixincludeversion:
	@ echo "Unfixing C source file [with bigloo.h]"
	@ for p in $(C_SOURCE_FILES); do     \
             echo $$p;                       \
	     cat $$p | sed -e s,"bigloo$(VERSION)$(LEVEL).h","bigloo.h", > $$p.new; \
	     \rm -rf $$p; mv $$p.new $$p;    \
          done;

#*---------------------------------------------------------------------*/
#*    includes                                                         */
#*---------------------------------------------------------------------*/
.PHONY: includes
includes: $(LIB)/bigloo.h                \
          $(LIB)/bigloo$(VERSION).h      \
          $(LIB)/bigloo_cfg$(VERSION).h

#*---------------------------------------------------------------------*/
#*    $(LIB)/bigloo.h:                                                 */
#*---------------------------------------------------------------------*/
$(LIB)/bigloo.h:
	echo "#include <bigloo$(VERSION).h>" > $@

#*---------------------------------------------------------------------*/
#*    $(LIB)/bigloo$(VERSION).h:                                       */
#*---------------------------------------------------------------------*/
$(LIB)/bigloo$(VERSION).h: $(INCLUDE_FILE)
	version=$(VERSION);                                     \
	cat $(INCLUDE_FILE)                                   | \
           sed -e s,"$(CONFIG_NAME)","$(CONFIG_NAME)$$version", \
           > $@

#*---------------------------------------------------------------------*/
#*    $(LIB)/bigloo_cfg$(VERSION).h:                                   */
#*---------------------------------------------------------------------*/
$(LIB)/bigloo_cfg$(VERSION).h: $(CONFIG_FILE)
	cp $(CONFIG_FILE) $@

#*---------------------------------------------------------------------*/
#*    $(CONGIF_FILE).h:                                                */
#*---------------------------------------------------------------------*/
configure: 
	@- rm -f $(CONFIG_FILE)
	@ $(MAKE) $(CONFIG_FILE)
	cp $(CONFIG_FILE) $(LIB)/bigloo_cfg$(VERSION).h

$(CONFIG_FILE): $(CONFIGURE)
	$(CONFIGURE) --bigloo_cfg.h=$(CONFIG_FILE) \
                     --libdir=$(LIB)               \
                     --indent=stdindent

#*---------------------------------------------------------------------*/
#*    Dmakefile                                                        */
#*    -------------------------------------------------------------    */
#*    This entry build the Dmakefile file that is used to boot         */
#*    Bigloo (from .c file) on a new host.                             */
#*    -------------------------------------------------------------    */
#*    This entry can be used only on a platform that has bootstrapped  */
#*    Bigloo. That is, this makefile cannot be generated on a          */
#*    platform that wants to install Bigloo.                           */
#*---------------------------------------------------------------------*/
Dmakefile: Makefile
	@- rm -f Dmakefile > /dev/null
	@ echo "# !!! This is a generated file, don't edit !!!" > $@
	@ echo "BIGLOO=bigloo$(VERSION)" >> $@
	@ echo "LIBRARYNAME=$$""(BIGLOO)" >> $@
	@ echo "CC=$(CC)" >> $@
	@ echo "CFLAGS=$(CFLAGS)" >> $@
	@ echo "BIN=../bin" >> $@
	@ echo "AR=ar" >> $@
	@ echo "ARFLAGS=$(ARFLAGS)" >> $@
	@ echo "LD=ld -G" >> $@
	@ echo "GC_DIR=$(GC_DIR)" >> $@
	@ echo "" >> $@
	@ $(MAKE) -s Dobjects OBJECTS_NAME=OBJECTS_U O=.Olib_u >> $@
	@ echo "" >> $@
	@ $(MAKE) -s Dobjects OBJECTS_NAME=OBJECTS O=.Olib >> $@
	@ echo "" >> $@
	@ echo "heap:" >> $@
	@ echo "	@- rm -f ../lib/$(HEAP_FILE)" >> $@
	@ echo "	@ BIGLOOLIB=$(LIB); export BIGLOOLIB; \\" >> $@
	@ echo "	    $$""(BIN)/$$""(BIGLOO) $(BHEAPFLAGS) \\" >> $@
	@ echo "	    Llib/make-lib.scm -heap $(HEAP_FILE)" >> $@
	@ echo "" >> $@
	@ echo "libs: $(LIB)/bigloo$(VERSION).h $(LIB)/bigloo_cfg$(VERSION).h" >> $@
	@ echo '	$$(MAKE) -f Dmakefile libgc LD="$$(LD)" LIBRARYNAME="$$(LIBRARYNAME)"' >> $@
	@ echo '	$$(MAKE) -f Dmakefile lib_u LD="$$(LD)" LIBRARYNAME="$$(LIBRARYNAME)"' >> $@
	@ echo '	$$(MAKE) -f Dmakefile lib LD="$$(LD)" LIBRARYNAME="$$(LIBRARYNAME)"' >> $@
	@ echo "" >> $@
	@ echo "lib_u: lib_u.a lib_u.so" >> $@
	@ echo "lib: lib.a lib.so" >> $@
	@ echo "" >> $@
	@ echo 'lib_u.a: $$(OBJECTS_U)' >> $@
	@ echo "	$$""(AR) $$""(ARFLAGS) ../lib/lib$$""(LIBRARYNAME)$(VERSION)_u.a $$""(OBJECTS_U)" >> $@
	@ echo "	$$""(RANLIB) ../lib/lib$$""(LIBRARYNAME)$(VERSION)_u.a" >> $@
	@ echo "" >> $@
	@ echo 'lib_u.so: $$(OBJECTS_U)' >> $@
	@ echo "	$$""(LD) -o ../lib/lib$$""(LIBRARYNAME)$(VERSION)_u.so $$""(OBJECTS_U) -lm -lc" >> $@
	@ echo "" >> $@
	@ echo 'lib.a: $$(OBJECTS)' >> $@
	@ echo "	$$""(AR) $$""(ARFLAGS) ../lib/lib$$""(LIBRARYNAME)$(VERSION).a $$""(OBJECTS)" >> $@
	@ echo "	$$""(RANLIB) ../lib/lib$$""(LIBRARYNAME)$(VERSION).a" >> $@
	@ echo "" >> $@
	@ echo 'lib.so: $$(OBJECTS)' >> $@
	@ echo "	$$""(LD) -o ../lib/lib$$""(LIBRARYNAME)$(VERSION).so $$""(OBJECTS) -lm -lc" >> $@
	@ echo "" >> $@
	@ echo "libgc: libgc.a libgc.so" >> $@
	@ echo "" >> $@
	@ echo "libgc.a:" >> $@
	@ echo "	@ (cd $$""(GC_DIR); $$""(MAKE) gc.a CC=$(CC) \\" >> $@
	@ echo '	   CFLAGS="-O2 -DSILENT -DNO_SIGNALS -DNO_DEBUGGING")' >> $@
	@ echo '	@ cp $$(GC_DIR)/gc.a $(LIB)/libgc.a; $$(RANLIB) $(LIB)/libgc.a' >> $@
	@ echo "" >> $@
	@ echo "libgc.so:" >> $@
	@ echo '	@ (cd $$(GC_DIR); $$(MAKE) libmsgc.so LD="$$(LD)")' >> $@
	@ echo '	@ cp $$(GC_DIR)/libgc.so $(LIB)/libgc.so' >> $@
	@ echo "" >> $@
	@ echo "clean:" >> $@
	@ echo '	@- rm -f $$(OBJECTS) $$(OBJECTS_U)' >> $@
	@ echo '	@- rm -f $(LIB)/*' >> $@
	@ echo "" >> $@
	@ echo ".Olib_u/%.o: %.c" >> $@
	@ echo '	$$(CC) -I$(LIB) -I$(GC_DIR) $$(CFLAGS) $$*.c -c && mv `basename $$*.o` .Olib_u/$$*.o' >> $@
	@ echo ".Olib_u/%.o: .Olib_u/%.c" >> $@
	@ echo '	$$(CC) -I$(LIB) -I$(GC_DIR) $$(CFLAGS) .Olib_u/$$*.c -c && mv `basename $$*.o` .Olib_u/$$*.o' >> $@
	@ echo ".Olib/%.o: %.c" >> $@
	@ echo '	$$(CC) -I$(LIB) -I$(GC_DIR) $$(CFLAGS) $$*.c -c && mv `basename $$*.o` .Olib/$$*.o' >> $@
	@ echo ".Olib/%.o: .Olib/%.c" >> $@
	@ echo '	$$(CC) -I$(LIB) -I$(GC_DIR) $$(CFLAGS) .Olib/$$*.c -c && mv `basename $$*.o` .Olib/$$*.o' >> $@
	@ echo "" >> $@
	@ $(MAKE) -s Dmach_dep O=.Olib_u >> $@
	@ echo "" >> $@
	@ $(MAKE) -s Dmach_dep O=.Olib >> $@
	@ echo "" >> $@
	@ echo '$(IF_MACH_EXE): $(IF_MACH_SRC)' >> $@
	@ echo '	@ $$(CC) $$(CFLAGS) -o $(IF_MACH_EXE) $(IF_MACH_SRC)' >> $@
	@ echo "" >> $@
	@ echo '$(IF_NOT_THERE_EXE): $(IF_NOT_THERE_SRC)' >> $@
	@ echo '	@ $$(CC) $$(CFLAGS) -o $(IF_NOT_THERE_EXE) $(IF_NOT_THERE_SRC)' >> $@
	@ echo "" >> $@
	@ echo "$(LIB)/bigloo$(VERSION).h: $(INCLUDE_FILE)" >> $@
	@ echo "	cat $(INCLUDE_FILE) | sed -e s,"$(CONFIG_NAME)","$(CONFIG_NAME)$(VERSION)", > "'$$@' >> $@
	@ echo "" >> $@
	@ echo "$(LIB)/bigloo_cfg$(VERSION).h: $(CONFIG_FILE)" >> $@
	@ echo "	cp $(CONFIG_FILE) " '$$@' >> $@

Dmach_dep:
	@ echo "$(O)/Mlib/mach_dep.o: Mlib/mach_dep.c              \\"
	@ echo "                         Mlib/sparc_sunos5_mach_dep.s \\"
	@ echo "                         Mlib/sparc_sunos4_mach_dep.s \\"
	@ echo '                         $(IF_MACH_EXE)               \\'
	@ echo '                         $(IF_NOT_THERE_EXE)'
	@ echo "	@ echo \"Mlib/mach_dep.c:\""
	@ echo "	@-rm -f $(O)/Mlib/mach_dep.o"
	@ echo '	@ $(IF_MACH_EXE) sparc sunos5 $$(AS) Mlib/sparc_sunos5_mach_dep.s -o sparc_sunos5_mach_dep.o'
	@ echo '	@ $(IF_MACH_EXE) sparc sunos5 mv sparc_sunos5_mach_dep.o $(O)/Mlib/mach_dep.o'
	@ echo '	@ $(IF_MACH_EXE) sparc sunos4 $$(AS) Mlib/sparc_sunos4_mach_dep.s -o sparc_sunos4_mach_dep.o'
	@ echo '	@ $(IF_MACH_EXE) sparc sunos4 mv sparc_sunos4_mach_dep.o $(O)/Mlib/mach_dep.o'
	@ echo '	@ $(IF_NOT_THERE_EXE) $(O)/Mlib/mach_dep.o \\'
	@ echo "          $$""(CC) -I$(LIB) -I$(GC_DIR) -c $$""(CFLAGS) Mlib/mach_dep.c"
	@ echo '	@ $(IF_NOT_THERE_EXE) $(O)/Mlib/mach_dep.o mv mach_dep.o $(O)/Mlib/mach_dep.o'
	@ echo ""
	@ echo "$(O)/Clib/inline-alloc.o: Clib/inline-alloc.c      \\"
	@ echo "                        Mlib/alpha_osf_inline-alloc.s \\"
	@ echo "                        $(IF_MACH_EXE)                \\"
	@ echo "                        $(IF_NOT_THERE_EXE)"
	@ echo "	@ $(IF_MACH_EXE) alpha osf echo \"Mlib/alpha_osf_inline-alloc.s:\""
	@ echo "	@ rm -f $(O)/Clib/inline-alloc.o"
	@ echo '	@ $(IF_MACH_EXE) alpha osf $$(AS) -O Mlib/alpha_osf_inline-alloc.s -o alpha_osf_inline-alloc.o'
	@ echo '	@ $(IF_MACH_EXE) alpha osf mv alpha_osf_inline-alloc.o $(O)/Clib/inline-alloc.o'
	@ echo '	@ $(IF_NOT_THERE_EXE) $(O)/Clib/inline-alloc.o echo "Clib/inline-alloc.c:"'
	@ echo "	@ $(IF_NOT_THERE_EXE) $(O)/Clib/inline-alloc.o \\"
	@ echo '          $$(CC) -I$(LIB) -I$(GC_DIR) -c $$(CFLAGS) Clib/inline-alloc.c -o $(O)/Clib/inline-alloc.o'
	@ echo "	@ $(IF_NOT_THERE_EXE) $(O)/Clib/inline-alloc.o \\"
	@ echo '            mv inline-alloc.o $(O)/Clib/inline-alloc.o'

Dobjects:
	@ echo "$(OBJECTS_NAME)=$(O_OBJ_MLIB) $(O_OBJ_CLIB) $(O_OBJ_SCHEME)"

#*---------------------------------------------------------------------*/
#*    libgc.a                                                          */
#*---------------------------------------------------------------------*/
.PHONY: libgc.a
libgc.a: $(LIB)/libgc.a

$(LIB)/libgc.a: $(GC_DIR)
	@ (cd $(GC_DIR); $(MAKE) gc.a CC=$(CC) \
           CFLAGS="-O2 -DSILENT -DNO_SIGNALS -DNO_DEBUGGING")
	@ cp $(GC_DIR)/gc.a $(LIB)/libgc.a; $(RANLIB) $(LIB)/libgc.a

#*---------------------------------------------------------------------*/
#*    libgc.so                                                         */
#*---------------------------------------------------------------------*/
.PHONY: libgc.so
libgc.so: $(LIB)/libgc.so

$(LIB)/libgc.so: $(GC_DIR)
	@ (cd $(GC_DIR); $(MAKE) libmsgc.so LD="$(LD)")

#*---------------------------------------------------------------------*/
#*    Dependences                                                      */
#*---------------------------------------------------------------------*/
$(O)/Clib/inline-alloc.o: $(GC_DIR)
