CPP=g++
SWIG=swig
SWIGOPTS_LANG=-c++ -python 

PYTHONDIR=/usr/include/python2.6
WCCLDIR=/usr/local/include/libwccl/
CORPUS2DIR=/usr/local/include/libcorpus2/
PWRUTILDIR=

CORPUS2BIN=/usr/local/lib/libcorpus2.so
PWRUTILBIN=/usr/local/lib/libpwrutils.so
CCLBIN=/usr/local/lib/libwccl.so
ANTLRLIB=/usr/lib/libantlr-pic.a 

# CPPFLAGS=-fPIC -Wall -O2
CPPFLAGS=-fPIC -O2

CBIN=libcclvalue.o \
	libcclbool.o \
	libcclposition.o \
	libccltset.o \
	libcclstrset.o \
	libcclmatch.o \
	libcclmatchdata.o \
	libccltokenmatch.o \
	libcclannotationmatch.o \
	libcclmatchvector.o \
	libcclexpression.o \
	libcclparsedexpression.o \
	libcclfunctionaloperator.o \
	libccloperator.o \
	libcclvariables.o \
	libcclsentencecontext.o \
	libcclparser.o \
	libcclactionexeccontext.o \
	libccltagaction.o \
	libccltagrule.o \
	libccltagrulesequence.o \
	libcclmatchrule.o \
	libcclfunctionalopsequence.o \
	wccl.o

CBINOUT=_libcclvalue.so \
				_libcclstrset.so \
				_libcclbool.so \
				_libcclposition.so \
				_libccltset.so \
				_libcclexpression.so \
				_libcclparsedexpression.so \
				_libcclfunctionaloperator.so \
				_libcclvariables.so \
				_libcclmatch.so \
				_libcclmatchdata.so \
				_libccltokenmatch.so \
				_libcclannotationmatch.so \
				_libcclmatchvector.so \
				_libcclsentencecontext.so \
				_libccloperator.so \
				_libcclparser.so \
				_libcclactionexeccontext.so \
				_libccltagaction.so \
				_libccltagrule.so \
				_libccltagrulesequence.so \
				_libcclmatchrule.so \
				_wccl.so \
				_libcclfunctionalopsequence.so \
				_boost_shared_ptr.so

CWRAP=libcclvalue_wrap.cxx \
			libcclstrset_wrap.cxx \
			libcclbool_wrap.cxx \
			libcclposition_wrap.cxx \
			libccltset_wrap.cxx \
			libcclexpression_wrap.cxx \
			libcclparsedexpression_wrap.cxx \
			libcclfunctionaloperator_wrap.cxx \
			libcclvariables_wrap.cxx \
			libcclmatch_wrap.cxx \
			libcclmatchdata_wrap.cxx \
			libccltokenmatch_wrap.cxx \
			libcclannotationmatch_wrap.cxx \
			libcclmatchvector_wrap.cxx \
			libcclsentencecontext_wrap.cxx \
			libccloperator_wrap.cxx \
			libcclparser_wrap.cxx \
			libcclactionexeccontext_wrap.cxx \
			libccltagaction_wrap.cxx \
			libccltagrule_wrap.cxx \
			libccltagrulesequence_wrap.cxx \
			libcclmatchrule_wrap.cxx \
			wccl_wrap.cxx \
			libcclfunctionalopsequence_wrap.cxx \
			boost_shared_ptr_wrap.cxx

CWRAPBIN=libcclvalue_wrap.o \
				 libcclstrset_wrap.o \
				 libcclbool_wrap.o \
				 libcclposition_wrap.o \
				 libccltset_wrap.o \
				 libcclexpression_wrap.o \
				 libcclparsedexpression_wrap.o \
				 libcclfunctionaloperator_wrap.o \
				 libcclvariables_wrap.o \
				 libcclmatch_wrap.o \
				 libcclmatchdata_wrap.o \
				 libccltokenmatch_wrap.o \
				 libcclannotationmatch_wrap.o \
				 libcclmatchvector_wrap.o \
				 libcclsentencecontext_wrap.o \
				 libccloperator_wrap.o \
				 libcclparser_wrap.o \
				 libcclactionexeccontext_wrap.o \
				 libccltagaction_wrap.o \
				 libccltagrule_wrap.o \
				 libccltagrulesequence_wrap.o \
				 libcclmatchrule_wrap.o \
				 wccl_wrap.o \
				 libcclfunctionalopsequence_wrap.o \
				 boost_shared_ptr_wrap.o

PYMODULES=libcclvalue.py \
					libcclstrset.py \
					libcclbool.py \
					libcclposition.py \
					libccltset.py \
					libcclmatch.py \
					libcclmatchdata.py \
					libccltokenmatch.py \
					libcclexpression.py \
					libcclparsedexpression.py \
					libcclvariables.py \
					libcclsentencecontext.py \
					libcclannotationmatch.py \
					libcclmatchvector.py \
					libcclfunctionaloperator.py \
					libccloperator.py \
					libcclparser.py \
					libcclactionexeccontext.py \
					libccltagaction.py \
					libccltagrule.py \
					libccltagrulesequence.py \
					libcclmatchrule.py \
					wccl.py \
					libcclfunctionalopsequence.py \
					boost_shared_ptr.py

PYCBIN=libcclvalue.pyc \
			 libcclstrset.pyc \
			 libcclbool.pyc \
			 libcclposition.pyc \
			 libccltset.pyc \
			 libcclmatch.pyc \
			 libcclmatchdata.pyc \
			 libccltokenmatch.pyc \
			 libcclexpression.pyc \
			 libcclparsedexpression.pyc \
			 libcclvariables.pyc \
			 libcclsentencecontext.pyc \
			 libcclannotationmatch.pyc \
			 libcclmatchvector.pyc \
			 libcclfunctionaloperator.pyc \
			 libccloperator.pyc \
			 libcclparser.pyc \
			 libcclactionexeccontext.pyc \
			 libccltagaction.pyc \
			 libccltagrule.pyc \
			 libccltagrulesequence.pyc \
			 libcclmatchrule.pyc \
			 wccl.pyc \
			 libcclfunctionalopsequence.pyc \
			 boost_shared_ptr.pyc

all:boost_shared_ptr.o $(CBIN)
	# Nothing to do

# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
#  boost::shared_ptr wrappers
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# shared_ptr
boost_shared_ptr.o:
	$(SWIG) $(SWIGOPTS_LANG) boost_shared_ptr.i
	$(CPP) -c boost_shared_ptr_wrap.cxx -I$(PYTHONDIR) $(CPPFLAGS)
	$(CPP) -shared boost_shared_ptr_wrap.o -o _boost_shared_ptr.so

# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
#  CCL Wrappers
# -----------------------------------------------------------------------------
# -----------------------------------------------------------------------------
# Value
libcclvalue.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclvalue.i
	$(CPP) -c libcclvalue_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclvalue_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclvalue.so

# Bool
libcclbool.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclbool.i
	$(CPP) -c libcclbool_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclbool_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclbool.so

# Position
libcclposition.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclposition.i
	$(CPP) -c libcclposition_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclposition_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclposition.so

# TSet
libccltset.o:
	$(SWIG) $(SWIGOPTS_LANG) libccltset.i
	$(CPP) -c libccltset_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libccltset_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libccltset.so

# StrSet
libcclstrset.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclstrset.i
	$(CPP) -c libcclstrset_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclstrset_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclstrset.so

# match
libcclmatch.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclmatch.i
	$(CPP) -c libcclmatch_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclmatch_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclmatch.so

# MatchData
libcclmatchdata.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclmatchdata.i
	$(CPP) -c libcclmatchdata_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclmatchdata_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclmatchdata.so

# TokenMatch
libccltokenmatch.o:
	$(SWIG) $(SWIGOPTS_LANG) libccltokenmatch.i
	$(CPP) -c libccltokenmatch_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libccltokenmatch_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libccltokenmatch.so

# AnnotationMatch
libcclannotationmatch.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclannotationmatch.i
	$(CPP) -c libcclannotationmatch_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclannotationmatch_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclannotationmatch.so

# MatchVector
libcclmatchvector.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclmatchvector.i
	$(CPP) -c libcclmatchvector_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclmatchvector_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclmatchvector.so

# Expression
libcclexpression.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclexpression.i
	$(CPP) -c libcclexpression_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclexpression_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclexpression.so

# ParsedExpression
libcclparsedexpression.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclparsedexpression.i
	$(CPP) -c libcclparsedexpression_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclparsedexpression_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclparsedexpression.so

# FunctionalOperator
libcclfunctionaloperator.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclfunctionaloperator.i
	$(CPP) -c libcclfunctionaloperator_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclfunctionaloperator_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclfunctionaloperator.so

# Operator
libccloperator.o:
	$(SWIG) $(SWIGOPTS_LANG) libccloperator.i
	$(CPP) -c libccloperator_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libccloperator_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libccloperator.so

# Variables
libcclvariables.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclvariables.i
	$(CPP) -c libcclvariables_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclvariables_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclvariables.so

# SentenceContext
libcclsentencecontext.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclsentencecontext.i
	$(CPP) -c libcclsentencecontext_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclsentencecontext_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclsentencecontext.so

# -----------------------------------------------------------------------------

# User Parser
libcclparser.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclparser.i
	$(CPP) -c libcclparser_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclparser_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclparser.so

# -----------------------------------------------------------------------------

# ActionExecContext
libcclactionexeccontext.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclactionexeccontext.i
	$(CPP) -c libcclactionexeccontext_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclactionexeccontext_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclactionexeccontext.so

# TagAction
libccltagaction.o:
	$(SWIG) $(SWIGOPTS_LANG) libccltagaction.i
	$(CPP) -c libccltagaction_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libccltagaction_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libccltagaction.so

# TagRule
libccltagrule.o:
	$(SWIG) $(SWIGOPTS_LANG) libccltagrule.i
	$(CPP) -c libccltagrule_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libccltagrule_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libccltagrule.so

# TagRuleSequence
libccltagrulesequence.o:
	$(SWIG) $(SWIGOPTS_LANG) libccltagrulesequence.i
	$(CPP) -c libccltagrulesequence_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libccltagrulesequence_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libccltagrulesequence.so

# MatchRule
libcclmatchrule.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclmatchrule.i
	$(CPP) -c libcclmatchrule_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclmatchrule_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclmatchrule.so

# FunctionalOpSequence
libcclfunctionalopsequence.o:
	$(SWIG) $(SWIGOPTS_LANG) libcclfunctionalopsequence.i
	$(CPP) -c libcclfunctionalopsequence_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared libcclfunctionalopsequence_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _libcclfunctionalopsequence.so

# -----------------------------------------------------------------------------
# Wccl Library
wccl.o:
	$(SWIG) $(SWIGOPTS_LANG) wccl.i
	$(CPP) -c wccl_wrap.cxx -I$(PYTHONDIR) -I$(WCCLDIR) $(CPPFLAGS)
	$(CPP) -shared wccl_wrap.o \
		$(CCLBIN) $(ANTLRLIB) -o _wccl.so

# -----------------------------------------------------------------------------
clean:
	rm -f $(CBIN) $(CBINOUT) $(CWRAP) $(CWRAPBIN) $(PYMODULES) $(PYCBIN)