prefix=/usr
libdir = ${prefix}/lib

CFROOT=../..
CF_CONNECTORS=../../connectors

ifeq "${YAZ_CONFIG}" ""
YAZ_CONFIG := $(shell if test -x $(CFROOT)/../yaz/yaz-config; then echo $(CFROOT)/../yaz/yaz-config; else echo yaz-config; fi)
endif

YAZ_REQUIRED_VERSION=4.2.62

ifeq "${MP_CONFIG}" ""
MP_CONFIG := $(shell if test -x $(CFROOT)/../metaproxy/metaproxy-config; then echo $(CFROOT)/../metaproxy/metaproxy-config; else echo metaproxy-config; fi)
endif

ifeq "${MP_PROG}" ""
MP_PROG := $(shell if test -x $(CFROOT)/../metaproxy/src/metaproxy; then echo $(CFROOT)/../metaproxy/src/metaproxy; else echo metaproxy; fi)
endif

MP_REQUIRED_VERSION := $(shell perl -ne 'if (/libmetaproxy5-dev \(>= ([0-9\.]+)\)/) { print "$$1"; exit }'  ../../debian/control)

MP_CFLAGS := `$(MP_CONFIG) --cflags`
MP_LIBS := $(shell $(MP_CONFIG) --libs|sed s@-lzoompp@@)
MP_URL=http://localhost:9070/connector
MP_RUN_CONFIG=mp_config.xml

# if PKG_CONFIG_PATH is already from invocation, leave it alone
ifeq "${PKG_CONFIG_PATH}" ""
PKG_CONFIG_PATH := $(shell if test -d /usr/cf-xulrunner/lib64/pkgconfig; then echo  /usr/cf-xulrunner/lib64/pkgconfig; else echo /usr/cf-xulrunner/lib/pkgconfig; fi)
PKG_CONFIG := PKG_CONFIG_PATH=$(PKG_CONFIG_PATH) pkg-config
else
PKG_CONFIG := pkg-config
endif

CF_PROXY := localhost:3128

# Uncomment the following lines to compile with a Xulrunner that do not
# provide pkg-config.. Such as the sdk versions
#XRDEV := /home/adam/proj/xulrunner-sdk-17

ifeq "${XRDEV}" ""
MOZ_PKG := libxul
XRDEV := $(shell $(PKG_CONFIG) --variable=sdkdir $(MOZ_PKG))
MOZ_MAJOR := $(shell $(PKG_CONFIG) --modversion $(MOZ_PKG)|cut -d . -f 1)
else
MOZ_MAJOR := $(shell awk '/.define FIREFOX/ {print $$3}' $(XRDEV)/include/mozilla-config.h|cut -d . -f 1)
endif

XRDEVD=$(shell echo $(XRDEV)|sed s/-devel//)
ifeq "$(XRDEV)" "$(XRDEVD)"
# no -devel in sdkdir, so we assume that the runtime is in 'bin'
SODIR=$(XRDEV)/bin
else
# -devel in sdkdir, assume runtime is in non-devel area (Debian wheezy)
SODIR=$(XRDEVD)
endif
IDLDIR=$(XRDEV)/idl

XPIDL_USES_PYTHON := $(shell if test -f $(XRDEV)/sdk/bin/header.py; then echo 1; else echo 0; fi)

ifeq "${XPIDL_USES_PYTHON}" "1"
PYTHON_BIN := $(shell if test -x /usr/bin/python26; then echo /usr/bin/python26; else echo python; fi)

XPIDL_HEADER=$(PYTHON_BIN) $(XRDEV)/sdk/bin/header.py
XPIDL_TYPELIB=$(PYTHON_BIN) $(XRDEV)/sdk/bin/typelib.py
%.h: %.idl
	$(XPIDL_HEADER) --cachedir=`pwd` -o $@ -I $(IDLDIR) $^

%.xpt: %.idl
	$(XPIDL_TYPELIB) --cachedir=`pwd` -o $@ -I $(IDLDIR) $^
else
XPIDL=$(XRDEV)/bin/xpidl
XPIDL_HEADER=$(XPIDL) -m header -w -v
XPIDL_TYPELIB=$(XPIDL) -m typelib -w -v
%.h: %.idl
	$(XPIDL_HEADER) -I $(IDLDIR) $^

%.xpt: %.idl
	$(XPIDL_TYPELIB) -I $(IDLDIR) $^
endif

######################################################################
# OS specific section
#
UNAME := $(shell uname)

# Linux
ifeq "${UNAME}" "Linux"

ifeq "${MOZ_MAJOR}" "17"
MOZ_GLUE := -Wl,--whole-archive -lmozglue -lmemory -Wl,--no-whole-archive \
  -rdynamic
else
MOZ_GLUE := -lmozalloc -rdynamic
endif

ifeq "${MOZ_PKG}" ""
MOZ_SDK_CFLAGS := -DXPCOM_GLUE -I$(XRDEV)/include -I$(XRDEV)/include/nspr
MOZ_SDK_LIBS := -L$(XRDEV)/lib -lxpcomglue $(MOZ_GLUE)
else
MOZ_SDK_CFLAGS := $(shell $(PKG_CONFIG) --cflags $(MOZ_PKG)) -DMOZ_GLUE_IN_PROGRAM=1
MOZ_SDK_LIBS := $(shell $(PKG_CONFIG) --libs $(MOZ_PKG)) $(MOZ_GLUE)
endif

# For Mozilla2 libxul.so is loaded by the exectuable
# In this case, tell our apps where it is (usually libxul.so
# and related libraries are NOT in ld.so.conf paths)
#MOZ_SDK_LIBS += -Wl,--rpath=$(XRDEV)/lib -Wl,--rpath=$(SODIR)
MOZ_SDK_LIBS += -Wl,--rpath=$(SODIR)
MOZ_SDK_CFLAGS += -DDEFAULT_GRE_HOME=\"$(SODIR)\"

# Debian lenny has GCC 4.3.2 so we assume it's safe to pass the --std option
STD_OPTION := $(shell test -f /etc/debian_version && echo "--std=gnu++0x")

MOZ_CFLAGS := $(shell $(PKG_CONFIG) --cflags gtk+-2.0) $(MOZ_SDK_CFLAGS) $(STD_OPTION)
MOZ_LIBS := $(shell $(PKG_CONFIG) --libs gtk+-2.0) $(MOZ_SDK_LIBS) -lX11

endif

# MacOS 10.6/Darwin
ifeq "${UNAME}" "Darwin"
_XULRUNNER_SDK_DMG=0
ifeq "$(_XULRUNNER_SDK_DMG)" "1"
  # xulrunner installed by DMG from mozilla.org, assume arch i386
  XRDEV=../../../xulrunner-sdk
  MOZ_LIBS=-framework Cocoa -L${XRDEV}/lib -lxpcomglue `$(PKG_CONFIG)  --libs gtk+-2.0`
  MOZ_CFLAGS=-arch i386 -DXPCOM_GLUE -fshort-wchar -I${XRDEV}/include `$(PKG_CONFIG) --cflags gtk+-2.0`
else
  #xulrunner from ports, >= 1.9 force i386
  MOZ_VERSION=`$(PKG_CONFIG) --modversion libxul-embedding`
  MOZILLA2=$(shell if [[ $(MOZ_VERSION) = 2* ]]; then echo 1; else echo 0; fi)
  ifeq "$(MOZILLA2)" "1"
    MOZ_ARCH=
  else
    MOZ_ARCH=-arch i386
  endif
  MOZ_LIBS=-framework Cocoa `$(PKG_CONFIG)  --libs libxul-embedding gtk+-2.0`
  MOZ_CFLAGS=$(MOZ_ARCH) -DDARWIN -DMOZILLA2=$(MOZILLA2) \
    `$(PKG_CONFIG) --cflags libxul-embedding gtk+-2.0 nspr`
endif
MP_LIBS += -lboost_thread-mt
MP_CFLAGS += -fvisibility=hidden
endif

######################################################################
# FreeBSD 9.0-RELEASE
#
ifeq "${UNAME}" "FreeBSD"
MOZILLA2=0
XPIDL=${XRDEV}/../xpidl
SODIR=$(shell $(PKG_CONFIG) --variable=sdkdir libxul )/../
IDLDIR=`$(PKG_CONFIG) --variable=idldir libxul`
MOZ_SDK_LIBS=`$(PKG_CONFIG) --libs libxul`
MOZ_LIBS=`$(PKG_CONFIG) --libs gtk+-2.0 $(MOZ_PKG)` $(MOZ_SDK_LIBS)
MOZ_CFLAGS=`$(PKG_CONFIG) --cflags libxul gtk+-2.0 $(MOZ_PKG)` $(MOZ_SDK_CFLAGS) -DMOZILLA2=$(MOZILLA2) $(STD_OPTION)
MOZ_CFLAGS += -DDEFAULT_GRE_HOME=\"${SODIR}\"
endif

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

MOZ_CFLAGS += -DMOZ_MAJOR=$(MOZ_MAJOR)

CF_LIB = libcf_engine.a

CF_VERSION=$(shell . $(CFROOT)/IDMETA; echo $$VERSION)

YAZ_FLAGS=`$(YAZ_CONFIG) --cflags server`
YAZ_LIBS=`$(YAZ_CONFIG) --libs server static`

# You might add -g here..
OPT_FLAGS=-g -Wall
DL_CXXFLAGS=$(OPT_FLAGS) -fPIC $(YAZ_FLAGS) $(MOZ_CFLAGS) -DCF_VERSION=\"$(CF_VERSION)\"
CXXFLAGS=$(DL_CXXFLAGS) -fno-rtti -fvisibility=hidden

.PHONY: all clean install mp_module help distclean install_mp install_other
.PHONY: unittest check check-yaz check-metaproxy check-xul local-js

LOCAL_JS=defaults/preferences/prefs.js \
	components/ConnectorRuntime.js \
	components/ContentFilter.js \
	components/AppInfo.js

all: check-config-tools local-js \
	cfhello cfrun mp_module json_parse rpn_to_json cf_test

local-js: $(LOCAL_JS)

######## all headers

HEADERS = \
	cf_display.h \
	cf_embed.h \
	cf_engine.h \
	cf_factory.h \
	cf_metadata.h \
	cf_logger.h \
	connector_wrap.h \
	ConsoleListener.h \
	EmbeddingSetup.h \
	embed.h \
	database_args.h \
	json.h \
	moz_web_view.h \
	nsIConnectorRuntime.h \
	nsIContentFilter.h \
	rpn_to_json.h \
	type7_sort.h \
	WebBrowserChrome.h \
	cf_assert.h \
	cf_config.h

######## default prefs

defaults/preferences/prefs.js: prefs.js
	mkdir -p defaults/preferences
	cp prefs.js defaults/preferences/prefs.js
	cd defaults/preferences; patch < ../../prefs.patch

######## XPCOM

components/ConnectorRuntime.js: nsIConnectorRuntime.h ConnectorRuntime.js \
		nsIConnectorRuntime.xpt
	mkdir -p components
	cp nsIConnectorRuntime.xpt components
	cp ConnectorRuntime.js components

components/ContentFilter.js: nsIContentFilter.h \
		$(CFROOT)/builder/components/ContentFilter.js \
		nsIContentFilter.xpt
	mkdir -p components
	cp $(CFROOT)/builder/components/ContentFilter.js components
	cp nsIContentFilter.xpt components

components/AppInfo.js: AppInfo.js
	mkdir -p components
	cp AppInfo.js components

######## library

LIB_OBJS = \
	cf_assert.o \
	cf_display.o \
	cf_factory.o \
	cf_metadata.o \
	cf_engine.o \
	connector_wrap.o \
	ConsoleListener.o \
	EmbeddingSetup.o \
	embed.o \
	database_args.o \
	json_xml.o \
	moz_web_view.o \
	rpn_to_json.o \
	type7_sort.o \
	WebBrowserChrome.o

$(LIB_OBJS): $(HEADERS) $(CFROOT)/IDMETA

$(CF_LIB): $(LIB_OBJS)
	@rm -f $(CF_LIB)
	ar cr $(CF_LIB) $(LIB_OBJS)
	ranlib $(CF_LIB)

######### cfrun
CFRUN_OBJ = cfrun.o

$(CFRUN_OBJ): $(HEADERS)

cfrun: $(CFRUN_OBJ) $(CF_LIB)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(CFRUN_OBJ) -o cfrun \
		$(CF_LIB) $(YAZ_LIBS) $(MOZ_LIBS)

######## cfhello
CFHELLO_OBJ = cfhello.o

$(CFHELLO_OBJ): $(HEADERS)

cfhello: $(CFHELLO_OBJ) $(CF_LIB)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(CFHELLO_OBJ) -o cfhello \
		$(CF_LIB) $(YAZ_LIBS) $(MOZ_LIBS)

######### json_parse
JSON_MAIN_OBJ = json_main.o

$(JSON_MAIN_OBJ): $(HEADERS)

json_parse: $(JSON_MAIN_OBJ) $(CF_LIB)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(JSON_MAIN_OBJ) -o json_parse \
		$(CF_LIB) $(YAZ_LIBS) $(MOZ_LIBS)

######### type7_sort
TYPE7_MAIN_OBJ = type7_main.o

$(TYPE7_MAIN_OBJ): $(HEADERS)

type7_sort: $(TYPE7_MAIN_OBJ) $(CF_LIB)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(TYPE7_MAIN_OBJ) -o type7_sort \
		$(CF_LIB) $(YAZ_LIBS) $(MOZ_LIBS)

######### rpn_to_json
RPN_TO_JSON_OBJ = rpn_to_json_main.o

$(RPN_TO_JSON_OBJ): $(HEADERS)

rpn_to_json: $(RPN_TO_JSON_OBJ) $(CF_LIB)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(RPN_TO_JSON_OBJ) -o rpn_to_json \
		$(CF_LIB) $(YAZ_LIBS) $(MOZ_LIBS)

######### cf_test
CF_TEST_OBJ = cf_test.o

$(CF_TEST_OBJ): $(HEADERS)

cf_test: $(CF_TEST_OBJ) $(CF_LIB)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(CF_TEST_OBJ) -o cf_test \
		$(CF_LIB) $(YAZ_LIBS) $(MOZ_LIBS)

######### embed_test
EMBED_TEST_OBJ = embed_test.o

embed_test: $(EMBED_TEST_OBJ)
	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(EMBED_TEST_OBJ) -o embed_test \
	$(YAZ_LIBS) $(MOZ_SDK_LIBS)

######### Metaproxy Module

MP_SO = metaproxy_filter_cf.so

mp_module: $(MP_SO) ${MP_RUN_CONFIG}

$(MP_SO): metaproxy_filter_cf.cpp $(CF_LIB)
	$(CXX) -shared $(DL_CXXFLAGS) $(LDFLAGS) $(MP_CFLAGS) $< -o $(MP_SO) \
		$(CF_LIB) $(MP_LIBS) $(MOZ_LIBS)

mp_run_repo: $(MP_SO)
	CF_MODULE_PATH=`cd ../../builder/modules; pwd` \
		CF_REPO_FETCH_URL=http://cfrepo.indexdata.com/repo.pl/%s.cf \
		CF_REPO_AUTH_URL=http://cfrepo.indexdata.com/auth.xml \
		CF_TMP_DIR=`pwd` CF_APP_PATH=`pwd` \
		$(MP_PROG) -c mp_config.xml -X -l mp.log

mp_run: $(MP_SO)
	CF_MODULE_PATH=`cd ../../builder/modules; pwd` \
		CF_APP_PATH=`pwd` \
		$(MP_PROG) -c mp_config.xml -X

ws_run:
	curl --output ws.log --data-binary @${CF_CONNECTORS}/doaj.cf $(MP_URL)
	cat ws.log | cut -d":" -f 2|cut -d"}" -f 1 >id
	curl --header "Content-Type: application/json" --data-binary '{}' $(MP_URL)/`cat id`/run_tests/search,parse,next,parse
	curl --header "Content-Type: application/json" --data-binary '{"keyword":"water"}' $(MP_URL)/`cat id`/run_task/search
	curl --header "Content-Type: application/json" --data-binary '{}' $(MP_URL)/`cat id`/run_task/parse
	curl --header "Content-Type: text/plain" --data-binary '' $(MP_URL)/`cat id`/log
	curl --request DELETE $(MP_URL)/`cat id`

######################################################################
check-config-tools:
	@${YAZ_CONFIG} --version >/dev/null
	@${MP_CONFIG} --version  >/dev/null

check-yaz:
	@echo "Required YAZ version is: ${YAZ_REQUIRED_VERSION}"
	@echo "Your YAZ version is:     `${YAZ_CONFIG} --version`"
	@have_version=`${YAZ_CONFIG} --version| awk 'BEGIN { FS = "."; } { printf "%d", ($$1 * 1000 + $$2) * 1000 + $$3;}'`; \
	req_version=`echo "${YAZ_REQUIRED_VERSION}" | awk 'BEGIN { FS = "."; } { printf "%d", ($$1 * 1000 + $$2) * 1000 + $$3;}'`; \
	test "$$have_version" -ge "$$req_version"
	
check-metaproxy:
	@echo "Required metaproxy version is: ${MP_REQUIRED_VERSION}"
	@echo "Your metaproxy version is:     `${MP_CONFIG} --version`"
	@have_version=`${MP_CONFIG} --version| awk 'BEGIN { FS = "."; } { printf "%d", ($$1 * 1000 + $$2) * 1000 + $$3;}'`; \
	req_version=`echo "${MP_REQUIRED_VERSION}" | awk 'BEGIN { FS = "."; } { printf "%d", ($$1 * 1000 + $$2) * 1000 + $$3;}'`; \
	test "$$have_version" -ge "$$req_version"

check-xul: check-yaz check-metaproxy
	@echo "You are running xulrunner version: "`$(PKG_CONFIG)  --modversion libxul`
	@echo "libxul linking at compile time: ${SODIR}"
	@echo "libxul linking at run time:     ${XRDEV}"
	@echo "Your LD_LIBRARY_PATH is set to: \"$$LD_LIBRARY_PATH\""
	@if cmp ${XRDEV}/lib/libxul.so ${SODIR}/libxul.so 2>/dev/null; then \
		echo  "You are using the same libxul.so for linking at compile and start time - Great!"; \
	else \
		echo "You are using *different* libxul.so for linking at compile and start time!!!"; \
	fi
	@ls -Ll ${XRDEV}/lib/libxul.* ${SODIR}/libxul.*
	@echo ""

check-proxy: check-proxy-installation check-proxy-port
check-proxy-installation:
	@if [ -e /sbin/chkconfig ]; then \
	    /sbin/chkconfig --list squid; \
	elif [ -e /usr/sbin/update-rc.d ]; then \
	    /usr/sbin/update-rc.d -n squid defaults; \
	fi

check-proxy-port:
	@p=`echo ${CF_PROXY} | sed 's/:/ /'`; \
	if ! echo "GET /" | nc $$p >/dev/null 2>&1; then \
	    echo ">>> proxy ${CF_PROXY} is not available! <<<"; \
	    exit 1; \
	else \
	    echo "A squid daemon is apparently runnning on ${CF_PROXY}"; \
	fi


distclean: clean shutdown-servers clean-logs
	rm -rf logs

shutdown-servers:
	for i in logs/server*.pid; do \
		test -f $$i && kill `cat $$i`; \
	done; true

clean-logs:
	rm -f logs/*.input logs/*.stdout logs/*.stderr logs/*.status logs/*.png

clean:
	rm -f cfrun cfhello cf-zserver json_parse rpn_to_json type7_sort
	rm -f embed_test cf_test
	rm -f *.o *.a *.xpt nsIConnectorRuntime.h nsIContentFilter.h
	rm -fr socket components mozembed defaults
	rm -f *.so *.log *.bak *.tdy *.cf core
	rm -f mp_config.xml

## installation
install: install_mp install_other

install_other: cfrun
	mkdir -p $(DESTDIR)$(prefix)/bin $(DESTDIR)$(prefix)/sbin
	cp cfrun $(DESTDIR)$(prefix)/bin/cfrun
	mkdir -p $(DESTDIR)$(prefix)/share/cf/app/defaults/preferences
	cp chrome.manifest $(DESTDIR)$(prefix)/share/cf/app
	cp -r components $(DESTDIR)$(prefix)/share/cf/app
	cp prefs.js $(DESTDIR)$(prefix)/share/cf/app/defaults/preferences
	cp -r ../../builder/modules $(DESTDIR)$(prefix)/share/cf

install_mp: $(MP_SO)
	mkdir -p $(DESTDIR)/etc/cf
	cp cf.xml $(DESTDIR)/etc/cf/
	mkdir -p $(DESTDIR)/etc/cf-zserver
	cp cf-zserver.port.xml $(DESTDIR)/etc/cf-zserver/
	cp cf-zserver.route.xml $(DESTDIR)/etc/cf-zserver/
	cp CF2MARC21slim.xsl $(DESTDIR)/etc/cf-zserver/
	mkdir -p $(DESTDIR)$(libdir)/cf
	cp $(MP_SO) $(DESTDIR)$(libdir)/cf

MAX_CLIENTS=8
test-connectors:
	env MAX_CLIENTS=${MAX_CLIENTS} ./test-connector-xvfb.sh

PERL_SCRIPTS:=  $(shell file * | egrep perl | awk '{print $$1}' | perl -ne 's/://; print if !/.(bak|tdy)$$/' | sort)
perltidy:
	ls ${PERL_SCRIPTS} | xargs -n1 -P8 perl -c
	ls ${PERL_SCRIPTS} | xargs -n2 -P4 perltidy -b

######################################################################
# you may want to stop the regression tests at first error with:
# REGRESSION_FATAL=true make check
#

${MP_RUN_CONFIG}: ${MP_RUN_CONFIG}.in
	perl -npe '$$port = $$ENV{_mp_port} ? $$ENV{_mp_port} : "9070"; s,>\@:9070<,>\@:$$port<,' $< > $@

check:
	@$(MAKE) git-status
	@if test "$$make_opt" != "-s"; then $(MAKE) check-xul; fi
	@$(MAKE) hudson-links
	@$(MAKE) unittest-silent
	@$(MAKE) regression

git-status:
	@echo "Run tests on branch: `git branch | egrep '\*'`"
	@echo "Last commit: `git log --oneline | head -1`"

regression: all 
	@echo "Running regression tests"
	RET=0; $(MAKE) -s regression1; \
	test $$? -ne 0 && RET=1; \
	./mp-stop.sh; \
	exit $$RET

regression1:
	MP_PROG=$(MP_PROG) ./mp-start.sh
	error () { $$REGRESSION_FATAL && exit 1; RET=$$1; }; \
	${CF_CONNECTORS}/cf-zserver-regression/regression.sh || error 1; \
	${CF_CONNECTORS}/mp-regression-proxy/regression.sh || error 3; \
	${CF_CONNECTORS}/mp-regression-setpreference/regression.sh || error 4; \
	${CF_CONNECTORS}/ws-regression/regression.sh || error 5; \
	if test -n "$$RET"; then \
	    echo ""; \
	    echo "Sorry, the regression test $$RET failed"; \
	    echo "Please check the log files: `pwd`/mp.log /var/log/messages"; \
	    exit $$RET; \
	fi

hudson-links:
	@if test -n "$$HUDSON_URL" -a -n "$$JOB_NAME"; then \
	    echo ""; \
	    echo "Please check the following links for detailed CF log output:"; \
	    echo "$$HUDSON_URL/job/$$JOB_NAME/ws/engine/src/mp.log"; \
	    echo "$$HUDSON_URL/job/$$JOB_NAME/ws/engine/src/unittests.log"; \
	    echo ""; \
	fi

UNITTEST_LOGFILE := $(shell pwd)/unittests.log
# unittest.sh finds all modules that have unit tests, and runs them all.
unittest: all
	./unittests.sh
	./rpn_to_json_unittest.sh
	./cf_test

unittest-silent: all
	@echo "Running unit tests"
	@echo -n "  unittest "; \
	if ./unittests.sh > ${UNITTEST_LOGFILE} 2>&1; then \
	    echo "OK"; \
	else \
	    echo "Failed; inspect ${UNITTEST_LOGFILE}"; \
	    tail -n 50 ${UNITTEST_LOGFILE}; \
	    exit 1; \
	fi
	@echo -n "  rpn_to_json_unittest "; \
	if ./rpn_to_json_unittest.sh >> ${UNITTEST_LOGFILE} 2>&1; then \
	    echo "OK"; \
	else \
	    echo "Failed; inspect ${UNITTEST_LOGFILE}"; \
	    tail -n 50 ${UNITTEST_LOGFILE}; \
	    exit 1; \
	fi
	@echo -n "  cf_test "; \
	if ./rpn_to_json_unittest.sh >> ${UNITTEST_LOGFILE} 2>&1; then \
	    echo "OK"; \
	else \
	   echo "Failed; inspect ${UNITTEST_LOGFILE}"; \
	   tail -n 50 ${UNITTEST_LOGFILE}; \
	   exit 1; \
	fi

help:
	@echo "make [ all | clean | distclean ]"
	@echo "     [ check-xul | check | unittest ]"

