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

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

#*---------------------------------------------------------------------*/
#*    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
JVMLN		= ln -s
# 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, safe, debug ---------------------------------------------*/
BGSAFEFLAGS	= $(BSAFEFLAGS) -g
#*--- Bigloo, unsafe, optimize ----------------------------------------*/
BUNSAFEFLAGS	= -O4 -mklib -unsafe -cc $(CC) -fsharing -q -s \
                  -copt $(CPICFLAGS)
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 \
                  inline-alloc

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

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  		= init5 expand5 misc5 syntaxenv5 usual5 prefs5 \
                  syntaxrules5

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_SYS_SRC	= $(SCM_R5RS) $(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-link
	@ $(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.a ]; then \
            mv $(BOOTLIBDIR)/libbigloo.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).a \
         $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ).$(SHAREDSUFFIX)

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

$(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ).$(SHAREDSUFFIX): $(OBJECTS)
	@ if [ ! "$(LD)" = "true" ]; then \
	   rm -f $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ).$(SHAREDSUFFIX); \
	   $(LD) -o $(BOOTLIBDIR)/lib$(LIBRARYNAME)$(LIBQ).$(SHAREDSUFFIX) \
                   $(OBJECTS) -lm -lc; \
	   echo "lib$(LIBRARYNAME)$(LIBQ).$(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) -jvm-purify" \
                BFLAGS_USR="$(BSAFEFLAGS) -jvm-purify" \
                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
	@/bin/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.a.old
	@ if [ -f $(BOOTLIBDIR)/libbigloo.a ]; then \
            mv $(BOOTLIBDIR)/libbigloo.a $(BOOTLIBDIR)/libbigloo.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:
	(cd objs/class/bigloo; \
         CLASSPATH=$(BOOTDIR)/runtime/objs/class:.:$$CLASSPATH; \
         export CLASSPATH; \
         $(JAVAC) $(JVMCPATH) $(JCFLAGS) $(JLIB_SRC))
class_u/jlib:
	(cd objs/class_u/bigloo; \
         CLASSPATH=$(BOOTDIR)/runtime/objs/class_u:.:$$CLASSPATH; \
         export CLASSPATH; \
         $(JAVAC) $(JVMCPATH) $(JCFLAGS) $(JLIB_SRC))
class_p/jlib:
	(cd objs/class_p/bigloo; \
         CLASSPATH=$(BOOTDIR)/runtime/objs/class_p:.:$$CLASSPATH; \
         export CLASSPATH; \
         $(JAVAC) $(JVMCPATH) $(JCFLAGS) $(JLIB_SRC))

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

gcs: gc gc_p gc_d

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

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)$(LIBQ)
	@ (cd $(GC_DIR)$(LIBQ); $(MAKE) gc.a CC=$(CC) CFLAGS="$(GCFLAGS)")
	@ cp $(GC_DIR)$(LIBQ)/gc.a $(LIB)/libgc$(LIBQ).a; $(RANLIB) $(LIB)/libgc$(LIBQ).a

gcshared: $(GC_DIR)$(LIBQ)
	@ (cd $(GC_DIR)$(LIBQ); \
            if [ ! "$(LD)" = "true" ]; then \
              $(MAKE) libmsgc.$(SHAREDSUFFIX) LD="$(LD)" CFLAGS="$(GCFLAGS) $(CPICFLAGS)"; \
            fi)
	@ if [ ! "$(LD)" = "true" ]; then \
            cp $(GC_DIR)$(LIBQ)/libmsgc.$(SHAREDSUFFIX) \
            $(LIB)/libgc$(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: link includes gc
	@ $(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 gc lib-c_u lib-c heap-c

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

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

install:
	if [ $(LIBDIR) != $(BOOTLIBDIR) ]; then \
           (base=`echo $(LIBDIR) | sed 's/[/][^/]*$$//'`; \
            if [ ! -d $$base ]; then \
               mkdir $$base; chmod a+rx $$base; \
            fi); \
	   if [ ! -d $(LIBDIR) ]; then \
              mkdir $(LIBDIR); chmod a+rx $(LIBDIR); \
           fi; \
	   cp $(BOOTLIBDIR)/bigloo.h $(LIBDIR)/bigloo.h; \
           chmod $(BMASK) $(LIBDIR)/bigloo.h; \
	   cp $(BOOTLIBDIR)/bigloo_config.h $(LIBDIR)/bigloo_config.h; \
           chmod $(BMASK) $(LIBDIR)/bigloo_config.h; \
	   cp $(BOOTLIBDIR)/bigloo.heap $(LIBDIR)/bigloo.heap; \
           chmod $(BMASK) $(LIBDIR)/bigloo.heap; \
	   cp $(BOOTLIBDIR)/libbigloo.a $(LIBDIR)/libbigloo.a; \
           chmod $(BMASK) $(LIBDIR)/libbigloo.a; \
           $(RANLIB) $(LIBDIR)/libbigloo.a; \
           if [ -f $(BOOTLIBDIR)/libbigloo.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libbigloo.$(SHAREDSUFFIX) $(LIBDIR)/libbigloo.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libbigloo.$(SHAREDSUFFIX); \
           fi; \
	   cp $(BOOTLIBDIR)/libbigloo_u.a $(LIBDIR)/libbigloo_u.a; \
           chmod $(BMASK) $(LIBDIR)/libbigloo_u.a; \
	   $(RANLIB) $(LIBDIR)/libbigloo_u.a; \
           if [ -f $(BOOTLIBDIR)/libbigloo_u.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libbigloo_u.$(SHAREDSUFFIX) $(LIBDIR)/libbigloo_u.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libbigloo_u.$(SHAREDSUFFIX); \
           fi; \
	   cp $(BOOTLIBDIR)/libgc.a $(LIBDIR)/libgc.a; \
	   chmod $(BMASK) $(LIBDIR)/libgc.a; \
	   $(RANLIB) $(LIBDIR)/libgc.a; \
           if [ -f $(BOOTLIBDIR)/libgc.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libgc.$(SHAREDSUFFIX) $(LIBDIR)/libgc.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libgc.$(SHAREDSUFFIX); \
           fi; \
	fi

install-jvm:
	cp $(BOOTLIBDIR)/bigloo.jheap $(LIBDIR)/bigloo.jheap; \
           chmod $(BMASK) $(LIBDIR)/bigloo.jheap; \
	cp $(BOOTLIBDIR)/bigloo.zip $(LIBDIR)/bigloo.zip; \
           chmod $(BMASK) $(LIBDIR)/bigloo.zip; \
	cp $(BOOTLIBDIR)/bigloo_u.zip $(LIBDIR)/bigloo_u.zip; \
           chmod $(BMASK) $(LIBDIR)/bigloo_u.zip; \

install-bee:
	if [ $(LIBDIR) != lib ]; then \
	   cp $(BOOTLIBDIR)/libbigloo_p.a $(LIBDIR)/libbigloo_p.a; \
           chmod $(BMASK) $(LIBDIR)/libbigloo_p.a; \
           $(RANLIB) $(LIBDIR)/libbigloo_p.a; \
           if [ -f $(BOOTLIBDIR)/libbigloo_p.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libbigloo_p.$(SHAREDSUFFIX) $(LIBDIR)/libbigloo_p.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libbigloo_p.$(SHAREDSUFFIX); \
           fi; \
	   cp $(BOOTLIBDIR)/libbigloo_d.a $(LIBDIR)/libbigloo_d.a; \
           chmod $(BMASK) $(LIBDIR)/libbigloo_d.a; \
           $(RANLIB) $(LIBDIR)/libbigloo_d.a; \
           if [ -f $(BOOTLIBDIR)/libbigloo_d.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libbigloo_d.$(SHAREDSUFFIX) $(LIBDIR)/libbigloo_d.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libbigloo_d.$(SHAREDSUFFIX); \
           fi; \
	   cp $(BOOTLIBDIR)/libgc_d.a $(LIBDIR)/libgc_d.a; \
	   chmod $(BMASK) $(LIBDIR)/libgc_d.a; \
	   $(RANLIB) $(LIBDIR)/libgc_d.a; \
           if [ -f $(BOOTLIBDIR)/libgc_d.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libgc_d.$(SHAREDSUFFIX) $(LIBDIR)/libgc_d.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libgc_d.$(SHAREDSUFFIX); \
           fi; \
	   cp $(BOOTLIBDIR)/libgc_p.a $(LIBDIR)/libgc_p.a; \
	   chmod $(BMASK) $(LIBDIR)/libgc_p.a; \
	   $(RANLIB) $(LIBDIR)/libgc_p.a; \
           if [ -f $(BOOTLIBDIR)/libgc_p.$(SHAREDSUFFIX) ]; then \
	      cp $(BOOTLIBDIR)/libgc_p.$(SHAREDSUFFIX) $(LIBDIR)/libgc_p.$(SHAREDSUFFIX); \
	      chmod $(BMASK) $(LIBDIR)/libgc_p.$(SHAREDSUFFIX); \
           fi; \
	fi

uninstall: uninstall-bee uninstall-jvm
	-rm -f $(LIBDIR)/bigloo.h
	-rm -f $(LIBDIR)/bigloo_config.h
	-rm -f $(LIBDIR)/bigloo.heap
	-rm -f $(LIBDIR)/libbigloo.a
	-rm -f $(LIBDIR)/libbigloo.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libbigloo_u.a
	-rm -f $(LIBDIR)/libbigloo_u.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libgc.a
	-rm -f $(LIBDIR)/libgc.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libgc_p.a
	-rm -f $(LIBDIR)/libgc_p.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libgc_d.a
	-rm -f $(LIBDIR)/libgc_d.$(SHAREDSUFFIX)
	-rm -rf $(LIBDIR)

uninstall-jvm:
	-rm -f $(LIBDIR)/bigloo.jheap
	-rm -f $(LIBDIR)/bigloo.zip
	-rm -f $(LIBDIR)/bigloo_u.zip

uninstall-bee:
	-rm -f $(LIBDIR)/libbigloo_p.a
	-rm -f $(LIBDIR)/libbigloo_p.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libbigloo_d.a
	-rm -f $(LIBDIR)/libbigloo_d.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libgc_p.a
	-rm -f $(LIBDIR)/libgc_p.$(SHAREDSUFFIX)
	-rm -f $(LIBDIR)/libgc_d.a
	-rm -f $(LIBDIR)/libgc_d.$(SHAREDSUFFIX)

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

gcclean:
	@- rm -rf $(GC_DIR)_p
	@- rm -rf $(GC_DIR)_d
	@- rm -f $(IF_MACH_EXE)
	@- (cd $(GC_DIR); $(MAKE) clean)

clean-c: gcclean
	/bin/rm -f $(BOOTLIBDIR)/bigloo.h
	/bin/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:
	$(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:
	/bin/rm -f $(OBJECTS)

cleanclass:
	/bin/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
	/bin/rm -f $(BOOTLIBDIR)/$(HEAPC_FILE)
	/bin/rm -f $(BOOTLIBDIR)/$(HEAPJVM_FILE)
	/bin/rm -f $(BOOTLIBDIR)/lib$(LIBRARYNAME)*.*
	/bin/rm -f $(BOOTLIBDIR)/libgc*.*
	/bin/rm -rf objs/class*

distclean: cleanall

#*---------------------------------------------------------------------*/
#*     .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/$(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)_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)/*.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-link link

objs-sans-link: Jlib/configure.java
	mkdir -p objs/obj/Clib
	mkdir -p objs/obj/Ieee
	mkdir -p objs/obj/Llib
	(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

link:
	(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)
	(objs="class_u class class_p"; \
         for d in $$objs; do \
          (cd objs/$$d/bigloo; \
            for f in $(JAVA_JLIB:Jlib/%=%); do \
               if [ ! -f $$f ]; then \
                  /bin/rm -f $$f; \
                  $(JVMLN) $(BOOTDIR)/runtime/Jlib/$$f . ; \
               fi; \
            done;) \
         done;)

obj: objs-sans-link link

#*---------------------------------------------------------------------*/
#*    $(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=$(BOOTLIBDIR) \
                             --zipdir=$(BOOTLIBDIR) \
                             --indent=stdindent \
                             --no-summary
	/bin/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=$(BOOTLIBDIR) \
                             --zipdir=$(BOOTLIBDIR) \
                             --indent=stdindent \
                             --no-summary
	/bin/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)
