#*---------------------------------------------------------------------*/
#*    serrano/ml/camloo/runtime0.2/Makefile ...                        */
#*                                                                     */
#*    Auteur      :  Manuel SERRANO                                    */
#*    Creation    :  Tue May 14 14:21:00.2991                          */
#*    Last change :  Fri May 20 19:35:06 1994 (serrano)                */
#*                                                                     */
#*    Le makefile pour construire la librarie de caml-bigloo ...       */
#*    -------------------------------------------------------------    */
#*    Ce fichier peut-etre interprete soit par `make' sur les machines */
#*    SUN soit par `gmake' sur toutes les autres machines.             */
#*---------------------------------------------------------------------*/

#*---------------------------------------------------------------------*/
#*     Les flags ...                                                   */
#*---------------------------------------------------------------------*/
MACH        	= `arch`
PWD         	= `pwd`
CC          	= gcc
AS		= as
VERSION		= 0.2
BIGLOO          = bigloo1.6
CAMLCOMP	= $(BIGLOO)
CAMLOODIR	= /net/cornas/icsla2/serrano/ml/camloo
LIBDIR         	= $(CAMLOODIR)/lib/$(VERSION)
BIGLOOLIBDIR	= `$(BIGLOO) -query | grep "\*lib-dir[ ]*\*" | sed 's/\*lib-dir\*[ ]*: //'`
INCLUDE     	= -I$(LIBDIR) -I"$(BIGLOOLIBDIR)"
HEAPNAME	= caml-bigloo.heap
LIBNAME		= libbigloo_caml_u.a
BEEP            = beep
SHELL           = /bin/csh
DATE		= `date +%m-%d-%y`
CAML		= caml

#*---------------------------------------------------------------------*/
#*     Les suffixes ...                                                */
#*---------------------------------------------------------------------*/
.SUFFIXES:
.SUFFIXES: .ml .scm .c .o .ml .mli .zi .mlp

#*---------------------------------------------------------------------*/
#*    Les objects C de la librairie                                    */
#*---------------------------------------------------------------------*/
_OBJ_C		= constr.o sys.o alloc.o fail.o sys.o io.o misc.o \
                  setjmp.o string.o

OBJ_C		= $(_OBJ_C:%=Clib/%)                  
O_OBJ_C     	= $(OBJ_C:%=$(O)/%)

#*---------------------------------------------------------------------*/
#*    Les objects C de la librairie                                    */
#*---------------------------------------------------------------------*/
_OBJ_CAMLC	= ints.o alloc.o str.o floats.o hash.o lexing.o \
                  parsing.o

OBJ_CAMLC	= $(_OBJ_CAMLC:%=CAMLClib/%)                  
O_OBJ_CAMLC 	= $(OBJ_CAMLC:%=$(O)/%)

#*---------------------------------------------------------------------*/
#*    Les objets des extansions                                        */
#*---------------------------------------------------------------------*/
_OBJ_LLIB	= make-lib.o constr.o handle.o bio.o bint.o bmisc.o \
                  sys.o bfloat.o tag.o intext.o bstring.o

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

#*---------------------------------------------------------------------*/
#*    Les objets de la librairie standard                              */
#*---------------------------------------------------------------------*/
_OBJ_MLIB	= eq.o exc.o list.o int.o fstring.o fchar.o string.o \
                  char.o fvect.o vect.o filename.o float.o pair.o    \
                  random.o baltree.o map.o stack.o set.o sort.o      \
                  queue.o io.o arg.o stream.o printf.o printexc.o    \
                  hashtbl.o lexing.o genlex.o parsing.o

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

#*---------------------------------------------------------------------*/
#*    Les fichiers interfaces de la librairie standard                 */
#*---------------------------------------------------------------------*/
OBJ_MLIB_MLI	= int.zi exc.zi fstring.zi fchar.zi ref.zi string.zi \
                  char.zi bool.zi eq.zi list.zi fvect.zi vect.zi     \
                  sys.zi filename.zi float.zi pair.zi random.zi      \
                  baltree.zi map.zi stack.zi set.zi sort.zi queue.zi \
                  obj.zi io.zi arg.zi stream.zi obj.zi printf.zi     \
                  printexc.zi hashtbl.zi lexing.zi genlex.zi         \
                  parsing.zi iparsing.zi

O_OBJ_MLIB_MLI	= $(OBJ_MLIB_MLI:%=Mlib/%)

#*---------------------------------------------------------------------*/
#*    La construction du `heap'                                        */
#*---------------------------------------------------------------------*/
heap:
	@ $(BIGLOO) Llib/make-lib.scm -mkheap +ALPHA                 \
	  -heap $(LIBDIR)/$(HEAPNAME)
	@ echo "Heap Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    La librairie                                                     */
#*---------------------------------------------------------------------*/
lib: lib_u

#*---------------------------------------------------------------------*/
#*    La librairie `libbigloo_caml_u.a' (safe)                         */
#*---------------------------------------------------------------------*/
#* lib_s:                                                              */
#* 	@ $(MAKE) blib BFLAGS="-O3 -mklib -cc $(CC) -fshared-data -cg -g -rm"\ */
#*                     CAMLFLAGS="-O none"                                \ */
#* 	            CFLAGS="$(INCLUDE) -g"                             \ */
#* 	            O=".Olib"                                          \ */
#* 	            D="$(LIBNAME)"                                     */
lib_s:  
	@ $(MAKE) blib BFLAGS="-mklib -cc $(CC) -fshared-data -cg -g -rm"\
                    CAMLFLAGS="-O none"                                \
	            CFLAGS="$(INCLUDE) -g"                             \
	            O=".Olib"                                          \
	            D="$(LIBNAME)"

#*---------------------------------------------------------------------*/
#*    La librairie `libbigloo_caml_u.a' (unsafe)                       */
#*---------------------------------------------------------------------*/
lib_u:  
	@ $(MAKE) blib BFLAGS="-unsafe -O3 -mklib -cc $(CC) -fshared-data"\
                    CAMLFLAGS="-O none"                                \
	            CFLAGS="$(INCLUDE) -O"                             \
	            O=".Olib"                                          \
	            D="$(LIBNAME)"

#*---------------------------------------------------------------------*/
#*    clean                                                            */
#*---------------------------------------------------------------------*/
clean:
	@ cp $(LIBDIR)/caml-bigloo.heap $(LIBDIR)/caml-bigloo.heap.$(DATE)
	@ $(MAKE) clean-clib
	@ $(MAKE) clean-llib
	@ $(MAKE) clean-mlib
	@ echo "Cleanup Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*    clean-clib ...                                                   */
#*---------------------------------------------------------------------*/
clean-clib:
	@- \rm -f .Olib/{Clib,CAMLClib}/*

#*---------------------------------------------------------------------*/
#*    clean-llib                                                       */
#*---------------------------------------------------------------------*/
clean-llib:
	@- \rm -f .Olib/Llib/*

#*---------------------------------------------------------------------*/
#*    clean-mlib                                                       */
#*---------------------------------------------------------------------*/
clean-mlib:
	@- \rm -f Mlib/*.zi
	@- \rm -f Mlib/*.sci
	@- \rm -f .Olib/Mlib/*.[co]

#*---------------------------------------------------------------------*/
#*    blib                                                             */
#*---------------------------------------------------------------------*/
blib: $(O_OBJ_MLIB_MLI) \
      $(O_OBJ_C)        \
      $(O_OBJ_LLIB)     \
      $(O_OBJ_MLIB)     \
      $(O_OBJ_CAMLC)
	@ \rm -f $(LIBDIR)/$(D)
	@ ar rcv $(LIBDIR)/$(D) \
                 $(O_OBJ_C)     \
                 $(O_OBJ_LLIB)  \
                 $(O_OBJ_MLIB)  \
                 $(O_OBJ_CAMLC)
	@ ranlib $(LIBDIR)/$(D)
	@ echo "$(D) Done..."
	@ $(BEEP)
	@ echo "-------------------------------"

#*---------------------------------------------------------------------*/
#*     touchall ...                                                    */
#*---------------------------------------------------------------------*/
touchall:
	@ touch Llib/*.scm {CAMLClib,Clib}/*.c Mlib/*.{ml,mli}
	@ echo "touchall done..."
	@ $(BEEP)
	@ echo "-------------------------------"

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

#*---------------------------------------------------------------------*/
#*    La regle implicite `.scm.o'                                      */
#*---------------------------------------------------------------------*/
.Olib/%.o: %.scm
	@ $(BIGLOO) -copt "$(INCLUDE)" $(BFLAGS) $*.scm -o .Olib/$*.o -A

#*---------------------------------------------------------------------*/
#*    La regle implicite `.ml.o'                                       */
#*---------------------------------------------------------------------*/
.Olib/%.o: %.ml
	@ $(BIGLOO) -A -o .Olib/$*.o $*.ml $(BFLAGS) -extend $(CAML) $(CAMLFLAGS)

#*---------------------------------------------------------------------*/
#*    La regle implicite `.mli.zi'                                     */
#*---------------------------------------------------------------------*/
.mli.zi:
	@ $(CAMLCOMP) $*.mli -mklib -extend $(CAML) $(CAMLFLAGS)

#*---------------------------------------------------------------------*/
#*    La regle implicite `.c.o'                                        */
#*---------------------------------------------------------------------*/
$(O)/%.o: %.c
	@ echo "$*.c:"
	@ $(CC) $(CFLAGS) $*.c -o $(O)/$*.o -c


        

