### Makefile for same-fringe implementations.

###--------------------------------------------------------------------------
### Notes about organization.
###
### Most projects have lots of stuff in just a few languages, so it makes
### sense to put the language configuration in one place.  This one's
### different.  Its entire purpose is to demonstrate lots of different
### approaches.
###
### So, at the top we declare the main targets; then each language has its
### configuration and build rules.

.SUFFIXES: .o
LANGS			 =
SOURCES			 =
TARGETS			 = $(patsubst %,%-fringe,$(LANGS))
CLEANFILES		 = $(TARGETS)

all::
clean::; rm -f $(CLEANFILES)

###--------------------------------------------------------------------------
### Testing.

CLEANFILES		+= test.*
test:: all
	@win=0 lose=0;							\
	for lang in $(LANGS); do					\
	  echo >&3 "*** $$lang";					\
	  printf "Test $$lang...";					\
	  time=`command time -o/dev/stdout -f "%U user; %S system; %E"	\
		./test ./$${lang}-fringe 2>&3`;				\
	  if [ $$? -eq 0 ]; then					\
	    win=$$(expr $$win + 1);					\
	    printf " ok ($$time)\n";					\
	  else								\
	    lose=$$(expr $$lose + 1);					\
	    printf " FAILED\n";						\
	  fi;								\
	done 3>test.log;						\
	if [ $$lose -eq 0 ]; then					\
	  echo "All $$win test(s) OK";					\
	else								\
	  echo "FAILED $$lose test(s)!";				\
	  exit 1;							\
	fi

###--------------------------------------------------------------------------
### Reporting.

report::
	wc -l $(SOURCES) | sort -n

###--------------------------------------------------------------------------
### C.

CC			 = gcc
CFLAGS			 = -O2 -g -pedantic -Wall
CLEANFILES		+= *.o
.SUFFIXES: .c
.c.o:; $(CC) -c $(CFLAGS) -o $@ $<

LANGS			+= c
SOURCES			+= c-fringe.c
c-fringe: c-fringe.o
	$(CC) -o $@ $^

###--------------------------------------------------------------------------
### Haskell.

HC			 = ghc
HFLAGS			 = -O2 -XFlexibleInstances
CLEANFILES		+= *.hi *.hc
.SUFFIXES: .hs
.hs.o:; $(HC) -c $(HFLAGS) -o $@ $<

LANGS			+= haskell
SOURCES			+= haskell-fringe.hs
haskell-fringe: haskell-fringe.o
	$(HC) -o $@ $^

###--------------------------------------------------------------------------
### Icon.

ICONT			 = icont
IFLAGS			 = -u -fa

LANGS			+= icon
SOURCES			+= icon-fringe.icn
icon-fringe: icon-fringe.icn
	$(ICONT) -o $@ $^

###--------------------------------------------------------------------------
### Common Lisp.

CLEANFILES		+= *.core

LANGS			+= cl
SOURCES			+= cl-fringe.lisp
cl-fringe: cl-fringe.lisp
##	cl-launch -R -o $@ -f `pwd`/$^	-- slow to start
	cl-launch -o $@ -f `pwd`/$^ +I -r launch -d $@.core

###--------------------------------------------------------------------------
### F#.

FSC			 = fsc
CLEANFILES		+= *.exe
.SUFFIXES: .fs .exe
.fs.exe:; fsc -o $@ $<

LANGS			+= f\#
SOURCES			+= f\#-fringe.fs
f\#-fringe: f\#-fringe.exe
	chmod +x $<
	cp $< $@

###--------------------------------------------------------------------------
### Scheme.

SCMC			 = csc
SCMFLAGS		 = -c -O2 
.SUFFIXES: .scm
.scm.o:; $(SCMC) $(SCMFLAGS) -o $@ $<

LANGS			+= scheme
SOURCES			+= scheme-fringe.scm
scheme-fringe: scheme-fringe.o
	$(SCMC) -o $@ $^

###--------------------------------------------------------------------------
### Go.

GOOBJ			 = 8
GOC			 = $(GOOBJ)g
GOLINK			 = $(GOOBJ)l
CLEANFILES		+= *.$(GOOBJ)
.SUFFIXES: .$(GOOBJ) .go
.go.$(GOOBJ):; $(GOC) $(GOFLAGS) $<

LANGS			+= go
SOURCES			+= go-fringe.go
go-fringe: go-fringe.$(GOOBJ)
	$(GOLINK) -o $@ $^

###--------------------------------------------------------------------------
### Smalltalk.

LANGS			+= smalltalk
TARGETS			+= smalltalk-fringe.im
SOURCES			+= smalltalk-fringe.st
smalltalk-fringe.im: smalltalk-fringe.st
	echo "ObjectMemory snapshot: '$@.new'" | gst $^ -
	mv $@.new $@
smalltalk-fringe:
	{ echo '#! /bin/sh';						\
	  echo '"exec" "gst" "-I" "$@.im" "-f" "$$0" "$$@"';		\
	  echo 'ObjectMemory quit: (Node main: Smalltalk arguments)';	\
	} >$@.new
	chmod +x $@.new
	mv $@.new $@

###----- That's all, folks --------------------------------------------------

all:: $(TARGETS)