/tags/rel-2.0.2/Examples/Makefile.in

# · Autoconf · 1280 lines · 690 code · 251 blank · 339 comment · 31 complexity · 3d0ffdd2a0f15c35c946e86e27d95e1f MD5 · raw file 

    

  1. # ------------------------------------------------------------
    2. 

  2. # SWIG Examples Makefile
    3. 

  3. #
    4. 

  4. # This file is used by the examples to build modules.  Assuming
    5. 

  5. # you ran configure, this file will probably work.  However,
    6. 

  6. # it's not perfect so you might need to do some hand tweaking.
    7. 

  7. #
    8. 

  8. # Other notes:
    9. 

  9. #
    10. 

  10. # 1.   Take a look at the prefixes below.   Since SWIG works with
    11. 

  11. #      multiple target languages, you may need to find out where
    12. 

  12. #      certain packages have been installed.   Set the prefixes
    13. 

  13. #      accordingly.
    14. 

  14. #
    15. 

  15. # 2.   To use this makefile, set required varibles, eg SRCS, INTERFACE, 
    16. 

  16. #      INTERFACEDIR, INCLUDES, LIBS, TARGET, and do a
    17. 

  17. #           $(MAKE) -f Makefile.template.in SRCS='$(SRCS)' \
    18. 

  18. #           INCLUDES='$(INCLUDES) LIBS='$(LIBS)' INTERFACE='$(INTERFACE)' \
    19. 

  19. #           INTERFACEDIR='$(INTERFACEDIR)' TARGET='$(TARGET)' method
    20. 

  20. #
    21. 

  21. #      'method' describes what is being built.
    22. 

  22. #---------------------------------------------------------------
    23. 

  23. 

  24. TARGET     =
    25. 

  25. CC         = @CC@
    26. 

  26. CXX        = @CXX@
    27. 

  27. CFLAGS     = @PLATFLAGS@
    28. 

  28. prefix     = @prefix@
    29. 

  29. exec_prefix= @exec_prefix@
    30. 

  30. SRCS       =
    31. 

  31. INCLUDES   =
    32. 

  32. LIBS       =
    33. 

  33. INTERFACE  =
    34. 

  34. INTERFACEDIR  =
    35. 

  35. INTERFACEPATH = $(INTERFACEDIR)$(INTERFACE)
    36. 

  36. SWIGOPT    =
    37. 

  37. SWIG       = swig
    38. 

  38. 

  39. LIBM       = @LIBM@
    40. 

  40. LIBC       = @LIBC@
    41. 

  41. LIBCRYPT   = @LIBCRYPT@
    42. 

  42. SYSLIBS    = $(LIBM) $(LIBC) $(LIBCRYPT)
    43. 

  43. LIBPREFIX  =
    44. 

  44. 

  45. # RUNTOOL is for use with runtime tools, eg set it to valgrind
    46. 

  46. RUNTOOL    =
    47. 

  47. # COMPILETOOL is a way to run the compiler under another tool, or more commonly just to stop the compiler executing
    48. 

  48. COMPILETOOL=
    49. 

  49. 

  50. # X11 options
    51. 

  51. 

  52. XLIB       = @XLIBSW@
    53. 

  53. XINCLUDE   = @XINCLUDES@
    54. 

  54. 

  55. IWRAP      = $(INTERFACE:.i=_wrap.i)
    56. 

  56. ISRCS      = $(IWRAP:.i=.c)
    57. 

  57. ICXXSRCS   = $(IWRAP:.i=.cxx)
    58. 

  58. IOBJS      = $(IWRAP:.i=.@OBJEXT@)
    59. 

  59. 

  60. ##################################################################
    61. 

  61. # Dynamic loading for C++
    62. 

  62. # If you are going to be building dynamic loadable modules in C++,
    63. 

  63. # you may need to edit this line appropriately.
    64. 

  64. #
    65. 

  65. # This line works for g++, but I'm not sure what it might be
    66. 

  66. # for other C++ compilers
    67. 

  67. ##################################################################
    68. 

  68. 

  69. CPP_DLLIBS = #-L/usr/local/lib/gcc-lib/sparc-sun-solaris2.5.1/2.7.2 \
    70. 

  70.              -L/usr/local/lib -lg++ -lstdc++ -lgcc
    71. 

  71. 

  72. # Solaris workshop 5.0
    73. 

  73. # CPP_DLLIBS = -L/opt/SUNWspro/lib -lCrun
    74. 

  74. 

  75. # Symbols used for using shared libraries
    76. 

  76. SO=		@SO@
    77. 

  77. LDSHARED=	@LDSHARED@
    78. 

  78. CCSHARED=	@CCSHARED@
    79. 

  79. CXXSHARED=      @CXXSHARED@
    80. 

  80. 

  81. # This is used for building shared libraries with a number of C++
    82. 

  82. # compilers.   If it doesn't work,  comment it out.
    83. 

  83. @TRYLINKINGWITHCXX@
    84. 

  84. 

  85. OBJS      = $(SRCS:.c=.@OBJEXT@) $(CXXSRCS:.cxx=.@OBJEXT@)
    86. 

  86. 

  87. distclean:
    88. 

  88. 	rm -f Makefile
    89. 

  89. 	rm -f guile/Makefile
    90. 

  90. 	rm -f xml/Makefile
    91. 

  91. 

  92. ##################################################################
    93. 

  93. #####                       Tcl/Tk                          ######
    94. 

  94. ##################################################################
    95. 

  95. 

  96. # Set these to your local copy of Tcl/Tk.
    97. 

  97. 

  98. TCL_INCLUDE = @TCLINCLUDE@
    99. 

  99. TCL_LIB     = @TCLLIB@
    100. 

  100. TCL_OPTS    = @LIBS@
    101. 

  101. TK_OPTS     = -ltk -ltcl @LIBS@
    102. 

  102. 

  103. # Extra Tcl specific dynamic linking options
    104. 

  104. TCL_DLNK   = @TCLDYNAMICLINKING@
    105. 

  105. TCL_SO     = @TCL_SO@
    106. 

  106. TCLLDSHARED = @TCLLDSHARED@
    107. 

  107. TCLCXXSHARED = @TCLCXXSHARED@
    108. 

  108. 

  109. # -----------------------------------------------------------
    110. 

  110. # Build a new version of the tclsh shell
    111. 

  111. # -----------------------------------------------------------
    112. 

  112. 

  113. 

  114. tclsh: $(SRCS)
    115. 

  115. 	$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACEPATH)
    116. 

  116. 	$(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
    117. 

  117. 	$(TCL_LIB)  $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
    118. 

  118. 

  119. tclsh_cpp: $(SRCS)
    120. 

  120. 	$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACEPATH)
    121. 

  121. 	$(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
    122. 

  122. 	$(TCL_LIB) $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
    123. 

  123. 

  124. # -----------------------------------------------------------
    125. 

  125. # Build a new copy of wish
    126. 

  126. # -----------------------------------------------------------
    127. 

  127. 

  128. wish: $(SRCS)
    129. 

  129. 	$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -lwish.i $(INTERFACEPATH)
    130. 

  130. 	$(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
    131. 

  131. 	$(XINCLUDE) $(TCL_LIB) $(TK_OPTS) $(XLIB) $(LIBS) $(SYSLIBS) -o $(TARGET)
    132. 

  132. 

  133. 

  134. wish_cpp: $(SRCS)
    135. 

  135. 	$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -lwish.i $(INTERFACEPATH)
    136. 

  136. 	$(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
    137. 

  137. 	$(XINCLUDE) $(TCL_LIB) $(TK_OPTS) $(XLIB) $(LIBS) $(SYSLIBS) -o $(TARGET)
    138. 

  138. 

  139. # -----------------------------------------------------------
    140. 

  140. # Build a Tcl dynamic loadable module (you might need to tweak this)
    141. 

  141. # -----------------------------------------------------------
    142. 

  142. 

  143. tcl:  $(SRCS)
    144. 

  144. 	$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACEPATH)
    145. 

  145. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE)
    146. 

  146. 	$(TCLLDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
    147. 

  147. 

  148. # -----------------------------------------------------------
    149. 

  149. # Build a Tcl7.5 dynamic loadable module for C++
    150. 

  150. # -----------------------------------------------------------
    151. 

  151. 

  152. tcl_cpp: $(SRCS)
    153. 

  153. 	$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACEPATH)
    154. 

  154. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE)
    155. 

  155. 	$(TCLCXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
    156. 

  156. 

  157. # -----------------------------------------------------------------
    158. 

  158. # Cleaning the Tcl examples
    159. 

  159. # -----------------------------------------------------------------
    160. 

  160. 

  161. tcl_clean:
    162. 

  162. 	rm -f *_wrap* *~ .~* mytclsh@EXEEXT@
    163. 

  163. 	rm -f core @EXTRA_CLEAN@
    164. 

  164. 	rm -f *.@OBJEXT@ *@SO@
    165. 

  165. 

  166. ##################################################################
    167. 

  167. #####                       PERL 5                          ######
    168. 

  168. ##################################################################
    169. 

  169. 

  170. # You need to set this variable to the Perl5 directory containing the
    171. 

  171. # files "perl.h", "EXTERN.h" and "XSUB.h".   With Perl5.003, it's
    172. 

  172. # usually something like /usr/local/lib/perl5/arch-osname/5.003/CORE.
    173. 

  173. 

  174. PERL5_INCLUDE= @PERL5EXT@
    175. 

  175. 

  176. # Extra Perl specific dynamic linking options
    177. 

  177. PERL5_DLNK   = @PERL5DYNAMICLINKING@
    178. 

  178. PERL5_CCFLAGS = @PERL5CCFLAGS@
    179. 

  179. 

  180. # ----------------------------------------------------------------
    181. 

  181. # Build a Perl5 dynamically loadable module (C)
    182. 

  182. # ----------------------------------------------------------------
    183. 

  183. 

  184. perl5: $(SRCS)
    185. 

  185. 	$(SWIG) -perl5 $(SWIGOPT) $(INTERFACEPATH)
    186. 

  186. 	$(CC) -c -Dbool=char $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PERL5_CCFLAGS) -I$(PERL5_INCLUDE)
    187. 

  187. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PERL5_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    188. 

  188. 

  189. # ----------------------------------------------------------------
    190. 

  190. # Build a Perl5 dynamically loadable module (C++)
    191. 

  191. # ----------------------------------------------------------------
    192. 

  192. 

  193. perl5_cpp: $(SRCS)
    194. 

  194. 	$(SWIG) -perl5 -c++ $(SWIGOPT) $(INTERFACEPATH)
    195. 

  195. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PERL5_CCFLAGS) -I$(PERL5_INCLUDE)
    196. 

  196. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PERL5_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    197. 

  197. 

  198. # ----------------------------------------------------------------
    199. 

  199. # Build a module from existing XS C source code.   (ie. from xsubpp).
    200. 

  200. # ----------------------------------------------------------------
    201. 

  201. perl5_xs: $(SRCS)
    202. 

  202. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(INCLUDES) -I$(PERL5_INCLUDE)
    203. 

  203. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(LIBS) -o $(TARGET)$(SO)
    204. 

  204. 

  205. # ----------------------------------------------------------------
    206. 

  206. # Build a statically linked Perl5 executable
    207. 

  207. # ----------------------------------------------------------------
    208. 

  208. 

  209. PERL5_LIB    = -L$(PERL5_INCLUDE) -l@PERL5LIB@ @LIBS@ $(SYSLIBS)
    210. 

  210. 

  211. perl5_static: $(SRCS)
    212. 

  212. 	$(SWIG) -perl5 -static -lperlmain.i $(SWIGOPT) $(INTERFACEPATH)
    213. 

  213. 	$(CC) $(CFLAGS) -Dbool=char $(SRCS) $(ISRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
    214. 

  214. 

  215. perl5_static_cpp: $(SRCS)
    216. 

  216. 	$(SWIG) -perl5 -c++ -static -lperlmain.i $(SWIGOPT) $(INTERFACEPATH)
    217. 

  217. 	$(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
    218. 

  218. 

  219. # -----------------------------------------------------------------
    220. 

  220. # Cleaning the Perl5 examples
    221. 

  221. # -----------------------------------------------------------------
    222. 

  222. 

  223. perl5_clean:
    224. 

  224. 	rm -f *_wrap* *~ .~* myperl@EXEEXT@ *.pm
    225. 

  225. 	rm -f core @EXTRA_CLEAN@
    226. 

  226. 	rm -f *.@OBJEXT@ *@SO@
    227. 

  227. 

  228. ##################################################################
    229. 

  229. #####                       PYTHON                          ######
    230. 

  230. ##################################################################
    231. 

  231. 

  232. # Make sure these locate your Python installation
    233. 

  233. ifeq (,$(PY3))
    234. 

  234.   PYTHON_INCLUDE= $(DEFS) @PYINCLUDE@
    235. 

  235.   PYTHON_LIB    = @PYLIB@
    236. 

  236.   PYTHON        = @PYTHON@
    237. 

  237. else
    238. 

  238.   PYTHON_INCLUDE= $(DEFS) @PY3INCLUDE@
    239. 

  239.   PYTHON_LIB    = @PY3LIB@
    240. 

  240.   PYTHON        = @PYTHON3@
    241. 

  241. endif
    242. 

  242. 

  243. # Extra Python specific linking options
    244. 

  244. ifeq (,$(PY3))
    245. 

  245.   PYTHON_DLNK   = @PYTHONDYNAMICLINKING@
    246. 

  246.   PYTHON_LINK   = @PYLINK@
    247. 

  247. else
    248. 

  248.   PYTHON_DLNK   = @PYTHON3DYNAMICLINKING@
    249. 

  249.   PYTHON_LINK   = @PY3LINK@
    250. 

  250. endif
    251. 

  251. PYTHON_SO     = @PYTHON_SO@
    252. 

  252. 

  253. # SWIG option for Python
    254. 

  254. ifeq (,$(PY3))
    255. 

  255.   SWIGPYTHON = $(SWIG) -python
    256. 

  256. else
    257. 

  257.   SWIGPYTHON = $(SWIG) -python -py3
    258. 

  258. endif
    259. 

  259. 

  260. # ----------------------------------------------------------------
    261. 

  261. # Build a C dynamically loadable module
    262. 

  262. # ----------------------------------------------------------------
    263. 

  263. 

  264. python: $(SRCS)
    265. 

  265. 	$(SWIGPYTHON) $(SWIGOPT) $(INTERFACEPATH)
    266. 

  266. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PYTHON_INCLUDE)
    267. 

  267. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
    268. 

  268. 

  269. # -----------------------------------------------------------------
    270. 

  270. # Build a C++ dynamically loadable module
    271. 

  271. # -----------------------------------------------------------------
    272. 

  272. 

  273. python_cpp: $(SRCS)
    274. 

  274. 	$(SWIGPYTHON) -c++ $(SWIGOPT) $(INTERFACEPATH)
    275. 

  275. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PYTHON_INCLUDE)
    276. 

  276. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
    277. 

  277. 

  278. # -----------------------------------------------------------------
    279. 

  279. # Build statically linked Python interpreter
    280. 

  280. #
    281. 

  281. # These should only be used in conjunction with the %include embed.i
    282. 

  282. # library file
    283. 

  283. # -----------------------------------------------------------------
    284. 

  284. 

  285. #TKINTER = -L/usr/X11R6.3/lib -L/usr/local/compat/lib -ltk4.0 -ltcl7.4 -lX11
    286. 

  286. TKINTER =
    287. 

  287. PYTHON_LIBOPTS = $(PYTHON_LINK) @LIBS@ $(TKINTER) $(SYSLIBS)
    288. 

  288. 

  289. python_static: $(SRCS)
    290. 

  290. 	$(SWIGPYTHON) -lembed.i $(SWIGOPT) $(INTERFACEPATH)
    291. 

  291. 	$(CC) $(CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
    292. 

  292. 	$(PYTHON_INCLUDE) $(LIBS) -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
    293. 

  293. 

  294. python_static_cpp: $(SRCS)
    295. 

  295. 	$(SWIGPYTHON) -c++ -lembed.i $(SWIGOPT) $(INTERFACEPATH)
    296. 

  296. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    297. 

  297. 	$(PYTHON_INCLUDE) $(LIBS)  -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
    298. 

  298. 

  299. # -----------------------------------------------------------------
    300. 

  300. # Running a Python example
    301. 

  301. # -----------------------------------------------------------------
    302. 

  302. 

  303. ifeq (,$(PY3))
    304. 

  304.   PYSCRIPT = runme.py
    305. 

  305. else
    306. 

  306.   PYSCRIPT = runme3.py
    307. 

  307. endif
    308. 

  308. 

  309. PY2TO3 = 2to3 `2to3 -l | grep -v -E "Available|import$$" | awk '{print "-f "$$0}'`
    310. 

  310. 

  311. python_run: $(PYSCRIPT)
    312. 

  312. 	env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH PYTHONPATH=$(srcdir):$$PYTHONPATH $(PYTHON) $(PYSCRIPT) >/dev/null
    313. 

  313. 

  314. runme3.py: runme.py
    315. 

  315. 	cp $< $@
    316. 

  316. 	$(PY2TO3) -w $@ >/dev/null 2>&1
    317. 

  317. 

  318. # -----------------------------------------------------------------
    319. 

  319. # Cleaning the python examples
    320. 

  320. # -----------------------------------------------------------------
    321. 

  321. 

  322. python_clean:
    323. 

  323. 	rm -f *_wrap* *~ .~* mypython@EXEEXT@ *.pyc
    324. 

  324. 	rm -f core @EXTRA_CLEAN@
    325. 

  325. 	rm -f *.@OBJEXT@ *@SO@ *@PYTHON_SO@
    326. 

  326. 	if [ -f runme.py ]; then rm -f runme3.py runme3.py.bak; fi
    327. 

  327. 

  328. 

  329. ##################################################################
    330. 

  330. #####                       OCTAVE                          ######
    331. 

  331. ##################################################################
    332. 

  332. 

  333. # Make sure these locate your Octave installation
    334. 

  334. OCTAVE_INCLUDE= $(DEFS) @OCTAVEEXT@
    335. 

  335. OCTAVE_LIB    =
    336. 

  336. 

  337. # Extra Octave specific dynamic linking options
    338. 

  338. OCTAVE_DLNK   = @OCTAVEDYNAMICLINKING@
    339. 

  339. OCTAVE_SO     = @OCTAVE_SO@
    340. 

  340. 

  341. # ----------------------------------------------------------------
    342. 

  342. # Build a C dynamically loadable module
    343. 

  343. # Note: Octave requires C++ compiler when compiling C wrappers
    344. 

  344. # ----------------------------------------------------------------
    345. 

  345. 

  346. octave: $(SRCS)
    347. 

  347. 	$(SWIG) -octave $(SWIGOPT) $(INTERFACEPATH)
    348. 

  348. 	$(CXX) -g -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(INCLUDES) -I$(OCTAVE_INCLUDE)
    349. 

  349. 	$(CC) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CSRCS) $(INCLUDES)
    350. 

  350. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
    351. 

  351. 

  352. # -----------------------------------------------------------------
    353. 

  353. # Build a C++ dynamically loadable module
    354. 

  354. # -----------------------------------------------------------------
    355. 

  355. 

  356. octave_cpp: $(SRCS)
    357. 

  357. 	$(SWIG) -c++ -octave $(SWIGOPT) $(INTERFACEPATH)
    358. 

  358. 	$(CXX) -g -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) -I$(OCTAVE_INCLUDE)
    359. 

  359. 	$(CXXSHARED) -g $(CFLAGS) $(OBJS) $(IOBJS) $(OCTAVE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(OCTAVE_SO)
    360. 

  360. 

  361. # -----------------------------------------------------------------
    362. 

  362. # Cleaning the octave examples
    363. 

  363. # -----------------------------------------------------------------
    364. 

  364. 

  365. octave_clean:
    366. 

  366. 	rm -f *_wrap* *~ .~* myoctave@EXEEXT@ *.pyc
    367. 

  367. 	rm -f core @EXTRA_CLEAN@
    368. 

  368. 	rm -f *.@OBJEXT@ *@SO@ *@OCTAVE_SO@
    369. 

  369. 

  370. ##################################################################
    371. 

  371. #####                       GUILE                           ######
    372. 

  372. ##################################################################
    373. 

  373. 

  374. # Make sure these locate your Guile installation
    375. 

  375. GUILE_INCLUDE = @GUILEINCLUDE@
    376. 

  376. GUILE_LIB     = @GUILELIB@
    377. 

  377. GUILE_SO      = @GUILE_SO@
    378. 

  378. GUILE_LIBPREFIX = lib
    379. 

  379. 

  380. #------------------------------------------------------------------
    381. 

  381. # Build a dynamically loaded module with passive linkage and the scm interface
    382. 

  382. #------------------------------------------------------------------
    383. 

  383. guile: $(SRCS)
    384. 

  384. 	$(SWIG) -guile -scm -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
    385. 

  385. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ISRCS) $(SRCS)
    386. 

  386. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    387. 

  387. 

  388. guile_cpp: $(SRCS)
    389. 

  389. 	$(SWIG) -c++ -guile -scm -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
    390. 

  390. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    391. 

  391. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    392. 

  392. 

  393. guile_externalhdr:
    394. 

  394. 	$(SWIG) -guile -external-runtime $(TARGET)
    395. 

  395. 

  396. #------------------------------------------------------------------
    397. 

  397. # Build a dynamically loaded module with passive linkage and the gh interface
    398. 

  398. #------------------------------------------------------------------
    399. 

  399. guile_gh: $(SRCS)
    400. 

  400. 	$(SWIG) -guile -gh -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
    401. 

  401. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ISRCS) $(SRCS)
    402. 

  402. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    403. 

  403. 

  404. guile_gh_cpp: $(SRCS)
    405. 

  405. 	$(SWIG) -c++ -guile -gh -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
    406. 

  406. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    407. 

  407. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    408. 

  408. 

  409. # -----------------------------------------------------------------
    410. 

  410. # Build a dynamically loadable module with passive linkage
    411. 

  411. # -----------------------------------------------------------------
    412. 

  412. 

  413. guile_passive: $(SRCS)
    414. 

  414. 	$(SWIG) -guile -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
    415. 

  415. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ISRCS) $(SRCS)
    416. 

  416. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    417. 

  417. 

  418. guile_passive_cpp: $(SRCS)
    419. 

  419. 	$(SWIG) -c++ -guile -Linkage passive $(SWIGOPT) $(INTERFACEPATH)
    420. 

  420. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    421. 

  421. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    422. 

  422. 

  423. # -----------------------------------------------------------------
    424. 

  424. # Build statically linked Guile interpreter
    425. 

  425. # -----------------------------------------------------------------
    426. 

  426. 

  427. GUILE_LIBOPTS = @GUILELINK@ @LIBS@ $(SYSLIBS)
    428. 

  428. 

  429. guile_static: $(SRCS)
    430. 

  430. 	$(SWIG) -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACEPATH)
    431. 

  431. 	$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
    432. 

  432. 	  -DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
    433. 

  433. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    434. 

  434. 

  435. guile_static_cpp: $(SRCS)
    436. 

  436. 	$(SWIG) -c++ -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACEPATH)
    437. 

  437. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    438. 

  438. 	  -DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
    439. 

  439. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    440. 

  440. 

  441. guile_simple: $(SRCS)
    442. 

  442. 	$(SWIG) -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACEPATH)
    443. 

  443. 	$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
    444. 

  444. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    445. 

  445. 

  446. guile_simple_cpp: $(SRCS)
    447. 

  447. 	$(SWIG) -c++ -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACEPATH)
    448. 

  448. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    449. 

  449. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    450. 

  450. 

  451. # -----------------------------------------------------------------
    452. 

  452. # Cleaning the Guile examples
    453. 

  453. # -----------------------------------------------------------------
    454. 

  454. 

  455. guile_clean:
    456. 

  456. 	rm -f *_wrap* *~ .~* my-guile@EXEEXT@ $(TARGET)@EXEEXT@
    457. 

  457. 	rm -f core @EXTRA_CLEAN@
    458. 

  458. 	rm -f *.@OBJEXT@ *@GUILE_SO@
    459. 

  459. 

  460. ##################################################################
    461. 

  461. #####                       JAVA                            ######
    462. 

  462. ##################################################################
    463. 

  463. 

  464. # You need to set this variable to the java directories containing the
    465. 

  465. # files "jni.h" and "md.h"
    466. 

  466. # usually something like /usr/java/include and /usr/java/include/<arch-osname>.
    467. 

  467. JAVA_INCLUDE= @JAVAINC@
    468. 

  468. 

  469. # Extra Java specific dynamic linking options
    470. 

  470. JAVA_DLNK  = @JAVADYNAMICLINKING@
    471. 

  471. JAVA_LIBPREFIX = @JAVALIBRARYPREFIX@
    472. 

  472. JAVASO =@JAVASO@
    473. 

  473. JAVALDSHARED = @JAVALDSHARED@
    474. 

  474. JAVACXXSHARED = @JAVACXXSHARED@
    475. 

  475. JAVACFLAGS = @JAVACFLAGS@
    476. 

  476. 

  477. # ----------------------------------------------------------------
    478. 

  478. # Build a java dynamically loadable module (C)
    479. 

  479. # ----------------------------------------------------------------
    480. 

  480. 

  481. java: $(SRCS)
    482. 

  482. 	$(SWIG) -java $(SWIGOPT) $(INTERFACEPATH)
    483. 

  483. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(JAVA_INCLUDE)
    484. 

  484. 	$(JAVALDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
    485. 

  485. 

  486. # ----------------------------------------------------------------
    487. 

  487. # Build a java dynamically loadable module (C++)
    488. 

  488. # ----------------------------------------------------------------
    489. 

  489. 

  490. java_cpp: $(SRCS)
    491. 

  491. 	$(SWIG) -java -c++ $(SWIGOPT) $(INTERFACEPATH)
    492. 

  492. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(JAVA_INCLUDE)
    493. 

  493. 	$(JAVACXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
    494. 

  494. 

  495. # -----------------------------------------------------------------
    496. 

  496. # Cleaning the java examples
    497. 

  497. # -----------------------------------------------------------------
    498. 

  498. 

  499. java_clean:
    500. 

  500. 	rm -f *_wrap* *~ .~* *.class `find . -name \*.java | grep -v runme.java`
    501. 

  501. 	rm -f core @EXTRA_CLEAN@
    502. 

  502. 	rm -f *.@OBJEXT@ *@JAVASO@
    503. 

  503. 

  504. ##################################################################
    505. 

  505. #####                      MODULA3                          ######
    506. 

  506. ##################################################################
    507. 

  507. 

  508. MODULA3_INCLUDE= @MODULA3INC@
    509. 

  509. 

  510. # ----------------------------------------------------------------
    511. 

  511. # Build a modula3 dynamically loadable module (C)
    512. 

  512. # ----------------------------------------------------------------
    513. 

  513. 

  514. modula3: $(SRCS)
    515. 

  515. 	$(SWIG) -modula3 $(SWIGOPT) $(INTERFACEPATH)
    516. 

  516. #	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) \
    517. 

  517. #       $(OBJS) $(IOBJS) $(LIBS)
    518. 

  518. 

  519. modula3_cpp: $(SRCS)
    520. 

  520. 	$(SWIG) -modula3 -c++ $(SWIGOPT) $(INTERFACEPATH)
    521. 

  521. 

  522. # -----------------------------------------------------------------
    523. 

  523. # Cleaning the modula3 examples
    524. 

  524. # -----------------------------------------------------------------
    525. 

  525. 

  526. modula3_clean:
    527. 

  527. 	rm -f *_wrap* *.i3 *.m3
    528. 

  528. 	rm -f core @EXTRA_CLEAN@
    529. 

  529. 	rm -f *.@OBJEXT@ *@SO@
    530. 

  530. 

  531. ##################################################################
    532. 

  532. #####                       MZSCHEME                        ######
    533. 

  533. ##################################################################
    534. 

  534. 

  535. MZC = @MZC@
    536. 

  536. MZDYNOBJ = @MZDYNOBJ@
    537. 

  537. MZSCHEME_SO = @MZSCHEME_SO@
    538. 

  538. 

  539. # ----------------------------------------------------------------
    540. 

  540. # Build a C/C++ dynamically loadable module
    541. 

  541. # ----------------------------------------------------------------
    542. 

  542. 

  543. mzscheme: $(SRCS)
    544. 

  544. 	$(SWIG) -mzscheme $(SWIGOPT) $(INTERFACEPATH)
    545. 

  545. 	$(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ISRCS) $(SRCS)
    546. 

  546. 	$(COMPILETOOL) $(MZC) --ld $(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS)
    547. 

  547. 

  548. mzscheme_cpp: $(SRCS)
    549. 

  549. 	$(SWIG) -mzscheme -c++ $(SWIGOPT) $(INTERFACEPATH)
    550. 

  550. 	$(COMPILETOOL) $(MZC) `echo $(INCLUDES) | sed 's/-I/++ccf -I/g'` --cc $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    551. 

  551. 	$(CXXSHARED) $(CFLAGS) -o $(LIBPREFIX)$(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS) $(MZDYNOBJ) $(CPP_DLLIBS)
    552. 

  552. 

  553. # -----------------------------------------------------------------
    554. 

  554. # Cleaning the mzscheme examples
    555. 

  555. # -----------------------------------------------------------------
    556. 

  556. 

  557. mzscheme_clean:
    558. 

  558. 	rm -f *_wrap* *~ .~*
    559. 

  559. 	rm -f core @EXTRA_CLEAN@
    560. 

  560. 	rm -f *.@OBJEXT@ *@SO@
    561. 

  561. 

  562. ##################################################################
    563. 

  563. #####                          Ocaml                         #####
    564. 

  564. ##################################################################
    565. 

  565. 

  566. OCC=@OCAMLC@
    567. 

  567. OCAMLDLGEN=@OCAMLDLGEN@
    568. 

  568. OCAMLFIND=@OCAMLFIND@
    569. 

  569. OCAMLMKTOP=@OCAMLMKTOP@ $(SWIGWHERE)
    570. 

  570. NOLINK ?= false
    571. 

  571. OCAMLPP= -pp "camlp4o ./swigp4.cmo"
    572. 

  572. OCAMLP4WHERE=`$(COMPILETOOL) camlp4 -where`
    573. 

  573. OCAMLCORE=\
    574. 

  574. 	rm -rf swig.mli swig.ml swigp4.ml && \
    575. 

  575. 	$(SWIG) -ocaml -co swig.mli 2>/dev/null &&  \
    576. 

  576. 	$(SWIG) -ocaml -co swig.ml 2>/dev/null &&  \
    577. 

  577. 	$(SWIG) -ocaml -co swigp4.ml 2>/dev/null &&  \
    578. 

  578. 	$(OCC) -c swig.mli &&  \
    579. 

  579. 	$(OCC) -c swig.ml &&  \
    580. 

  580. 	$(OCC) -I $(OCAMLP4WHERE) -pp "camlp4o pa_extend.cmo q_MLast.cmo" \
    581. 

  581. 		-c swigp4.ml
    582. 

  582. 

  583. ocaml_static: $(SRCS)
    584. 

  584. 	$(OCAMLCORE)
    585. 

  585. 	$(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
    586. 

  586. 	$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
    587. 

  587. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    588. 

  588. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    589. 

  589. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    590. 

  590. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    591. 

  591. 	$(NOLINK) || $(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
    592. 

  592. 		swig.cmo \
    593. 

  593. 		$(INTERFACE:%.i=%.cmo) \
    594. 

  594. 		$(PROGFILE:%.ml=%.cmo) \
    595. 

  595. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) -cclib "$(LIBS)"
    596. 

  596. 

  597. ocaml_dynamic: $(SRCS)
    598. 

  598. 	$(OCAMLCORE)
    599. 

  599. 	$(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
    600. 

  600. 	$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
    601. 

  601. 	$(CXXSHARED) $(CFLAGS) $(CCSHARED) $(CFLAGS) -o $(INTERFACE:%.i=%@SO@) \
    602. 

  602. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) $(LIBS)
    603. 

  603. 	$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
    604. 

  604. 		$(INTERFACE:%.i=%_dynamic.ml)
    605. 

  605. 	mv $(INTERFACE:%.i=%_dynamic.ml) $(INTERFACE:%.i=%.ml)
    606. 

  606. 	rm $(INTERFACE:%.i=%.mli)
    607. 

  607. 	$(OCAMLFIND) $(OCC) -g -c -package dl $(INTERFACE:%.i=%.ml)
    608. 

  608. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    609. 

  609. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    610. 

  610. 	$(NOLINK) || $(OCAMLFIND) \
    611. 

  611. 		$(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
    612. 

  612. 		swig.cmo \
    613. 

  613. 		-package dl -linkpkg \
    614. 

  614. 		$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo)
    615. 

  615. 

  616. ocaml_static_toplevel: $(SRCS)
    617. 

  617. 	$(OCAMLCORE)
    618. 

  618. 	$(SWIG) -ocaml $(SWIGOPT) $(INTERFACEPATH)
    619. 

  619. 	$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
    620. 

  620. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    621. 

  621. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    622. 

  622. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    623. 

  623. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    624. 

  624. 	$(NOLINK) || $(OCAMLMKTOP) \
    625. 

  625. 		swig.cmo \
    626. 

  626. 		-I $(OCAMLP4WHERE) camlp4o.cma swigp4.cmo \
    627. 

  627. 		-g -ccopt -g -cclib -g -custom -o $(TARGET)_top \
    628. 

  628. 		$(INTERFACE:%.i=%.cmo) \
    629. 

  629. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) -cclib "$(LIBS)"
    630. 

  630. 

  631. ocaml_static_cpp: $(SRCS)
    632. 

  632. 	$(OCAMLCORE)
    633. 

  633. 	$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
    634. 

  634. 	cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
    635. 

  635. 	$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
    636. 

  636. 		$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
    637. 

  637. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    638. 

  638. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    639. 

  639. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    640. 

  640. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    641. 

  641. 	$(NOLINK) || $(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
    642. 

  642. 		swig.cmo \
    643. 

  643. 		$(INTERFACE:%.i=%.cmo) \
    644. 

  644. 		$(PROGFILE:%.ml=%.cmo) \
    645. 

  645. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
    646. 

  646. 		-cclib "$(LIBS)" -cc '$(CXX) -Wno-write-strings'
    647. 

  647. 

  648. ocaml_static_cpp_toplevel: $(SRCS)
    649. 

  649. 	$(OCAMLCORE)
    650. 

  650. 	$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
    651. 

  651. 	cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
    652. 

  652. 	$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
    653. 

  653. 		$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
    654. 

  654. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    655. 

  655. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    656. 

  656. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    657. 

  657. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    658. 

  658. 	$(NOLINK) || $(OCAMLMKTOP) \
    659. 

  659. 		swig.cmo \
    660. 

  660. 		-I $(OCAMLP4WHERE) dynlink.cma camlp4o.cma swigp4.cmo \
    661. 

  661. 		-g -ccopt -g -cclib -g -custom -o $(TARGET)_top \
    662. 

  662. 		$(INTERFACE:%.i=%.cmo) \
    663. 

  663. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
    664. 

  664. 		-cclib "$(LIBS)" -cc '$(CXX) -Wno-write-strings'
    665. 

  665. 

  666. ocaml_dynamic_cpp: $(SRCS)
    667. 

  667. 	$(OCAMLCORE)
    668. 

  668. 	$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACEPATH)
    669. 

  669. 	cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
    670. 

  670. 	$(OCC) -cc '$(CXX) -Wno-write-strings' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
    671. 

  671. 		$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS) -ccopt -fPIC
    672. 

  672. 	$(CXXSHARED) $(CFLAGS) -o $(INTERFACE:%.i=%@SO@) \
    673. 

  673. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
    674. 

  674. 		$(CPP_DLLIBS) $(LIBS)
    675. 

  675. 	$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
    676. 

  676. 		$(INTERFACE:%.i=%_dynamic.ml)
    677. 

  677. 	mv $(INTERFACE:%.i=%_dynamic.ml) $(INTERFACE:%.i=%.ml)
    678. 

  678. 	rm $(INTERFACE:%.i=%.mli)
    679. 

  679. 	$(OCAMLFIND) $(OCC) -g -c -package dl $(INTERFACE:%.i=%.ml)
    680. 

  680. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    681. 

  681. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    682. 

  682. 	$(NOLINK) || $(OCAMLFIND) \
    683. 

  683. 		swig.cmo \
    684. 

  684. 		$(OCC) -cclib -export-dynamic -g -ccopt -g -cclib -g -custom \
    685. 

  685. 		-o $(TARGET) \
    686. 

  686. 		-package dl -linkpkg \
    687. 

  687. 		$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo) -cc '$(CXX) -Wno-write-strings'
    688. 

  688. 

  689. ocaml_clean:
    690. 

  690. 	rm -f *_wrap* *~ .~* *.cmo *.cmi $(MLFILE) $(MLFILE)i swig.mli swig.cmi swig.ml swig.cmo swigp4.ml swigp4.cmo
    691. 

  691. 	rm -f core @EXTRA_CLEAN@
    692. 

  692. 	rm -f *.@OBJEXT@ *@SO@
    693. 

  693. 

  694. ##################################################################
    695. 

  695. #####                       RUBY                            ######
    696. 

  696. ##################################################################
    697. 

  697. 

  698. # Make sure these locate your Ruby installation
    699. 

  699. RUBY_CFLAGS= @RUBYCCDLFLAGS@ $(DEFS)
    700. 

  700. RUBY_INCLUDE= @RUBYINCLUDE@
    701. 

  701. RUBY_LIB     = @RUBYLIB@
    702. 

  702. RUBY_DLNK = @RUBYDYNAMICLINKING@
    703. 

  703. 

  704. # ----------------------------------------------------------------
    705. 

  705. # Build a C dynamically loadable module
    706. 

  706. # ----------------------------------------------------------------
    707. 

  707. 

  708. ruby: $(SRCS)
    709. 

  709. 	$(SWIG) -ruby $(SWIGOPT) $(INTERFACEPATH)
    710. 

  710. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(RUBY_INCLUDE)
    711. 

  711. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    712. 

  712. 

  713. # -----------------------------------------------------------------
    714. 

  714. # Build a C++ dynamically loadable module
    715. 

  715. # -----------------------------------------------------------------
    716. 

  716. 

  717. ruby_cpp: $(SRCS)
    718. 

  718. 	$(SWIG) -c++ -ruby $(SWIGOPT) $(INTERFACEPATH)
    719. 

  719. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(RUBY_INCLUDE)
    720. 

  720. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    721. 

  721. 

  722. # -----------------------------------------------------------------
    723. 

  723. # Build statically linked Ruby interpreter
    724. 

  724. #
    725. 

  725. # These should only be used in conjunction with the %include embed.i
    726. 

  726. # library file
    727. 

  727. # -----------------------------------------------------------------
    728. 

  728. 

  729. RUBY_LIBOPTS = @RUBYLINK@ @LIBS@ $(SYSLIBS)
    730. 

  730. 

  731. ruby_static: $(SRCS)
    732. 

  732. 	$(SWIG) -ruby -lembed.i $(SWIGOPT) $(INTERFACEPATH)
    733. 

  733. 	$(CC) $(CFLAGS) $(RUBY_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
    734. 

  734. 	$(RUBY_INCLUDE) $(LIBS) -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
    735. 

  735. 

  736. ruby_cpp_static: $(SRCS)
    737. 

  737. 	$(SWIG) -c++ -ruby -lembed.i $(SWIGOPT) $(INTERFACEPATH)
    738. 

  738. 	$(CXX) $(CFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    739. 

  739. 	$(RUBY_INCLUDE) $(LIBS)  -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
    740. 

  740. 

  741. 

  742. # -----------------------------------------------------------------
    743. 

  743. # Cleaning the Ruby examples
    744. 

  744. # -----------------------------------------------------------------
    745. 

  745. 

  746. ruby_clean:
    747. 

  747. 	rm -f *_wrap* *~ .~* myruby@EXEEXT@ *.pm
    748. 

  748. 	rm -f core @EXTRA_CLEAN@
    749. 

  749. 	rm -f *.@OBJEXT@ *@SO@
    750. 

  750. 

  751. ##################################################################
    752. 

  752. #####                       PHP                             ######
    753. 

  753. ##################################################################
    754. 

  754. 

  755. # -------------------------------------------------------------------
    756. 

  756. # Build a PHP dynamically loadable module (C)
    757. 

  757. # -------------------------------------------------------------------
    758. 

  758. 

  759. PHP_INCLUDE = @PHPINC@
    760. 

  760. PHP_SO      = @PHP_SO@
    761. 

  761. 

  762. php: $(SRCS)
    763. 

  763. 	$(SWIG) -php $(SWIGOPT) $(INTERFACEPATH)
    764. 

  764. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PHP_INCLUDE)
    765. 

  765. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
    766. 

  766. 

  767. # --------------------------------------------------------------------
    768. 

  768. # Build a PHP dynamically loadable module (C++)
    769. 

  769. # --------------------------------------------------------------------
    770. 

  770. 

  771. php_cpp: $(SRCS)
    772. 

  772. 	$(SWIG) -php -cppext cxx -c++ $(SWIGOPT) $(INTERFACEPATH)
    773. 

  773. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PHP_INCLUDE)
    774. 

  774. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO)
    775. 

  775. 

  776. # -----------------------------------------------------------------
    777. 

  777. # Running a PHP example
    778. 

  778. # -----------------------------------------------------------------
    779. 

  779. 

  780. PHP=@PHP@
    781. 

  781. PHPSCRIPT ?= runme.php
    782. 

  782. 

  783. php_run:
    784. 

  784. 	env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(PHP) -n -q -d extension_dir=. -d safe_mode=Off $(PHPSCRIPT)
    785. 

  785. 

  786. # -----------------------------------------------------------------
    787. 

  787. # Cleaning the PHP examples
    788. 

  788. # -----------------------------------------------------------------
    789. 

  789. 

  790. php_clean:
    791. 

  791. 	rm -f *_wrap* *~ .~* example.php php_example.h
    792. 

  792. 	rm -f core @EXTRA_CLEAN@
    793. 

  793. 	rm -f *.@OBJEXT@ *@SO@
    794. 

  794. 

  795. ##################################################################
    796. 

  796. #####                       Pike                            ######
    797. 

  797. ##################################################################
    798. 

  798. 

  799. # Make sure these locate your Pike installation
    800. 

  800. PIKE_CFLAGS  = @PIKECCDLFLAGS@ -DHAVE_CONFIG_H
    801. 

  801. PIKE_INCLUDE = @PIKEINCLUDE@
    802. 

  802. PIKE_LIB     = @PIKELIB@
    803. 

  803. PIKE_DLNK    = @PIKEDYNAMICLINKING@
    804. 

  804. 

  805. # ----------------------------------------------------------------
    806. 

  806. # Build a C dynamically loadable module
    807. 

  807. # ----------------------------------------------------------------
    808. 

  808. 

  809. pike: $(SRCS)
    810. 

  810. 	$(SWIG) -pike $(SWIGOPT) $(INTERFACEPATH)
    811. 

  811. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PIKE_INCLUDE)
    812. 

  812. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    813. 

  813. 

  814. # -----------------------------------------------------------------
    815. 

  815. # Build a C++ dynamically loadable module
    816. 

  816. # -----------------------------------------------------------------
    817. 

  817. 

  818. pike_cpp: $(SRCS)
    819. 

  819. 	$(SWIG) -c++ -pike $(SWIGOPT) $(INTERFACEPATH)
    820. 

  820. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PIKE_INCLUDE)
    821. 

  821. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    822. 

  822. 

  823. # -----------------------------------------------------------------
    824. 

  824. # Build statically linked Pike interpreter
    825. 

  825. #
    826. 

  826. # These should only be used in conjunction with the %include embed.i
    827. 

  827. # library file
    828. 

  828. # -----------------------------------------------------------------
    829. 

  829. 

  830. PIKE_LIBOPTS = @PIKELINK@ @LIBS@ $(SYSLIBS)
    831. 

  831. 

  832. pike_static: $(SRCS)
    833. 

  833. 	$(SWIG) -pike -lembed.i $(SWIGOPT) $(INTERFACEPATH)
    834. 

  834. 	$(CC) $(CFLAGS) $(PIKE_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
    835. 

  835. 	$(PIKE_INCLUDE) $(LIBS) -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
    836. 

  836. 

  837. pike_cpp_static: $(SRCS)
    838. 

  838. 	$(SWIG) -c++ -pike -lembed.i $(SWIGOPT) $(INTERFACEPATH)
    839. 

  839. 	$(CXX) $(CFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    840. 

  840. 	$(PIKE_INCLUDE) $(LIBS)  -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
    841. 

  841. 

  842. # -----------------------------------------------------------------
    843. 

  843. # Cleaning the Pike examples
    844. 

  844. # -----------------------------------------------------------------
    845. 

  845. 

  846. pike_clean:
    847. 

  847. 	rm -f *_wrap* *~ .~* mypike@EXEEXT@
    848. 

  848. 	rm -f core @EXTRA_CLEAN@
    849. 

  849. 	rm -f *.@OBJEXT@ *@SO@
    850. 

  850. 

  851. 

  852. ##################################################################
    853. 

  853. #####                      Chicken                          ######
    854. 

  854. ##################################################################
    855. 

  855. 

  856. CHICKEN = @CHICKEN@
    857. 

  857. CHICKEN_CSC = @CHICKEN_CSC@
    858. 

  858. CHICKEN_LIBOPTS = @CHICKENLIB@  $(SYSLIBS)
    859. 

  859. CHICKEN_SHAREDLIBOPTS = @CHICKENSHAREDLIB@  $(SYSLIBS)
    860. 

  860. CHICKEN_CFLAGS = @CHICKENOPTS@
    861. 

  861. CHICKENOPTS = -quiet
    862. 

  862. CHICKEN_MAIN =
    863. 

  863. 

  864. # SWIG produces $(ISRCS) (the C wrapper file)
    865. 

  865. # and $(CHICKEN_GENERATED_SCHEME) (the Scheme wrapper file):
    866. 

  866. CHICKEN_GENERATED_SCHEME = $(INTERFACE:.i=.scm)
    867. 

  867. CHICKEN_COMPILED_SCHEME = $(INTERFACE:.i=_chicken.c)
    868. 

  868. CHICKEN_COMPILED_OBJECT = $(CHICKEN_COMPILED_SCHEME:.c=.@OBJEXT@)
    869. 

  869. 

  870. # flags for the main chicken sources (only used when compiling staticly)
    871. 

  871. CHICKEN_COMPILED_MAIN = $(CHICKEN_MAIN:.scm=_chicken.c)
    872. 

  872. CHICKEN_COMPILED_MAIN_OBJECT = $(CHICKEN_COMPILED_MAIN:.c=.@OBJEXT@)
    873. 

  873. 

  874. # -----------------------------------------------------------------
    875. 

  875. # Build a CHICKEN dynamically loadable module
    876. 

  876. # -----------------------------------------------------------------
    877. 

  877. 

  878. # This is the old way to build chicken, but it does not work correctly with exceptions
    879. 

  879. chicken_direct: $(SRCS)
    880. 

  880. 	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
    881. 

  881. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    882. 

  882. 		-dynamic -feature chicken-compile-shared \
    883. 

  883. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    884. 

  884. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    885. 

  885. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) $(CHICKEN_COMPILED_SCHEME)
    886. 

  886. 	$(LDSHARED) $(CFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
    887. 

  887. 		$(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
    888. 

  888. 

  889. chicken_direct_cpp: $(CXXSRCS) $(CHICKSRCS)
    890. 

  890. 	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
    891. 

  891. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    892. 

  892. 		-dynamic -feature chicken-compile-shared \
    893. 

  893. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    894. 

  894. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    895. 

  895. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(CHICKEN_COMPILED_SCHEME)
    896. 

  896. 	$(CXXSHARED) $(CFLAGS) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
    897. 

  897. 		$(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
    898. 

  898. 

  899. # -----------------------------------------------------------------
    900. 

  900. # Build statically linked CHICKEN interpreter
    901. 

  901. # -----------------------------------------------------------------
    902. 

  902. 

  903. # The following two targets are also used by the test suite
    904. 

  904. chicken_static: $(SRCS) $(CHICKSRCS)
    905. 

  905. 	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
    906. 

  906. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    907. 

  907. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    908. 

  908. 	$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
    909. 

  909. 		-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
    910. 

  910. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    911. 

  911. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) \
    912. 

  912. 		$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
    913. 

  913. 	$(CC) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
    914. 

  914. 		$(OBJS) $(IOBJS) $(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
    915. 

  915. 

  916. chicken_static_cpp: $(CXXSRCS) $(CHICKSRCS)
    917. 

  917. 	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
    918. 

  918. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    919. 

  919. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    920. 

  920. 	$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
    921. 

  921. 		-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
    922. 

  922. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    923. 

  923. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) \
    924. 

  924. 		$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
    925. 

  925. 	$(CXX) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
    926. 

  926. 		$(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
    927. 

  927. 

  928. # ----------------------------------------------------------------
    929. 

  929. # Build a shared library using csc
    930. 

  930. # ----------------------------------------------------------------
    931. 

  931. 

  932. chicken:
    933. 

  933. 	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
    934. 

  934. 	$(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ISRCS) -o $(TARGET)$(SO)
    935. 

  935. 

  936. chicken_cpp:
    937. 

  937. 	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACEPATH)
    938. 

  938. 	$(COMPILETOOL) $(CHICKEN_CSC) -s `echo $(INCLUDES) | sed 's/-I/-C -I/g'` $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ICXXSRCS) $(CXXSRCS) -o $(TARGET)$(SO)
    939. 

  939. 

  940. chicken_externalhdr:
    941. 

  941. 	$(SWIG) -chicken -external-runtime $(TARGET)
    942. 

  942. 

  943. chicken_clean:
    944. 

  944. 	rm -f *_wrap* *~ .~* *_chicken*
    945. 

  945. 	rm -f core @EXTRA_CLEAN@
    946. 

  946. 	rm -f *.@OBJEXT@ *@SO@
    947. 

  947. 

  948. ##################################################################
    949. 

  949. #####                      CSHARP                           ######
    950. 

  950. ##################################################################
    951. 

  951. 

  952. # Extra CSharp specific dynamic linking options
    953. 

  953. CSHARP_DLNK  = @CSHARPDYNAMICLINKING@
    954. 

  954. CSHARP_LIBPREFIX = @CSHARPLIBRARYPREFIX@
    955. 

  955. CSHARPCOMPILER = @CSHARPCOMPILER@
    956. 

  956. CSHARPCILINTERPRETER = @CSHARPCILINTERPRETER@
    957. 

  957. CSHARPCFLAGS = @CSHARPCFLAGS@
    958. 

  958. CSHARPSO = @CSHARPSO@
    959. 

  959. 

  960. # ----------------------------------------------------------------
    961. 

  961. # Build a CSharp dynamically loadable module (C)
    962. 

  962. # ----------------------------------------------------------------
    963. 

  963. 

  964. csharp: $(SRCS)
    965. 

  965. 	$(SWIG) -csharp $(SWIGOPT) $(INTERFACEPATH)
    966. 

  966. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
    967. 

  967. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
    968. 

  968. 

  969. # ----------------------------------------------------------------
    970. 

  970. # Build a CSharp dynamically loadable module (C++)
    971. 

  971. # ----------------------------------------------------------------
    972. 

  972. 

  973. csharp_cpp: $(SRCS)
    974. 

  974. 	$(SWIG) -csharp -c++ $(SWIGOPT) $(INTERFACEPATH)
    975. 

  975. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
    976. 

  976. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
    977. 

  977. 

  978. # ----------------------------------------------------------------
    979. 

  979. # Compile CSharp files
    980. 

  980. # ----------------------------------------------------------------
    981. 

  981. 

  982. csharp_compile: $(SRCS)
    983. 

  983. 	$(COMPILETOOL) $(CSHARPCOMPILER) $(CSHARPFLAGS) $(CSHARPSRCS)
    984. 

  984. 

  985. # -----------------------------------------------------------------
    986. 

  986. # Cleaning the CSharp examples
    987. 

  987. # -----------------------------------------------------------------
    988. 

  988. 

  989. csharp_clean:
    990. 

  990. 	rm -f *_wrap* *~ .~* runme runme.exe *.exe.mdb gc.log `find . -name \*.cs | grep -v runme.cs`
    991. 

  991. 	rm -f core @EXTRA_CLEAN@
    992. 

  992. 	rm -f *.@OBJEXT@ *@CSHARPSO@
    993. 

  993. 

  994. ##################################################################
    995. 

  995. #####                      LUA                              ######
    996. 

  996. ##################################################################
    997. 

  997. 

  998. # lua flags
    999. 

  999. LUA_INCLUDE= @LUAFLAGS@
    1000. 

  1000. LUA_LIB    = @LUALINK@
    1001. 

  1001. 

  1002. # Extra specific dynamic linking options
    1003. 

  1003. LUA_DLNK   = @LUADYNAMICLINKING@
    1004. 

  1004. LUA_SO     = @LUA_SO@
    1005. 

  1005. 

  1006. # Extra code for lua static link
    1007. 

  1007. LUA_INTERP     = ../lua.c
    1008. 

  1008. 

  1009. # ----------------------------------------------------------------
    1010. 

  1010. # Build a C dynamically loadable module
    1011. 

  1011. # ----------------------------------------------------------------
    1012. 

  1012. 

  1013. lua: $(SRCS)
    1014. 

  1014. 	$(SWIG) -lua $(SWIGOPT) $(INTERFACEPATH)
    1015. 

  1015. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(LUA_INCLUDE)
    1016. 

  1016. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
    1017. 

  1017. 

  1018. # -----------------------------------------------------------------
    1019. 

  1019. # Build a C++ dynamically loadable module
    1020. 

  1020. # -----------------------------------------------------------------
    1021. 

  1021. 

  1022. lua_cpp: $(SRCS)
    1023. 

  1023. 	$(SWIG) -c++ -lua $(SWIGOPT) $(INTERFACEPATH)
    1024. 

  1024. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(LUA_INCLUDE)
    1025. 

  1025. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(LUA_LIB) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(LUA_SO)
    1026. 

  1026. 

  1027. # -----------------------------------------------------------------
    1028. 

  1028. # Build statically linked Lua interpreter
    1029. 

  1029. # -----------------------------------------------------------------
    1030. 

  1030. 

  1031. lua_static: $(SRCS)
    1032. 

  1032. 	$(SWIG) -lua -module example $(SWIGOPT) $(INTERFACEPATH)
    1033. 

  1033. 	$(CC) $(CFLAGS)  $(ISRCS) $(SRCS) $(LUA_INTERP) $(INCLUDES) \
    1034. 

  1034. 	$(LUA_INCLUDE) $(LIBS) $(LUA_LIB) -o $(TARGET)
    1035. 

  1035. 

  1036. lua_static_cpp: $(SRCS)
    1037. 

  1037. 	$(SWIG) -c++ -lua -module example $(SWIGOPT) $(INTERFACEPATH)
    1038. 

  1038. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(LUA_INTERP) $(INCLUDES) \
    1039. 

  1039. 	$(LUA_INCLUDE) $(LIBS)  $(LUA_LIB) -o $(TARGET)
    1040. 

  1040. 

  1041. # -----------------------------------------------------------------
    1042. 

  1042. # Cleaning the lua examples
    1043. 

  1043. # -----------------------------------------------------------------
    1044. 

  1044. 

  1045. lua_clean:
    1046. 

  1046. 	rm -f *_wrap* *~ .~* mylua@EXEEXT@
    1047. 

  1047. 	rm -f core @EXTRA_CLEAN@
    1048. 

  1048. 	rm -f *.@OBJEXT@ *@SO@
    1049. 

  1049. 

  1050. ##################################################################
    1051. 

  1051. #####                   ALLEGRO CL                          ######
    1052. 

  1052. ##################################################################
    1053. 

  1053. 

  1054. allegrocl: $(SRCS)
    1055. 

  1055. 	$(SWIG) -allegrocl -cwrap $(SWIGOPT) $(INTERFACEPATH)
    1056. 

  1056. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
    1057. 

  1057. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1058. 

  1058. 

  1059. allegrocl_cpp: $(SRCS)
    1060. 

  1060. 	$(SWIG) -c++ -allegrocl $(SWIGOPT) $(INTERFACEPATH)
    1061. 

  1061. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
    1062. 

  1062. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1063. 

  1063. 

  1064. allegrocl_clean:
    1065. 

  1065. 	rm -f *_wrap* *~ .~*
    1066. 

  1066. 	rm -f core @EXTRA_CLEAN@
    1067. 

  1067. 	rm -f *.@OBJEXT@ *@SO@
    1068. 

  1068. 

  1069. ##################################################################
    1070. 

  1070. #####                      CLISP                            ######
    1071. 

  1071. ##################################################################
    1072. 

  1072. 

  1073. clisp: $(SRCS)
    1074. 

  1074. 	$(SWIG) -clisp $(SWIGOPT) $(INTERFACEPATH)
    1075. 

  1075. 

  1076. clisp_cpp: $(SRCS)
    1077. 

  1077. 	$(SWIG) -c++ -clisp $(SWIGOPT) $(INTERFACEPATH)
    1078. 

  1078. 

  1079. clisp_clean:
    1080. 

  1080. 	rm -f *_wrap* *~ .~*
    1081. 

  1081. 	rm -f core @EXTRA_CLEAN@
    1082. 

  1082. 	rm -f *.@OBJEXT@ *@SO@
    1083. 

  1083. 

  1084. ##################################################################
    1085. 

  1085. #####                      CFFI                             ######
    1086. 

  1086. ##################################################################
    1087. 

  1087. 

  1088. cffi: $(SRCS)
    1089. 

  1089. 	$(SWIG) -cffi $(SWIGOPT) $(INTERFACEPATH)
    1090. 

  1090. #	$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
    1091. 

  1091. #	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1092. 

  1092. 

  1093. cffi_cpp: $(SRCS)
    1094. 

  1094. 	$(SWIG) -c++ -cffi $(SWIGOPT) $(INTERFACEPATH)
    1095. 

  1095. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
    1096. 

  1096. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1097. 

  1097. 

  1098. cffi_clean:
    1099. 

  1099. 	rm -f *_wrap* *~ .~*
    1100. 

  1100. 	rm -f core @EXTRA_CLEAN@
    1101. 

  1101. 	rm -f *.@OBJEXT@ *@SO@
    1102. 

  1102. 

  1103. ##################################################################
    1104. 

  1104. #####                      UFFI                             ######
    1105. 

  1105. ##################################################################
    1106. 

  1106. 

  1107. uffi: $(SRCS)
    1108. 

  1108. 	$(SWIG) -uffi $(SWIGOPT) $(INTERFACEPATH)
    1109. 

  1109. #	$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCS)
    1110. 

  1110. #	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1111. 

  1111. 

  1112. uffi_cpp: $(SRCS)
    1113. 

  1113. 	$(SWIG) -c++ -uffi $(SWIGOPT) $(INTERFACEPATH)
    1114. 

  1114. #	$(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES)
    1115. 

  1115. #	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1116. 

  1116. 

  1117. uffi_clean:
    1118. 

  1118. 	rm -f *_wrap* *~ .~*
    1119. 

  1119. 	rm -f core @EXTRA_CLEAN@
    1120. 

  1120. 	rm -f *.@OBJEXT@ *@SO@
    1121. 

  1121. 

  1122. ##################################################################
    1123. 

  1123. #####                      R                                ######
    1124. 

  1124. ##################################################################
    1125. 

  1125. 

  1126. R = R
    1127. 

  1127. RCXXSRCS = $(INTERFACE:.i=_wrap.cpp) #Need to use _wrap.cpp for R build system as it does not understand _wrap.cxx
    1128. 

  1128. RRSRC = $(INTERFACE:.i=.R)
    1129. 

  1129. 

  1130. r: $(SRCS)
    1131. 

  1131. 	$(SWIG) -r $(SWIGOPT) $(INTERFACEPATH)
    1132. 

  1132. 	+( PKG_CPPFLAGS="$(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(ISRCS) $(SRCS) )
    1133. 

  1133. 

  1134. r_cpp: $(CXXSRCS)
    1135. 

  1135. 	$(SWIG) -c++ -r $(SWIGOPT) -o $(RCXXSRCS) $(INTERFACEPATH)
    1136. 

  1136. 	+( PKG_CPPFLAGS="$(INCLUDES)" $(COMPILETOOL) $(R) CMD SHLIB -o $(LIBPREFIX)$(TARGET)$(SO) $(RCXXSRCS) $(SRCS) $(CXXSRCS))
    1137. 

  1137. 

  1138. r_clean:
    1139. 

  1139. 	rm -f *_wrap* *~ .~*
    1140. 

  1140. 	rm -f core @EXTRA_CLEAN@
    1141. 

  1141. 	rm -f *.@OBJEXT@ *@SO@ NAMESPACE
    1142. 

  1142. 	rm -f $(RRSRC) runme.Rout .RData
    1143. 

  1143. 

  1144. ##################################################################
    1145. 

  1145. #####                        Go                             ######
    1146. 

  1146. ##################################################################
    1147. 

  1147. 

  1148. GO = @GO@
    1149. 

  1149. GOGCC = @GOGCC@
    1150. 

  1150. 

  1151. GOSWIGARG = `if $(GOGCC) ; then echo -gccgo; fi`
    1152. 

  1152. GOCOMPILEARG = `if $(GOGCC) ; then echo -c -g; fi`
    1153. 

  1153. 

  1154. GOSRCS = $(INTERFACE:.i=.go)
    1155. 

  1155. GOCSRCS = $(INTERFACE:.i=_gc.c)
    1156. 

  1156. 

  1157. GOC = $(GO:g=c)
    1158. 

  1158. GOLD = $(GO:g=l)
    1159. 

  1159. 

  1160. GOPACKAGE = $(INTERFACE:.i=.a)
    1161. 

  1161. 

  1162. GOOBJEXT = $(GO:g=)
    1163. 

  1163. GOGCOBJS = $(GOSRCS:.go=.$(GOOBJEXT))
    1164. 

  1164. GOGCCOBJS = $(GOSRCS:.go=.@OBJEXT@)
    1165. 

  1165. 

  1166. # ----------------------------------------------------------------
    1167. 

  1167. # Build a Go dynamically loadable module (C)
    1168. 

  1168. # ----------------------------------------------------------------
    1169. 

  1169. 

  1170. go: $(SRCS)
    1171. 

  1171. 	$(SWIG) -go $(GOSWIGARG) $(SWIGOPT) $(INTERFACEPATH)
    1172. 

  1172. 	$(CC) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
    1173. 

  1173. 	$(LDSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1174. 

  1174. 	$(COMPILETOOL) $(GO) -I . $(GOCOMPILEARG) $(GOSRCS)
    1175. 

  1175. 	if ! $(GOGCC) ; then \
    1176. 

  1176. 	  $(COMPILETOOL) $(GOC) -I $${GOROOT}/pkg/$${GOOS}_$${GOARCH} $(GOCSRCS) && \
    1177. 

  1177. 	  $(COMPILETOOL) gopack grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
    1178. 

  1178. 	fi
    1179. 

  1179. 

  1180. # ----------------------------------------------------------------
    1181. 

  1181. # Build a Go dynamically loadable module (C++)
    1182. 

  1182. # ----------------------------------------------------------------
    1183. 

  1183. 

  1184. go_cpp: $(SRCS)
    1185. 

  1185. 	$(SWIG) -go -c++ $(GOSWIGARG) $(SWIGOPT) $(INTERFACEPATH)
    1186. 

  1186. 	$(CXX) -g -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
    1187. 

  1187. 	$(CXXSHARED) $(CFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    1188. 

  1188. 	$(COMPILETOOL) $(GO) -I . $(GOCOMPILEARG) $(GOSRCS)
    1189. 

  1189. 	if ! $(GOGCC) ; then \
    1190. 

  1190. 	  $(COMPILETOOL) $(GOC) -I $${GOROOT}/pkg/$${GOOS}_$${GOARCH} $(GOCSRCS) && \
    1191. 

  1191. 	  $(COMPILETOOL) gopack grc $(GOPACKAGE) $(GOGCOBJS) $(GOCSRCS:.c=.$(GOOBJEXT)); \
    1192. 

  1192. 	fi
    1193. 

  1193. 

  1194. # -----------------------------------------------------------------
    1195. 

  1195. # Running a Go example
    1196. 

  1196. # -----------------------------------------------------------------
    1197. 

  1197. 

  1198. go_run: runme.go
    1199. 

  1199. 	$(GO) $(GOCOMPILEARG) runme.go
    1200. 

  1200. 	if $(GOGCC) ; then \
    1201. 

  1201. 	  $(COMPILETOOL) $(GO) -o runme runme.@OBJEXT@ $(GOGCCOBJS) $(LIBPREFIX)$(TARGET)$(SO); \
    1202. 

  1202. 	else \
    1203. 

  1203. 	  $(COMPILETOOL) $(GOLD) -r $${GOROOT}/pkg/$${GOOS}_$${GOARCH}:. -o runme runme.$(GOOBJEXT); \
    1204. 

  1204. 	fi
    1205. 

  1205. 	env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./runme
    1206. 

  1206. 

  1207. # -----------------------------------------------------------------
    1208. 

  1208. # Cleaning the Go examples
    1209. 

  1209. # -----------------------------------------------------------------
    1210. 

  1210. 

  1211. go_clean:
    1212. 

  1212. 	rm -f *_wrap* *_gc* .~* runme
    1213. 

  1213. 	rm -f core @EXTRA_CLEAN@
    1214. 

  1214. 	rm -f *.@OBJEXT@ *.[568] *.a *@SO@
    1215. 

  1215. 

  1216. ##################################################################
    1217. 

  1217. #####                         D                             ######
    1218. 

  1218. ##################################################################
    1219. 

  1219. 

  1220. DLIBPREFIX = @DLIBPREFIX@
    1221. 

  1221. 

  1222. ifeq (,$(D_VERSION))
    1223. 

  1223.   D_VERSION = @DDEFAULTVERSION@
    1224. 

  1224. endif
    1225. 

  1225. 

  1226. ifeq (2,$(D_VERSION))
    1227. 

  1227.   SWIGD = $(SWIG) -d -d2
    1228. 

  1228.   DCOMPILER = @D2COMPILER@
    1229. 

  1229. else
    1230. 

  1230.   SWIGD = $(SWIG) -d
    1231. 

  1231.   DCOMPILER = @D1COMPILER@
    1232. 

  1232. endif
    1233. 

  1233. 

  1234. ifeq (dmd,$(DCOMPILER))
    1235. 

  1235.   # DMD is 32bit only by now
    1236. 

  1236.   DCFLAGS = -m32
    1237. 

  1237. endif
    1238. 

  1238. 

  1239. # ----------------------------------------------------------------
    1240. 

  1240. # Build a dynamically loadable D wrapper for a C module
    1241. 

  1241. # ----------------------------------------------------------------
    1242. 

  1242. 

  1243. d: $(SRCS)
    1244. 

  1244. 	$(SWIGD) $(SWIGOPT) $(INTERFACEPATH)
    1245. 

  1245. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
    1246. 

  1246. 	$(LDSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
    1247. 

  1247. 

  1248. # ----------------------------------------------------------------
    1249. 

  1249. # Build a dynamically loadable D wrapper for a C++ module
    1250. 

  1250. # ----------------------------------------------------------------
    1251. 

  1251. 

  1252. d_cpp: $(SRCS)
    1253. 

  1253. 	$(SWIGD) -c++ $(SWIGOPT) $(INTERFACEPATH)
    1254. 

  1254. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
    1255. 

  1255. 	$(CXXSHARED) $(CFLAGS) $(DCFLAGS) $(EXTRA_LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(DLIBPREFIX)$(TARGET)$(SO)
    1256. 

  1256. 

  1257. # ----------------------------------------------------------------
    1258. 

  1258. # Compile D files
    1259. 

  1259. # ----------------------------------------------------------------
    1260. 

  1260. 

  1261. # Clear the DFLAGS environment variable for the compiler call itself
    1262. 

  1262. # to work around a discrepancy in argument handling between DMD and LDC.
    1263. 

  1263. d_compile: $(SRCS)
    1264. 

  1264. 	DFLAGS="" $(COMPILETOOL) $(DCOMPILER) $(DFLAGS) $(DSRCS)
    1265. 

  1265. 

  1266. # -----------------------------------------------------------------
    1267. 

  1267. # Run D example
    1268. 

  1268. # -----------------------------------------------------------------
    1269. 

  1269. 

  1270. d_run:
    1271. 

  1271. 	env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) ./runme
    1272. 

  1272. 

  1273. # -----------------------------------------------------------------
    1274. 

  1274. # Clean the D examples
    1275. 

  1275. # -----------------------------------------------------------------
    1276. 

  1276. 

  1277. d_clean:
    1278. 

  1278. 	rm -f *_wrap* *~ .~* runme runme.exe `find . -name \*.d | grep -v runme.d`
    1279. 

  1279. 	rm -f core @EXTRA_CLEAN@
    1280. 

  1280. 	rm -f *.@OBJEXT@ *@SO@
    1281.