
#  Le Makefile de fabrication des diffe'rents syste`mes 
#  Le-Lisp version 15.2 > 1-Aout-1987 
#  -- Maintenance: Ce Makefile est ge'ne're' automatiquement --

# - -DSUNOS40 & -Bstatic pour les syste`mes Sun 4.x
# [suppose' etre le defaut] -- a suprimer en SUNOS3.x--
SUNOS=-DSUNOS40 -Bstatic

SYSTEM= sun

HOST=$(SYSTEM)
MAKE=make

SHELL=/bin/sh

CC=/bin/cc

# Pour les cores executables:
# La variable EXE, est soit vide, soit a la valeur "exe"
#   si elle est vide, les systemes Lisp ne sont pas fabrique's
#      par defaut en mode execore;
#   si elle vaut "exe", les systemes Lisp sont fabrique's
#      par defaut en mode execore;
#

# pour passer Le-Lisp en mode EXECORE par defaut:
#EXE=exe

########################
# Les noms des binaires 
########################

#BIN=lefpu31 # ne marche pas (FD)
BIN=lelisp31

ALLBINS=lefpu31bin lefpu64bin lesoft31bin lesoft64bin lefpu31exebin lefpu64exebin lesoft31exebin lesoft64exebin lefpu31X11bin lefpu64X11bin lesoft31X11bin lesoft64X11bin lefpu31X11exebin lefpu64X11exebin lesoft31X11exebin lesoft64X11exebin lefpu31M11bin lefpu64M11bin lesoft31M11bin lesoft64M11bin lefpu31M11exebin lefpu64M11exebin lesoft31M11exebin lesoft64M11exebin lefpu31OLbin lefpu64OLbin lesoft31OLbin lesoft64OLbin lefpu31OLexebin lefpu64OLexebin lesoft31OLexebin lesoft64OLexebin 

#########################
# Les syste`mes standard
#########################
CORES= cmplc++ lelisp leX11bin

ALLCORES= lelisp cmplc lelispX11 cmplc++ lelisps ceyx lelisp64 camlisp camlispbig

##########################################################
# Les entre'es classiques
##########################################################
# Standard.
# Pour faire les systemes clients : $(CORES)
# % make
all:	$(CORES)
allcore: $(ALLCORES)
allbin:	$(ALLBINS)

# Pour nettoyer tout ce qui est fabrique' par ce makefile: Les binaires, 
# les commandes standard.
# % make clean
clean: cleanbin cleancore cleano
cleanbin:
	/bin/rm -f $(ALLBINS)
cleancore:
	/bin/rm -f $(ALLCORES)
	/bin/rm -f llcore/?*.core
cleano:
	/bin/rm -f o/?*.o

# Pour effacer tout ce qui n'est pas indispensable a` une utilisation minimale
#  de Le-Lisp.  Attention, plus aucun binaire, plus aucune image me'moire de 
#  Le-Lisp ne sera faisable de`s que cette commande aura e'te' lance'e!
#
# Il est e'vident qu'aucune  maintenance ne pourra etre effectue'e
#  sans une distribution COMPLETE de Le-Lisp.
#
# % make minimal
minimal:
	@( echo "Voulez-vous vraiment ne garder qu'un Le-Lisp minimun?(o/n) ";\
	read rep ;\

	if [ $$rep = "o" ] ;\
	then \
		echo "OK, on y va..." ;\
		(cd .. ;\
		/bin/rm -f TAR* LL*FILES ;\
		/bin/rm -rf benchmarks ;\
		/bin/rm -rf ceyx ;\
		/bin/rm -rf common ;\
		/bin/rm -rf info ;\
		/bin/rm -rf lltest ;\
		/bin/rm -rf system ) ;\
		/bin/rm -f *bin.o
		/bin/rm -rf conf ;\
		/bin/rm -rf recette ;\
		/bin/rm -rf o ;\
		/bin/rm -ri llcore ;\
		/bin/rm -f *FILES* ;\
		/bin/rm -f make* ;\
		echo "C'est fait." ;\
	fi )

##########################################################################
# Les options de'pendant du syste`me
##########################################################################
#
########################################
# pour les includes C propres a Le-Lisp:

LLINCLUDE=-I../common

# Pour avoir des messages en breton 

FOREIGN=-DFOREIGN

# Pour l'edition de liens dynamique

CLOAD= -DCLOAD

# Pour preciser la taille des pages en me'moire

LLPAGESIZE=

# Le fichier initial au lancement d'un lelispbin sans argument

FILEINI=-DFILEINI=\"../llib/startup.ll\"

# le nom du syste`me : Le-Lisp ou CAML ou ...

LLSYSNAME=-DLLSYSNAME=\"CAML\"

# le timbre d'unicite

STAMP=-DSTAMP=\"$$$$\"

# Pour faire du debug

DEBUG=

#
# LOCALVARS = -x par defaut, pas de symboles locaux.
#           = -X pour aider au debug  (toutes les variables 
#             locales sont conserve'es dans la table des symboles).

LOCALVARS=-x

# Les flags pour le link

LDFLAGS= -z $(LOCALVARS)

# Les librairies du linker

LDLIBS= -lm -lc

# Les flags de compilation C pour Le-Lisp

LL_CFLAGS= 	$(LLPAGESIZE) $(CLOAD) $(FOREIGN) \
		$(FILEINI) $(LLINCLUDE) $(LLSYSNAME)

########################################
# Les flags de compilation C pour C sur sun

C_CFLAGS=-O -sun3 -DNBSYST=22 -DBSD4x -DBSD42 -DINRIA $(SUNOS) -DSUN 

# Les flags de compilation C
CFLAGS= $(C_CFLAGS) $(DEBUG) $(LL_CFLAGS)

########################################
# les flags de compilation C pour X11

WINDOW= -DX11

# Pour ld qui doit trouver les lib*.a
# de la forme: $(XLIB)/libX*.a

XLIB=-L/usr/lib

# Pour les includes qui doivent trouver les *.h:
# de la forme: $(XINCLUDE)/X/?*.h

XINCLUDE=/usr/include

# les flags de compilations C pour X11

X11_CFLAGS=$(WINDOW) -I$(XINCLUDE)

X11_LDFLAGS= $(XLIB)

X11_LDLIBS= -lX11

########################################
# les flags de compilation C pour Motif

# Pour ld qui doit trouver les lib*.a

MOTIFLIB=-L/usr/lib

MXtLIB=$(XLIB)

# Pour les includes qui doivent trouver les *.h:
# de la forme: $(MOTIFINCLUDE)/X11/?*.h

MOTIFINCLUDE=/usr/include

MXtINCLUDE=$(XINCLUDE)

# les options de compilations C pour Motif

MOTIFVERSION=MOTIF1_1

MOTIFOPTIONS= -DSTRINGS_ALIGNED -DXT_BV -DMOTIF_BV -D_NO_PROTO -D$(MOTIFVERSION)

# les flags de compilations C pour motif

MOTIF_LDFLAGS= $(MOTIFLIB) $(MXtLIB)

MOTIF_LDLIBS= -lXm -lXt

MOTIF_CFLAGS= $(MOTIFOPTIONS) -I$(MXtINCLUDE) -I$(MOTIFINCLUDE)

########################################
# les flags de compilation C pour OpenLook

# Pour ld qui doit trouver les lib*.a

OLITLIB=-L/usr/share/openwin/lib

OXtLIB=

# Pour les includes qui doivent trouver les *.h:
# de la forme: $(OLITINCLUDE)/?*.h

OPENINCLUDE=/usr/share/openwin/include

OLITINCLUDE=$(OPENINCLUDE) -I$(OPENINCLUDE)/Xol

OXtINCLUDE=$(OLITINCLUDE)

# les options de compilations C pour OpenLook

OLITOPTIONS= -DSTRINGS_ALIGNED -DXT_BV -DOLIT_BV -D_NO_PROTO

# les flags de compilations C pour OpenLook

OLIT_LDFLAGS= $(OLITLIB) $(OXtLIB)

OLIT_LDLIBS= -lXol -lXt

OLIT_CFLAGS= $(OLITOPTIONS) -I$(OXtINCLUDE) -I$(OLITINCLUDE)

#########################################################################

common_cobj= o/llmain.o o/camlstdio.o o/llfloat.o o/time.o

cobj=	$(common_cobj) o/caml.o \
	o/Xlib_runtime.o o/Xlib_stubs.o o/c-fail.o o/ddr_ext.o

cexeobj= $(common_cobj) o/camlexe.o execore.o \
	o/Xlib_runtime.o o/Xlib_stubs.o o/c-fail.o o/ddr_ext.o

#########################################################################
# Comment refaire les binaires standard
# Le(s) binaire(s) standard

################################################################
# camlispbin

camlispbin: camlisp31$(EXE)bin
	@/bin/rm -f camlispbin
	ln camlisp31$(EXE)bin camlispbin

camlisp31bin: $(cobj) $(BIN)bin.o
	$(CC) $(CFLAGS) $(X11_LDFLAGS) $(LDFLAGS) -o camlisp31bin \
	$(cobj) $(BIN)bin.o \
	$(X11_LDLIBS) $(LDLIBS)

camlisp31exebin: $(cexeobj) $(BIN)bin.o
	$(CC) $(CFLAGS) $(X11_LDFLAGS) $(LDFLAGS) -o camlisp31exebin \
	$(cexeobj) $(BIN)bin.o \
	$(X11_LDLIBS) $(LDLIBS)

lelispbin: lefpu31$(EXE)bin
	@/bin/rm -f lelispbin
	ln lefpu31$(EXE)bin lelispbin

lelispexebin: lefpu31exebin
	@/bin/rm -f lelispexebin
	ln lefpu31exebin lelispexebin

# Comment refaire les binaires pour lelisp standard
#  (calculs flottants soft)
lesoft31bin: $(cobj) lesoft31bin.o
	$(CC) $(CFLAGS) $(LDFLAGS)  -o lesoft31bin \
	$(cobj) lesoft31bin.o \
	$(LDLIBS)

lesoft64bin: $(cobj) lesoft64bin.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o lesoft64bin \
	$(cobj) lesoft64bin.o \
	$(LDLIBS) 

#  (la meme chose en mode execore)
lesoft31exebin: $(cexeobj) lesoft31bin.o
	$(CC) $(CFLAGS) $(LDFLAGS)  -o lesoft31exebin \
	$(cexeobj) lesoft31bin.o \
	$(LDLIBS)

lesoft64exebin: $(cexeobj) lesoft64bin.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o lesoft64exebin \
	$(cexeobj) lesoft64bin.o \
	$(LDLIBS) 

# (calculs flottants fpu 68881)
lefpu31bin: $(cobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o lefpu31bin \
	$(cobj) lefpu31bin.o \
	$(LDLIBS) 

# (calculs flottants fpu 68881)
lefpu64bin: $(cobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o lefpu64bin \
	$(cobj) lefpu64bin.o \
	$(LDLIBS) 

# (la meme chose ne mode execore)
lefpu31exebin: $(cexeobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o lefpu31exebin \
	$(cexeobj) lefpu31bin.o \
	$(LDLIBS) 

lefpu64exebin: $(cobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o lefpu64exebin \
	$(cexeobj) lefpu64bin.o \
	$(LDLIBS) 

#########################################################################
# Pour faire un binaire Le-Lisp integrant un bitmap X11 

x11cobj= o/x11.o o/evloop.o

# Les entrees courantes:

leX11bin: $(BIN)X11$(EXE)bin
	@/bin/rm -f leX11bin
	ln $(BIN)X11$(EXE)bin leX11bin

leX11exebin: $(BIN)X11exebin
	@/bin/rm -f leX11exebin
	ln $(BIN)X11exebin leX11exebin

# Les entrees specifiques:

lesoft31X11bin: $(cobj) $(x11cobj) lesoft31bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o lesoft31X11bin \
		$(cobj) $(x11cobj) lesoft31bin.o  \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) 

lesoft64X11bin: $(cobj) $(x11cobj) lesoft64bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o lesoft64X11bin \
		$(cobj) $(x11cobj) lesoft64bin.o  \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) 

lefpu31X11bin: $(cobj) $(x11cobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o lefpu31X11bin \
		$(cobj) $(x11cobj) lefpu31bin.o  \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) 

lefpu64X11bin: $(cobj) $(x11cobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o lefpu64X11bin \
		$(cobj) $(x11cobj) lefpu64bin.o  \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) 

lefpu31X11exebin: $(cexeobj) $(x11cobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o lefpu31X11exebin \
		$(cexeobj) $(x11cobj) lefpu31bin.o  \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) 

lefpu64X11exebin: $(cexeobj) $(x11cobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o lefpu64X11exebin \
		$(cexeobj) $(x11cobj) lefpu64bin.o  \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) 

#########################################################################
# Pour faire un binaire Le-Lisp integrant un bitmap Motif

motifcobj= o/mintrinsic.o o/motifobj.o o/evloop.o

# Les entrees courantes:

leM11bin: $(BIN)M11$(EXE)bin
	@/bin/rm -f leM11bin
	ln $(BIN)M11$(EXE)bin leM11bin

leM11exebin: $(BIN)M11exebin
	@/bin/rm -f leM11exebin
	ln $(BIN)M11exebin leM11exebin

# Les entrees specifiques:

lesoft31M11bin: $(cobj) $(motifcobj) lesoft31bin.o
	$(CC) $(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS) -o lesoft31M11bin \
		$(cobj) $(motifcobj) lesoft31bin.o  \
		$(MOTIF_LDFLAGS) $(MOTIF_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lesoft64M11bin: $(cobj) $(motifcobj) lesoft64bin.o
	$(CC) $(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS) -o lesoft64M11bin \
		$(cobj) $(motifcobj) lesoft64bin.o  \
		$(MOTIF_LDFLAGS) $(MOTIF_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu31M11bin: $(cobj) $(motifcobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS) -o lefpu31M11bin \
		$(cobj) $(motifcobj) lefpu31bin.o  \
		$(MOTIF_LDFLAGS) $(MOTIF_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu64M11bin: $(cobj) $(motifcobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS) -o lefpu64M11bin \
		$(cobj) $(motifcobj) lefpu64bin.o  \
		$(MOTIF_LDFLAGS) $(MOTIF_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu31M11exebin: $(cexeobj) $(motifcobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS) -o lefpu31M11exebin \
		$(cexeobj) $(motifcobj) lefpu31bin.o  \
		$(MOTIF_LDFLAGS) $(MOTIF_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu64M11exebin: $(cexeobj) $(motifcobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS) -o lefpu64M11exebin \
		$(cexeobj) $(motifcobj) lefpu64bin.o  \
		$(MOTIF_LDFLAGS) $(MOTIF_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

#########################################################################
# Pour faire un binaire Le-Lisp integrant un bitmap OpenLook

olcobj= o/ointrinsic.o o/olitobj.o o/evloop.o

# Les entrees courantes:

leOLbin: $(BIN)OL$(EXE)bin
	@/bin/rm -f leOLbin
	ln $(BIN)OL$(EXE)bin leOLbin

leOLexebin: $(BIN)OLexebin
	@/bin/rm -f leOLexebin
	ln $(BIN)OLexebin leOLexebin

# Les entrees specifiques:

lesoft31OLbin: $(cobj) $(olcobj) lesoft31bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) $(OLIT_CFLAGS) -o lesoft31OLbin \
		$(cobj) $(olcobj) lesoft31bin.o  \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lesoft64OLbin: $(cobj) $(olcobj) lesoft64bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) $(OLIT_CFLAGS) -o lesoft64OLbin \
		$(cobj) $(olcobj) lesoft64bin.o  \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu31OLbin: $(cobj) $(olcobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) $(OLIT_CFLAGS) -o lefpu31OLbin \
		$(cobj) $(olcobj) lefpu31bin.o  \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu64OLbin: $(cobj) $(olcobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) $(OLIT_CFLAGS) -o lefpu64OLbin \
		$(cobj) $(olcobj) lefpu64bin.o  \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu31OLexebin: $(cexeobj) $(olcobj) lefpu31bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) $(OLIT_CFLAGS) -o lefpu31OLexebin \
		$(cexeobj) $(olcobj) lefpu31bin.o  \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

lefpu64OLexebin: $(cexeobj) $(olcobj) lefpu64bin.o
	$(CC) $(CFLAGS) $(X11_CFLAGS) $(OLIT_CFLAGS) -o lefpu64OLexebin \
		$(cexeobj) $(olcobj) lefpu64bin.o  \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) 

#########################################################################
#                 Les fichiers .c
#########################################################################
LINTFLAGS=-nchxa
lint:
	mv $(cobj) .
	$(MAKE) CC=/bin/lint \
		CFLAGS="$(LINTFLAGS) $(LL_CFLAGS)" \
		$(cobj) 

o/llmain.o: ../common/llmain.c
	$(CC) $(CFLAGS) -c ../common/llmain.c
	mv llmain.o o

o/lelisp.o: ../common/lelisp.c
	$(CC) $(CFLAGS) -DSTAMP=\"$$$$\" -c ../common/lelisp.c
	mv lelisp.o o/lelisp.o

# CAML
o/caml.o: ../common/caml.c
	$(CC) $(CFLAGS) -DSTAMP=\"$$$$\" -c ../common/caml.c
	mv caml.o o/caml.o

o/lelispexe.o: ../common/lelisp.c 
	$(CC) $(CFLAGS) -DSTAMP=\"$$$$\" -DEXECORE -c ../common/lelisp.c
	mv lelisp.o o/lelispexe.o

# CAML
o/camlexe.o: ../common/caml.c 
	$(CC) $(CFLAGS) -DSTAMP=\"$$$$\" -DEXECORE -c ../common/caml.c
	mv caml.o o/camlexe.o

o/execore.o: execore.c
	$(CC) $(CFLAGS) -DEXECORE -c execore.c
	mv execore.o o/execore.o

o/llstdio.o: ../common/llstdio.c
	$(CC) $(CFLAGS) -c ../common/llstdio.c
	mv llstdio.o o

# CAML
o/camlstdio.o: ../common/camlstdio.c
	$(CC) -DMAXCHAR=1024 $(CFLAGS) -c ../common/camlstdio.c
	mv camlstdio.o o

o/evloop.o: ../common/evloop.c
	$(CC) $(CFLAGS) -c ../common/evloop.c
	mv evloop.o o

o/llfloat.o: ../common/llfloat.c
	$(CC) $(CFLAGS) -c ../common/llfloat.c
	mv llfloat.o o

o/llnumb.o:  ../common/llnumb.c
	$(CC) $(CFLAGS) -c ../common/llnumb.c
	mv llnumb.o o

o/cstruct.o: ../common/cstruct.c
	$(CC) $(CFLAGS) -c ../common/cstruct.c
	mv cstruct.o o

# (* CAML

o/time.o: ../Xlib/time.c
	$(CC) $(CFLAGS) $(X11_CFLAGS) -c ../Xlib/time.c
	mv time.o o

o/Xlib_runtime.o: ../Xlib/Xlib_runtime.c
	$(CC) $(CFLAGS) $(X11_CFLAGS) -c ../Xlib/Xlib_runtime.c
	mv Xlib_runtime.o o

o/Xlib_stubs.o: ../Xlib/Xlib_stubs.c
	$(CC) $(CFLAGS) $(X11_CFLAGS) -c ../Xlib/Xlib_stubs.c
	mv Xlib_stubs.o o

o/c-fail.o: ../Xlib/c-fail.c
	$(CC) $(CFLAGS) $(X11_CFLAGS) -c ../Xlib/c-fail.c
	mv c-fail.o o

o/ddr_ext.o: ../Xlib/ddr_ext.c
	$(CC) $(CFLAGS) $(X11_CFLAGS) -c ../Xlib/ddr_ext.c
	mv ddr_ext.o o/.
# CAML *)

# Pour le bitmap X11
o/x11.o: ../virbitmap/X11/x11lib.c ../virbitmap/X11/x11share.c
	@if [ -f $(XINCLUDE)/X11/Xlib.h ] ;\
	then \
		( cd ../virbitmap/X11 ; \
		$(MAKE) ../../$(SYSTEM)/o/x11.o \
			SYSTEM=$(SYSTEM) \
			CC=$(CC) \
			CFLAGS='$(CFLAGS) $(X11_CFLAGS)' ) ;\
	else \
		echo "make: ** Les bibliotheques de X11 ne sont pas en $(XINCLUDE)/X11" ;\
		echo "      ** Editer la variable XINCLUDE dans le makefile." ;\
		exit 1 ;\
	fi 

# pour le bitmap Motif
o/mintrinsic.o:
	@if [ -f $(MXtINCLUDE)/X11/Shell.h ] ;\
	then \
		( cd ../virbitmap/X11/intrinsic; \
		$(MAKE) ../../../$(SYSTEM)/o/mintrinsic.o \
			SYSTEM=$(SYSTEM) \
			CC=$(CC) \
			CFLAGS='$(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS)' );\
	else \
		echo "make: ** Xt's *.h are not in $(MXtINCLUDE)" ;\
		echo "      ** Edit Makefile's variable MXtINCLUDE." ;\
		exit 1 ;\
	fi

o/motifobj.o:
	@if [ -f $(MOTIFINCLUDE)/Xm/Xm.h ] ;\
	then \
		( cd ../virbitmap/X11/intrinsic/motif; \
		$(MAKE) ../../../../$(SYSTEM)/o/motifobj.o \
			SYSTEM=$(SYSTEM) \
			CC=$(CC) \
			CFLAGS='$(CFLAGS) $(MOTIF_CFLAGS) $(X11_CFLAGS)' );\
	else \
		echo "make: ** Motif's *.h are not in $(MOTIFINCLUDE)" ;\
		echo "      ** Edit Makefile's variable MOTIFINCLUDE." ;\
		exit 1 ;\
	fi

# pour le bitmap OpenLook
o/ointrinsic.o:
	@if [ -f $(OXtINCLUDE)/X11/Shell.h ] ;\
	then \
		( cd ../virbitmap/X11/intrinsic; \
		$(MAKE) ../../../$(SYSTEM)/o/ointrinsic.o \
			SYSTEM=$(SYSTEM) \
			CC=$(CC) \
			CFLAGS='$(CFLAGS) $(OLIT_CFLAGS) $(X11_CFLAGS)' );\
	else \
		echo "make: ** Xt's *.h are not in $(OXtINCLUDE)" ;\
		echo "      ** Edit Makefile's variable OXtINCLUDE." ;\
		exit 1 ;\
	fi

o/olitobj.o:
	@if [ -f $(OLITINCLUDE)/Xol/BaseWindow.h ] ;\
	then \
		( cd ../virbitmap/X11/intrinsic/olit; \
		$(MAKE) ../../../../$(SYSTEM)/o/olitobj.o \
			SYSTEM=$(SYSTEM) \
			CC=$(CC) \
			CFLAGS='$(CFLAGS) $(OLIT_CFLAGS) $(X11_CFLAGS)' );\
	else \
		echo "make: ** OpenLook's *.h are not in $(OLITINCLUDE)" ;\
		echo "      ** Edit Makefile's variable OLITINCLUDE." ;\
		exit 1 ;\
	fi

#####################################################################
#       D'autres fichiers C
# 
# 
# Pour tester les callexterns (sans cload)
letestextbin: $(cobj) $(BIN)bin.o o/testext.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o letestextbin \
		$(cobj) o/testext.o $(BIN)bin.o \
		$(LDLIBS) 

o/testext.o: ../lltest/testext.c
	$(CC) -c ../lltest/testext.c
	mv testext.o o/testext.o

leftestbin: $(cobj) $(BIN)bin.o o/testfortran.o
	$(CC) $(CFLAGS) $(LDFLAGS) -o leftestbin \
		$(cobj) o/testfortran.o $(BIN)bin.o \
		$(LDLIBS) 

o/testfortran.o: ../lltest/testfortran.f
	f77 -c ../lltest/testfortran.f
	mv testfortran.o o/testfortran.o

# pour les tests de pilotage de Le-Lisp par C
fromcbin: o/lelisp.o o/llstdio.o o/llfloat.o lesoft31bin.o o/fromc.o
	$(CC) $(LDFLAGS) -o fromcbin \
		o/lelisp.o o/llstdio.o o/llfloat.o o/fromc.o lesoft31bin.o \
		$(LDLIBS) 

o/fromc.o: ../lltest/fromc.c
	$(CC) $(CFLAGS) -c ../lltest/fromc.c
	mv fromc.o o

##########################################################
# Ceci n'est valide que pour un SUN2 avec une bande SUN3 #
pobj=	o/llsun.o \
	o/llinit.o  o/toperr.o  o/gc.o     o/physio.o o/read.o \
	o/macroch.o o/print.o   o/eval.o   o/fspecs.o o/cntrl.o  \
	o/carcdr.o  o/symbs.o   o/fntstd.o o/number.o o/specnb.o \
	o/string.o  o/chars.o   o/extend.o o/bllsht.o

lelispbin.o: $(pobj)
	ld -r -x $(pobj) -o lelispbin.o

################################################
# FABRICATION DES IMAGES
# 
# si rien n'est precise' on range les cores dans ./llcore/
# si on veut les ranger ailleurs, en conformite' avec le configurateur
# % make lelisp LLCORE=/tmp
LLCORE=
# # # # # # # # # # # # # # # # # # # # # # # # 
# Les tailles par de'faut des zones de donne'es
################################################

# tailles des flottants pour les xxxx31bin
SIZEF31= 0

# tailles des flottants pour les xxxx64bin
SIZEF64= 16

# tailles des flottants pour les xxxxbin
# par defaut: les flottants sont sur 31 bits
FLOAT= $(SIZEF31)

# normal avec plutot des CONS <~ 1.5 Mega-octets
STACK_C=6
CODE_C=400
HEAP_C=128
NUMBER_C=0
VECTOR_C=1
STRING_C=5
SYMBOL_C=5
CONS_C=9
SZCONS=  -stack $(STACK_C) -code $(CODE_C) -heap $(HEAP_C) \
	-number $(NUMBER_C) -vector $(VECTOR_C) -string $(STRING_C) \
	-symbol $(SYMBOL_C) -cons $(CONS_C) -float $(FLOAT)

# normal avec plutot du code  <~ 1.5 Mega-octets
STACK_D=6
CODE_D=600
HEAP_D=256
NUMBER_D=0
VECTOR_D=4
STRING_D=5
SYMBOL_D=5
CONS_D=4
SZCODE=  -stack $(STACK_D) -code $(CODE_D) -heap $(HEAP_D) \
	-number $(NUMBER_D) -vector $(VECTOR_D) -string $(STRING_D) \
	-symbol $(SYMBOL_D) -cons $(CONS_D) -float $(FLOAT)

# gros  <~ 2.8 Mega-octets
STACK_P=8
CODE_P=1200
HEAP_P=512
NUMBER_P=0
VECTOR_P=8
STRING_P=12
SYMBOL_P=11
CONS_P=8
SZ++= -stack $(STACK_P) -code $(CODE_P) -heap $(HEAP_P) \
	-number $(NUMBER_P) -vector $(VECTOR_P) -string $(STRING_P) \
	-symbol $(SYMBOL_P) -cons $(CONS_P) -float $(FLOAT)

# petit <~ 700k octets
STACK_M=6
CODE_M=1
HEAP_M=96
NUMBER_M=0
VECTOR_M=2
STRING_M=2
SYMBOL_M=2
CONS_M=4
SZ-= -stack $(STACK_M) -code $(CODE_M) -heap $(HEAP_M) \
	-number $(NUMBER_M) -vector $(VECTOR_M) -string $(STRING_M) \
	-symbol $(SYMBOL_M) -cons $(CONS_M) -float $(FLOAT)
 
# caml
SIZEZ= -stack 64 -code 1200 -heap 1024 -number 0 \
        -vector 30 -string 40 -symbol 8 -cons 15 -float $(FLOAT)

# Tailles courantes
SIZE=$(SZCODE)
SIZEM=$(SZ-)
SIZEH=$(SZ++)

##########################################################
# Les points d'entre'e permettant de faire les syste`mes
##########################################################

# (* CAML
camlispSIZEZ= -stack 24 -code 1200 -heap 1200 -number 0 \
      -vector 30 -string 50 -symbol 4 -cons 15 -float 0

camlispbigSIZEZ= -stack 24 -code 2400 -heap 1500 -number 0 \
      -vector 30 -string 60 -symbol 4 -cons 15 -float 0

camlisp:  conf/camlispconf.ll camlispbin
	./config camlisp camlispbin camlispconf.ll $(camlispSIZEZ)

camlispbig:  conf/camlispconf.ll camlispbin
	./config camlispbig camlispbin camlispconf.ll $(camlispbigSIZEZ)
# CAML *)

### lelisp "systeme standard modulaire"
lelisp::  conf/lelispconf.ll lelisp$(EXE)bin llcore/lelisp.$(EXE)core
	./config lelisp lelisp$(EXE)bin lelispconf.ll $(LLCORE) $(SIZE)
lelisp:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/lelisp.core lelisp; \
		/bin/rm llcore/lelisp.core ; fi
llcore/lelisp.$(EXE)core:

### lelisp- "systeme standard interprete"
lelisp-::  conf/lelisp-conf.ll lelisp$(EXE)bin llcore/lelisp-.$(EXE)core
	./config lelisp- lelisp$(EXE)bin lelisp-conf.ll $(LLCORE) $(SIZEM)
lelisp-:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/lelisp-.core lelisp-; \
		/bin/rm llcore/lelisp-.core ; fi
llcore/lelisp-.$(EXE)core:

### lelisp++ "gros systeme standard modulaire"
lelisp++::  conf/lelispconf.ll lelisp$(EXE)bin llcore/lelisp++.$(EXE)core
	./config lelisp++ lelisp$(EXE)bin lelispconf.ll $(LLCORE) $(SIZEH)
lelisp++:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/lelisp++.core lelisp++; \
		/bin/rm llcore/lelisp++.core ; fi
llcore/lelisp++.$(EXE)core:

### lelisps "systeme standard compile"
lelisps::  conf/lelispsconf.ll lelisp$(EXE)bin llcore/lelisps.$(EXE)core
	./config lelisps lelisp$(EXE)bin lelispsconf.ll $(LLCORE) $(SZCONS)
lelisps:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/lelisps.core lelisps; \
		/bin/rm llcore/lelisps.core ; fi
llcore/lelisps.$(EXE)core:

### cmplc "systeme complice modulaire"
cmplc::  conf/cmplcconf.ll lelisp$(EXE)bin llcore/cmplc.$(EXE)core
	./config cmplc lelisp$(EXE)bin cmplcconf.ll $(LLCORE) $(SIZE)
cmplc:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/cmplc.core cmplc; \
		/bin/rm llcore/cmplc.core ; fi
llcore/cmplc.$(EXE)core:

### cmplc++ "gros systeme complice modulaire"
cmplc++::  conf/cmplcconf.ll lelisp$(EXE)bin llcore/cmplc++.$(EXE)core
	./config cmplc++ lelisp$(EXE)bin cmplcconf.ll $(LLCORE) $(SIZEH)
cmplc++:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/cmplc++.core cmplc++; \
		/bin/rm llcore/cmplc++.core ; fi
llcore/cmplc++.$(EXE)core:

### ceyx "systeme standard modulaire avec CEYX"
ceyx::  conf/ceyxconf.ll lelisp$(EXE)bin llcore/ceyx.$(EXE)core
	./config ceyx lelisp$(EXE)bin ceyxconf.ll $(LLCORE) $(SIZE)
ceyx:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/ceyx.core ceyx; \
		/bin/rm llcore/ceyx.core ; fi
llcore/ceyx.$(EXE)core:

### lelispX11 "systeme standard modulaire avec BV sur X11"
lelispX11::  conf/leX11conf.ll leX11$(EXE)bin llcore/lelispX11.$(EXE)core
	./config lelispX11 leX11$(EXE)bin leX11conf.ll $(LLCORE) $(SIZE)
lelispX11:: 
	@if [ ! -z "$(EXE)" ]; then \
		cp llcore/lelispX11.core lelispX11; \
		/bin/rm llcore/lelispX11.core ; fi
llcore/lelispX11.$(EXE)core:

### lelisp: systeme standard modulaire sur 64bitfloats

lelisp64: conf/lelispconf.ll  lefpu64$(EXE)bin
	./config lelisp64 lefpu64$(EXE)bin lelispconf.ll $(LLCORE) $(SIZE) -float $(SIZEF64)

### qq exemples de configurations spe'cifiques:

lesoft31: conf/lesoftconf.ll  lesoft31$(EXE)bin
	./config lesoft31 lesoft31$(EXE)bin lesoftconf.ll $(LLCORE) $(SIZE)

lesoft64: conf/lesoftconf.ll  lesoft64$(EXE)bin
	./config lesoft64 lesoft64$(EXE)bin lesoftconf.ll $(LLCORE) $(SIZE) -float $(SIZEF64)

cpfpu31: conf/cpfpuconf.ll  lefpu31$(EXE)bin
	./config cpfpu31 lefpu31$(EXE)bin cpfpuconf.ll $(LLCORE) $(SIZE)

# etc etc

##########################################################################
# Les fichiers de configuration des differents systemes
##########################################################################
conf/lelispconf.ll: conf/lefpuconf.ll
	@/bin/rm -f conf/lelispconf.ll
	ln conf/lefpuconf.ll conf/lelispconf.ll

conf/cmplcconf.ll: conf/cpfpuconf.ll
	@/bin/rm -f conf/cmplcconf.ll
	ln conf/cpfpuconf.ll conf/cmplcconf.ll

conf/leX11conf.ll: conf/lX11fpuconf.ll
	@/bin/rm -f conf/leX11conf.ll
	ln conf/lX11fpuconf.ll conf/leX11conf.ll

#########################################################################
# une entre'e ge'ne'riques pour les utilisateurs exigents
# tous les fichiers etant parametre's, on peut refaire son propre binaire
# (on peut meme redifinir le compilo: ex: CC=/bin/f77
# ex: 
# % make monlelispbin USERBIN=monlelispbin USERO="foo.o bar.o"
# pour eventuellement changer de mode flottants
USERBINO=$(BIN)bin.o
# pour le nom du binaire 
USERBIN=monlelispbin
USERXBIN=monlelispX11bin

USEREXEBIN=monlexebin
USEREXEXBIN=monlexeX11bin

# les fichiers *.o utilisateurs
USERO=
# pour avoir des flags supplementaires
USERFLAGS=

# le binaire le plus simple
$(USERBIN): $(cobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) -o $(USERBIN) \
		$(cobj) $(USERBINO) $(USERO) \
		 $(LDFLAGS) $(LDLIBS) $(USERFLAGS) 

# le binaire qui integre X
$(USERXBIN): $(cobj) $(x11cobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o $(USERXBIN) \
		$(cobj) $(x11cobj) $(USERBINO) $(USERO) \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) \
		$(USERFLAGS) 

USERMBIN=monlelispM11bin
$(USERMBIN): $(cobj) $(olitcobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) $(OLIT_CFLAGS) $(X11_CFLAGS) -o $(USERMBIN) \
		$(cobj) $(olitcobj) $(USERBINO) $(USERO) \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) \
		$(USERFLAGS)

USEROLBIN=monlelispOLbin
$(USEROLBIN): $(cobj) $(olitcobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) $(OLIT_CFLAGS) $(X11_CFLAGS) -o $(USEROLBIN) \
		$(cobj) $(olitcobj) $(USERBINO) $(USERO) \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) \
		$(USERFLAGS)

# pour faire un binaire avec core executable
$(USEREXEBIN): $(cexeobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) -o $(USEREXEBIN) \
		$(cexeobj) $(USERBINO) $(USERO) \
		 $(LDFLAGS) $(LDLIBS) $(USERFLAGS) 

# un binaire avec core executable, qui integre X
$(USEREXEXBIN): $(cexeobj) $(x11cobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) $(X11_CFLAGS) -o $(USEREXEXBIN) \
		$(cexeobj) $(x11cobj) $(USERBINO) $(USERO) \
		$(X11_LDFLAGS) $(X11_LDLIBS) $(LDFLAGS) $(LDLIBS) \
		$(USERFLAGS) 

USEREXEMBIN=monlexeM11bin
$(USEREXEMBIN): $(cexeobj) $(olitcobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) $(OLIT_CFLAGS) $(X11_CFLAGS) -o $(USEREXEMBIN) \
		$(cexeobj) $(olitcobj) $(USERBINO) $(USERO) \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) \
		$(USERFLAGS)

USEROLBIN=monlexeOLbin
$(USEROLBIN): $(cexeobj) $(olitcobj) $(USERBINO) $(USERO)
	$(CC) $(CFLAGS) $(OLIT_CFLAGS) $(X11_CFLAGS) -o $(USEROLBIN) \
		$(cexeobj) $(olitcobj) $(USERBINO) $(USERO) \
		$(OLIT_LDFLAGS) $(OLIT_LDLIBS) \
		$(X11_LDFLAGS) $(X11_LDLIBS) \
		$(LDFLAGS) $(LDLIBS) \
		$(USERFLAGS)

# Une entre'e ge'ne'rique pour aider l'utilisateur
#  a` faire des cores lie's a` son binaire
# 
# Le nom de la commande lancant le systeme 
USERLELISP=monlelisp
# 
# Le configurateur qui dit ce qu'on met dans ce core
# Attention: ce fichier doit etre adresse' par un path absolu
#            ou etre range' dans lelisp/$(SYSTEM)/conf
USERCONF= $(USERLELISP)conf.ll
# 
# Le re'pertoire ou` ranger les cores: par de'faut lelisp/$(SYSTEM)/llcore
#  Attention si on en change $(USERCONF) doit l'inte'grer
USERLLCORE=
# 
# Le binaire de l'utilisateur pour fabriquer ce systeme
#  par defaut c'est le USERXBIN classique integrant X
#  mais on peut aussi avoir:
#  USERLELISPBIN=" \$(USERBIN)" pour ne pas integrer X
#   ou
#  USERLELISPBIN=/home/moi/monbin pour faire ce qu'on veut
#  
USERLELISPBIN=$(USERXBIN)
USERSIZE=$(SIZE)

$(USERLELISP):  $(USERLELISPBIN) $(USERLLCORE)/$(USERLELISP).core
	./config $(USERLELISP) $(USERLELISPBIN) $(USERCONF) $(USERLLCORE) $(USERSIZE)
$(USERLLCORE)/$(USERLELISP).core:
