mirror of https://github.com/swig/swig
1826 lines
66 KiB
Makefile
1826 lines
66 KiB
Makefile
# ------------------------------------------------------------
|
|
# SWIG Examples Makefile
|
|
#
|
|
# This file is used by the examples to build modules. Assuming
|
|
# you ran configure, this file will probably work. However,
|
|
# it's not perfect so you might need to do some hand tweaking.
|
|
#
|
|
# Other notes:
|
|
#
|
|
# 1. Take a look at the prefixes below. Since SWIG works with
|
|
# multiple target languages, you may need to find out where
|
|
# certain packages have been installed. Set the prefixes
|
|
# accordingly.
|
|
#
|
|
# 2. To use this makefile, set required variables, eg SRCS, INTERFACE,
|
|
# INTERFACEDIR, INCLUDES, LIBS, TARGET, and do a
|
|
# $(MAKE) -f Makefile.template.in SRCS='$(SRCS)' \
|
|
# INCLUDES='$(INCLUDES) LIBS='$(LIBS)' INTERFACE='$(INTERFACE)' \
|
|
# INTERFACEDIR='$(INTERFACEDIR)' TARGET='$(TARGET)' method
|
|
#
|
|
# 'method' describes what is being built.
|
|
#---------------------------------------------------------------
|
|
|
|
TARGET =
|
|
CC = @CC@
|
|
CXX = @CXX@
|
|
CFLAGS = @PLATCFLAGS@
|
|
CXXFLAGS = @BOOST_CPPFLAGS@ @PLATCXXFLAGS@
|
|
prefix = @prefix@
|
|
exec_prefix= @exec_prefix@
|
|
SRCS =
|
|
INCLUDES =
|
|
LIBS =
|
|
INTERFACE =
|
|
INTERFACEDIR =
|
|
INTERFACEPATH = $(INTERFACEDIR)$(INTERFACE)
|
|
SWIGOPT =
|
|
SWIG = swig
|
|
|
|
LIBM = @LIBM@
|
|
LIBC = @LIBC@
|
|
LIBCRYPT = @LIBCRYPT@
|
|
SYSLIBS = $(LIBM) $(LIBC) $(LIBCRYPT)
|
|
LIBPREFIX =
|
|
|
|
# RUNTOOL is for use with runtime tools, eg set it to valgrind
|
|
RUNTOOL =
|
|
# COMPILETOOL is a way to run the compiler under another tool, or more commonly just to stop the compiler executing
|
|
COMPILETOOL=
|
|
# RUNPIPE is for piping output of running interpreter/compiled code somewhere, eg RUNPIPE=\>/dev/null
|
|
RUNPIPE=
|
|
|
|
RUNME = runme
|
|
|
|
IWRAP = $(INTERFACE:.i=_wrap.i)
|
|
ISRCS = $(IWRAP:.i=.c)
|
|
ICXXSRCS = $(IWRAP:.i=.cxx)
|
|
IOBJS = $(IWRAP:.i=.@OBJEXT@)
|
|
|
|
##################################################################
|
|
# Some options for silent output
|
|
##################################################################
|
|
|
|
ifneq (,$(findstring s, $(filter-out --%, $(MAKEFLAGS))))
|
|
# make -s detected
|
|
SILENT=1
|
|
else
|
|
SILENT=
|
|
endif
|
|
|
|
ifneq (,$(SILENT))
|
|
SILENT_OPTION = -s
|
|
SILENT_PIPE = >/dev/null
|
|
ANT_QUIET = -q -logfile /dev/null
|
|
else
|
|
SILENT_OPTION =
|
|
SILENT_PIPE =
|
|
ANT_QUIET =
|
|
endif
|
|
|
|
##################################################################
|
|
# Dynamic loading for C++
|
|
# If you are going to be building dynamic loadable modules in C++,
|
|
# you may need to edit this line appropriately.
|
|
#
|
|
# This line works for g++, but I'm not sure what it might be
|
|
# for other C++ compilers
|
|
##################################################################
|
|
|
|
CPP_DLLIBS = #-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.5.1/2.7.2 \
|
|
-L/usr/local/lib -lg++ -lstdc++ -lgcc
|
|
|
|
# Solaris workshop 5.0
|
|
# CPP_DLLIBS = -L/opt/SUNWspro/lib -lCrun
|
|
|
|
# Symbols used for using shared libraries
|
|
SO= @SO@
|
|
LDSHARED= @LDSHARED@
|
|
CCSHARED= @CCSHARED@
|
|
CXXSHARED= @CXXSHARED@
|
|
|
|
# This is used for building shared libraries with a number of C++
|
|
# compilers. If it doesn't work, comment it out.
|
|
@TRYLINKINGWITHCXX@
|
|
|
|
OBJS = $(SRCS:.c=.@OBJEXT@) $(CXXSRCS:.cxx=.@OBJEXT@)
|
|
|
|
distclean:
|
|
rm -f Makefile
|
|
rm -f xml/Makefile
|
|
|
|
##################################################################
|
|
##### Tcl/Tk ######
|
|
##################################################################
|
|
|
|
# Set these to your local copy of Tcl/Tk.
|
|
|
|
TCLSH = tclsh
|
|
TCL_INCLUDE = @TCLINCLUDE@
|
|
TCL_LIB = @TCLLIB@
|
|
TCL_OPTS = @LIBS@
|
|
TK_OPTS = -ltk -ltcl @LIBS@
|
|
|
|
# Extra Tcl specific dynamic linking options
|
|
TCL_DLNK = @TCLDYNAMICLINKING@
|
|
TCL_SO = @TCL_SO@
|
|
TCLLDSHARED = @TCLLDSHARED@
|
|
TCLCXXSHARED = @TCLCXXSHARED@
|
|
TCL_SCRIPT = $(RUNME).tcl
|
|
|
|
# -----------------------------------------------------------
|
|
# Build a new version of the tclsh shell
|
|
# -----------------------------------------------------------
|
|
|
|
tclsh: $(SRCS)
|
|
$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
|
|
$(TCL_LIB) $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
|
|
|
|
tclsh_cpp: $(SRCS)
|
|
$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
|
|
$(TCL_LIB) $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------
|
|
# Build a Tcl dynamic loadable module (you might need to tweak this)
|
|
# -----------------------------------------------------------
|
|
|
|
tcl: $(SRCS)
|
|
$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE)
|
|
$(TCLLDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
|
|
|
|
# -----------------------------------------------------------
|
|
# Build a Tcl7.5 dynamic loadable module for C++
|
|
# -----------------------------------------------------------
|
|
|
|
tcl_cpp: $(SRCS)
|
|
$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE)
|
|
$(TCLCXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run Tcl example
|
|
# -----------------------------------------------------------------
|
|
|
|
tcl_run:
|
|
$(RUNTOOL) $(TCLSH) $(TCL_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
tcl_version:
|
|
echo 'puts $$tcl_version;exit 0' | $(TCLSH)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Tcl examples
|
|
# -----------------------------------------------------------------
|
|
|
|
tcl_clean:
|
|
rm -f *_wrap* *~ .~* mytclsh@EXEEXT@
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### PERL 5 ######
|
|
##################################################################
|
|
|
|
# You need to set this variable to the Perl5 directory containing the
|
|
# files "perl.h", "EXTERN.h" and "XSUB.h". With Perl5.003, it's
|
|
# usually something like /usr/local/lib/perl5/arch-osname/5.003/CORE.
|
|
|
|
PERL5_INCLUDE= @PERL5EXT@
|
|
|
|
# Extra Perl specific dynamic linking options
|
|
PERL5_DLNK = @PERL5DYNAMICLINKING@
|
|
PERL5_CCFLAGS = @PERL5CCFLAGS@
|
|
PERL5_CCDLFLAGS = @PERL5CCDLFLAGS@
|
|
PERL5_CCCDLFLAGS = @PERL5CCCDLFLAGS@
|
|
PERL5_LDFLAGS = @PERL5LDFLAGS@
|
|
PERL = @PERL@
|
|
PERL5_LIB = -L$(PERL5_INCLUDE) -l@PERL5LIB@ @LIBS@ $(SYSLIBS)
|
|
PERL5_SCRIPT = $(RUNME).pl
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a Perl5 dynamically loadable module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
perl5: $(SRCS)
|
|
$(SWIG) -perl5 $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c -Dbool=char $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PERL5_CCFLAGS) $(PERL5_CCCDLFLAGS) -I$(PERL5_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(PERL5_CCDLFLAGS) $(OBJS) $(IOBJS) $(PERL5_LDFLAGS) $(PERL5_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a Perl5 dynamically loadable module (C++)
|
|
# ----------------------------------------------------------------
|
|
|
|
perl5_cpp: $(SRCS)
|
|
$(SWIG) -perl5 -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PERL5_CCFLAGS) $(PERL5_CCCDLFLAGS) -I$(PERL5_INCLUDE)
|
|
$(CXXSHARED) $(CXXFLAGS) $(PERL5_CCDLFLAGS) $(OBJS) $(IOBJS) $(PERL5_LDFLAGS) $(PERL5_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a module from existing XS C source code. (ie. from xsubpp).
|
|
# ----------------------------------------------------------------
|
|
perl5_xs: $(SRCS)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(INCLUDES) -I$(PERL5_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(LIBS) -o $(TARGET)$(SO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a statically linked Perl5 executable
|
|
# ----------------------------------------------------------------
|
|
|
|
perl5_static: $(SRCS)
|
|
$(SWIG) -perl5 -static -lperlmain.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) -Dbool=char $(SRCS) $(ISRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
|
|
|
|
perl5_static_cpp: $(SRCS)
|
|
$(SWIG) -perl5 -c++ -static -lperlmain.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running a Perl5 example
|
|
# -----------------------------------------------------------------
|
|
|
|
perl5_run:
|
|
$(RUNTOOL) $(PERL) $(PERL5_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
perl5_version:
|
|
$(PERL) -v | grep "This is"
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Perl5 examples
|
|
# -----------------------------------------------------------------
|
|
|
|
perl5_clean:
|
|
rm -f *_wrap* *~ .~* myperl@EXEEXT@ *.pm
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### PYTHON ######
|
|
##################################################################
|
|
|
|
# Make sure these locate your Python installation
|
|
ifeq (,$(PY3))
|
|
PYTHON_INCLUDE= $(DEFS) @PYINCLUDE@
|
|
PYTHON_LIB = @PYLIB@
|
|
PYTHON = @PYTHON@
|
|
else
|
|
PYTHON_INCLUDE= $(DEFS) @PY3INCLUDE@
|
|
PYTHON_LIB = @PY3LIB@
|
|
PYTHON = @PYTHON3@
|
|
endif
|
|
|
|
# Extra Python specific linking options
|
|
ifeq (,$(PY3))
|
|
PYTHON_DLNK = @PYTHONDYNAMICLINKING@
|
|
PYTHON_LINK = @PYLINK@
|
|
else
|
|
PYTHON_DLNK = @PYTHON3DYNAMICLINKING@
|
|
PYTHON_LINK = @PY3LINK@
|
|
endif
|
|
PYTHON_SO = @PYTHON_SO@
|
|
|
|
# SWIG option for Python
|
|
ifeq (,$(PY3))
|
|
SWIGPYTHON = $(SWIG) -python
|
|
else
|
|
SWIGPYTHON = $(SWIG) -python -py3
|
|
endif
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a C dynamically loadable module
|
|
# ----------------------------------------------------------------
|
|
|
|
python: $(SRCS)
|
|
$(SWIGPYTHON) $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PYTHON_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build a C++ dynamically loadable module
|
|
# -----------------------------------------------------------------
|
|
|
|
python_cpp: $(SRCS)
|
|
$(SWIGPYTHON) -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PYTHON_INCLUDE)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build statically linked Python interpreter
|
|
#
|
|
# These should only be used in conjunction with the %include embed.i
|
|
# library file
|
|
# -----------------------------------------------------------------
|
|
|
|
#TKINTER = -L/usr/X11R6.3/lib -L/usr/local/compat/lib -ltk4.0 -ltcl7.4 -lX11
|
|
TKINTER =
|
|
PYTHON_LIBOPTS = $(PYTHON_LINK) @LIBS@ $(TKINTER) $(SYSLIBS)
|
|
|
|
python_static: $(SRCS)
|
|
$(SWIGPYTHON) -lembed.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
|
|
$(PYTHON_INCLUDE) $(LIBS) -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
|
|
|
|
python_static_cpp: $(SRCS)
|
|
$(SWIGPYTHON) -c++ -lembed.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
|
|
$(PYTHON_INCLUDE) $(LIBS) -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running a Python example
|
|
# -----------------------------------------------------------------
|
|
|
|
ifeq (,$(PY3))
|
|
PYSCRIPT = $(RUNME).py
|
|
else
|
|
PYSCRIPT = $(RUNME)3.py
|
|
endif
|
|
|
|
PY2TO3 = 2to3 `2to3 -l | grep -v -E "Available|import$$" | awk '{print "-f "$$0}'`
|
|
|
|
python_run: $(PYSCRIPT)
|
|
$(RUNTOOL) $(PYTHON) $(PYSCRIPT) $(RUNPIPE)
|
|
|
|
$(RUNME)3.py: $(RUNME).py
|
|
cp $< $@
|
|
$(PY2TO3) -w $@ >/dev/null 2>&1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
python_version:
|
|
$(PYTHON) -V
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the python examples
|
|
# -----------------------------------------------------------------
|
|
|
|
python_clean:
|
|
rm -rf __pycache__
|
|
rm -f *_wrap* *~ .~* mypython@EXEEXT@ *.pyc
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@ *@PYTHON_SO@
|
|
rm -f $(TARGET).py
|
|
if [ -f $(RUNME).py ]; then rm -f $(RUNME)3.py $(RUNME)3.py.bak; fi
|
|
|
|
|
|
##################################################################
|
|
##### OCTAVE ######
|
|
##################################################################
|
|
|
|
# Make sure these locate your Octave installation
|
|
OCTAVE = OCTAVE_HISTFILE=/dev/null @OCTAVE@
|
|
OCTAVE_CXX = $(DEFS) @OCTAVE_CPPFLAGS@ @OCTAVE_CXXFLAGS@
|
|
|
|
# Extra Octave specific dynamic linking options
|
|
OCTAVE_DLNK = @OCTAVE_LDFLAGS@
|
|
OCTAVE_SO = @OCTAVE_SO@
|
|
|
|
OCTAVE_SCRIPT = $(RUNME).m
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a C dynamically loadable module
|
|
# Note: Octave requires C++ compiler when compiling C wrappers
|
|
# ----------------------------------------------------------------
|
|
|
|
octave: $(SRCS)
|
|
$(SWIG) -octave $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -g -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(INCLUDES) $(OCTAVE_CXX)
|
|
$(CC) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CSRCS) $(INCLUDES)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build a C++ dynamically loadable module
|
|
# -----------------------------------------------------------------
|
|
|
|
octave_cpp: $(SRCS)
|
|
$(SWIG) -c++ -octave $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -g -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(OCTAVE_CXX)
|
|
$(CXXSHARED) -g $(CXXFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running an Octave example
|
|
# -----------------------------------------------------------------
|
|
|
|
octave_run:
|
|
$(RUNTOOL) $(OCTAVE) $(OCTAVE_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
octave_version:
|
|
$(OCTAVE) --version | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Octave examples
|
|
# -----------------------------------------------------------------
|
|
|
|
octave_clean:
|
|
rm -rf __pycache__
|
|
rm -f *_wrap* *~ .~* myoctave@EXEEXT@ *.pyc
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@ *@OCTAVE_SO@
|
|
|
|
##################################################################
|
|
##### GUILE ######
|
|
##################################################################
|
|
|
|
# Make sure these locate your Guile installation
|
|
GUILE = @GUILE@
|
|
GUILE_CFLAGS = @GUILE_CFLAGS@
|
|
GUILE_SO = @GUILE_SO@
|
|
GUILE_LIBS = @GUILE_LIBS@
|
|
GUILE_LIBOPTS = @LIBS@ $(SYSLIBS)
|
|
GUILE_LIBPREFIX = lib
|
|
GUILE_SCRIPT = $(RUNME).scm
|
|
|
|
#------------------------------------------------------------------
|
|
# Build a dynamically loaded module with passive linkage
|
|
#------------------------------------------------------------------
|
|
guile: $(SRCS)
|
|
$(SWIG) -guile -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_CFLAGS) $(ISRCS) $(SRCS)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(GUILE_LIBS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
|
|
|
|
guile_cpp: $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
|
|
$(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO): $(SRCS)
|
|
$(SWIG) -c++ -guile -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(INCLUDES) $(GUILE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(GUILE_LIBS) $(LIBS) $(CPP_DLLIBS) -o $@
|
|
|
|
guile_externalhdr:
|
|
$(SWIG) -guile -external-runtime $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build Guile interpreter augmented with extra functions
|
|
# -----------------------------------------------------------------
|
|
|
|
guile_augmented:
|
|
$(SWIG) -guile $(SWIGOPT) $(INTERFACE)
|
|
$(CC) $(CXXFLAGS) $(SRCS) $(ISRCS) $(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build statically linked Guile interpreter
|
|
# -----------------------------------------------------------------
|
|
|
|
guile_static: $(SRCS)
|
|
$(SWIG) -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
|
|
-DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
|
|
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
|
|
|
|
guile_static_cpp: $(SRCS)
|
|
$(SWIG) -c++ -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
|
|
-DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
|
|
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
|
|
|
|
guile_simple: $(SRCS)
|
|
$(SWIG) -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
|
|
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
|
|
|
|
guile_simple_cpp: $(SRCS)
|
|
$(SWIG) -c++ -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
|
|
$(GUILE_CFLAGS) $(GUILE_LIBS) $(LIBS) $(GUILE_LIBOPTS) -o $(TARGET)-guile
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running a Guile example
|
|
# -----------------------------------------------------------------
|
|
|
|
guile_run:
|
|
env GUILE_AUTO_COMPILE=0 $(RUNTOOL) $(GUILE) -l $(GUILE_SCRIPT) $(RUNPIPE)
|
|
|
|
guile_augmented_run:
|
|
env GUILE_AUTO_COMPILE=0 $(RUNTOOL) ./$(TARGET) $(GUILE_RUNOPTIONS) -s $(GUILE_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
guile_version:
|
|
$(GUILE) --version | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Guile examples
|
|
# -----------------------------------------------------------------
|
|
|
|
guile_clean:
|
|
rm -f *_wrap* *~ .~* my-guile@EXEEXT@ $(TARGET)@EXEEXT@
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@GUILE_SO@
|
|
|
|
##################################################################
|
|
##### JAVA ######
|
|
##################################################################
|
|
|
|
# You need to set this variable to the java directories containing the
|
|
# files "jni.h" and "md.h"
|
|
# usually something like /usr/java/include and /usr/java/include/<arch-osname>.
|
|
JAVA_INCLUDE= @JAVAINC@
|
|
|
|
# Extra Java specific dynamic linking options
|
|
JAVA_DLNK = @JAVADYNAMICLINKING@
|
|
JAVA_LIBPREFIX = @JAVALIBRARYPREFIX@
|
|
JAVASO =@JAVASO@
|
|
JAVALDSHARED = @JAVALDSHARED@
|
|
JAVACXXSHARED = @JAVACXXSHARED@
|
|
JAVACFLAGS = @JAVACFLAGS@
|
|
JAVA = @JAVA@
|
|
JAVAC = @JAVAC@
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a java dynamically loadable module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
java: $(SRCS)
|
|
$(SWIG) -java $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(JAVA_INCLUDE)
|
|
$(JAVALDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a java dynamically loadable module (C++)
|
|
# ----------------------------------------------------------------
|
|
|
|
java_cpp: $(SRCS)
|
|
$(SWIG) -java -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(JAVACFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(JAVA_INCLUDE)
|
|
$(JAVACXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Compile java files
|
|
# ----------------------------------------------------------------
|
|
|
|
java_compile: $(SRCS)
|
|
$(COMPILETOOL) $(JAVAC) $(JAVACFLAGS) $(JAVASRCS)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run java example
|
|
# -----------------------------------------------------------------
|
|
|
|
java_run:
|
|
env LD_LIBRARY_PATH=. $(RUNTOOL) $(JAVA) $(RUNME) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
java_version:
|
|
$(JAVA) -version
|
|
$(JAVAC) -version || echo "Unknown javac version"
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the java examples
|
|
# -----------------------------------------------------------------
|
|
|
|
java_clean:
|
|
rm -f *_wrap* *~ .~* *.class `find . -name \*.java | grep -v $(RUNME).java`
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@JAVASO@
|
|
|
|
##################################################################
|
|
##### JAVASCRIPT ######
|
|
##################################################################
|
|
|
|
# Note: These targets are also from within Makefiles in the Example directories.
|
|
# There is a common makefile, 'Examples/javascript/js_example.mk' to simplify
|
|
# create a configuration for a new example.
|
|
|
|
|
|
ROOT_DIR = @ROOT_DIR@
|
|
JSCFLAGS = @JSCFLAGS@
|
|
JSCXXFLAGS = @JSCXXFLAGS@
|
|
JSINCLUDES = @JSCOREINC@ @JSV8INC@
|
|
JSDYNAMICLINKING = @JSCOREDYNAMICLINKING@ @JSV8DYNAMICLINKING@
|
|
JSLIBRARYPREFIX = @JSLIBRARYPREFIX@
|
|
JSSO =@JSSO@
|
|
JSLDSHARED = @JSLDSHARED@
|
|
JSCXXSHARED = @JSCXXSHARED@
|
|
|
|
SWIGJS = $(SWIG) -javascript
|
|
|
|
# ----------------------------------------------------------------
|
|
# Creating and building Javascript wrappers
|
|
# ----------------------------------------------------------------
|
|
|
|
javascript_wrapper:
|
|
$(SWIGJS) $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.c $(INTERFACEPATH)
|
|
|
|
javascript_wrapper_cpp: $(SRCS)
|
|
$(SWIGJS) -c++ $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.cxx $(INTERFACEPATH)
|
|
|
|
javascript_build: $(SRCS)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(JSCFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(JSINCLUDES)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
javascript_build_cpp:: $(SRCS)
|
|
$(CXX) -c $(CCSHARED) $(CFLAGS) $(JSCFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(JSINCLUDES)
|
|
$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# TODO: make node-gyp configurable and detected via ./configure
|
|
javascript_build_node: $(SRCS)
|
|
node-gyp --loglevel=silent configure build 1>>/dev/null
|
|
|
|
# These targets are used by the test-suite:
|
|
|
|
javascript: $(SRCS) javascript_custom_interpreter
|
|
$(SWIGJS) $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(JSCFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(JSINCLUDES)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
javascript_cpp: $(SRCS) javascript_custom_interpreter
|
|
$(SWIGJS) -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CFLAGS) $(JSCFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(JSINCLUDES)
|
|
$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JSDYNAMICLINKING) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running a javascript example
|
|
# -----------------------------------------------------------------
|
|
|
|
javascript_custom_interpreter:
|
|
(cd $(ROOT_DIR)/Tools/javascript && $(MAKE) JSENGINE='$(JSENGINE)')
|
|
|
|
javascript_run: javascript_custom_interpreter
|
|
$(ROOT_DIR)/Tools/javascript/javascript -$(JSENGINE) -L $(TARGET) runme.js
|
|
|
|
# TODO: make node configurable and detected via ./configure
|
|
javascript_run_node:
|
|
node runme.js
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the javascript examples
|
|
# -----------------------------------------------------------------
|
|
|
|
javascript_clean:
|
|
rm -rf build
|
|
rm -f *_wrap* runme
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@JSSO@ *.$(SO)
|
|
(cd $(ROOT_DIR)/Tools/javascript && $(MAKE) -s clean)
|
|
|
|
##################################################################
|
|
##### ANDROID ######
|
|
##################################################################
|
|
|
|
ANDROID = android
|
|
ANDROID_NDK_BUILD = ndk-build
|
|
ANDROID_ADB = adb
|
|
ANT = ant
|
|
TARGETID = 1
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build an Android dynamically loadable module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
android: $(SRCS)
|
|
$(ANDROID) $(SILENT_OPTION) update project --target $(TARGETID) --name $(PROJECTNAME) --path .
|
|
$(SWIG) -java $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.c $(INTERFACEPATH)
|
|
+$(ANDROID_NDK_BUILD) $(SILENT_PIPE)
|
|
$(ANT) $(ANT_QUIET) debug
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build an Android dynamically loadable module (C++)
|
|
# ----------------------------------------------------------------
|
|
|
|
android_cpp: $(SRCS)
|
|
$(ANDROID) $(SILENT_OPTION) update project --target $(TARGETID) --name $(PROJECTNAME) --path .
|
|
$(SWIG) -java -c++ $(SWIGOPT) -o $(INTERFACEDIR)$(TARGET)_wrap.cpp $(INTERFACEPATH)
|
|
+$(ANDROID_NDK_BUILD) $(SILENT_PIPE)
|
|
$(ANT) $(ANT_QUIET) debug
|
|
|
|
# ----------------------------------------------------------------
|
|
# Android install
|
|
# ----------------------------------------------------------------
|
|
|
|
android_install:
|
|
-$(ANDROID_ADB) uninstall $(PACKAGENAME)
|
|
$(ANDROID_ADB) install $(INSTALLOPTIONS) bin/$(PROJECTNAME)-debug.apk
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
android_version:
|
|
$(ANDROID_ADB) version
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Android examples
|
|
# -----------------------------------------------------------------
|
|
|
|
android_clean:
|
|
ant -q -logfile /dev/null clean
|
|
rm -f $(INTERFACEDIR)$(TARGET)_wrap.*
|
|
rm -f `find $(PACKAGEDIR) -name \*.java | grep -v $(PROJECTNAME).java`
|
|
rm -rf obj
|
|
|
|
##################################################################
|
|
##### MODULA3 ######
|
|
##################################################################
|
|
|
|
MODULA3_INCLUDE= @MODULA3INC@
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a modula3 dynamically loadable module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
modula3: $(SRCS)
|
|
$(SWIG) -modula3 $(SWIGOPT) $(INTERFACEPATH)
|
|
# $(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) \
|
|
# $(OBJS) $(IOBJS) $(LIBS)
|
|
|
|
modula3_cpp: $(SRCS)
|
|
$(SWIG) -modula3 -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run modula3 example
|
|
# -----------------------------------------------------------------
|
|
|
|
modula3_run:
|
|
$(RUNTOOL) false $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
modula3_version:
|
|
echo "Unknown modula3 version"
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the modula3 examples
|
|
# -----------------------------------------------------------------
|
|
|
|
modula3_clean:
|
|
rm -f *_wrap* *.i3 *.m3
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### MZSCHEME ######
|
|
##################################################################
|
|
|
|
MZSCHEME = mzscheme
|
|
MZC = @MZC@
|
|
MZDYNOBJ = @MZDYNOBJ@
|
|
MZSCHEME_SO = @MZSCHEME_SO@
|
|
MZSCHEME_SCRIPT = $(RUNME).scm
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a C/C++ dynamically loadable module
|
|
# ----------------------------------------------------------------
|
|
|
|
mzscheme: $(SRCS)
|
|
$(SWIG) -mzscheme $(SWIGOPT) $(INTERFACEPATH)
|
|
$(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ISRCS) $(SRCS)
|
|
$(COMPILETOOL) $(MZC) --ld $(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS)
|
|
|
|
mzscheme_cpp: $(SRCS)
|
|
$(SWIG) -mzscheme -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ICXXSRCS) $(SRCS) $(CXXSRCS)
|
|
$(CXXSHARED) $(CXXFLAGS) -o $(LIBPREFIX)$(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS) $(MZDYNOBJ) $(CPP_DLLIBS)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run mzscheme example
|
|
# -----------------------------------------------------------------
|
|
|
|
mzscheme_run:
|
|
env LD_LIBRARY_PATH=. $(RUNTOOL) $(MZSCHEME) -r $(MZSCHEME_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
mzscheme_version:
|
|
$(MZSCHEME) -v
|
|
$(MZC) -v
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the mzscheme examples
|
|
# -----------------------------------------------------------------
|
|
|
|
mzscheme_clean:
|
|
rm -f *_wrap* *~ .~*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### Ocaml #####
|
|
##################################################################
|
|
|
|
OCC=@OCAMLC@
|
|
OCAMLDLGEN=@OCAMLDLGEN@
|
|
OCAMLFIND=@OCAMLFIND@
|
|
OCAMLMKTOP=@OCAMLMKTOP@ $(SWIGWHERE)
|
|
NOLINK ?= false
|
|
OCAMLPP= -pp "camlp4o ./swigp4.cmo"
|
|
OCAMLP4WHERE=`$(COMPILETOOL) camlp4 -where`
|
|
OCAMLCORE=\
|
|
rm -rf swig.mli swig.ml swigp4.ml && \
|
|
$(SWIG) -ocaml -co swig.mli 2>/dev/null && \
|
|
$(SWIG) -ocaml -co swig.ml 2>/dev/null && \
|
|
$(SWIG) -ocaml -co swigp4.ml 2>/dev/null && \
|
|
$(OCC) -c swig.mli && \
|
|
$(OCC) -c swig.ml && \
|
|
$(OCC) -I $(OCAMLP4WHERE) -pp "camlp4o pa_extend.cmo q_MLast.cmo" \
|
|
-c swigp4.ml
|
|
|
|
ocaml_static: $(SRCS)
|
|
$(OCAMLCORE)
|
|
$(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
|
|
$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
|
|
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
|
|
$(OCC) $(OCAMLPP) -c $(PROGFILE)
|
|
$(NOLINK) || $(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
|
|
swig.cmo \
|
|
$(INTERFACE:%.i=%.cmo) \
|
|
$(PROGFILE:%.ml=%.cmo) \
|
|
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) -cclib "$(LIBS)"
|
|
|
|
ocaml_dynamic: $(SRCS)
|
|
$(OCAMLCORE)
|
|
$(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
|
|
$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
|
|
$(CXXSHARED) $(CXXFLAGS) $(CCSHARED) $(CFLAGS) -o $(INTERFACE:%.i=%@SO@) \
|
|
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) $(LIBS)
|
|
$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
|
|
$(INTERFACE:%.i=%_dynamic.ml)
|
|
mv $(INTERFACE:%.i=%_dynamic.ml) $(INTERFACE:%.i=%.ml)
|
|
rm $(INTERFACE:%.i=%.mli)
|
|
$(OCAMLFIND) $(OCC) -g -c -package dl $(INTERFACE:%.i=%.ml)
|
|
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
|
|
$(OCC) $(OCAMLPP) -c $(PROGFILE)
|
|
$(NOLINK) || $(OCAMLFIND) \
|
|
$(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
|
|
swig.cmo \
|
|
-package dl -linkpkg \
|
|
$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo)
|
|
|
|
ocaml_static_toplevel: $(SRCS)
|
|
$(OCAMLCORE)
|
|
$(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
|
|
$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
|
|
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
|
|
$(OCC) $(OCAMLPP) -c $(PROGFILE)
|
|
$(NOLINK) || $(OCAMLMKTOP) \
|
|
swig.cmo \
|
|
-I $(OCAMLP4WHERE) camlp4o.cma swigp4.cmo \
|
|
-g -ccopt -g -cclib -g -custom -o $(TARGET)_top \
|
|
$(INTERFACE:%.i=%.cmo) \
|
|
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) -cclib "$(LIBS)"
|
|
|
|
ocaml_static_cpp: $(SRCS)
|
|
$(OCAMLCORE)
|
|
$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
|
|
$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
|
|
$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
|
|
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
|
|
$(OCC) $(OCAMLPP) -c $(PROGFILE)
|
|
$(NOLINK) || $(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
|
|
swig.cmo \
|
|
$(INTERFACE:%.i=%.cmo) \
|
|
$(PROGFILE:%.ml=%.cmo) \
|
|
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
|
|
-cclib "$(LIBS)" -cc '$(CXX) -Wno-write-strings'
|
|
|
|
ocaml_static_cpp_toplevel: $(SRCS)
|
|
$(OCAMLCORE)
|
|
$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
|
|
$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
|
|
$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.mli)
|
|
$(OCC) -g -c $(INTERFACE:%.i=%.ml)
|
|
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
|
|
$(OCC) $(OCAMLPP) -c $(PROGFILE)
|
|
$(NOLINK) || $(OCAMLMKTOP) \
|
|
swig.cmo \
|
|
-I $(OCAMLP4WHERE) dynlink.cma camlp4o.cma swigp4.cmo \
|
|
-g -ccopt -g -cclib -g -custom -o $(TARGET)_top \
|
|
$(INTERFACE:%.i=%.cmo) \
|
|
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
|
|
-cclib "$(LIBS)" -cc '$(CXX) -Wno-write-strings'
|
|
|
|
ocaml_dynamic_cpp: $(SRCS)
|
|
$(OCAMLCORE)
|
|
$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
|
|
$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
|
|
$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS) -ccopt -fPIC
|
|
$(CXXSHARED) $(CXXFLAGS) -o $(INTERFACE:%.i=%@SO@) \
|
|
$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
|
|
$(CPP_DLLIBS) $(LIBS)
|
|
$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
|
|
$(INTERFACE:%.i=%_dynamic.ml)
|
|
mv $(INTERFACE:%.i=%_dynamic.ml) $(INTERFACE:%.i=%.ml)
|
|
rm $(INTERFACE:%.i=%.mli)
|
|
$(OCAMLFIND) $(OCC) -g -c -package dl $(INTERFACE:%.i=%.ml)
|
|
test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
|
|
$(OCC) $(OCAMLPP) -c $(PROGFILE)
|
|
$(NOLINK) || $(OCAMLFIND) \
|
|
swig.cmo \
|
|
$(OCC) -cclib -export-dynamic -g -ccopt -g -cclib -g -custom \
|
|
-o $(TARGET) \
|
|
-package dl -linkpkg \
|
|
$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo) -cc '$(CXX) -Wno-write-strings'
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run ocaml example
|
|
# -----------------------------------------------------------------
|
|
|
|
ocaml_run:
|
|
$(RUNTOOL) ./$(TARGET) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
ocaml_version:
|
|
$(OCC) -version
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Ocaml examples
|
|
# -----------------------------------------------------------------
|
|
|
|
ocaml_clean:
|
|
rm -f *_wrap* *~ .~* *.cmo *.cmi $(MLFILE) $(MLFILE)i swig.mli swig.cmi swig.ml swig.cmo swigp4.ml swigp4.cmo
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### RUBY ######
|
|
##################################################################
|
|
|
|
# Make sure these locate your Ruby installation
|
|
RUBY_CFLAGS= @RUBYCCDLFLAGS@ $(DEFS)
|
|
RUBY_INCLUDE= @RUBYINCLUDE@
|
|
RUBY_LIB = @RUBYLIB@
|
|
RUBY_DLNK = @RUBYDYNAMICLINKING@
|
|
RUBY_LIBOPTS = @RUBYLINK@ @LIBS@ $(SYSLIBS)
|
|
RUBY_SO = @RUBYSO@
|
|
RUBY = @RUBY@
|
|
RUBY_SCRIPT = $(RUNME).rb
|
|
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a C dynamically loadable module
|
|
# ----------------------------------------------------------------
|
|
|
|
ruby: $(SRCS)
|
|
$(SWIG) -ruby $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(RUBY_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(RUBY_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build a C++ dynamically loadable module
|
|
# -----------------------------------------------------------------
|
|
|
|
ruby_cpp: $(SRCS)
|
|
$(SWIG) -c++ -ruby $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(RUBY_INCLUDE)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(RUBY_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build statically linked Ruby interpreter
|
|
#
|
|
# These should only be used in conjunction with the %include embed.i
|
|
# library file
|
|
# -----------------------------------------------------------------
|
|
|
|
ruby_static: $(SRCS)
|
|
$(SWIG) -ruby -lembed.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) $(RUBY_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
|
|
$(RUBY_INCLUDE) $(LIBS) -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
|
|
|
|
ruby_cpp_static: $(SRCS)
|
|
$(SWIG) -c++ -ruby -lembed.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
|
|
$(RUBY_INCLUDE) $(LIBS) -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run Ruby example
|
|
# -----------------------------------------------------------------
|
|
|
|
ruby_run:
|
|
$(RUNTOOL) $(RUBY) -I. $(RUBY_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
ruby_version:
|
|
$(RUBY) -v
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Ruby examples
|
|
# -----------------------------------------------------------------
|
|
|
|
ruby_clean:
|
|
rm -f *_wrap* *~ .~* myruby@EXEEXT@ *.pm
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### PHP ######
|
|
##################################################################
|
|
|
|
PHP = @PHP@
|
|
PHP_INCLUDE = @PHPINC@
|
|
PHP_SO = @PHP_SO@
|
|
PHP_SCRIPT = $(RUNME).php
|
|
|
|
# -------------------------------------------------------------------
|
|
# Build a PHP dynamically loadable module (C)
|
|
# -------------------------------------------------------------------
|
|
|
|
php: $(SRCS)
|
|
$(SWIG) -php $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PHP_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
|
|
|
|
# --------------------------------------------------------------------
|
|
# Build a PHP dynamically loadable module (C++)
|
|
# --------------------------------------------------------------------
|
|
|
|
php_cpp: $(SRCS)
|
|
$(SWIG) -php -cppext cxx -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PHP_INCLUDE)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running a PHP example
|
|
# -----------------------------------------------------------------
|
|
|
|
php_run:
|
|
$(RUNTOOL) $(PHP) -n -q -d extension_dir=. -d safe_mode=Off $(PHP_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
php_version:
|
|
$(PHP) -v | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the PHP examples
|
|
# -----------------------------------------------------------------
|
|
|
|
php_clean:
|
|
rm -f *_wrap* *~ .~* example.php php_example.h
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### Pike ######
|
|
##################################################################
|
|
|
|
# Make sure these locate your Pike installation
|
|
PIKE = pike
|
|
PIKE_CFLAGS = @PIKECCDLFLAGS@ -DHAVE_CONFIG_H
|
|
PIKE_INCLUDE = @PIKEINCLUDE@
|
|
PIKE_LIB = @PIKELIB@
|
|
PIKE_DLNK = @PIKEDYNAMICLINKING@
|
|
PIKE_LIBOPTS = @PIKELINK@ @LIBS@ $(SYSLIBS)
|
|
PIKE_SCRIPT = $(RUNME).pike
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a C dynamically loadable module
|
|
# ----------------------------------------------------------------
|
|
|
|
pike: $(SRCS)
|
|
$(SWIG) -pike $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PIKE_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build a C++ dynamically loadable module
|
|
# -----------------------------------------------------------------
|
|
|
|
pike_cpp: $(SRCS)
|
|
$(SWIG) -c++ -pike $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PIKE_INCLUDE)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build statically linked Pike interpreter
|
|
#
|
|
# These should only be used in conjunction with the %include embed.i
|
|
# library file
|
|
# -----------------------------------------------------------------
|
|
|
|
pike_static: $(SRCS)
|
|
$(SWIG) -pike -lembed.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) $(PIKE_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
|
|
$(PIKE_INCLUDE) $(LIBS) -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
|
|
|
|
pike_cpp_static: $(SRCS)
|
|
$(SWIG) -c++ -pike -lembed.i $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
|
|
$(PIKE_INCLUDE) $(LIBS) -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run pike example
|
|
# -----------------------------------------------------------------
|
|
|
|
pike_run:
|
|
$(RUNTOOL) $(PIKE) $(PIKE_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
pike_version:
|
|
$(PIKE) -v 2>&1 | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Pike examples
|
|
# -----------------------------------------------------------------
|
|
|
|
pike_clean:
|
|
rm -f *_wrap* *~ .~* mypike@EXEEXT@
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
|
|
##################################################################
|
|
##### Chicken ######
|
|
##################################################################
|
|
|
|
CHICKEN = @CHICKEN@
|
|
CHICKEN_CSC = @CHICKEN_CSC@
|
|
CHICKEN_CSI = @CHICKEN_CSI@
|
|
CHICKEN_LIBOPTS = @CHICKENLIB@ $(SYSLIBS)
|
|
CHICKEN_SHAREDLIBOPTS = @CHICKENSHAREDLIB@ $(SYSLIBS)
|
|
CHICKEN_CFLAGS = @CHICKENOPTS@
|
|
CHICKENOPTS = -quiet
|
|
CHICKEN_MAIN =
|
|
CHICKEN_SCRIPT = $(RUNME).scm
|
|
|
|
# SWIG produces $(ISRCS) (the C wrapper file)
|
|
# and $(CHICKEN_GENERATED_SCHEME) (the Scheme wrapper file):
|
|
CHICKEN_GENERATED_SCHEME = $(INTERFACE:.i=.scm)
|
|
CHICKEN_COMPILED_SCHEME = $(INTERFACE:.i=_chicken.c)
|
|
CHICKEN_COMPILED_OBJECT = $(CHICKEN_COMPILED_SCHEME:.c=.@OBJEXT@)
|
|
|
|
# flags for the main chicken sources (only used when compiling statically)
|
|
CHICKEN_COMPILED_MAIN = $(CHICKEN_MAIN:.scm=_chicken.c)
|
|
CHICKEN_COMPILED_MAIN_OBJECT = $(CHICKEN_COMPILED_MAIN:.c=.@OBJEXT@)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build a CHICKEN dynamically loadable module
|
|
# -----------------------------------------------------------------
|
|
|
|
# This is the old way to build chicken, but it does not work correctly with exceptions
|
|
chicken_direct: $(SRCS)
|
|
$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
|
|
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
|
|
-dynamic -feature chicken-compile-shared \
|
|
-output-file $(CHICKEN_COMPILED_SCHEME)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
|
|
$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) $(CHICKEN_COMPILED_SCHEME)
|
|
$(LDSHARED) $(CFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
|
|
$(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
chicken_direct_cpp: $(CXXSRCS) $(CHICKSRCS)
|
|
$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
|
|
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
|
|
-dynamic -feature chicken-compile-shared \
|
|
-output-file $(CHICKEN_COMPILED_SCHEME)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(CHICKEN_CFLAGS) \
|
|
$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(CHICKEN_COMPILED_SCHEME)
|
|
$(CXXSHARED) $(CXXFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
|
|
$(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build statically linked CHICKEN interpreter
|
|
# -----------------------------------------------------------------
|
|
|
|
# The following two targets are also used by the test suite
|
|
chicken_static: $(SRCS) $(CHICKSRCS)
|
|
$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
|
|
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
|
|
-output-file $(CHICKEN_COMPILED_SCHEME)
|
|
$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
|
|
-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
|
|
$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) \
|
|
$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
|
|
$(CC) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
|
|
$(OBJS) $(IOBJS) $(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
|
|
|
|
chicken_static_cpp: $(CXXSRCS) $(CHICKSRCS)
|
|
$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
|
|
$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
|
|
-output-file $(CHICKEN_COMPILED_SCHEME)
|
|
$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
|
|
-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(CHICKEN_CFLAGS) \
|
|
$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) \
|
|
$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
|
|
$(CXX) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
|
|
$(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a shared library using csc
|
|
# ----------------------------------------------------------------
|
|
|
|
chicken:
|
|
$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
|
|
$(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ISRCS) -o $(TARGET)$(SO)
|
|
|
|
chicken_cpp:
|
|
$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
|
|
$(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ICXXSRCS) $(CXXSRCS) -o $(TARGET)$(SO)
|
|
|
|
chicken_externalhdr:
|
|
$(SWIG) -chicken -external-runtime $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run CHICKEN example
|
|
# -----------------------------------------------------------------
|
|
|
|
chicken_run:
|
|
env LD_LIBRARY_PATH=. $(RUNTOOL) $(CHICKEN_CSI) $(CHICKEN_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
chicken_version:
|
|
$(CHICKEN) -version | grep -i version
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the CHICKEN examples
|
|
# -----------------------------------------------------------------
|
|
|
|
chicken_clean:
|
|
rm -f *_wrap* *~ .~* *_chicken*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### CSHARP ######
|
|
##################################################################
|
|
|
|
# Extra CSharp specific dynamic linking options
|
|
CSHARP_DLNK = @CSHARPDYNAMICLINKING@
|
|
CSHARP_LIBPREFIX = @CSHARPLIBRARYPREFIX@
|
|
CSHARPCOMPILER = @CSHARPCOMPILER@
|
|
CSHARPCILINTERPRETER = @CSHARPCILINTERPRETER@
|
|
CSHARPCILINTERPRETER_FLAGS = @CSHARPCILINTERPRETER_FLAGS@
|
|
CSHARPCFLAGS = @CSHARPCFLAGS@
|
|
CSHARPSO = @CSHARPSO@
|
|
CSHARP_RUNME = $(CSHARPCILINTERPRETER) $(CSHARPCILINTERPRETER_FLAGS) ./$(RUNME).exe
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a CSharp dynamically loadable module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
csharp: $(SRCS)
|
|
$(SWIG) -csharp $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a CSharp dynamically loadable module (C++)
|
|
# ----------------------------------------------------------------
|
|
|
|
csharp_cpp: $(SRCS)
|
|
$(SWIG) -csharp -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(CSHARPCFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Compile CSharp files
|
|
# ----------------------------------------------------------------
|
|
|
|
csharp_compile: $(SRCS)
|
|
$(COMPILETOOL) $(CSHARPCOMPILER) $(CSHARPFLAGS) $(CSHARPSRCS)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run CSharp example
|
|
# -----------------------------------------------------------------
|
|
|
|
csharp_run:
|
|
env LD_LIBRARY_PATH=. $(RUNTOOL) $(CSHARP_RUNME) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
# Version check below also works with MS csc.exe which does not understand --version
|
|
csharp_version:
|
|
$(CSHARPCOMPILER) --version | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the CSharp examples
|
|
# -----------------------------------------------------------------
|
|
|
|
csharp_clean:
|
|
rm -f *_wrap* *~ .~* $(RUNME) $(RUNME).exe *.exe.mdb gc.log `find . -name \*.cs | grep -v $(RUNME).cs`
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@CSHARPSO@
|
|
|
|
##################################################################
|
|
##### LUA ######
|
|
##################################################################
|
|
|
|
# lua flags
|
|
LUA_INCLUDE= @LUAFLAGS@
|
|
LUA_LIB = @LUALINK@
|
|
|
|
# Extra specific dynamic linking options
|
|
LUA_DLNK = @LUADYNAMICLINKING@
|
|
LUA_SO = @LUA_SO@
|
|
|
|
LUA = @LUABIN@
|
|
LUA_SCRIPT = $(RUNME).lua
|
|
|
|
# Extra code for lua static link
|
|
LUA_INTERP = ../lua.c
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a C dynamically loadable module
|
|
# ----------------------------------------------------------------
|
|
|
|
lua: $(SRCS)
|
|
$(SWIG) -lua $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(LUA_INCLUDE)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build a C++ dynamically loadable module
|
|
# -----------------------------------------------------------------
|
|
|
|
lua_cpp: $(SRCS)
|
|
$(SWIG) -c++ -lua $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(LUA_INCLUDE)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Build statically linked Lua interpreter
|
|
# -----------------------------------------------------------------
|
|
|
|
lua_static: $(SRCS)
|
|
$(SWIG) -lua -module example $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(LUA_INTERP) $(INCLUDES) \
|
|
$(LUA_INCLUDE) $(LIBS) $(LUA_LIB) -o $(TARGET)
|
|
|
|
lua_static_cpp: $(SRCS)
|
|
$(SWIG) -c++ -lua -module example $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(LUA_INTERP) $(INCLUDES) \
|
|
$(LUA_INCLUDE) $(LIBS) $(LUA_LIB) -o $(TARGET)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run Lua example
|
|
# -----------------------------------------------------------------
|
|
|
|
lua_run:
|
|
$(RUNTOOL) $(LUA) $(LUA_SCRIPT) $(RUNPIPE)
|
|
|
|
lua_embed_run:
|
|
$(RUNTOOL) ./$(TARGET) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
lua_version:
|
|
$(LUA) -v | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the lua examples
|
|
# -----------------------------------------------------------------
|
|
|
|
lua_clean:
|
|
rm -f *_wrap* *~ .~* mylua@EXEEXT@
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### ALLEGRO CL ######
|
|
##################################################################
|
|
|
|
ALLEGROCL = @ALLEGROCLBIN@
|
|
ALLEGROCL_SCRIPT=$(RUNME).lisp
|
|
|
|
allegrocl: $(SRCS)
|
|
$(SWIG) -allegrocl -cwrap $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
allegrocl_cpp: $(SRCS)
|
|
$(SWIG) -c++ -allegrocl $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run ALLEGRO CL example
|
|
# -----------------------------------------------------------------
|
|
|
|
allegrocl_run:
|
|
$(RUNTOOL) $(ALLEGROCL) -batch -s $(ALLEGROCL_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
allegrocl_version:
|
|
$(ALLEGROCL) --version
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the ALLEGRO CL examples
|
|
# -----------------------------------------------------------------
|
|
|
|
allegrocl_clean:
|
|
rm -f *_wrap* *~ .~*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### CLISP ######
|
|
##################################################################
|
|
|
|
CLISP = @CLISPBIN@
|
|
CLISP_SCRIPT=$(RUNME).lisp
|
|
|
|
clisp: $(SRCS)
|
|
$(SWIG) -clisp $(SWIGOPT) $(INTERFACEPATH)
|
|
|
|
clisp_cpp: $(SRCS)
|
|
$(SWIG) -c++ -clisp $(SWIGOPT) $(INTERFACEPATH)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run CLISP example
|
|
# -----------------------------------------------------------------
|
|
|
|
clisp_run:
|
|
$(RUNTOOL) $(CLISP) -batch -s $(CLISP_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
clisp_version:
|
|
$(CLISP) --version | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the CLISP examples
|
|
# -----------------------------------------------------------------
|
|
|
|
clisp_clean:
|
|
rm -f *_wrap* *~ .~*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### CFFI ######
|
|
##################################################################
|
|
|
|
CFFI = @CFFIBIN@
|
|
CFFI_SCRIPT=$(RUNME).lisp
|
|
|
|
cffi: $(SRCS)
|
|
$(SWIG) -cffi $(SWIGOPT) $(INTERFACEPATH)
|
|
# $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
|
|
# $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
cffi_cpp: $(SRCS)
|
|
$(SWIG) -c++ -cffi $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run CFFI example
|
|
# -----------------------------------------------------------------
|
|
|
|
cffi_run:
|
|
$(RUNTOOL) $(CFFI) -batch -s $(CFFI_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
cffi_version:
|
|
$(CFFI) --version
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the CFFI examples
|
|
# -----------------------------------------------------------------
|
|
|
|
cffi_clean:
|
|
rm -f *_wrap* *~ .~*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### UFFI ######
|
|
##################################################################
|
|
|
|
UFFI = @UFFIBIN@
|
|
UFFI_SCRIPT=$(RUNME).lisp
|
|
|
|
uffi: $(SRCS)
|
|
$(SWIG) -uffi $(SWIGOPT) $(INTERFACEPATH)
|
|
# $(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
|
|
# $(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
uffi_cpp: $(SRCS)
|
|
$(SWIG) -c++ -uffi $(SWIGOPT) $(INTERFACEPATH)
|
|
# $(CXX) -c $(CCSHARED) $(CXXFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
|
|
# $(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run UFFI example
|
|
# -----------------------------------------------------------------
|
|
|
|
uffi_run:
|
|
$(RUNTOOL) $(UFFI) -batch -s $(UFFI_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
uffi_version:
|
|
$(UFFI) --version
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the UFFI examples
|
|
# -----------------------------------------------------------------
|
|
|
|
uffi_clean:
|
|
rm -f *_wrap* *~ .~*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|
|
|
|
##################################################################
|
|
##### R ######
|
|
##################################################################
|
|
|
|
R = R
|
|
RCXXSRCS = $(INTERFACE:.i=_wrap.cpp) #Need to use _wrap.cpp for R build system as it does not understand _wrap.cxx
|
|
RRSRC = $(INTERFACE:.i=.R)
|
|
R_CFLAGS=-fPIC
|
|
R_SCRIPT=$(RUNME).R
|
|
|
|
# need to compile .cxx files outside of R build system to make sure that
|
|
# we get -fPIC
|
|
# CMD SHLIB stdout is piped to /dev/null to prevent echo of compiler command
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a R dynamically loadable module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
r: $(SRCS)
|
|
$(SWIG) -r $(SWIGOPT) $(INTERFACEPATH)
|
|
ifneq ($(SRCS),)
|
|
$(CC) -g -c $(CFLAGS) $(R_CFLAGS) $(SRCS) $(INCLUDES)
|
|
endif
|
|
+( PKG_CPPFLAGS="$(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(ISRCS) $(OBJS) > /dev/null )
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a R dynamically loadable module (C++)
|
|
# ----------------------------------------------------------------
|
|
|
|
r_cpp: $(CXXSRCS)
|
|
$(SWIG) -c++ -r $(SWIGOPT) -o $(RCXXSRCS) $(INTERFACEPATH)
|
|
ifneq ($(CXXSRCS),)
|
|
$(CXX) -g -c $(CXXFLAGS) $(R_CFLAGS) $(CXXSRCS) $(INCLUDES)
|
|
endif
|
|
+( PKG_CPPFLAGS="$(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(RCXXSRCS) $(OBJS) > /dev/null )
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run R example
|
|
# -----------------------------------------------------------------
|
|
|
|
r_run:
|
|
$(RUNTOOL) $(R) CMD BATCH $(R_SCRIPT) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
r_version:
|
|
$(R) --version | head -n 1
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the R examples
|
|
# -----------------------------------------------------------------
|
|
|
|
r_clean:
|
|
rm -f *_wrap* *~ .~*
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@ NAMESPACE
|
|
rm -f $(RRSRC) $(RUNME).Rout .RData
|
|
|
|
##################################################################
|
|
##### Go ######
|
|
##################################################################
|
|
|
|
GO = @GO@
|
|
GOGCC = @GOGCC@
|
|
GO1 = @GO1@
|
|
GO12 = @GO12@
|
|
GO13 = @GO13@
|
|
GOC = @GOC@
|
|
GOOPT = @GOOPT@
|
|
GOVERSIONOPTION = @GOVERSIONOPTION@
|
|
|
|
GOSWIGARG = `if $(GOGCC) ; then echo -gccgo; fi`
|
|
GOCOMPILEARG = `if $(GOGCC) ; then echo -c -g; elif $(GO1) ; then echo tool $(GOC:c=g) ; fi` `if $(GO13) ; then echo -pack ; fi`
|
|
|
|
GOSRCS = $(INTERFACE:.i=.go)
|
|
GOCSRCS = $(INTERFACE:.i=_gc.c)
|
|
|
|
GOLD = $(GOC:c=l)
|
|
GOTOOL = `if $(GO1) ; then echo go tool; fi`
|
|
GOPACK = `if $(GO1) ; then echo go tool pack; else echo gopack; fi`
|
|
|
|
GOPACKAGE = $(INTERFACE:.i=.a)
|
|
|
|
GOOBJEXT = $(GOC:c=)
|
|
GOGCOBJS = $(GOSRCS:.go=.$(GOOBJEXT))
|
|
GOGCCOBJS = $(GOSRCS:.go=.@OBJEXT@)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a Go module (C)
|
|
# ----------------------------------------------------------------
|
|
|
|
go: $(SRCS)
|
|
$(SWIG) -go $(GOOPT) $(GOSWIGARG) $(SWIGOPT) $(INTERFACEPATH)
|
|
if $(GO12) || $(GO13) || $(GOGCC); then \
|
|
$(CC) -g -c $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES); \
|
|
else \
|
|
$(CC) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES); \
|
|
$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO); \
|
|
fi
|
|
$(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(GOSRCS)
|
|
if ! $(GOGCC) ; then \
|
|
$(COMPILETOOL) $(GOTOOL) $(GOC) -I $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`} $(GOCSRCS); \
|
|
rm -f $(GOPACKAGE); \
|
|
if $(GO13); then \
|
|
cp $(GOGCOBJS) $(GOPACKAGE); \
|
|
$(COMPILETOOL) $(GOPACK) r $(GOPACKAGE) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
|
|
elif $(GO12); then \
|
|
$(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
|
|
else \
|
|
$(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
|
|
fi; \
|
|
fi
|
|
if test -f $(RUNME).go; then \
|
|
$(GO) $(GOCOMPILEARG) $(RUNME).go; \
|
|
if $(GOGCC) ; then \
|
|
$(COMPILETOOL) $(GO) -o $(RUNME) $(RUNME).@OBJEXT@ $(GOGCCOBJS) $(OBJS) $(IOBJS); \
|
|
elif $(GO12) || $(GO13); then \
|
|
$(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld $(CC) -extldflags "$(CFLAGS)" -o $(RUNME) $(RUNME).$(GOOBJEXT); \
|
|
else \
|
|
$(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $(RUNME) $(RUNME).$(GOOBJEXT); \
|
|
fi; \
|
|
fi
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a Go module (C++)
|
|
# ----------------------------------------------------------------
|
|
|
|
go_cpp: $(SRCS)
|
|
$(SWIG) -go -c++ $(GOOPT) $(GOSWIGARG) $(SWIGOPT) $(INTERFACEPATH)
|
|
if $(GO12) || $(GO13) || $(GOGCC); then \
|
|
$(CXX) -g -c $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES); \
|
|
else \
|
|
$(CXX) -g -c $(CCSHARED) $(CXXFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES); \
|
|
$(CXXSHARED) $(CXXFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO); \
|
|
fi
|
|
$(COMPILETOOL) $(GO) $(GOCOMPILEARG) -I . $(GOSRCS)
|
|
if ! $(GOGCC) ; then \
|
|
$(COMPILETOOL) $(GOTOOL) $(GOC) -I $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`} $(GOCSRCS); \
|
|
rm -f $(GOPACKAGE); \
|
|
if $(GO13); then \
|
|
cp $(GOGCOBJS) $(GOPACKAGE); \
|
|
$(COMPILETOOL) $(GOPACK) r $(GOPACKAGE) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
|
|
elif $(GO12); then \
|
|
$(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)) $(OBJS) $(IOBJS); \
|
|
else \
|
|
$(COMPILETOOL) $(GOPACK) grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
|
|
fi; \
|
|
fi
|
|
if test -f $(RUNME).go; then \
|
|
$(GO) $(GOCOMPILEARG) $(RUNME).go; \
|
|
if $(GOGCC) ; then \
|
|
$(COMPILETOOL) $(GO) -o $(RUNME) $(RUNME).@OBJEXT@ $(GOGCCOBJS) $(OBJS) $(IOBJS) -lstdc++; \
|
|
elif $(GO12) || $(GO13); then \
|
|
$(COMPILETOOL) $(GOTOOL) $(GOLD) -linkmode external -extld $(CXX) -extldflags "$(CXXFLAGS)" -o $(RUNME) $(RUNME).$(GOOBJEXT); \
|
|
else \
|
|
$(COMPILETOOL) $(GOTOOL) $(GOLD) -r $${GOROOT:-`go env GOROOT`}/pkg/$${GOOS:-`go env GOOS`}_$${GOARCH:-`go env GOARCH`}:. -o $(RUNME) $(RUNME).$(GOOBJEXT); \
|
|
fi; \
|
|
fi
|
|
|
|
# -----------------------------------------------------------------
|
|
# Running Go example
|
|
# -----------------------------------------------------------------
|
|
|
|
go_run:
|
|
env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./$(RUNME) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
go_version:
|
|
$(GO) $(GOVERSIONOPTION)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Cleaning the Go examples
|
|
# -----------------------------------------------------------------
|
|
|
|
go_clean:
|
|
rm -f *_wrap* *_gc* .~* $(RUNME) $(GOSRCS)
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *.[568] *.a *@SO@
|
|
|
|
##################################################################
|
|
##### D ######
|
|
##################################################################
|
|
|
|
DLIBPREFIX = @DLIBPREFIX@
|
|
|
|
ifeq (,$(D_VERSION))
|
|
D_VERSION = @DDEFAULTVERSION@
|
|
endif
|
|
|
|
ifeq (2,$(D_VERSION))
|
|
SWIGD = $(SWIG) -d -d2
|
|
DCOMPILER = @D2COMPILER@
|
|
else
|
|
SWIGD = $(SWIG) -d
|
|
DCOMPILER = @D1COMPILER@
|
|
endif
|
|
|
|
D_RUNME = ./$(RUNME)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a dynamically loadable D wrapper for a C module
|
|
# ----------------------------------------------------------------
|
|
|
|
d: $(SRCS)
|
|
$(SWIGD) $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CC) -c $(CCSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
|
|
$(LDSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Build a dynamically loadable D wrapper for a C++ module
|
|
# ----------------------------------------------------------------
|
|
|
|
d_cpp: $(SRCS)
|
|
$(SWIGD) -c++ $(SWIGOPT) $(INTERFACEPATH)
|
|
$(CXX) -c $(CCSHARED) $(CXXFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
|
|
$(CXXSHARED) $(CXXFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
|
|
|
|
# ----------------------------------------------------------------
|
|
# Compile D files
|
|
# ----------------------------------------------------------------
|
|
|
|
# Clear the DFLAGS environment variable for the compiler call itself
|
|
# to work around a discrepancy in argument handling between DMD and LDC.
|
|
d_compile: $(SRCS)
|
|
DFLAGS="" $(COMPILETOOL) $(DCOMPILER) $(DFLAGS) $(DSRCS)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Run D example
|
|
# -----------------------------------------------------------------
|
|
|
|
d_run:
|
|
$(RUNTOOL) $(D_RUNME) $(RUNPIPE)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Version display
|
|
# -----------------------------------------------------------------
|
|
|
|
d_version:
|
|
# Needs improvement!
|
|
echo D version guess - $(D_VERSION)
|
|
|
|
# -----------------------------------------------------------------
|
|
# Clean the D examples
|
|
# -----------------------------------------------------------------
|
|
|
|
d_clean:
|
|
rm -f *_wrap* *~ .~* $(RUNME) $(RUNME).exe `find . -name \*.d | grep -v $(RUNME).d`
|
|
rm -f core @EXTRA_CLEAN@
|
|
rm -f *.@OBJEXT@ *@SO@
|