#*=====================================================================*/
#*    serrano/prgm/project/bigloo/runtime/Makefile                     */
#*    -------------------------------------------------------------    */
#*    Author      :  Manuel Serrano                                    */
#*    Creation    :  Tue Mar 21 08:14:18 1995                          */
#*    Last change :  Tue Oct 12 16:25:31 2004 (serrano)                */
#*    Copyright   :  1995-2004 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
EFLAGS		=
# 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_s
OBJDIR_USR	= obj_s
# This two variables control how we are booting (from Scheme or C)
SCMOBJSUFFIX	= %.o
COBJSUFFIX	= 
# Default class file locations
CLASSDIR_SYS	= class_s
CLASSDIR_USR	= class_s
# Default class file locations
DOTNETDIR_SYS	= dotnet_s
DOTNETDIR_USR	= dotnet_s
# The class suffix
SCMCLASSSUFFIX	= %.class
# The dotnet suffix
SCMDOTNETSUFFIX = %.obj
# 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 ------------------------------------------------*/
BGLJFLAGS	= -saw -jfile $(JFILE)
BJSAFEFLAGS	= -jvm-purify
#*--- Bigloo .NET flags -----------------------------------------------*/
BDOTNETFLAGS	= -saw -dotnet-mono-workaround -dotnet-pnet-workaround
BDOTNETSFLAGS	= -dotnet-managed
#*--- 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 $(CPICFLAGS) # -copt -DBIGLOO_GC_MALLOC_PROFILE
CUNSAFEPFLAGS	= -I$(BOOTLIBDIR) $(CFLAGS_P) $(CPICFLAGS) -DPROFILE # -DBIGLOO_GC_MALLOC_PROFILE
#*--- Bigloo, safe, debug, heap ---------------------------------------*/
BSAFEDBGFLAGS	= $(BSAFEFLAGS) -gheap -copt $(CPICFLAGS)
#*--- Bigloo, unsafe, heap --------------------------------------------*/
BUNSAFEDBGFLAGS	= $(BUNSAFEFLAGS) -gheap -copt $(CPICFLAGS)
CDBGFLAGS	= -I$(BOOTLIBDIR) $(CPICFLAGS) $(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)

#*---------------------------------------------------------------------*/
#*    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 \
                  cdynamic cdate csleep

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 \
		  cnst nil \
		  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 bgldynamic date os \
                  input_procedure_port

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

#*---------------------------------------------------------------------*/
#*    C# objects                                                       */
#*---------------------------------------------------------------------*/
CSLIB		= 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 \
		  cnst nil \
		  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 bgldynamic date \
		  output_stream_port output_socket_port os \
		  input_procedure_port callback

CS_CSLIB	= $(CSLIB:%=CSlib/%.cs)

#*---------------------------------------------------------------------*/
#*    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 date

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 everror \
                  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)

#*---------------------------------------------------------------------*/
#*    Src files                                                        */
#*---------------------------------------------------------------------*/
SRC_FILES	= $(SCM_USR_SRC) $(SCM_SYS_SRC) \
                  $(C_CLIB) $(JAVA_JLIB) $(CS_CSLIB) \
                  Mlib/mach_dep.c \
                  Mlib/sparc_sunos4_mach_dep.s Mlib/sparc_sunos5_mach_dep.s \
                  Ilib/realcallback.il

#*---------------------------------------------------------------------*/
#*    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_CLIB:%.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)

#*---------------------------------------------------------------------*/
#*    .NET obj files                                                  */
#*---------------------------------------------------------------------*/
DOTNETOBJ 	= $(SCM_SYS_SRC:%.scm=objs/$(DOTNETDIR_SYS)/%.obj) \
                  $(SCM_USR_SRC:%.scm=objs/$(DOTNETDIR_USR)/%.obj) \
                  objs/$(DOTNETDIR_SYS)/Ilib/realcallback.obj

#*---------------------------------------------------------------------*/
#*    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) $(EFLAGS) $(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) $(EFLAGS) -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_s lib_u lib_p lib_d lib-c lib-c_u lib-c_p lib-c_d libs libs-c

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

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

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) $(EXTRALIBS) -lc || exit 1; \
           else \
	     $(LD) -o $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) \
                      $(LDSONAME) lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) \
                      $(OBJECTS) $(EXTRALIBS) -lc || exit 1; \
           fi && \
	   echo "lib$(LIBRARYNAME)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX) done..."; \
	   echo "-------------------------------"; \
          fi

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

libs-jvm: lib-jvm_u lib-jvm_s

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


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_JLIB:Jlib/%.java=bigloo/%.class) \
                 $(JAVA_JLIB:Jlib/%.java=bigloo/%[$$]*.class)) || exit 1
	@ 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_s-$(RELEASE).a.old
	@ if [ -f $(BOOTLIBDIR)/libbigloo_s-$(RELEASE).a ]; then \
            mv $(BOOTLIBDIR)/libbigloo_s-$(RELEASE).a $(BOOTLIBDIR)/libbigloo_s-$(RELEASE).a.old; \
          fi
	$(MAKE) one-lib-jas \
                SCMCLASSSUFFIX="%.jas" \
                BGLJFLAGS="$(BGLJFLAGS) -jast" \
                BFLAGS_SYS="$(BUNSAFEFLAGS)" \
                BFLAGS_USR="$(BSAFEFLAGS)" \
                CLASSDIR_USR=class_s 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_s/jlib:
	(cd Jlib && \
         $(JAVAC) -classpath ../objs/class_s -d ../objs/class_s \
                  $(JCFLAGS) $(JLIB_SRC))

class_u/jlib:
	(cd Jlib && \
         $(JAVAC) -classpath ../objs/class_u -d ../objs/class_u \
                  $(JCFLAGS) $(JLIB_SRC))

class_p/jlib:
	(cd Jlib && \
         $(JAVAC) -classpath ../objs/class_p -d ../objs/class_p \
                  $(JCFLAGS) $(JLIB_SRC))

#*---------------------------------------------------------------------*/
#*    Bigloo .Net libraries compilation                                */
#*---------------------------------------------------------------------*/
.PHONY: lib-dotnet lib-dotnet_s lib-dotnet_p libs-dotnet

libs-dotnet: lib-dotnet_u lib-dotnet

lib-dotnet: lib-dotnet_s
lib-dotnet_s: includes
	$(MAKE) one-lib-dotnet \
                BFLAGS_SYS="$(BUNSAFEFLAGS) $(BDOTNETSFLAGS) $(BDOTNETFLAGS)" \
                BFLAGS_USR="$(BSAFEFLAGS) $(BDOTNETSFLAGS) $(BDOTNETFLAGS)" \
                DOTNETDIR_USR=dotnet_s DOTNETDIR_SYS=dotnet_s \
                LIBQ=_s

lib-dotnet_u: includes
	$(MAKE) one-lib-dotnet \
                BFLAGS_SYS="$(BUNSAFEFLAGS) $(BDOTNETFLAGS)" \
                BFLAGS_USR="$(BUNSAFEFLAGS) $(BDOTNETFLAGS)" \
                DOTNETDIR_USR=dotnet_u DOTNETDIR_SYS=dotnet_u \
                LIBQ=_u

lib-dotnet_p: includes
	$(MAKE) one-lib-dotnet \
                BFLAGS_SYS="$(BUNSAFEPFLAGS) $(BDOTNETFLAGS)" \
                BFLAGS_USR="$(BUNSAFEPFLAGS) $(BDOTNETFLAGS)" \
                DOTNETDIR_USR=dotnet_p DOTNETDIR_SYS=dotnet_p \
                LIBQ=_p

one-lib-dotnet: $(DOTNETOBJ) one-lib-dotnet-$(DOTNETLDSTYLE)

one-lib-dotnet-$(DOTNETLDSTYLE): $(DOTNETOBJ)
	$(DOTNETLD) -L$(BOOTLIBDIR)/$(RELEASE) -shared \
                    -l System.dll \
                    -o $(BOOTLIBDIR)/$(LIBRARYNAME)$(LIBQ)-$(RELEASE).dll \
                    -- $(DOTNETOBJ) $(CS_CSLIB)

#*---------------------------------------------------------------------*/
#*    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) $(CPICFLAGS)" \
                LIB="$(BOOTLIBDIR)"

gc_fth.debug:
	if [ "$(CGCTHREADFLAGS)" != "no" ]; then \
	  $(MAKE) one-gc \
                  LIBSUF="_fth" \
                  LIBQ="" \
                  GCFLAGS="-Iinclude -g -DSILENT -DFINALIZE_ON_DEMAND -I/users/serrano/prgm/project/bigloo/lib/2.5d $(CPICFLAGS) $(CGCTHREADFLAGS)" \
                  LIB="$(BOOTLIBDIR)"; \
        fi

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

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

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

one-gc: gcstatic gcshared

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

gcshared: $(GCDIR)$(LIBSUF)$(LIBQ)
	(cd $(GCDIR)$(LIBSUF)$(LIBQ) && \
            if [ ! "$(LD)" = "true" ]; then \
              $(MAKE) libmsgc.$(SHAREDSUFFIX) LD="$(LD)" CFLAGS="$(GCFLAGS) $(CPICFLAGS)" \
	              SONAME="libbigloogc$(LIBSUF)$(LIBQ)-$(RELEASE).$(SHAREDSUFFIX)"; \
            fi)
	if [ ! "$(LD)" = "true" ]; then \
            cp $(GCDIR)$(LIBSUF)$(LIBQ)/libmsgc.$(SHAREDSUFFIX) \
            $(LIB)/libbigloogc$(LIBSUF)$(LIBQ)-$(RELEASE).$(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 $(GCDIR); 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_s 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_s SCMOBJSUFFIX="" COBJSUFFIX=%.o

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

boot-dotnet: heap-jvm lib-dotnet_s lib-dotnet_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_s heap-c
	@ if [ "$(GCCUSTOM)" = "yes" ]; then \
	    $(MAKE) gc; \
	  fi

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

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

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_s-$(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_s.zip $(ZIPDIR)/bigloo_s.zip && \
             chmod $(BMASK) $(ZIPDIR)/bigloo_s.zip && \
	  cp $(BOOTLIBDIR)/bigloo_u.zip $(ZIPDIR)/bigloo_u.zip && \
             chmod $(BMASK) $(ZIPDIR)/bigloo_u.zip; \
        fi

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

install-bee:
	$(MAKE) install-lib LIB=libbigloo_p-$(RELEASE)
#* 	$(MAKE) install-lib LIB=libbigloo_d-$(RELEASE)                 */
#* 	$(MAKE) install-lib LIB=libbigloogc_p-$(RELEASE)               */
#* 	$(MAKE) install-lib LIB=libbigloogc_d-$(RELEASE)               */

install-thread:
	if [ "$(GCCUSTOM)" = "yes" ]; then \
	   $(MAKE) install-lib LIB=libbigloogc_fth-$(RELEASE); \
        fi

uninstall: uninstall-bee uninstall-jvm uninstall-thread uninstall-dotnet
	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_s-$(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_s.zip
	-$(RM) -f $(ZIPDIR)/bigloo_u.zip

uninstall-dotnet:
	-$(RM) -f $(DESTDIR)$(FILDIR)/bigloo.jheap
	-$(RM) -f $(ZIPDIR)/bigloo_s-$(RELEASE).dll
	-$(RM) -f $(ZIPDIR)/bigloo_u-$(RELEASE).dll

uninstall-bee:
	- $(MAKE) uninstall-lib LIB=libbigloo-$(RELEASE)_p
	- $(MAKE) uninstall-lib LIB=libbigloogc-$(RELEASE)_p
#* 	- $(MAKE) uninstall-lib LIB=libbigloo-$(RELEASE)_d             */
#* 	- $(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 $(GCDIR)_fth
	@- $(RM) -rf $(GCDIR)_p
	@- $(RM) -rf $(GCDIR)_d
	@- $(RM) -f $(IF_MACH_EXE)
	@- (cd $(GCDIR) && $(MAKE) clean)

clean-c: gcclean
	$(RM) -f $(BOOTLIBDIR)/bigloo.h
	$(RM) -f $(BOOTLIBDIR)/bigloo_config.h
	$(MAKE) cleanobj OBJDIR_USR=obj_s 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_s CLASSDIR_SYS=class_u
	$(MAKE) cleanclass CLASSDIR_USR=class_u CLASSDIR_SYS=class_u
	$(MAKE) cleanclass CLASSDIR_USR=class_p CLASSDIR_SYS=class_p

clean-dotnet:
	$(RM) -rf objs/dotnet*/bigloo/*.dotnet
	$(RM) -rf objs/dotnet*/bigloo/runtime/*/*.dotnet
	$(MAKE) cleandotnet DOTNETDIR_USR=dotnet_s DOTNETDIR_SYS=dotnet_u
	$(MAKE) cleandotnet DOTNETDIR_USR=dotnet_u DOTNETDIR_SYS=dotnet_u
	$(MAKE) cleandotnet DOTNETDIR_USR=dotnet_p DOTNETDIR_SYS=dotnet_p

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

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

cleandotnet:
	$(RM) -f $(DOTNETOBJ)
	$(RM) -f $(DOTNETOBJ:%.obj=%.il) 

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*.*
	$(RM) -f $(BOOTLIBDIR)/bigloo_s-$(RELEASE).dll
	$(RM) -f $(BOOTLIBDIR)/bigloo_u-$(RELEASE).dll
	$(RM) -f $(BOOTLIBDIR)/bigloo_u.zip
	$(RM) -f $(BOOTLIBDIR)/bigloo_s.zip

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

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

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

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

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

#*---------------------------------------------------------------------*/
#*     .c --> .o                                                       */
#*---------------------------------------------------------------------*/
objs/obj_u/$(COBJSUFFIX): objs/obj_u/%.c
	$(CC) $(CUNSAFEFLAGS) $(GCINCLUDE) -c objs/obj_u/$*.c && mv $(@F) objs/obj_u/$*.o
objs/obj_s/$(COBJSUFFIX): objs/obj_s/%.c
	$(CC) $(CUNSAFEFLAGS) $(GCINCLUDE) -c objs/obj_s/$*.c && mv $(@F) objs/obj_s/$*.o

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

#*---------------------------------------------------------------------*/
#*     .scm --> .c                                                     */
#*---------------------------------------------------------------------*/
objs/obj_u/%.c: %.scm
	$(BIGLOO) $(EFLAGS) $(BFLAGS_SYS) -c $*.scm -indent -o objs/obj_u/$*.c
objs/obj_s/%.c: %.scm
	$(BIGLOO) $(EFLAGS) $(BFLAGS_USR) -c $*.scm -indent -o objs/obj_s/$*.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) $(GCINCLUDE) Mlib/mach_dep.c && \
             mv mach_dep.o objs/$(OBJDIR_SYS)/Mlib/mach_dep.o; \
          fi

#*---------------------------------------------------------------------*/
#*    realcallback.obj                                                 */
#*---------------------------------------------------------------------*/
objs/$(DOTNETDIR_SYS)/Ilib/realcallback.obj: Ilib/realcallback.il
	$(DOTNETASM) Ilib/realcallback.il && mv Ilib/realcallback.obj objs/$(DOTNETDIR_SYS)/Ilib/realcallback.obj

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

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

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

#*---------------------------------------------------------------------*/
#*     .scm --> .obj                                                   */
#*---------------------------------------------------------------------*/
objs/dotnet_u/$(SCMDOTNETSUFFIX): %.scm
	$(BIGLOO) $(EFLAGS) -dotnet $(BGLJFLAGS) $(BFLAGS_SYS) -c $< -o $@

objs/dotnet_s/$(SCMDOTNETSUFFIX): %.scm
	$(BIGLOO) $(EFLAGS) -dotnet $(BGLJFLAGS) $(BFLAGS_USR) -c $< -o $@

objs/dotnet_p/$(SCMDOTNETSUFFIX): %.scm
	$(BIGLOO) $(EFLAGS) -dotnet $(BGLJFLAGS) $(BFLAGS_USR) -c $< -o $@

objs/dotnet_s/Eval/evmeaning.obj: Eval/evmeaning.scm
	$(BIGLOO) $(EFLAGS) -unsafe -dotnet $(BGLJFLAGS) $(BFLAGS_USR) -c Eval/evmeaning.scm -o $@

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

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

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

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

#*---------------------------------------------------------------------*/
#*    $(GCDIR)$(LIBQ) ...                                              */
#*---------------------------------------------------------------------*/
gc_dir:
	@ mkdir $(GCDIR)$(LIBQ)
	@ (cd $(GCDIR)$(LIBQ) && \
           for p in $(GCDIR)/*.c; do \
             ln -s $$p .; \
           done && \
           for p in $(GCDIR)/*.s; do \
             ln -s $$p .; \
           done && \
           for p in $(GCDIR)/*.S; do \
             ln -s $$p .; \
           done && \
           for p in $(GCDIR)/*.h; do \
             ln -s $$p .; \
           done && \
           ln -s $(GCDIR)/Makefile . && \
           ln -s $(GCDIR)/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_s/Clib
	mkdir -p objs/obj_s/Ieee
	mkdir -p objs/obj_s/Llib
	mkdir -p objs/obj_s/R5rs
	mkdir -p objs/dotnet_s/Clib
	mkdir -p objs/dotnet_s/Ieee
	mkdir -p objs/dotnet_s/Llib
	mkdir -p objs/dotnet_s/R5rs
	(dirs="Clib Ieee Llib Mlib Ilib R5rs Rgc Eval Lalr Match Pp Read"; \
         objs="obj_u obj_d obj_p dotnet_s dotnet_u dotnet_d dotnet_p"; \
         for o in $$objs; do \
           mkdir -p objs/$$o; \
           for d in $$dirs; do \
             mkdir -p objs/$$o/$$d; \
             touch objs/$$o/$$d/.dontremove; \
           done; \
         done)
	mkdir -p objs/class_s
	mkdir -p objs/class_s/bigloo
	mkdir -p objs/class_s/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_s 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)/autoconf/bigloo_config.h.in \
                               $(BOOTDIR)/Makefile
	$(BOOTDIR)/configure --bigloo_config.h=$(BOOTLIBDIR)/bigloo_config.h \
                             --bigloo_config.jvm=Jlib/configure.java \
                             --bigloo_config.dotnet=CSlib/configure.cs \
                             --libdir=$(LIBDIR) \
                             --fildir=$(FILDIR) \
                             --zipdir=$(ZIPDIR) \
                             --indent=stdindent \
                             --dotnet=force \
                             --no-summary
	$(RM) -f configure.log

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

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

#*---------------------------------------------------------------------*/
#*    ude                                                              */
#*---------------------------------------------------------------------*/
.PHONY: ude

ude: $(AFILE) $(JFILE)

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

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