/tags/rel-1-3-24/SWIG/Examples/Makefile.in

# · Autoconf · 864 lines · 454 code · 168 blank · 242 comment · 25 complexity · 67ed8fb15c8ad48f345d1d61151b358e 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, simply set SRCS, INTERFACE, INCLUDES, LIBS,
    16. 

  16. #      TARGET, and do a
    17. 

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

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

  19. #           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. SWIGOPT    =
    35. 

  35. SWIG       = swig@release_suffix@
    36. 

  36. 

  37. LIBM       = @LIBM@
    38. 

  38. LIBC       = @LIBC@
    39. 

  39. LIBCRYPT   = @LIBCRYPT@
    40. 

  40. SYSLIBS    = $(LIBM) $(LIBC) $(LIBCRYPT)
    41. 

  41. LIBPREFIX  =
    42. 

  42. 

  43. # X11 options
    44. 

  44. 

  45. XLIB       = @XLIBSW@
    46. 

  46. XINCLUDE   = @XINCLUDES@
    47. 

  47. 

  48. IWRAP      = $(INTERFACE:.i=_wrap.i)
    49. 

  49. ISRCS      = $(IWRAP:.i=.c)
    50. 

  50. ICXXSRCS   = $(IWRAP:.i=.cxx)
    51. 

  51. IOBJS      = $(IWRAP:.i=.@OBJEXT@)
    52. 

  52. 

  53. ##################################################################
    54. 

  54. # Dynamic loading for C++
    55. 

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

  56. # you may need to edit this line appropriately.
    57. 

  57. #
    58. 

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

  59. # for other C++ compilers
    60. 

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

  61. 

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

  63.              -L/usr/local/lib -lg++ -lstdc++ -lgcc
    64. 

  64. 

  65. # Solaris workshop 5.0 
    66. 

  66. # CPP_DLLIBS = -L/opt/SUNWspro/lib -lCrun
    67. 

  67. 

  68. # Symbols used for using shared libraries
    69. 

  69. SO=		@SO@
    70. 

  70. LDSHARED=	@LDSHARED@
    71. 

  71. CCSHARED=	@CCSHARED@
    72. 

  72. CXXSHARED=      @CXXSHARED@
    73. 

  73. 

  74. # This is used for building shared libraries with a number of C++
    75. 

  75. # compilers.   If it doesn't work,  comment it out.
    76. 

  76. @TRYLINKINGWITHCXX@
    77. 

  77. 

  78. OBJS      = $(SRCS:.c=.@OBJEXT@) $(CXXSRCS:.cxx=.@OBJEXT@)
    79. 

  79. 

  80. ##################################################################
    81. 

  81. #####                       Tcl/Tk                          ######
    82. 

  82. ##################################################################
    83. 

  83. 

  84. # Set these to your local copy of Tcl/Tk.
    85. 

  85. 

  86. TCL_INCLUDE = @TCLINCLUDE@
    87. 

  87. TCL_LIB     = @TCLLIB@
    88. 

  88. TCL_OPTS    = @LIBS@
    89. 

  89. TK_OPTS     = -ltk -ltcl @LIBS@
    90. 

  90. 

  91. # Extra Tcl specific dynamic linking options
    92. 

  92. TCL_DLNK   = @TCLDYNAMICLINKING@
    93. 

  93. TCL_LDSHARED = @TCL_LDSHARED@
    94. 

  94. TCL_CXXSHARED = @TCL_CXXSHARED@
    95. 

  95. TCL_SO     = @TCL_SO@
    96. 

  96. 

  97. # -----------------------------------------------------------
    98. 

  98. # Build a new version of the tclsh shell
    99. 

  99. # -----------------------------------------------------------
    100. 

  100. 

  101. 

  102. tclsh: $(SRCS)
    103. 

  103. 	$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACE)
    104. 

  104. 	$(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
    105. 

  105. 	$(TCL_LIB)  $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
    106. 

  106. 

  107. tclsh_cpp: $(SRCS)
    108. 

  108. 	$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -ltclsh.i $(INTERFACE)
    109. 

  109. 	$(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
    110. 

  110. 	$(TCL_LIB) $(TCL_OPTS) $(LIBS) $(SYSLIBS) -o $(TARGET)
    111. 

  111. 

  112. # -----------------------------------------------------------
    113. 

  113. # Build a new copy of wish
    114. 

  114. # -----------------------------------------------------------
    115. 

  115. 

  116. wish: $(SRCS)
    117. 

  117. 	$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -lwish.i $(INTERFACE)
    118. 

  118. 	$(CC) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) \
    119. 

  119. 	$(XINCLUDE) $(TCL_LIB) $(TK_OPTS) $(XLIB) $(LIBS) $(SYSLIBS) -o $(TARGET)
    120. 

  120. 

  121. 

  122. wish_cpp: $(SRCS)
    123. 

  123. 	$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -lwish.i $(INTERFACE)
    124. 

  124. 	$(CXX) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) \
    125. 

  125. 	$(XINCLUDE) $(TCL_LIB) $(TK_OPTS) $(XLIB) $(LIBS) $(SYSLIBS) -o $(TARGET)
    126. 

  126. 

  127. # -----------------------------------------------------------
    128. 

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

  129. # -----------------------------------------------------------
    130. 

  130. 

  131. tcl:  $(SRCS)
    132. 

  132. 	$(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACE)
    133. 

  133. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE)
    134. 

  134. 	$(TCL_LDSHARED) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
    135. 

  135. 

  136. # -----------------------------------------------------------
    137. 

  137. # Build a Tcl7.5 dynamic loadable module for C++
    138. 

  138. # -----------------------------------------------------------
    139. 

  139. 

  140. tcl_cpp: $(SRCS)
    141. 

  141. 	$(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) $(INTERFACE)
    142. 

  142. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE)
    143. 

  143. 	$(TCL_CXXSHARED) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO)
    144. 

  144. 

  145. # -----------------------------------------------------------------
    146. 

  146. # Cleaning the Tcl examples
    147. 

  147. # -----------------------------------------------------------------
    148. 

  148. 

  149. tcl_clean:
    150. 

  150. 	rm -f *.@OBJEXT@ *@SO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ mytclsh@EXEEXT@ 
    151. 

  151. 

  152. ##################################################################
    153. 

  153. #####                       PERL 5                          ######
    154. 

  154. ##################################################################
    155. 

  155. 

  156. # You need to set this variable to the Perl5 directory containing the
    157. 

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

  158. # usually something like /usr/local/lib/perl5/arch-osname/5.003/CORE.
    159. 

  159. 

  160. PERL5_INCLUDE= @PERL5EXT@
    161. 

  161. 

  162. # Extra Perl specific dynamic linking options
    163. 

  163. PERL5_DLNK   = @PERL5DYNAMICLINKING@
    164. 

  164. PERL5_CCFLAGS = @PERL5CCFLAGS@
    165. 

  165. 

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

  167. # Build a Perl5 dynamically loadable module (C)
    168. 

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

  169. 

  170. perl5: $(SRCS)
    171. 

  171. 	$(SWIG) -perl5 $(SWIGOPT) $(INTERFACE)
    172. 

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

  173. 	$(LDSHARED) $(OBJS) $(IOBJS) $(PERL5_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    174. 

  174. 

  175. # ----------------------------------------------------------------
    176. 

  176. # Build a Perl5 dynamically loadable module (C++)
    177. 

  177. # ----------------------------------------------------------------
    178. 

  178. 

  179. perl5_cpp: $(SRCS)
    180. 

  180. 	$(SWIG) -perl5 -c++ $(SWIGOPT) $(INTERFACE)
    181. 

  181. 	$(CXX) -c $(CCSHARED) $(CFLAGS) -Dexplicit= $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PERL5_CCFLAGS) -I$(PERL5_INCLUDE)
    182. 

  182. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(PERL5_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    183. 

  183. 

  184. # ----------------------------------------------------------------
    185. 

  185. # Build a module from existing XS C source code.   (ie. from xsubpp).
    186. 

  186. # ----------------------------------------------------------------
    187. 

  187. perl5_xs: $(SRCS)
    188. 

  188. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(INCLUDES) -I$(PERL5_INCLUDE)
    189. 

  189. 	$(LDSHARED) $(OBJS) $(LIBS) -o $(TARGET)$(SO)
    190. 

  190. 

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

  192. # Build a statically linked Perl5 executable
    193. 

  193. # ----------------------------------------------------------------
    194. 

  194. 

  195. PERL5_LIB    = -L$(PERL5_INCLUDE) -l@PERL5LIB@ @LIBS@ $(SYSLIBS)
    196. 

  196. 

  197. perl5_static: $(SRCS)
    198. 

  198. 	$(SWIG) -perl5 -static -lperlmain.i $(SWIGOPT) $(INTERFACE)
    199. 

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

  200. 

  201. perl5_static_cpp: $(SRCS)
    202. 

  202. 	$(SWIG) -perl5 -c++ -static -lperlmain.i $(SWIGOPT) $(INTERFACE)
    203. 

  203. 	$(CXX) $(CFLAGS) -Dexplicit= $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) -I$(PERL5_INCLUDE) $(PERL5_LIB) $(LIBS) -o $(TARGET)
    204. 

  204. 

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

  206. # Cleaning the Perl5 examples
    207. 

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

  208. 

  209. perl5_clean:
    210. 

  210. 	rm -f *.@OBJEXT@ *@SO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ myperl@EXEEXT@ *.pm
    211. 

  211. 

  212. ##################################################################
    213. 

  213. #####                       PYTHON                          ######
    214. 

  214. ##################################################################
    215. 

  215. 

  216. # Make sure these locate your Python installation
    217. 

  217. PYTHON_INCLUDE= -DHAVE_CONFIG_H @PYINCLUDE@
    218. 

  218. PYTHON_LIB    = @PYLIB@
    219. 

  219. 

  220. # Extra Python specific dynamic linking options
    221. 

  221. PYTHON_DLNK   = @PYTHONDYNAMICLINKING@
    222. 

  222. PYTHON_SO     = @PYTHON_SO@
    223. 

  223. 

  224. # ----------------------------------------------------------------
    225. 

  225. # Build a C dynamically loadable module
    226. 

  226. # ----------------------------------------------------------------
    227. 

  227. 

  228. python: $(SRCS)
    229. 

  229. 	$(SWIG) -python $(SWIGOPT) $(INTERFACE)
    230. 

  230. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PYTHON_INCLUDE)
    231. 

  231. 	$(LDSHARED) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
    232. 

  232. 

  233. # -----------------------------------------------------------------
    234. 

  234. # Build a C++ dynamically loadable module
    235. 

  235. # -----------------------------------------------------------------
    236. 

  236. 

  237. python_cpp: $(SRCS)
    238. 

  238. 	$(SWIG) -c++ -python $(SWIGOPT) $(INTERFACE)
    239. 

  239. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PYTHON_INCLUDE)
    240. 

  240. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(PYTHON_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)_$(TARGET)$(PYTHON_SO)
    241. 

  241. 

  242. # -----------------------------------------------------------------
    243. 

  243. # Build statically linked Python interpreter
    244. 

  244. #
    245. 

  245. # These should only be used in conjunction with the %include embed.i
    246. 

  246. # library file
    247. 

  247. # -----------------------------------------------------------------
    248. 

  248. 

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

  250. TKINTER =
    251. 

  251. PYTHON_LIBOPTS = @PYLINK@ @LIBS@ $(TKINTER) $(SYSLIBS)
    252. 

  252. 

  253. python_static: $(SRCS)
    254. 

  254. 	$(SWIG) -python -lembed.i $(SWIGOPT) $(INTERFACE)
    255. 

  255. 	$(CC) $(CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
    256. 

  256. 	$(PYTHON_INCLUDE) $(LIBS) -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
    257. 

  257. 

  258. python_static_cpp: $(SRCS)
    259. 

  259. 	$(SWIG) -c++ -python -lembed.i $(SWIGOPT) $(INTERFACE)
    260. 

  260. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    261. 

  261. 	$(PYTHON_INCLUDE) $(LIBS)  -L$(PYTHON_LIB) $(PYTHON_LIBOPTS) -o $(TARGET)
    262. 

  262. 

  263. # -----------------------------------------------------------------
    264. 

  264. # Cleaning the python examples
    265. 

  265. # -----------------------------------------------------------------
    266. 

  266. 

  267. python_clean:
    268. 

  268. 	rm -f *.@OBJEXT@ *@SO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ mypython@EXEEXT@ *.pyc
    269. 

  269. 

  270. ##################################################################
    271. 

  271. #####                       GUILE                           ######
    272. 

  272. ##################################################################
    273. 

  273. 

  274. # Make sure these locate your Guile installation
    275. 

  275. GUILE_INCLUDE = @GUILEINCLUDE@
    276. 

  276. GUILE_LIB     = @GUILELIB@
    277. 

  277. GUILE_SO      = @GUILE_SO@
    278. 

  278. GUILE_LIBPREFIX = lib
    279. 

  279. 

  280. #------------------------------------------------------------------
    281. 

  281. # Build a dynamically loaded module with passive linkage and the scm interface
    282. 

  282. #------------------------------------------------------------------
    283. 

  283. guile: $(SRCS)
    284. 

  284. 	$(SWIG) -guile -scm -Linkage passive $(SWIGOPT) $(INTERFACE)
    285. 

  285. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ISRCS) $(SRCS)
    286. 

  286. 	$(LDSHARED) $(OBJS) $(IOBJS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    287. 

  287. 

  288. guile_cpp: $(SRCS)
    289. 

  289. 	$(SWIG) -c++ -guile -scm -Linkage passive $(SWIGOPT) $(INTERFACE)
    290. 

  290. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    291. 

  291. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    292. 

  292. 

  293. #------------------------------------------------------------------
    294. 

  294. # Build a dynamically loaded module with passive linkage and the gh interface
    295. 

  295. #------------------------------------------------------------------
    296. 

  296. guile_gh: $(SRCS)
    297. 

  297. 	$(SWIG) -guile -gh -Linkage passive $(SWIGOPT) $(INTERFACE)
    298. 

  298. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ISRCS) $(SRCS)
    299. 

  299. 	$(LDSHARED) $(OBJS) $(IOBJS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    300. 

  300. 

  301. guile_gh_cpp: $(SRCS)
    302. 

  302. 	$(SWIG) -c++ -guile -gh -Linkage passive $(SWIGOPT) $(INTERFACE)
    303. 

  303. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    304. 

  304. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    305. 

  305. 

  306. # -----------------------------------------------------------------
    307. 

  307. # Build a dynamically loadable module with passive linkage
    308. 

  308. # -----------------------------------------------------------------
    309. 

  309. 

  310. guile_passive: $(SRCS)
    311. 

  311. 	$(SWIG) -guile -Linkage passive $(SWIGOPT) $(INTERFACE)
    312. 

  312. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ISRCS) $(SRCS)
    313. 

  313. 	$(LDSHARED) $(OBJS) $(IOBJS) $(LIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    314. 

  314. 

  315. guile_passive_cpp: $(SRCS)
    316. 

  316. 	$(SWIG) -c++ -guile -Linkage passive $(SWIGOPT) $(INTERFACE)
    317. 

  317. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(INCLUDES) $(GUILE_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    318. 

  318. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(GUILE_LIBPREFIX)$(TARGET)$(GUILE_SO)
    319. 

  319. 

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

  321. # Build statically linked Guile interpreter
    322. 

  322. # -----------------------------------------------------------------
    323. 

  323. 

  324. GUILE_LIBOPTS = @GUILELINK@ @LIBS@ $(SYSLIBS)
    325. 

  325. 

  326. guile_static: $(SRCS)
    327. 

  327. 	$(SWIG) -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACE)
    328. 

  328. 	$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
    329. 

  329. 	  -DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
    330. 

  330. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    331. 

  331. 

  332. guile_static_cpp: $(SRCS)
    333. 

  333. 	$(SWIG) -c++ -guile -lguilemain.i -Linkage ltdlmod $(SWIGOPT) $(INTERFACE)
    334. 

  334. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    335. 

  335. 	  -DSWIGINIT="SCM scm_init_$(TARGET)_module(void); scm_init_$(TARGET)_module();" \
    336. 

  336. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    337. 

  337. 

  338. guile_simple: $(SRCS)
    339. 

  339. 	$(SWIG) -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACE)
    340. 

  340. 	$(CC) $(CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) \
    341. 

  341. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    342. 

  342. 

  343. guile_simple_cpp: $(SRCS)
    344. 

  344. 	$(SWIG) -c++ -guile -lguilemain.i -Linkage simple $(SWIGOPT) $(INTERFACE)
    345. 

  345. 	$(CXX) $(CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    346. 

  346. 	  $(GUILE_INCLUDE) $(LIBS) -L$(GUILE_LIB) $(GUILE_LIBOPTS) -o $(TARGET)-guile
    347. 

  347. 

  348. # -----------------------------------------------------------------
    349. 

  349. # Cleaning the Guile examples
    350. 

  350. # -----------------------------------------------------------------
    351. 

  351. 

  352. guile_clean:
    353. 

  353. 	rm -f *.@OBJEXT@ *@SO@ *.$(GUILE_SO) *_wrap* *~ .~* core @EXTRA_CLEAN@ my-guile@EXEEXT@ $(TARGET)@EXEEXT@
    354. 

  354. 

  355. ##################################################################
    356. 

  356. #####                       JAVA                            ######
    357. 

  357. ##################################################################
    358. 

  358. 

  359. # You need to set this variable to the java directories containing the
    360. 

  360. # files "jni.h" and "md.h"
    361. 

  361. # usually something like /usr/java/include and /usr/java/include/<arch-osname>.
    362. 

  362. JAVA_INCLUDE= @JAVAINC@
    363. 

  363. 

  364. # Extra Java specific dynamic linking options
    365. 

  365. JAVA_DLNK  = @JAVADYNAMICLINKING@
    366. 

  366. JAVA_LIBPREFIX = @JAVALIBRARYPREFIX@
    367. 

  367. JAVASO =@JAVASO@
    368. 

  368. JAVALDSHARED = @JAVALDSHARED@
    369. 

  369. JAVACXXSHARED = @JAVACXXSHARED@
    370. 

  370. JAVACFLAGS = @JAVACFLAGS@
    371. 

  371. 

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

  373. # Build a java dynamically loadable module (C)
    374. 

  374. # ----------------------------------------------------------------
    375. 

  375. 

  376. java: $(SRCS)
    377. 

  377. 	$(SWIG) -java $(SWIGOPT) $(INTERFACE)
    378. 

  378. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(JAVA_INCLUDE)
    379. 

  379. 	$(JAVALDSHARED) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
    380. 

  380. 

  381. # ----------------------------------------------------------------
    382. 

  382. # Build a java dynamically loadable module (C++)
    383. 

  383. # ----------------------------------------------------------------
    384. 

  384. 

  385. java_cpp: $(SRCS)
    386. 

  386. 	$(SWIG) -java -c++ $(SWIGOPT) $(INTERFACE)
    387. 

  387. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(JAVACFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(JAVA_INCLUDE)
    388. 

  388. 	$(JAVACXXSHARED) $(OBJS) $(IOBJS) $(JAVA_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(JAVA_LIBPREFIX)$(TARGET)$(JAVASO)
    389. 

  389. 

  390. # -----------------------------------------------------------------
    391. 

  391. # Cleaning the java examples
    392. 

  392. # -----------------------------------------------------------------
    393. 

  393. 

  394. java_clean:
    395. 

  395. 	rm -f *.@OBJEXT@ *@JAVASO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ *.class `find . -name \*.java | grep -v main.java`
    396. 

  396. 

  397. ##################################################################
    398. 

  398. #####                      MODULA3                          ######
    399. 

  399. ##################################################################
    400. 

  400. 

  401. MODULA3_INCLUDE= @MODULA3INC@
    402. 

  402. 

  403. # ----------------------------------------------------------------
    404. 

  404. # Build a modula3 dynamically loadable module (C)
    405. 

  405. # ----------------------------------------------------------------
    406. 

  406. 

  407. modula3: $(SRCS)
    408. 

  408. 	$(SWIG) -modula3 $(SWIGOPT) $(INTERFACE)
    409. 

  409. #	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) \
    410. 

  410. #       $(OBJS) $(IOBJS) $(LIBS)
    411. 

  411. 

  412. modula3_cpp: $(SRCS)
    413. 

  413. 	$(SWIG) -modula3 -c++ $(SWIGOPT) $(INTERFACE)
    414. 

  414. 

  415. # -----------------------------------------------------------------
    416. 

  416. # Cleaning the modula3 examples
    417. 

  417. # -----------------------------------------------------------------
    418. 

  418. 

  419. modula3_clean:
    420. 

  420. 	rm -f *_wrap* *.i3 *.m3
    421. 

  421. 

  422. ##################################################################
    423. 

  423. #####                       MZSCHEME                        ######
    424. 

  424. ##################################################################
    425. 

  425. 

  426. MZC = test -n "@MZC@" && @MZC@
    427. 

  427. MZDYNOBJ = @MZDYNOBJ@
    428. 

  428. MZSCHEME_SO = @MZSCHEME_SO@
    429. 

  429. 

  430. # ----------------------------------------------------------------
    431. 

  431. # Build a C/C++ dynamically loadable module
    432. 

  432. # ----------------------------------------------------------------
    433. 

  433. 

  434. mzscheme: $(SRCS)
    435. 

  435. 	$(SWIG) -mzscheme $(SWIGOPT) $(INTERFACE)
    436. 

  436. 	$(MZC) ++ccf "$(INCLUDES)" --cc $(ISRCS) $(SRCS)
    437. 

  437. 	$(MZC) --ld $(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS)
    438. 

  438. 

  439. mzscheme_cpp: $(SRCS)
    440. 

  440. 	$(SWIG) -mzscheme -c++ $(SWIGOPT) $(INTERFACE)
    441. 

  441. 	$(MZC) ++ccf "$(INCLUDES)" --cc $(ICXXSRCS) $(SRCS) $(CXXSRCS)
    442. 

  442. 	$(CXXSHARED) -o $(LIBPREFIX)$(TARGET)$(MZSCHEME_SO) $(OBJS) $(IOBJS) $(MZDYNOBJ) $(CPP_DLLIBS) 
    443. 

  443. 

  444. # -----------------------------------------------------------------
    445. 

  445. # Cleaning the mzscheme examples
    446. 

  446. # -----------------------------------------------------------------
    447. 

  447. 

  448. mzscheme_clean:
    449. 

  449. 	rm -f *.@OBJEXT@ *@SO@ *_wrap* *~ .~* core @EXTRA_CLEAN@
    450. 

  450. 

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

  452. #####                          Ocaml                         #####
    453. 

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

  454. 

  455. OCC=@OCAMLC@
    456. 

  456. OCAMLDLGEN=@OCAMLDLGEN@
    457. 

  457. OCAMLFIND=@OCAMLFIND@
    458. 

  458. OCAMLMKTOP=@OCAMLMKTOP@ $(SWIGWHERE)
    459. 

  459. NOLINK ?= false
    460. 

  460. OCAMLPP= -pp "camlp4o ./swigp4.cmo"
    461. 

  461. OCAMLCORE=\
    462. 

  462. 	rm -rf swig.mli swig.ml swigp4.ml && \
    463. 

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

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

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

  466. 	$(OCC) -c swig.mli &&  \
    467. 

  467. 	$(OCC) -c swig.ml &&  \
    468. 

  468. 	$(OCC) -I `camlp4 -where` -pp "camlp4o pa_extend.cmo q_MLast.cmo" \
    469. 

  469. 		-c swigp4.ml
    470. 

  470. 

  471. ocaml_static: $(SRCS)
    472. 

  472. 	$(OCAMLCORE)
    473. 

  473. 	$(SWIG) -ocaml $(SWIGOPT) $(INTERFACE)
    474. 

  474. 	$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
    475. 

  475. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    476. 

  476. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    477. 

  477. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    478. 

  478. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    479. 

  479. 	$(NOLINK) || $(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
    480. 

  480. 		swig.cmo \
    481. 

  481. 		$(INTERFACE:%.i=%.cmo) \
    482. 

  482. 		$(PROGFILE:%.ml=%.cmo) \
    483. 

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

  484. 

  485. ocaml_dynamic: $(SRCS)
    486. 

  486. 	$(OCAMLCORE)
    487. 

  487. 	$(SWIG) -ocaml $(SWIGOPT) $(INTERFACE)
    488. 

  488. 	$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
    489. 

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

  490. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) $(LIBS)
    491. 

  491. 	$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
    492. 

  492. 		$(INTERFACE:%.i=%_dynamic.ml)
    493. 

  493. 	mv $(INTERFACE:%.i=%_dynamic.ml) $(INTERFACE:%.i=%.ml)
    494. 

  494. 	rm $(INTERFACE:%.i=%.mli)
    495. 

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

  496. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    497. 

  497. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    498. 

  498. 	$(NOLINK) || $(OCAMLFIND) \
    499. 

  499. 		$(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
    500. 

  500. 		swig.cmo \
    501. 

  501. 		-package dl -linkpkg \
    502. 

  502. 		$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo)
    503. 

  503. 

  504. ocaml_static_toplevel: $(SRCS)
    505. 

  505. 	$(OCAMLCORE)
    506. 

  506. 	$(SWIG) -ocaml $(SWIGOPT) $(INTERFACE)
    507. 

  507. 	$(OCC) -g -c -ccopt -g -ccopt "$(INCLUDES)" $(ISRCS) $(SRCS)
    508. 

  508. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    509. 

  509. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    510. 

  510. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    511. 

  511. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    512. 

  512. 	$(NOLINK) || $(OCAMLMKTOP) \
    513. 

  513. 		swig.cmo \
    514. 

  514. 		-I `camlp4 -where` camlp4o.cma swigp4.cmo \
    515. 

  515. 		-g -ccopt -g -cclib -g -custom -o $(TARGET)_top \
    516. 

  516. 		$(INTERFACE:%.i=%.cmo) \
    517. 

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

  518. 

  519. ocaml_static_cpp: $(SRCS)
    520. 

  520. 	$(OCAMLCORE)
    521. 

  521. 	$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACE)
    522. 

  522. 	cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
    523. 

  523. 	$(OCC) -cc '$(CXX)' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
    524. 

  524. 		$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
    525. 

  525. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    526. 

  526. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    527. 

  527. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    528. 

  528. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    529. 

  529. 	$(NOLINK) || $(OCC) -g -ccopt -g -cclib -g -custom -o $(TARGET) \
    530. 

  530. 		swig.cmo \
    531. 

  531. 		$(INTERFACE:%.i=%.cmo) \
    532. 

  532. 		$(PROGFILE:%.ml=%.cmo) \
    533. 

  533. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
    534. 

  534. 		-cclib "$(LIBS)" -cc '$(CXX)' 
    535. 

  535. 

  536. ocaml_static_cpp_toplevel: $(SRCS)
    537. 

  537. 	$(OCAMLCORE)
    538. 

  538. 	$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACE)
    539. 

  539. 	cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
    540. 

  540. 	$(OCC) -cc '$(CXX)' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
    541. 

  541. 		$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS)
    542. 

  542. 	$(OCC) -g -c $(INTERFACE:%.i=%.mli)
    543. 

  543. 	$(OCC) -g -c $(INTERFACE:%.i=%.ml)
    544. 

  544. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    545. 

  545. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    546. 

  546. 	$(NOLINK) || $(OCAMLMKTOP) \
    547. 

  547. 		swig.cmo \
    548. 

  548. 		-I `camlp4 -where` camlp4o.cma swigp4.cmo \
    549. 

  549. 		-g -ccopt -g -cclib -g -custom -o $(TARGET)_top \
    550. 

  550. 		$(INTERFACE:%.i=%.cmo) \
    551. 

  551. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
    552. 

  552. 		-cclib "$(LIBS)" -cc '$(CXX)' 
    553. 

  553. 

  554. ocaml_dynamic_cpp: $(SRCS)
    555. 

  555. 	$(OCAMLCORE)
    556. 

  556. 	$(SWIG) -ocaml -c++ $(SWIGOPT) $(INTERFACE)
    557. 

  557. 	cp $(ICXXSRCS) $(ICXXSRCS:%.cxx=%.c)
    558. 

  558. 	$(OCC) -cc '$(CXX)' -g -c -ccopt -g -ccopt "-xc++ $(INCLUDES)" \
    559. 

  559. 		$(ICXXSRCS:%.cxx=%.c) $(SRCS) $(CXXSRCS) -ccopt -fPIC
    560. 

  560. 	$(CXXSHARED) $(CXXFLAGS) -o $(INTERFACE:%.i=%@SO@) \
    561. 

  561. 		$(INTERFACE:%.i=%_wrap.@OBJEXT@) $(OBJS) \
    562. 

  562. 		$(CPP_DLLIBS) $(LIBS)
    563. 

  563. 	$(OCAMLDLGEN) $(INTERFACE:%.i=%.ml) $(INTERFACE:%.i=%@SO@) > \
    564. 

  564. 		$(INTERFACE:%.i=%_dynamic.ml)
    565. 

  565. 	mv $(INTERFACE:%.i=%_dynamic.ml) $(INTERFACE:%.i=%.ml)
    566. 

  566. 	rm $(INTERFACE:%.i=%.mli)
    567. 

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

  568. 	test -z "$(PROGFILE)" || test -f "$(PROGFILE)" && \
    569. 

  569. 		$(OCC) $(OCAMLPP) -c $(PROGFILE)
    570. 

  570. 	$(NOLINK) || $(OCAMLFIND) \
    571. 

  571. 		swig.cmo \
    572. 

  572. 		$(OCC) -cclib -export-dynamic -g -ccopt -g -cclib -g -custom \
    573. 

  573. 		-o $(TARGET) \
    574. 

  574. 		-package dl -linkpkg \
    575. 

  575. 		$(INTERFACE:%.i=%.cmo) $(PROGFILE:%.ml=%.cmo) -cc '$(CXX)'
    576. 

  576. 

  577. ocaml_clean:
    578. 

  578. 	rm -f *.@OBJEXT@ *@SO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ *.cmo *.cmi $(MLFILE) $(MLFILE)i swig.mli swig.cmi swig.ml swig.cmo swigp4.ml swigp4.cmo
    579. 

  579. 

  580. ##################################################################
    581. 

  581. #####                       RUBY                            ######
    582. 

  582. ##################################################################
    583. 

  583. 

  584. # Make sure these locate your Ruby installation
    585. 

  585. RUBY_CFLAGS= @RUBYCCDLFLAGS@ -DHAVE_CONFIG_H
    586. 

  586. RUBY_INCLUDE= @RUBYINCLUDE@
    587. 

  587. RUBY_LIB     = @RUBYLIB@
    588. 

  588. RUBY_DLNK = @RUBYDYNAMICLINKING@
    589. 

  589. 

  590. # ----------------------------------------------------------------
    591. 

  591. # Build a C dynamically loadable module
    592. 

  592. # ----------------------------------------------------------------
    593. 

  593. 

  594. ruby: $(SRCS)
    595. 

  595. 	$(SWIG) -ruby $(SWIGOPT) $(INTERFACE)
    596. 

  596. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(RUBY_INCLUDE)
    597. 

  597. 	$(LDSHARED) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    598. 

  598. 

  599. # -----------------------------------------------------------------
    600. 

  600. # Build a C++ dynamically loadable module
    601. 

  601. # -----------------------------------------------------------------
    602. 

  602. 

  603. ruby_cpp: $(SRCS)
    604. 

  604. 	$(SWIG) -c++ -ruby $(SWIGOPT) $(INTERFACE)
    605. 

  605. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(RUBY_INCLUDE)
    606. 

  606. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(RUBY_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    607. 

  607. 

  608. # -----------------------------------------------------------------
    609. 

  609. # Build statically linked Ruby interpreter
    610. 

  610. #
    611. 

  611. # These should only be used in conjunction with the %include embed.i
    612. 

  612. # library file
    613. 

  613. # -----------------------------------------------------------------
    614. 

  614. 

  615. RUBY_LIBOPTS = @RUBYLINK@ @LIBS@ $(SYSLIBS)
    616. 

  616. 

  617. ruby_static: $(SRCS)
    618. 

  618. 	$(SWIG) -ruby -lembed.i $(SWIGOPT) $(INTERFACE)
    619. 

  619. 	$(CC) $(CFLAGS) $(RUBY_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
    620. 

  620. 	$(RUBY_INCLUDE) $(LIBS) -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
    621. 

  621. 

  622. ruby_cpp_static: $(SRCS)
    623. 

  623. 	$(SWIG) -c++ -ruby -lembed.i $(SWIGOPT) $(INTERFACE)
    624. 

  624. 	$(CXX) $(CFLAGS) $(RUBY_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    625. 

  625. 	$(RUBY_INCLUDE) $(LIBS)  -L$(RUBY_LIB) $(RUBY_LIBOPTS) -o $(TARGET)
    626. 

  626. 

  627. 

  628. # -----------------------------------------------------------------
    629. 

  629. # Cleaning the Ruby examples
    630. 

  630. # -----------------------------------------------------------------
    631. 

  631. 

  632. ruby_clean:
    633. 

  633. 	rm -f *.@OBJEXT@ *@SO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ myruby@EXEEXT@ *.pm
    634. 

  634. 

  635. ##################################################################
    636. 

  636. #####                       PHP                             ######
    637. 

  637. ##################################################################
    638. 

  638. 

  639. # -------------------------------------------------------------------
    640. 

  640. # Build a PHP4 dynamically loadable module (C)
    641. 

  641. # -------------------------------------------------------------------
    642. 

  642. 

  643. PHP4_INCLUDE = @PHP4INC@
    644. 

  644. PHP4_SO      = @PHP4_SO@
    645. 

  645. 

  646. php4: $(SRCS)
    647. 

  647. 	$(SWIG) -php4 -cppext cxx $(SWIGOPT) $(INTERFACE)
    648. 

  648. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(ISRCS) $(INCLUDES) $(PHP4_INCLUDE)
    649. 

  649. 	$(LDSHARED) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(PHP4_SO)
    650. 

  650. 

  651. # --------------------------------------------------------------------
    652. 

  652. # Build a PHP4 dynamically loadable module (C++)
    653. 

  653. # --------------------------------------------------------------------
    654. 

  654. 

  655. php4_cpp: $(SRCS)
    656. 

  656. 	$(SWIG) -php4 -cppext cxx -c++ $(SWIGOPT) $(INTERFACE)
    657. 

  657. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PHP4_INCLUDE)
    658. 

  658. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(PHP4_SO)
    659. 

  659. 

  660. # -----------------------------------------------------------------
    661. 

  661. # Running a PHP4 example
    662. 

  662. # -----------------------------------------------------------------
    663. 

  663. 

  664. PHP4=@PHP4@
    665. 

  665. 

  666. php4_run: 
    667. 

  667. 	env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(PHP4) -q -d extension_dir=. $(SCRIPT)
    668. 

  668. 

  669. # -----------------------------------------------------------------
    670. 

  670. # Cleaning the PHP4 examples
    671. 

  671. # -----------------------------------------------------------------
    672. 

  672. 

  673. php4_clean:
    674. 

  674. 	rm -f *.@OBJEXT@ *$(SO) *_wrap* *~ .~* core @EXTRA_CLEAN@ *.php
    675. 

  675. 

  676. ##################################################################
    677. 

  677. #####                       Pike                            ######
    678. 

  678. ##################################################################
    679. 

  679. 

  680. # Make sure these locate your Pike installation
    681. 

  681. PIKE_CFLAGS  = @PIKECCDLFLAGS@ -DHAVE_CONFIG_H
    682. 

  682. PIKE_INCLUDE = @PIKEINCLUDE@
    683. 

  683. PIKE_LIB     = @PIKELIB@
    684. 

  684. PIKE_DLNK    = @PIKEDYNAMICLINKING@
    685. 

  685. 

  686. # ----------------------------------------------------------------
    687. 

  687. # Build a C dynamically loadable module
    688. 

  688. # ----------------------------------------------------------------
    689. 

  689. 

  690. pike: $(SRCS)
    691. 

  691. 	$(SWIG) -pike $(SWIGOPT) $(INTERFACE)
    692. 

  692. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ISRCS) $(SRCS) $(INCLUDES) $(PIKE_INCLUDE)
    693. 

  693. 	$(LDSHARED) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    694. 

  694. 

  695. # -----------------------------------------------------------------
    696. 

  696. # Build a C++ dynamically loadable module
    697. 

  697. # -----------------------------------------------------------------
    698. 

  698. 

  699. pike_cpp: $(SRCS)
    700. 

  700. 	$(SWIG) -c++ -pike $(SWIGOPT) $(INTERFACE)
    701. 

  701. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) $(PIKE_INCLUDE)
    702. 

  702. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(PIKE_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO)
    703. 

  703. 

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

  705. # Build statically linked Pike interpreter
    706. 

  706. #
    707. 

  707. # These should only be used in conjunction with the %include embed.i
    708. 

  708. # library file
    709. 

  709. # -----------------------------------------------------------------
    710. 

  710. 

  711. PIKE_LIBOPTS = @PIKELINK@ @LIBS@ $(SYSLIBS)
    712. 

  712. 

  713. pike_static: $(SRCS)
    714. 

  714. 	$(SWIG) -pike -lembed.i $(SWIGOPT) $(INTERFACE)
    715. 

  715. 	$(CC) $(CFLAGS) $(PIKE_CFLAGS) @LINKFORSHARED@ $(ISRCS) $(SRCS) $(INCLUDES) \
    716. 

  716. 	$(PIKE_INCLUDE) $(LIBS) -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
    717. 

  717. 

  718. pike_cpp_static: $(SRCS)
    719. 

  719. 	$(SWIG) -c++ -pike -lembed.i $(SWIGOPT) $(INTERFACE)
    720. 

  720. 	$(CXX) $(CFLAGS) $(PIKE_CFLAGS) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(INCLUDES) \
    721. 

  721. 	$(PIKE_INCLUDE) $(LIBS)  -L$(PIKE_LIB) $(PIKE_LIBOPTS) -o $(TARGET)
    722. 

  722. 

  723. # -----------------------------------------------------------------
    724. 

  724. # Cleaning the Pike examples
    725. 

  725. # -----------------------------------------------------------------
    726. 

  726. 

  727. pike_clean:
    728. 

  728. 	rm -f *.@OBJEXT@ *$(SO) *_wrap* *~ .~* core @EXTRA_CLEAN@ mypike@EXEEXT@ 
    729. 

  729. 

  730. 

  731. ##################################################################
    732. 

  732. #####                      Chicken                          ######
    733. 

  733. ##################################################################
    734. 

  734. 

  735. CHICKEN = @CHICKEN@
    736. 

  736. CHICKEN_CSC = @CHICKEN_CSC@
    737. 

  737. CHICKEN_LIBOPTS = @CHICKENLIB@  $(SYSLIBS)
    738. 

  738. CHICKEN_SHAREDLIBOPTS = @CHICKENSHAREDLIB@  $(SYSLIBS)
    739. 

  739. CHICKEN_CFLAGS = @CHICKENOPTS@
    740. 

  740. CHICKENOPTS = -quiet
    741. 

  741. CHICKEN_MAIN =
    742. 

  742. 

  743. # SWIG produces $(ISRCS) (the C wrapper file) 
    744. 

  744. # and $(CHICKEN_GENERATED_SCHEME) (the Scheme wrapper file):
    745. 

  745. CHICKEN_GENERATED_SCHEME = $(INTERFACE:.i=.scm)
    746. 

  746. CHICKEN_COMPILED_SCHEME = $(INTERFACE:.i=_chicken.c)
    747. 

  747. CHICKEN_COMPILED_OBJECT = $(CHICKEN_COMPILED_SCHEME:.c=.@OBJEXT@)
    748. 

  748. 

  749. # flags for the main chicken sources (only used when compiling staticly)
    750. 

  750. CHICKEN_COMPILED_MAIN = $(CHICKEN_MAIN:.scm=_chicken.c)
    751. 

  751. CHICKEN_COMPILED_MAIN_OBJECT = $(CHICKEN_COMPILED_MAIN:.c=.@OBJEXT@)
    752. 

  752. 

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

  754. # Build a CHICKEN dynamically loadable module
    755. 

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

  756. 

  757. chicken: $(SRCS)
    758. 

  758. 	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACE)
    759. 

  759. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    760. 

  760. 		-dynamic -feature chicken-compile-shared \
    761. 

  761. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    762. 

  762. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    763. 

  763. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) $(CHICKEN_COMPILED_SCHEME)
    764. 

  764. 	$(LDSHARED) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
    765. 

  765. 		$(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
    766. 

  766. 

  767. chicken_cpp: $(CXXSRCS) $(CHICKSRCS)
    768. 

  768. 	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACE)
    769. 

  769. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    770. 

  770. 		-dynamic -feature chicken-compile-shared \
    771. 

  771. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    772. 

  772. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    773. 

  773. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) $(CHICKEN_COMPILED_SCHEME)
    774. 

  774. 	$(CXXSHARED) $(CHICKEN_COMPILED_OBJECT) $(OBJS) $(IOBJS) \
    775. 

  775. 		$(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(LIBPREFIX)$(TARGET)$(SO)
    776. 

  776. 

  777. # -----------------------------------------------------------------
    778. 

  778. # Build statically linked CHICKEN interpreter
    779. 

  779. # -----------------------------------------------------------------
    780. 

  780. 

  781. # The following two targets are also used by the test suite
    782. 

  782. chicken_static: $(SRCS) $(CHICKSRCS)
    783. 

  783. 	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACE)
    784. 

  784. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    785. 

  785. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    786. 

  786. 	$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
    787. 

  787. 		-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
    788. 

  788. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    789. 

  789. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ISRCS) $(SRCS) \
    790. 

  790. 		$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
    791. 

  791. 	$(CC) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
    792. 

  792. 		$(OBJS) $(IOBJS) $(LIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
    793. 

  793. 

  794. chicken_static_cpp: $(CXXSRCS) $(CHICKSRCS)
    795. 

  795. 	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACE)
    796. 

  796. 	$(CHICKEN) $(CHICKEN_GENERATED_SCHEME) $(CHICKENOPTS) \
    797. 

  797. 		-output-file $(CHICKEN_COMPILED_SCHEME)
    798. 

  798. 	$(CHICKEN) $(CHICKEN_MAIN) $(CHICKENOPTS) \
    799. 

  799. 		-output-file $(CHICKEN_MAIN:.scm=_chicken.c)
    800. 

  800. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(CHICKEN_CFLAGS) \
    801. 

  801. 		$(INCLUDES) $(CHICKEN_INCLUDE) $(ICXXSRCS) $(SRCS) $(CXXSRCS) \
    802. 

  802. 		$(CHICKEN_COMPILED_SCHEME) $(CHICKEN_COMPILED_MAIN)
    803. 

  803. 	$(CXX) $(CHICKEN_COMPILED_OBJECT) $(CHICKEN_COMPILED_MAIN_OBJECT) \
    804. 

  804. 		$(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) $(CHICKEN_SHAREDLIBOPTS) -o $(TARGET)
    805. 

  805. 

  806. # ----------------------------------------------------------------
    807. 

  807. # Build a shared library using csc
    808. 

  808. # ----------------------------------------------------------------
    809. 

  809. 

  810. chicken_csc:
    811. 

  811. 	$(SWIG) -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACE)
    812. 

  812. 	$(CHICKEN_CSC) -sv $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ISRCS) -o $(TARGET)$(SO)
    813. 

  813. 

  814. chicken_csc_cpp:
    815. 

  815. 	$(SWIG) -c++ -chicken $(SWIGOPT) $(INCLUDE) $(INTERFACE)
    816. 

  816. 	$(CHICKEN_CSC) -sv $(CHICKEN_GENERATED_SCHEME) $(SRCS) $(ICXXSRCS) $(CXXSRCS) -o $(TARGET)$(SO)
    817. 

  817. 

  818. chicken_clean:
    819. 

  819. 	rm -f *.@OBJEXT@ *$(SO) *_wrap* *~ .~* core @EXTRA_CLEAN@ *_chicken*
    820. 

  820. 

  821. ##################################################################
    822. 

  822. #####                      CSHARP                           ######
    823. 

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

  824. 

  825. # Extra CSharp specific dynamic linking options
    826. 

  826. CSHARP_DLNK  = @CSHARPDYNAMICLINKING@
    827. 

  827. CSHARP_LIBPREFIX = @CSHARPLIBRARYPREFIX@
    828. 

  828. CSHARPCOMPILER = @CSHARPCOMPILER@
    829. 

  829. CSHARPCILINTERPRETER = @CSHARPCILINTERPRETER@
    830. 

  830. CSHARPCFLAGS = @CSHARPCFLAGS@
    831. 

  831. CSHARPSO = @CSHARPSO@
    832. 

  832. 

  833. # ----------------------------------------------------------------
    834. 

  834. # Build a CSharp dynamically loadable module (C)
    835. 

  835. # ----------------------------------------------------------------
    836. 

  836. 

  837. csharp: $(SRCS)
    838. 

  838. 	$(SWIG) -csharp $(SWIGOPT) $(INTERFACE)
    839. 

  839. 	$(CC) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(ISRCS) $(INCLUDES)
    840. 

  840. 	$(LDSHARED) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
    841. 

  841. 

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

  843. # Build a CSharp dynamically loadable module (C++)
    844. 

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

  845. 

  846. csharp_cpp: $(SRCS)
    847. 

  847. 	$(SWIG) -csharp -c++ $(SWIGOPT) $(INTERFACE)
    848. 

  848. 	$(CXX) -c $(CCSHARED) $(CFLAGS) $(CSHARPCFLAGS) $(SRCS) $(CXXSRCS) $(ICXXSRCS) $(INCLUDES)
    849. 

  849. 	$(CXXSHARED) $(OBJS) $(IOBJS) $(CSHARP_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(CSHARP_LIBPREFIX)$(TARGET)$(CSHARPSO)
    850. 

  850. 

  851. # ----------------------------------------------------------------
    852. 

  852. # Compile CSharp files
    853. 

  853. # ----------------------------------------------------------------
    854. 

  854. 

  855. csharp_compile: $(SRCS)
    856. 

  856. 	$(CSHARPCOMPILER) $(CSHARPFLAGS) $(CSHARPSRCS)
    857. 

  857. 

  858. # -----------------------------------------------------------------
    859. 

  859. # Cleaning the CSharp examples
    860. 

  860. # -----------------------------------------------------------------
    861. 

  861. 

  862. csharp_clean:
    863. 

  863. 	rm -f *.@OBJEXT@ *@CSHARPSO@ *_wrap* *~ .~* core @EXTRA_CLEAN@ runme runme.exe gc.log `find . -name \*.cs | grep -v runme.cs`
    864.