#*=====================================================================*/
#*    serrano/prgm/project/bigloo/runtime/Makefile                     */
#*    -------------------------------------------------------------    */
#*    Author      :  Manuel Serrano                                    */
#*    Creation    :  Tue Mar 21 08:14:18 1995                          */
#*    Last change :  Tue Aug  6 10:21:53 2002 (serrano)                */
#*    Copyright   :  1995-2002 Manuel Serrano, see LICENSE file        */
#*    -------------------------------------------------------------    */
#*    The (gnu) makefile to build the Bigloo's library.                */
#*=====================================================================*/

#*---------------------------------------------------------------------*/
#*    Default configuration                                            */
#*---------------------------------------------------------------------*/
include ../Makefile.config
include ../Makefile.misc

#*---------------------------------------------------------------------*/
#*    Compilers, Tools and Destinations                                */
#*---------------------------------------------------------------------*/
# The Bigloo used to bootstrap the library and to produce the heap file
BIGLOO		= $(BOOTBINDIR)/bigloo
# The directory containing the collector
GC_DIR		= $(BOOTDIR)/gc-boehm
# the shell to be used
SHELL           = /bin/sh
# configure
CONFIGURE	= $(BOOTDIR)/configure
# The heap file
HEAPC_FILE	= bigloo.heap
HEAPJVM_FILE	= bigloo.jheap
# Default object file locations
OBJDIR_SYS	= obj
OBJDIR_USR	= obj
# This two variables control how we are booting (from Scheme or C)
SCMOBJSUFFIX	= %.o
COBJSUFFIX	= 
# Default class file locations
CLASSDIR_SYS	= class
CLASSDIR_USR	= class
# The class suffix
SCMCLASSSUFFIX	= %.class
# The module association file
AFILE		= .afile
AFILE_EXE	= $(BOOTBINDIR)/afile
# The package association file
JFILE		= .jfile
PBASE		= bigloo.runtime
JFILE_EXE	= $(BOOTBINDIR)/jfile
# The qualifier of the build library
LIBQ		= 
# IF_XXX tools
IF_MACH_SRC	= $(BOOTDIR)/tools/if_mach.c
IF_MACH_EXE	= $(BOOTBINDIR)/if_mach

#*---------------------------------------------------------------------*/
#*    Compilation flags                                                */
#*---------------------------------------------------------------------*/
#*--- General flags ---------------------------------------------------*/
# The Bigloo compilation option used the produce an heap file
BHEAPFLAGS	= -unsafe -q -mkheap -mklib -s
#*--- Bigloo, safe ----------------------------------------------------*/
BSAFEFLAGS	= -O3 -mklib -cc $(CC) -fsharing \
                  -q -rm -s -unsafev -eval '(set! *indent* 4)' \
                  -copt $(CPICFLAGS)
CSAFEFLAGS	= -I$(BOOTLIBDIR) $(CFLAGS) $(CPICFLAGS)
#*--- Bigloo JVM flags ------------------------------------------------*/
BJSAFEFLAGS	= -jvm-purify
#*--- Bigloo, safe, debug ---------------------------------------------*/
BGSAFEFLAGS	= $(BSAFEFLAGS) -g
#*--- Bigloo, unsafe, optimize ----------------------------------------*/
BUNSAFEFLAGS	= -O4 -mklib -cc $(CC) -fsharing -q -s \
                  -copt $(CPICFLAGS) -unsafe
CUNSAFEFLAGS	= -I$(BOOTLIBDIR) $(CFLAGS) $(CPICFLAGS)
#*--- Bigloo, unsafe, profiled ----------------------------------------*/
BUNSAFEPFLAGS	= -O4 -mklib -unsafe -cc $(CC) -fsharing -q -s \
                   -p # -copt -DBIGLOO_GC_MALLOC_PROFILE
CUNSAFEPFLAGS	= -I$(BOOTLIBDIR) $(CFLAGS_P) -DPROFILE # -DBIGLOO_GC_MALLOC_PROFILE
#*--- Bigloo, safe, debug, heap ---------------------------------------*/
BSAFEDBGFLAGS	= $(BSAFEFLAGS) -gheap
#*--- Bigloo, unsafe, heap --------------------------------------------*/
BUNSAFEDBGFLAGS	= $(BUNSAFEFLAGS) -gheap
CDBGFLAGS	= -I$(BOOTLIBDIR) $(CUNSAFEFLAGS) $(BACKPTRFLAGS) -DBIGLOO_TRACE
#*--- GC compilation flags --------------------------------------------*/
#  Any change to these flags must be reported on the bdb/blib/Makefile */
GCOFLAGS	= -I$(BOOTLIBDIR) $(CFLAGS)
GCPFLAGS	= -I$(BOOTLIBDIR) $(CFLAGS_P) -DGATHERSTATS -DPROFILE \
                  # -DBIGLOO_GC_MALLOC_PROFILE
GCDBGFLAGS	= $(GCOFLAGS) $(BACKPTRFLAGS)
#*--- Bigloo JVM specific compilation flags ---------------------------*/
BGLJFLAGS	= -jfile $(JFILE)

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

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

#*---------------------------------------------------------------------*/
#*    C objects                                                        */
#*---------------------------------------------------------------------*/
CLIB		= cinit-obj cmain cerror cports cstring csymbol cvector \
                  cwriter capply cstruct csystem ccontrol ceval chash \
                  ctrace callcc cbinary cforeign cdsssl \
                  cucs2 cunicode cprocess csocket crgc ccustom cdlopen \
                  cthread

C_CLIB		= $(CLIB:%=Clib/%.c)

#*---------------------------------------------------------------------*/
#*    Java objects                                                     */
#*---------------------------------------------------------------------*/
JLIB		= foreign buffer configure stackwriter\
                  bbool output_string_port \
		  bchar input_console_port pair \
		  bexception input_file_port procedure \
		  bint input_port real \
		  blong bllong belong input_string_port input_pipe_port rest \
		  key struct \
		  callcc keyword symbol \
		  cobj cell magic tvector \
		  cnst nil tvector_read \
		  constant numeral \
		  custom obj unspecified \
		  eof object \
		  exit optional \
		  extended_pair output_port binary_port \
		  socket client_socket server_socket input_socket_port \
                  process flusher stack_trace dlopen \
                  bucs2 ucs2string bglthread

JLIB_SRC	= $(JLIB:%=%.java)
JAVA_JLIB	= $(JLIB:%=Jlib/%.java)

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

SCM_IEEE	= $(IEEE:%=Ieee/%.scm)
C_SCM_IEEE	= $(IEEE:%=Ieee/%.c)

#*---------------------------------------------------------------------*/
#*    Scheme R5rs objects                                              */
#*---------------------------------------------------------------------*/
R5RS  		= syntax hygiene

SCM_R5RS	= $(R5RS:%=R5rs/%.scm)
C_SCM_R5RS	= $(R5RS:%=R5rs/%.c)

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

SCM_LLIB	= $(LLIB:%=Llib/%.scm)
C_SCM_LLIB	= $(LLIB:%=Llib/%.c)

#*---------------------------------------------------------------------*/
#*    The interpreter objects                                          */
#*---------------------------------------------------------------------*/
EVAL		= eval expand expanders expdlet expdbool expddefine \
                  expdcase expddo expdtry expdstruct evmeaning \
                  evcompile evenv progn macro expdquote evprimop \
                  expdsrfi0 expdrecord expdargs

SCM_EVAL	= $(EVAL:%=Eval/%.scm)
C_SCM_EVAL	= $(EVAL:%=Eval/%.c)

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

SCM_MATCH	= $(MATCH:%=Match/%.scm)
C_SCM_MATCH	= $(MATCH:%=Match/%.c)

#*---------------------------------------------------------------------*/
#*    The Regular grammar generator objects                            */
#*---------------------------------------------------------------------*/
RGC		= rgccompile rgcdfa rgcrules rgctree rgcconfig \
                  rgcexpand rgcset rgcposix rgc

SCM_RGC		= $(RGC:%=Rgc/%.scm)
C_SCM_RGC	= $(RGC:%=Rgc/%.c)

#*---------------------------------------------------------------------*/
#*    The Pretty-printer objects                                       */
#*---------------------------------------------------------------------*/
PP		= pp circle

SCM_PP		= $(PP:%=Pp/%.scm)
C_SCM_PP	= $(PP:%=Pp/%.c)

#*---------------------------------------------------------------------*/
#*    The reader                                                       */
#*---------------------------------------------------------------------*/
READ		= reader

SCM_READ	= $(READ:%=Read/%.scm)
C_SCM_READ	= $(READ:%=Read/%.c)

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

SCM_LALR	= $(LALR:%=Lalr/%.scm)
C_SCM_LALR	= $(LALR:%=Lalr/%.c)

#*---------------------------------------------------------------------*/
#*    All source files                                                 */
#*---------------------------------------------------------------------*/
SCM_USR_SRC	= $(SCM_IEEE) $(SCM_LLIB) $(SCM_R5RS)
SCM_SYS_SRC	= $(SCM_READ) $(SCM_RGC) $(SCM_PP) \
                  $(SCM_EVAL) $(SCM_MATCH) $(SCM_LALR)

C_SRC		= $(C_CLIB)
JAVA_SRC	= $(JAVA_JLIB)

#*---------------------------------------------------------------------*/
#*    Src files                                                        */
#*---------------------------------------------------------------------*/
SRC_FILES	= $(SCM_USR_SRC) $(SCM_SYS_SRC) $(C_SRC) $(JAVA_SRC)

#*---------------------------------------------------------------------*/
#*    Include files                                                    */
#*---------------------------------------------------------------------*/
INCLUDE_FILE	= Include/bigloo.h

#*---------------------------------------------------------------------*/
#*    Object files                                                     */
#*---------------------------------------------------------------------*/
OBJECTS		= $(SCM_SYS_SRC:%.scm=objs/$(OBJDIR_SYS)/%.o) \
                  $(SCM_USR_SRC:%.scm=objs/$(OBJDIR_USR)/%.o) \
                  $(C_SRC:%.c=objs/$(OBJDIR_SYS)/%.o) \
                  objs/$(OBJDIR_SYS)/Mlib/mach_dep.o

#*---------------------------------------------------------------------*/
#*    JVM class files                                                  */
#*---------------------------------------------------------------------*/
CLASSES		= $(SCM_SYS_SRC:%.scm=objs/$(CLASSDIR_SYS)/bigloo/runtime/%.class) \
                  $(SCM_USR_SRC:%.scm=objs/$(CLASSDIR_USR)/bigloo/runtime/%.class)

#*---------------------------------------------------------------------*/
#*    JVM class files                                                  */
#*---------------------------------------------------------------------*/
JAS		= $(SCM_SYS_SRC:%.scm=objs/$(CLASSDIR_SYS)/bigloo/runtime/%.jas) \
                  $(SCM_USR_SRC:%.scm=objs/$(CLASSDIR_USR)/bigloo/runtime/%.jas)

#*---------------------------------------------------------------------*/
#*    C Object files for the distribution                              */
#*---------------------------------------------------------------------*/
C_OBJECTS	= $(SCM_SYS_SRC:%.scm=objs/$(OBJDIR_SYS)/%.c) \
                  $(SCM_USR_SRC:%.scm=objs/$(OBJDIR_USR)/%.c)

#*---------------------------------------------------------------------*/
#*    Population                                                       */
#*---------------------------------------------------------------------*/
POPULATION	= $(SRC_FILES) \
                  Makefile \
                  Llib/make-lib.scm \
		  Lalr/lalr.sch \
		  Rgc/rgc-node.sch \
		  Eval/byte-code.sch \
		  Mlib/mach_dep.c \
		  $(INCLUDE_FILE)

#*---------------------------------------------------------------------*/
#*    .SUFFIXES                                                        */
#*---------------------------------------------------------------------*/
.SUFFIXES:

#*---------------------------------------------------------------------*/
#*    all                                                              */
#*---------------------------------------------------------------------*/
.PHONY: all all-c all-jvm

all: all-c all-jvm

all-c: heap-c libs-c gcs
all-jvm: heap-jvm libs-jvm

#*---------------------------------------------------------------------*/
#*    distrib                                                          */
#*---------------------------------------------------------------------*/
distrib: $(AFILE)
	@ if [ `pwd` = $(BOOTDIR)/runtime ]; then \
             echo "*** ERROR:Illegal dir to make a distrib `pwd`"; \
             exit 1; \
          fi
	@ $(MAKE) objs-sans-dirs
	@ $(MAKE) distlibs
	@ $(MAKE) $(JFILE)

#*---------------------------------------------------------------------*/
#*    The includes                                                     */
#*    -------------------------------------------------------------    */
#*    This entry point is used to force a regeneration of the          */
#*    include files after a `make clean'.                              */
#*---------------------------------------------------------------------*/
.PHONY: includes

includes: $(BOOTLIBDIR)/bigloo.h $(BOOTLIBDIR)/bigloo_config.h

#*---------------------------------------------------------------------*/
#*    The heap construction                                            */
#*---------------------------------------------------------------------*/
.PHONY: heap heap-c heap-jvm

heap: heap-c
heap-c: $(AFILE) includes
	@ $(RM) -f $(BOOTLIBDIR)/$(HEAPC_FILE)
	BIGLOOLIB=$(BOOTLIBDIR); export BIGLOOLIB; \
	LD_LIBRARY_PATH=$(BOOTLIBDIR):$$LD_LIBRARY_PATH; \
        export LD_LIBRARY_PATH; \
        $(BIGLOO) $(BHEAPFLAGS) -L $(BOOTLIBDIR) Llib/make-lib.scm -heap $(HEAPC_FILE)
	@ echo "Heap Done..."
	@ echo "-------------------------------"

heap-jvm: $(AFILE) $(JFILE) includes
	@ $(RM) -f $(BOOTLIBDIR)/$(HEAPJVM_FILE)
	BIGLOOLIB=$(BOOTLIBDIR); export BIGLOOLIB; \
	LD_LIBRARY_PATH=$(BOOTLIBDIR):$$LD_LIBRARY_PATH; \
        export LD_LIBRARY_PATH; \
        $(BIGLOO) -target jvm -jfile $(JFILE) -L $(BOOTLIBDIR) \
                  $(BHEAPFLAGS) Llib/make-lib.scm -heap $(HEAPJVM_FILE)
	@ echo "Heap Done..."
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    Bigloo C libraries compilation                                   */
#*---------------------------------------------------------------------*/
.PHONY: lib lib_u lib_p lib_d lib-c lib-c_u lib-c_p lib-c_d libs libs-c

libs: lib_u lib # lib_p lib_d
libs-c: lib-c_u lib-c # lib-c_p lib-c_d

lib: lib-c
lib-c: includes
	@ $(RM) -f $(BOOTLIBDIR)/libbigloo.a.old
	@ if [ -f $(BOOTLIBDIR)/libbigloo-$(RELEASE).a ]; then \
            mv $(BOOTLIBDIR)/libbigloo-$(RELEASE).a $(BOOTLIBDIR)/libbigloo.a.old; \
          fi
	$(MAKE) one-lib-c \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BSAFEFLAGS)" \
                OBJDIR_USR=obj OBJDIR_SYS=obj_u \
                LIBQ=

lib_u: lib-c_u
lib-c_u: includes
	$(MAKE) one-lib-c \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BUNSAFEFLAGS)" \
                OBJDIR_USR=obj_u OBJDIR_SYS=obj_u \
                LIBQ=_u

lib_p: lib-c_p                
lib-c_p: includes
	$(MAKE) one-lib-c \
                BFLAGS_SYS="$(BUNSAFEPFLAGS)" \
                BFLAGS_USR="$(BUNSAFEPFLAGS)" \
                OBJDIR_USR=obj_p OBJDIR_SYS=obj_p \
                LIBQ=_p

lib_d: lib-c_d                
lib-c_d: includes
	$(MAKE) one-lib-c \
                BFLAGS_SYS="$(BUNSAFEDBGFLAGS)" \
                BFLAGS_USR="$(BSAFEDBGFLAGS)" \
                OBJDIR_USR=obj_d OBJDIR_SYS=obj_d \
                LIBQ=_d
      
one-lib-c: $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).a \
         $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX)

$(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).a: $(OBJECTS)
	@ $(RM) -f $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).a
	$(AR) $(ARFLAGS) \
                $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).a $(OBJECTS)
	$(RANLIB) $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).a
	@ echo "lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).a done..."
	@ echo "-------------------------------"

$(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX): $(OBJECTS)
	@ if [ ! "$(LD)" = "true" ]; then \
	   $(RM) -f $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) && \
	   if [ "$(LDSONAME) " = " " ]; then \
	     $(LD) -o $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) \
                     $(OBJECTS) -lm -lc; \
           else \
	     $(LD) -o $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) \
                      $(LDSONAME) lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) \
                      $(OBJECTS) -lm -lc; \
           fi && \
	   echo "lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) done..."; \
	   echo "-------------------------------"; \
          fi

#*---------------------------------------------------------------------*/
#*    Bigloo JVM libraries compilation                                 */
#*---------------------------------------------------------------------*/
.PHONY: lib-jvm lib-jvm_u lib-jvm_p lib-jvm_d libs-jvm

libs-jvm: lib-jvm_u lib-jvm

lib-jvm: includes
	$(MAKE) one-lib-jvm \
                BFLAGS_SYS="$(BUNSAFEFLAGS) $(BJSAFEFLAGS)" \
                BFLAGS_USR="$(BSAFEFLAGS) $(BJSAFEFLAGS)" \
                CLASSDIR_USR=class CLASSDIR_SYS=class \
                LIBQ=

lib-jvm_u: includes
	$(MAKE) one-lib-jvm \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BUNSAFEFLAGS)" \
                CLASSDIR_USR=class_u CLASSDIR_SYS=class_u \
                LIBQ=_u
                
lib-jvm_p: includes
	$(MAKE) one-lib-jvm \
                BFLAGS_SYS="$(BUNSAFEPFLAGS)" \
                BFLAGS_USR="$(BUNSAFEPFLAGS)" \
                CLASSDIR_USR=class_p CLASSDIR_SYS=class_p \
                LIBQ=_p

one-lib-jvm: $(BOOTLIBDIR)/$(LIBRARYNAME)$(LIBQ).zip

$(BOOTLIBDIR)/$(LIBRARYNAME)$(LIBQ).zip: $(CLASSES) class$(LIBQ)/jlib Jlib/configure.java
	@$(RM) -f $(BOOTLIBDIR)/$(LIBRARYNAME)$(LIBQ).zip
	@(cd objs/class$(LIBQ) && \
	 $(ZIP) -q $(ZFLAGS) $(BOOTLIBDIR)/$(LIBRARYNAME)$(LIBQ).zip \
                 $(SCM_SYS_SRC:%.scm=bigloo/runtime/%.class) \
                 $(SCM_USR_SRC:%.scm=bigloo/runtime/%.class) \
                 $(JAVA_SRC:Jlib/%.java=bigloo/%.class) \
                bigloo/keybucket.class bigloo/bucket.class \
                bigloo/flusher[$$]*.class)
	@ echo "$(LIBRARYNAME)$(LIBQ).zip done..."
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    Bigloo JAS libraries compilation                                 */
#*---------------------------------------------------------------------*/
.PHONY: lib-jas lib-jas_u lib-jas_p lib-jas_d libs-jas jlib

libs-jas: lib-jas_u lib-jas lib-jas_p lib-jas_d

lib-jas: includes
	@ $(RM) -f $(BOOTLIBDIR)/libbigloo-$(RELEASE).a.old
	@ if [ -f $(BOOTLIBDIR)/libbigloo-$(RELEASE).a ]; then \
            mv $(BOOTLIBDIR)/libbigloo-$(RELEASE).a $(BOOTLIBDIR)/libbigloo-$(RELEASE).a.old; \
          fi
	$(MAKE) one-lib-jas \
                SCMCLASSSUFFIX="%.jas" \
                BGLJFLAGS="$(BGLJFLAGS) -jast" \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BSAFEFLAGS)" \
                CLASSDIR_USR=class CLASSDIR_SYS=class_u \
                LIBQ=

lib-jas_u: includes
	$(MAKE) one-lib-jas \
                SCMCLASSSUFFIX="%.jas" \
                BGLJFLAGS="$(BGLJFLAGS) -jvmas" \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BUNSAFEFLAGS)" \
                CLASSDIR_USR=class_u CLASSDIR_SYS=class_u \
                LIBQ=_u
                
lib-jas_p: includes
	$(MAKE) one-lib-jas \
                SCMCLASSSUFFIX="%.jas" \
                BGLJFLAGS="$(BGLJFLAGS) -jvmas" \
                BFLAGS_SYS="$(BUNSAFEPFLAGS)" \
                BFLAGS_USR="$(BUNSAFEPFLAGS)" \
                CLASSDIR_USR=class_p CLASSDIR_SYS=class_p \
                LIBQ=_p

one-lib-jas: $(JAS)

class/jlib:
	(CLASSPATH=$(BOOTDIR)/runtime/objs/class:.:$$CLASSPATH; \
         export CLASSPATH; \
         cd Jlib && \
         $(JAVAC) -d ../objs/class \
                  $(JVMCPATH) $(JCFLAGS) $(JLIB_SRC))

class_u/jlib:
	(CLASSPATH=$(BOOTDIR)/runtime/objs/class_u:.:$$CLASSPATH; \
         export CLASSPATH; \
         cd Jlib && \
         $(JAVAC) -d ../objs/class_u \
                  $(JVMCPATH) $(JCFLAGS) $(JLIB_SRC))

class_p/jlib:
	(CLASSPATH=$(BOOTDIR)/runtime/objs/class_p:.:$$CLASSPATH; \
         export CLASSPATH; \
         cd Jlib && \
         $(JAVAC) -d ../objs/class_p \
                  $(JVMCPATH) $(JCFLAGS) $(JLIB_SRC))

#*---------------------------------------------------------------------*/
#*    Gc libraries compilation                                         */
#*---------------------------------------------------------------------*/
.PHONY: gc gc_d gc_p gcs gc_fth

gcs: gc gc_fth # gc_p gc_d

gc:
	$(MAKE) one-gc \
                LIBQ="" \
                GCFLAGS="$(CGCFLAGS) $(GCOFLAGS)" \
                LIB="$(BOOTLIBDIR)"

gc_fth:
	if [ "$(CGCTHREADFLAGS) " != " " ]; then \
	  $(MAKE) one-gc \
                  LIBSUF="_fth" \
                  LIBQ="" \
                  GCFLAGS="$(CGCFLAGS) $(GCOFLAGS) $(CGCTHREADFLAGS)" \
                  LIB="$(BOOTLIBDIR)"; \
        fi

gc_p:
	$(MAKE) one-gc \
                LIBQ="_p" \
                GCFLAGS="$(CGCFLAGS) $(GCPFLAGS)" \
                LIB="$(BOOTLIBDIR)"

gc_d:
	$(MAKE) one-gc \
                LIBQ="_d" \
                GCFLAGS="$(CGCFLAGS) $(GCDBGFLAGS)" \
                LIB="$(BOOTLIBDIR)"

one-gc: gcstatic gcshared

gcstatic: $(GC_DIR)$(LIBSUF)$(LIBQ)
	(cd $(GC_DIR)$(LIBSUF)$(LIBQ) && \
           $(MAKE) gc.a CC=$(CC) CFLAGS="$(GCFLAGS)")
	cp $(GC_DIR)$(LIBSUF)$(LIBQ)/gc.a \
           $(LIB)/libbigloogc$(LIBSUF)-$(RELEASE)$(LIBQ).a && \
           $(RANLIB) $(LIB)/libbigloogc$(LIBSUF)-$(RELEASE)$(LIBQ).a

gcshared: $(GC_DIR)$(LIBSUF)$(LIBQ)
	(cd $(GC_DIR)$(LIBSUF)$(LIBQ) && \
            if [ ! "$(LD)" = "true" ]; then \
              $(MAKE) libmsgc.$(SHAREDSUFFIX) LD="$(LD)" CFLAGS="$(GCFLAGS) $(CPICFLAGS)" \
	              SONAME="libbigloogc$(LIBSUF)-$(RELEASE)$(LIBQ).$(SHAREDSUFFIX)"; \
            fi)
	if [ ! "$(LD)" = "true" ]; then \
            cp $(GC_DIR)$(LIBSUF)$(LIBQ)/libmsgc.$(SHAREDSUFFIX) \
            $(LIB)/libbigloogc$(LIBSUF)-$(RELEASE)$(LIBQ).$(SHAREDSUFFIX); \
          fi

#*---------------------------------------------------------------------*/
#*    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/%)
	@ echo runtime/Clib/gc_profile.c

#*---------------------------------------------------------------------*/
#*    touchall                                                         */
#*---------------------------------------------------------------------*/
touchall:
	touch $(POPULATION)
	@- (cd $(GC_DIR); touch *.c)

#*---------------------------------------------------------------------*/
#*    Soure file distributions                                         */
#*---------------------------------------------------------------------*/
distlibs: distlib_u distlib

distlib_u:
	$(MAKE) one-distlib \
		BIGLOO=$(BIGLOO) \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BUNSAFEFLAGS)" \
                OBJDIR_USR=obj_u OBJDIR_SYS=obj_u


distlib:
	$(MAKE) one-distlib \
		BIGLOO=$(BIGLOO) \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BGSAFEFLAGS)" \
                OBJDIR_USR=obj OBJDIR_SYS=obj_u

one-distlib: $(C_OBJECTS)

#*---------------------------------------------------------------------*/
#*    boot                                                             */
#*    -------------------------------------------------------------    */
#*    Boot the library on a bare system.                               */
#*---------------------------------------------------------------------*/
boot: dirs includes
	@ if [ "$(GCCUSTOM)" = "yes" ]; then \
	    $(MAKE) gc; \
	  fi
	@ $(MAKE) lib-c_u lib-c SCMOBJSUFFIX="" COBJSUFFIX=%.o

boot-jvm: heap-jvm lib-jvm lib-jvm_u

#*---------------------------------------------------------------------*/
#*    bigboot                                                          */
#*    -------------------------------------------------------------    */
#*    Boot a new Bigloo using the Scheme files (instead of the C       */
#*    pre-compiled files).                                             */
#*---------------------------------------------------------------------*/
bigboot: objs includes lib-c_u lib-c heap-c
	@ if [ "$(GCCUSTOM)" = "yes" ]; then \
	    $(MAKE) gc; \
	  fi

#*---------------------------------------------------------------------*/
#*    compile-bee                                                      */
#*---------------------------------------------------------------------*/
compile-bee: lib_p lib_d gc_p gc_d

#*---------------------------------------------------------------------*/
#*    install & uninstall                                              */
#*---------------------------------------------------------------------*/
.PHONY: install install-bee install-jvm uninstall uninstall-bee \
        install-thread uninstall-thread

install:
	if [ $(DESTDIR)$(FILDIR) != $(BOOTLIBDIR) ]; then \
           (base=`echo $(DESTDIR)$(FILDIR) | sed 's/[/][^/]*$$//'`; \
            bbase=`echo $$base | sed 's/[/][^/]*$$//'`; \
            if [ ! -d $$bbase ]; then \
               (mkdir $$bbase && chmod a+rx $$bbase); \
            fi && \
            if [ ! -d $$base ]; then \
               mkdir $$base && chmod a+rx $$base; \
            fi) && \
	   if [ ! -d $(DESTDIR)$(FILDIR) ]; then \
              (mkdir $(DESTDIR)$(FILDIR) && chmod a+rx $(DESTDIR)$(FILDIR)); \
           fi && \
	   cp $(BOOTLIBDIR)/bigloo.h $(DESTDIR)$(FILDIR)/bigloo.h && \
           chmod $(BMASK) $(DESTDIR)$(FILDIR)/bigloo.h && \
	   cp $(BOOTLIBDIR)/bigloo_config.h $(DESTDIR)$(FILDIR)/bigloo_config.h && \
           chmod $(BMASK) $(DESTDIR)$(FILDIR)/bigloo_config.h && \
	   cp $(BOOTLIBDIR)/bigloo.heap $(DESTDIR)$(FILDIR)/bigloo.heap && \
           chmod $(BMASK) $(DESTDIR)$(FILDIR)/bigloo.heap; \
	fi
	$(MAKE) install-lib LIB=libbigloo-$(RELEASE)
	$(MAKE) install-lib LIB=libbigloo_u-$(RELEASE)
	if [ "$(GCCUSTOM)" = "yes" ]; then \
	  $(MAKE) install-lib LIB=libbigloogc-$(RELEASE); \
        fi

install-jvm:
	if [ $(ZIPDIR) != $(BOOTLIBDIR) ]; then \
	  cp $(BOOTLIBDIR)/bigloo.jheap $(DESTDIR)$(FILDIR)/bigloo.jheap && \
             chmod $(BMASK) $(DESTDIR)$(FILDIR)/bigloo.jheap && \
	  cp $(BOOTLIBDIR)/bigloo.zip $(ZIPDIR)/bigloo.zip && \
             chmod $(BMASK) $(ZIPDIR)/bigloo.zip && \
	  cp $(BOOTLIBDIR)/bigloo_u.zip $(ZIPDIR)/bigloo_u.zip && \
             chmod $(BMASK) $(ZIPDIR)/bigloo_u.zip; \
        fi

install-bee:
	$(MAKE) install-lib LIB=libbigloo-$(RELEASE)_p
	$(MAKE) install-lib LIB=libbigloo-$(RELEASE)_d
	$(MAKE) install-lib LIB=libbigloogc-$(RELEASE)_p
	$(MAKE) install-lib LIB=libbigloogc-$(RELEASE)_d

install-thread:
	$(MAKE) install-lib LIB=libbigloogc_fth-$(RELEASE); \

uninstall: uninstall-bee uninstall-jvm uninstall-thread
	if [ $(DESTDIR)$(FILDIR) != $(BOOTLIBDIR) ]; then \
          $(RM) -f $(DESTDIR)$(FILDIR)/bigloo.h && \
          $(RM) -f $(DESTDIR)$(FILDIR)/bigloo_config.h && \
          $(RM) -f $(DESTDIR)$(FILDIR)/bigloo.heap && \
	  $(MAKE) uninstall-lib LIB=libbigloo-$(RELEASE) && \
	  $(MAKE) uninstall-lib LIB=libbigloo_u-$(RELEASE) && \
	  $(MAKE) uninstall-lib LIB=libbigloogc-$(RELEASE) && \
          $(RM) -rf $(DESTDIR)$(FILDIR); \
        fi

uninstall-jvm:
	-$(RM) -f $(DESTDIR)$(FILDIR)/bigloo.jheap
	-$(RM) -f $(ZIPDIR)/bigloo.zip
	-$(RM) -f $(ZIPDIR)/bigloo_u.zip

uninstall-bee:
	- $(MAKE) uninstall-lib LIB=libbigloo-$(RELEASE)_p
	- $(MAKE) uninstall-lib LIB=libbigloo-$(RELEASE)_d
	- $(MAKE) uninstall-lib LIB=libbigloogc-$(RELEASE)_p
	- $(MAKE) uninstall-lib LIB=libbigloogc-$(RELEASE)_d

uninstall-thread:
	- $(MAKE) uninstall-lib LIB=libbigloogc_fth-$(RELEASE)

#*---------------------------------------------------------------------*/
#*    cleaning                                                         */
#*---------------------------------------------------------------------*/
.PHONY: gcclean clean-c clean-jvm clean cleanall distclean

gcclean:
	@- $(RM) -rf $(GC_DIR)_fth
	@- $(RM) -rf $(GC_DIR)_p
	@- $(RM) -rf $(GC_DIR)_d
	@- $(RM) -f $(IF_MACH_EXE)
	@- (cd $(GC_DIR) && $(MAKE) clean)

clean-c: gcclean
	$(RM) -f $(BOOTLIBDIR)/bigloo.h
	$(RM) -f $(BOOTLIBDIR)/bigloo_config.h
	$(MAKE) cleanobj OBJDIR_USR=obj OBJDIR_SYS=obj_u
	$(MAKE) cleanobj OBJDIR_USR=obj_u OBJDIR_SYS=obj_u
	$(MAKE) cleanobj OBJDIR_USR=obj_p OBJDIR_SYS=obj_p
	$(MAKE) cleanobj OBJDIR_USR=obj_d OBJDIR_SYS=obj_d

clean-jvm:
	$(RM) -rf objs/class*/bigloo/*.class
	$(RM) -rf objs/class*/bigloo/runtime/*/*.class
	$(MAKE) cleanclass CLASSDIR_USR=class CLASSDIR_SYS=class_u
	$(MAKE) cleanclass CLASSDIR_USR=class_u CLASSDIR_SYS=class_u
	$(MAKE) cleanclass CLASSDIR_USR=class_p CLASSDIR_SYS=class_p

cleanobj:
	$(RM) -f $(OBJECTS)

cleanclass:
	$(RM) -f $(CLASSES) $(JAS)

clean: clean-c clean-jvm

cleanall: clean-c clean
	@ if [ `pwd` = $$HOME/prgm/project/bigloo/runtime ]; then \
             echo "*** ERROR:Illegal dir to make a cleanall `pwd`"; \
             exit 1; \
          fi
	$(RM) -f $(BOOTLIBDIR)/$(HEAPC_FILE)
	$(RM) -f $(BOOTLIBDIR)/$(HEAPJVM_FILE)
	$(RM) -f $(BOOTLIBDIR)/lib$(LIBRARYNAME)*.*
	$(RM) -f $(BOOTLIBDIR)/libbigloogc*.*

distclean: cleanall
	$(RM) -rf objs/class*

#*---------------------------------------------------------------------*/
#*     .scm --> .o                                                     */
#*---------------------------------------------------------------------*/
objs/obj_u/$(SCMOBJSUFFIX): %.scm
	$(BIGLOO) $(BFLAGS_SYS) -c $*.scm -o objs/obj_u/$*.o

objs/obj/$(SCMOBJSUFFIX): %.scm
	$(BIGLOO) $(BFLAGS_USR) -c $*.scm -o objs/obj/$*.o

objs/obj_p/$(SCMOBJSUFFIX): %.scm
	$(BIGLOO) $(BFLAGS_USR) -c $*.scm -o objs/obj_p/$*.o

objs/obj_d/Ieee/$(SCMOBJSUFFIX): Ieee/%.scm
	$(BIGLOO) $(BFLAGS_USR) -c Ieee/$*.scm -o objs/obj_d/Ieee/$*.o
objs/obj_d/Llib/$(SCMOBJSUFFIX): Llib/%.scm
	$(BIGLOO) $(BFLAGS_USR) -c Llib/$*.scm -o objs/obj_d/Llib/$*.o
objs/obj_d/R5rs/$(SCMOBJSUFFIX): R5rs/%.scm
	$(BIGLOO) $(BFLAGS_USR) -c R5rs/$*.scm -o objs/obj_d/R5rs/$*.o
objs/obj_d/$(SCMOBJSUFFIX): %.scm
	$(BIGLOO) $(BFLAGS_SYS) -c $*.scm -o objs/obj_d/$*.o

#*---------------------------------------------------------------------*/
#*     .c --> .o                                                       */
#*---------------------------------------------------------------------*/
objs/obj_u/$(COBJSUFFIX): objs/obj_u/%.c
	$(CC) $(CUNSAFEFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include -c objs/obj_u/$*.c && mv $(@F) objs/obj_u/$*.o
objs/obj/$(COBJSUFFIX): objs/obj/%.c
	$(CC) $(CUNSAFEFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include -c objs/obj/$*.c && mv $(@F) objs/obj/$*.o

#*---------------------------------------------------------------------*/
#*     .c --> .o                                                       */
#*---------------------------------------------------------------------*/
objs/obj_u/Clib/%.o: Clib/%.c
	$(CC) $(CUNSAFEFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include -c Clib/$*.c && mv $(@F) objs/obj_u/Clib/$*.o
objs/obj/Clib/%.o: Clib/%.c
	$(CC) $(CSAFEFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include -c Clib/$*.c && mv $(@F) objs/obj/Clib/$*.o
objs/obj_d/Clib/%.o: Clib/%.c
	$(CC) $(CDBGFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include -c Clib/$*.c && mv $(@F) objs/obj_d/Clib/$*.o
objs/obj_p/Clib/%.o: Clib/%.c
	$(CC) $(CUNSAFEPFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include -c Clib/$*.c && mv $(@F) objs/obj_p/Clib/$*.o

#*---------------------------------------------------------------------*/
#*     .scm --> .c                                                     */
#*---------------------------------------------------------------------*/
objs/obj_u/%.c: %.scm
	$(BIGLOO) $(BFLAGS_SYS) -c $*.scm -indent -o objs/obj_u/$*.c
objs/obj/%.c: %.scm
	$(BIGLOO) $(BFLAGS_USR) -c $*.scm -indent -o objs/obj/$*.c

#*---------------------------------------------------------------------*/
#*    mach_dep.o                                                       */
#*---------------------------------------------------------------------*/
objs/$(OBJDIR_SYS)/Mlib/mach_dep.o: Mlib/mach_dep.c \
                      Mlib/sparc_sunos5_mach_dep.s \
                      Mlib/sparc_sunos4_mach_dep.s \
                      $(IF_MACH_EXE)
	@ echo "Mlib/mach_dep.c:"
	@ $(RM) -f objs/$(OBJDIR_SYS)/Mlib/mach_dep.o
	$(IF_MACH_EXE) sparc sunos5 $(AS) -o objs/$(OBJDIR_SYS)/Mlib/mach_dep.o Mlib/sparc_sunos5_mach_dep.s
	$(IF_MACH_EXE) sparc sunos4 $(AS) -o objs/$(OBJDIR_SYS)/Mlib/mach_dep.o Mlib/sparc_sunos4_mach_dep.s
	if [ ! -f objs/$(OBJDIR_SYS)/Mlib/mach_dep.o ]; then \
	   $(CC) -c $(CSAFEFLAGS) -I$(GC_DIR) -I$(GC_DIR)/include Mlib/mach_dep.c && \
             mv mach_dep.o objs/$(OBJDIR_SYS)/Mlib/mach_dep.o; \
          fi

#*---------------------------------------------------------------------*/
#*     .scm --> .class                                                 */
#*---------------------------------------------------------------------*/
objs/class_u/bigloo/runtime/$(SCMCLASSSUFFIX): %.scm $(JFILE)
	$(BIGLOO) -jvm $(BGLJFLAGS) $(BFLAGS_SYS) -c $< -o $@

objs/class/bigloo/runtime/$(SCMCLASSSUFFIX): %.scm $(JFILE)
	$(BIGLOO) -jvm $(BGLJFLAGS) $(BFLAGS_USR) -c $< -o $@

objs/class_p/bigloo/runtime/$(SCMCLASSSUFFIX): %.scm $(JFILE)
	$(BIGLOO) -jvm $(BGLJFLAGS) $(BFLAGS_USR) -c $< -o $@

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

#*---------------------------------------------------------------------*/
#*    $(GC_DIR)_thread ...                                             */
#*---------------------------------------------------------------------*/
$(GC_DIR)_fth:
	$(MAKE) gc_dir LIBQ=_fth

#*---------------------------------------------------------------------*/
#*    $(GC_DIR)_d ...                                                  */
#*---------------------------------------------------------------------*/
$(GC_DIR)_d:
	$(MAKE) gc_dir LIBQ=_d

#*---------------------------------------------------------------------*/
#*    $(GC_DIR)_p ...                                                  */
#*---------------------------------------------------------------------*/
$(GC_DIR)_p:
	$(MAKE) gc_dir LIBQ=_p

#*---------------------------------------------------------------------*/
#*    $(GC_DIR)$(LIBQ) ...                                             */
#*---------------------------------------------------------------------*/
gc_dir:
	@ mkdir $(GC_DIR)$(LIBQ)
	@ (cd $(GC_DIR)$(LIBQ) && \
           for p in $(GC_DIR)/*.c; do \
             ln -s $$p .; \
           done && \
           for p in $(GC_DIR)/*.s; do \
             ln -s $$p .; \
           done && \
           for p in $(GC_DIR)/*.S; do \
             ln -s $$p .; \
           done && \
           for p in $(GC_DIR)/*.h; do \
             ln -s $$p .; \
           done && \
           ln -s $(GC_DIR)/Makefile . && \
           ln -s $(GC_DIR)/include .)

#*---------------------------------------------------------------------*/
#*    objs                                                             */
#*    -------------------------------------------------------------    */
#*    This entry point creates all the directory where the object      */
#*    files and the Jvm classes are stored.                            */
#*---------------------------------------------------------------------*/
.PHONY: objs objs-sans-dirs dirs

objs-sans-dirs: Jlib/configure.java
	mkdir -p objs/obj/Clib
	mkdir -p objs/obj/Ieee
	mkdir -p objs/obj/Llib
	mkdir -p objs/obj/R5rs
	(dirs="Clib Ieee Llib Mlib R5rs Rgc Eval Lalr Match Pp Read"; \
         objs="obj_u obj_d obj_p"; \
         for o in $$objs; do \
           mkdir -p objs/$$o; \
           for d in $$dirs; do \
             mkdir -p objs/$$o/$$d; \
           done; \
         done)
	mkdir -p objs/class
	mkdir -p objs/class/bigloo
	mkdir -p objs/class/bigloo/runtime
	mkdir -p objs/class_u
	mkdir -p objs/class_u/bigloo
	mkdir -p objs/class_u/bigloo/runtime

dirs:
	(dirs="Jlib Ieee Llib Mlib R5rs Rgc Eval Lalr Match Pp Read"; \
         objs="class_u class class_p"; \
         for o in $$objs; do \
           echo objs/$$o/bigloo/runtime; \
           mkdir -p objs/$$o/bigloo/runtime; \
           for d in $$dirs; do \
             echo objs/$$o/bigloo/runtime/$$d; \
             mkdir -p objs/$$o/bigloo/runtime/$$d; \
           done; \
         done)

obj: objs-sans-dirs dirs

#*---------------------------------------------------------------------*/
#*    $(BOOTLIBDIR)/bigloo.h                                           */
#*---------------------------------------------------------------------*/
$(BOOTLIBDIR)/bigloo.h: Include/bigloo.h
	cp Include/bigloo.h $(BOOTLIBDIR)/bigloo.h

#*---------------------------------------------------------------------*/
#*    $(BOOTLIBDIR)/bigloo_config.h                                    */
#*---------------------------------------------------------------------*/
$(BOOTLIBDIR)/bigloo_config.h: $(BOOTDIR)/configure $(BOOTDIR)/Makefile
	$(BOOTDIR)/configure --bigloo_config.h=$(BOOTLIBDIR)/bigloo_config.h \
                             --bigloo_config.jvm=Jlib/configure.java \
                             --libdir=$(LIBDIR) \
                             --fildir=$(FILDIR) \
                             --zipdir=$(ZIPDIR) \
                             --indent=stdindent \
                             --no-summary
	$(RM) -f configure.log

#*---------------------------------------------------------------------*/
#*    Jlib/configure.java                                              */
#*---------------------------------------------------------------------*/
Jlib/configure.java: $(BOOTDIR)/configure $(BOOTDIR)/Makefile
	$(BOOTDIR)/configure --bigloo_config.h=$(BOOTLIBDIR)/bigloo_config.h \
                             --bigloo_config.jvm=Jlib/configure.java \
                             --libdir=$(LIBDIR) \
                             --fildir=$(FILDIR) \
                             --zipdir=$(ZIPDIR) \
                             --indent=stdindent \
                             --no-summary
	$(RM) -f configure.log

#*---------------------------------------------------------------------*/
#*    $(AFILE)                                                         */
#*---------------------------------------------------------------------*/
afile: $(AFILE)
$(AFILE):
	$(AFILE_EXE) $(SCM_USR_SRC) $(SCM_SYS_SRC) > $(AFILE)

#*---------------------------------------------------------------------*/
#*    $(JFILE)                                                         */
#*---------------------------------------------------------------------*/
$(JFILE):
	$(JFILE_EXE) -pbase $(PBASE) $(SCM_USR_SRC) $(SCM_SYS_SRC) > $(JFILE)
