PageRenderTime 34ms CodeModel.GetById 21ms RepoModel.GetById 0ms app.codeStats 0ms

/CS/migrated/tags/PRE_CSARRAY_SIZE_T_INDICES/configure.ac

#
m4 | 1622 lines | 925 code | 272 blank | 425 comment | 0 complexity | 6ac3c0ce8db342ef34d21c7b36940c09 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, LGPL-2.0 
    

  1. #                                               -*- Autoconf -*-
    2. 

  2. #==============================================================================
    3. 

  3. # Copyright (C)2003,2004 by Eric Sunshine <sunshine@sunshineco.com>
    4. 

  4. #
    5. 

  5. # Autoconf input script for Crystal Space.  Process this file with
    6. 

  6. # CS/bin/autogen.sh to produce a configure script.
    7. 

  7. #==============================================================================
    8. 

  8. AC_PREREQ([2.56])
    9. 

  9. 

  10. 

  11. #------------------------------------------------------------------------------
    12. 

  12. # cs_version_number
    13. 

  13. #	Keep this value synchronized with CS/include/csver.h.
    14. 

  14. #------------------------------------------------------------------------------
    15. 

  15. m4_define([cs_version_number], [0.98])
    16. 

  16. 

  17. 

  18. 

  19. #------------------------------------------------------------------------------
    20. 

  20. # cs_lib_paths_default
    21. 

  21. #	Whitespace delimited list of directory tuples in which to search, by
    22. 

  22. #	default, for external libraries.  Each list item can specify an
    23. 

  23. #	include|library directory tuple (for example, "/usr/include|/usr/lib"),
    24. 

  24. #	or a single directory (for example, "/usr").  If the second form is
    25. 

  25. #	used, then the directory itself is searched first.  If the external
    26. 

  26. #	resource is not found, then "include" and "lib" subdirectories of the
    27. 

  27. #	directory are searched.  Thus, specifying "/proj" is shorthand for
    28. 

  28. #	"/proj|/proj /proj/include|/proj/lib".
    29. 

  29. #
    30. 

  30. # Present Cases:
    31. 

  31. #	/usr/local -- Not all compilers search here by default, so we specify
    32. 

  32. #		it manually.
    33. 

  33. #	/sw -- Fink, the MacOS/X manager of Unix packages, installs here by
    34. 

  34. #		default.
    35. 

  35. #------------------------------------------------------------------------------
    36. 

  36. m4_define([cs_lib_paths_default],
    37. 

  37.     [/usr/local/include|/usr/local/lib /sw/include|/sw/lib])
    38. 

  38. 

  39. 

  40. 

  41. #==============================================================================
    42. 

  42. # INITIALIZATION
    43. 

  43. #==============================================================================
    44. 

  44. AC_INIT([crystal], [cs_version_number], [crystal-main@lists.sourceforge.net])
    45. 

  45. CS_PACKAGEINFO([Crystal Space],
    46. 

  46.     [Copyright (C)1998-2004 Jorrit Tyberghein and others],
    47. 

  47.     [http://crystal.sourceforge.net/])
    48. 

  48. AC_CONFIG_SRCDIR([libs/csutil/Jamfile])
    49. 

  49. AC_CONFIG_AUX_DIR([mk/autoconf])
    50. 

  50. AC_CANONICAL_HOST
    51. 

  51. 

  52. 

  53. 

  54. #------------------------------------------------------------------------------
    55. 

  55. # Check for compilers and common tools.
    56. 

  56. #------------------------------------------------------------------------------
    57. 

  57. AC_PROG_CC
    58. 

  58. CS_EMIT_BUILD_PROPERTY([CMD.CC], [$CC])
    59. 

  59. 

  60. AC_PROG_CXX
    61. 

  61. CS_EMIT_BUILD_PROPERTY([CMD.C++], [$CXX])
    62. 

  62. 

  63. # C++ compiler is used as linker.
    64. 

  64. CS_EMIT_BUILD_PROPERTY([CMD.LINK], [AS_ESCAPE([$(CMD.C++)])])
    65. 

  65. 

  66. AS_IF([test $ac_compiler_gnu = yes],
    67. 

  67.     [cs_compiler_name=GCC CS_HEADER_PROPERTY([COMP_GCC])],
    68. 

  68.     [cs_compiler_name="AS_TR_CPP([$CXX])"])
    69. 

  69. CS_EMIT_BUILD_PROPERTY([COMPILER.TYPE], [$cs_compiler_name])
    70. 

  70. CS_HEADER_PROPERTY([CS_COMPILER_NAME],
    71. 

  71.     [AS_ESCAPE(["])$cs_compiler_name[]AS_ESCAPE(["])])
    72. 

  72. 

  73. AC_PROG_RANLIB
    74. 

  74. CS_EMIT_BUILD_PROPERTY([RANLIB], [$RANLIB])
    75. 

  75. 

  76. AC_CHECK_TOOLS([DLLTOOL], [dlltool])
    77. 

  77. CS_EMIT_BUILD_PROPERTY([CMD.DLLTOOL], [$DLLTOOL])
    78. 

  78. 

  79. AC_CHECK_TOOLS([DLLWRAP], [dllwrap])
    80. 

  80. CS_EMIT_BUILD_PROPERTY([CMD.DLLWRAP], [$DLLWRAP])
    81. 

  81. 

  82. AC_CHECK_TOOLS([WINDRES], [windres])
    83. 

  83. CS_EMIT_BUILD_PROPERTY([CMD.WINDRES], [$WINDRES])
    84. 

  84. 

  85. AC_CHECK_TOOLS([OBJCOPY], [objcopy])
    86. 

  86. AS_IF([test -n "$OBJCOPY"],
    87. 

  87.     [CS_EMIT_BUILD_PROPERTY([OBJCOPY.AVAILABLE], [yes])
    88. 

  88.     CS_EMIT_BUILD_PROPERTY([CMD.OBJCOPY], [$OBJCOPY])])
    89. 

  89. 

  90. AC_CHECK_PROGS([FLEX], [flex])
    91. 

  91. CS_EMIT_BUILD_PROPERTY([CMD.FLEX], [$FLEX])
    92. 

  92. 

  93. AC_CHECK_PROGS([BISON], [bison])
    94. 

  94. AS_IF([test -n "$BISON"],
    95. 

  95.     [CS_CHECK_PROG_VERSION([bison], [$BISON --version], [1.35], [9.9],
    96. 

  96. 	[CS_EMIT_BUILD_PROPERTY([CMD.BISON], [$BISON])])])
    97. 

  97. 

  98. AC_CHECK_PROGS([DOXYGEN], [doxygen])
    99. 

  99. CS_EMIT_BUILD_PROPERTY([CMD.DOXYGEN], [$DOXYGEN])
    100. 

  100. 

  101. AC_CHECK_PROGS([TEXI2DVI], [texi2dvi])
    102. 

  102. CS_EMIT_BUILD_PROPERTY([CMD.TEXI2DVI], [$TEXI2DVI])
    103. 

  103. 

  104. AC_CHECK_PROGS([DVIPS], [dvips])
    105. 

  105. CS_EMIT_BUILD_PROPERTY([CMD.DVIPS], [$DVIPS])
    106. 

  106. 

  107. AC_CHECK_PROGS([DVIPDF], [dvipdf])
    108. 

  108. CS_EMIT_BUILD_PROPERTY([CMD.DVIPDF], [$DVIPDF])
    109. 

  109. 

  110. AC_CHECK_PROGS([MAKEINFO], [makeinfo])
    111. 

  111. CS_EMIT_BUILD_PROPERTY([CMD.MAKEINFO], [$MAKEINFO])
    112. 

  112. 

  113. AC_CHECK_PROGS([INSTALL], [install])
    114. 

  114. CS_EMIT_BUILD_PROPERTY([INSTALL], [$INSTALL])
    115. 

  115. 

  116. AC_CHECK_PROGS([SWIG], [swig])
    117. 

  117. AS_IF([test -n "$SWIG"],
    118. 

  118.     [CS_CHECK_PROG_VERSION([swig], [$SWIG -version 2>&1], [1.3.14],
    119. 

  119. 	[9.9|.9], [CS_EMIT_BUILD_PROPERTY([CMD.SWIG], [$SWIG])])])
    120. 

  120. 

  121. CS_CHECK_LIBTOOL
    122. 

  122. CS_EMIT_BUILD_PROPERTY([LIBTOOL], [$LIBTOOL])
    123. 

  123. CS_EMIT_BUILD_PROPERTY([APPLE_LIBTOOL], [$APPLE_LIBTOOL])
    124. 

  124. 

  125. CS_CHECK_MKDIR
    126. 

  126. CS_EMIT_BUILD_PROPERTY([CMD.MKDIR], [$MKDIR])
    127. 

  127. CS_EMIT_BUILD_PROPERTY([CMD.MKDIRS], [$MKDIRS])
    128. 

  128. 

  129. 

  130. 

  131. #------------------------------------------------------------------------------
    132. 

  132. # In order to avoid alienating users by forcing them to install and use Jam,
    133. 

  133. # config.status is instructed (see far below) to build Jam on the user's behalf
    134. 

  134. # from local sources, and to place the executable in the root of the build
    135. 

  135. # directory.  When checking for Jam, in addition to PATH, we also look in root
    136. 

  136. # of the build directory since we might already have built Jam on a previous
    137. 

  137. # configure run.
    138. 

  138. #
    139. 

  139. # IMPLEMENTATION NOTES
    140. 

  140. #
    141. 

  141. # The Crystal Space build system supports Jam versions starting with 2.4.
    142. 

  142. # Earlier versions are rejected. Examples of rejected versions include Apple's
    143. 

  143. # highly modified Jam (based upon 2.2.1), and ftjam (based upon
    144. 

  144. # 2.3.2). BoostJam reports its version number as 3.1.9 (or greater), though it
    145. 

  145. # is actually based upon Jam 2.4. Since we accept 2.4, and since 3.1.9 passes
    146. 

  146. # the "jam -v >= 2.4" assertion, this version anomaly is not a problem.
    147. 

  147. #
    148. 

  148. # We also check for 'make', since it is used to build Jam locally, when needed.
    149. 

  149. #------------------------------------------------------------------------------
    150. 

  150. m4_define([cs_jam_local_exe], [jam$EXEEXT])
    151. 

  151. 

  152. AC_PATH_PROGS([JAM], [jam], [], [$PATH$PATH_SEPARATOR.])
    153. 

  153. AS_IF([test -n "$JAM"],
    154. 

  154.     [CS_CHECK_PROG_VERSION([jam], ["$JAM" -v 2>&1], [2.4], [9.9|.9],
    155. 

  155. 	[cs_prog_jam_okay=yes], [cs_prog_jam_okay=no])],
    156. 

  156.     [cs_prog_jam_okay=no])
    157. 

  157. 

  158. AS_IF([test $cs_prog_jam_okay != yes],
    159. 

  159.     [JAM=./cs_jam_local_exe CS_NEED_LOCAL_JAM=yes])
    160. 

  160. CS_EMIT_BUILD_PROPERTY([JAM], [$JAM])
    161. 

  161. 

  162. AC_CHECK_PROGS([MAKE], [gnumake gmake make])
    163. 

  163. 

  164. 

  165. 

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

  167. # The cs-win32libs package is a convenience archive made available to Windows
    168. 

  168. # users of Crystal Space.  It contains common libraries, headers, and tools
    169. 

  169. # (such as zlib, libjpeg, cal3d, etc.) usable by MSVC, Mingw/MSYS, and Cygwin
    170. 

  170. # users.  It saves users the bother of having to install these packages
    171. 

  171. # manually one at a time.
    172. 

  172. #------------------------------------------------------------------------------
    173. 

  173. AC_CHECK_TOOLS([CSLIBS_CONFIG], [cslibs-config])
    174. 

  174. AS_IF([test $ac_compiler_gnu = yes],
    175. 

  175.     [cs_cv_cslibs_compiler="--compiler gcc-`$CXX -dumpversion`"])
    176. 

  176. AC_CACHE_CHECK([for cslibs package], [cs_cv_cslibs],
    177. 

  177.     [AS_IF([test -n "$CSLIBS_CONFIG"],
    178. 

  178. 	[cs_cv_cslibs=yes
    179. 

  179. 	cs_cv_cslibs_cflags=`
    180. 

  180. 	    AC_RUN_LOG([$CSLIBS_CONFIG --cflags $cs_cv_cslibs_compiler])`
    181. 

  181. 	cs_cv_cslibs_lflags=`
    182. 

  182. 	    AC_RUN_LOG([$CSLIBS_CONFIG --lflags $cs_cv_cslibs_compiler])`
    183. 

  183. 	cs_cv_cslibs_binpath=`
    184. 

  184. 	    AC_RUN_LOG([$CSLIBS_CONFIG --binpath $cs_cv_cslibs_compiler])`],
    185. 

  185. 	[cs_cv_cslibs=no])])
    186. 

  186. AS_IF([test $cs_cv_cslibs = yes],
    187. 

  187.     [CFLAGS="$CFLAGS $cs_cv_cslibs_cflags"
    188. 

  188.     CPPFLAGS="$CPPFLAGS $cs_cv_cslibs_cflags"
    189. 

  189.     LDFLAGS="$LDFLAGS $cs_cv_cslibs_lflags"
    190. 

  190.     PATH="$cs_cv_cslibs_binpath$PATH_SEPARATOR$PATH"])
    191. 

  191. 

  192. 

  193. 

  194. #------------------------------------------------------------------------------
    195. 

  195. # Check for NASM and extensions (such as %xdefine) which we require.
    196. 

  196. #------------------------------------------------------------------------------
    197. 

  197. AC_CHECK_TOOLS([NASM], [nasmw nasm])
    198. 

  198. AS_IF([test -n "$NASM"],
    199. 

  199.     [AC_CACHE_CHECK([if nasm is sufficiently recent], [cs_cv_prog_nasm_ok],
    200. 

  200. 	[echo "%xdefine TEST" > conftest.asm
    201. 

  201. 	AS_IF([AC_RUN_LOG(
    202. 

  202. 	    [$NASM conftest.asm -o conftest.$OBJEXT 1>&2])],
    203. 

  203. 	    [cs_cv_prog_nasm_ok=yes], [cs_cv_prog_nasm_ok=no])
    204. 

  204. 	rm -f conftest.*])
    205. 

  205.     AS_IF([test $cs_cv_prog_nasm_ok = yes],
    206. 

  206. 	[CS_EMIT_BUILD_PROPERTY([NASM.AVAILABLE], [yes])
    207. 

  207. 	CS_EMIT_BUILD_PROPERTY([CMD.NASM], [$NASM])
    208. 

  208. 	CS_HEADER_PROPERTY([DO_NASM])])])
    209. 

  209. 

  210. 

  211. 

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

  213. # Check for typical required libraries (libm, libmx, libdl, libnsl).
    214. 

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

  215. AC_DEFUN([CS_CHECK_COMMON_LIBS],
    216. 

  216.     [AC_LANG_PUSH([C])
    217. 

  217.     AC_CHECK_LIB([m], [pow], [cs_cv_libm_libs=-lm], [cs_cv_libm_libs=])
    218. 

  218.     AC_CHECK_LIB([m], [cosf], [cs_cv_libm_libs=-lm])
    219. 

  219.     AC_CHECK_LIB([mx], [cosf])
    220. 

  220.     AC_CHECK_LIB([dl], [dlopen], [cs_cv_libdl_libs=-ldl], [cs_cv_libdl_libs=])
    221. 

  221.     AC_CHECK_LIB([nsl], [gethostbyname])
    222. 

  222.     AC_LANG_POP([C])])
    223. 

  223. 

  224. CS_CHECK_COMMON_LIBS
    225. 

  225. 

  226. AS_IF([test $ac_cv_lib_m_pow = yes || test $ac_cv_lib_m_cosf = yes],
    227. 

  227.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lm], [+])])
    228. 

  228. AS_IF([test $ac_cv_lib_mx_cosf = yes],
    229. 

  229.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lmx], [+])])
    230. 

  230. AS_IF([test $ac_cv_lib_dl_dlopen = yes],
    231. 

  231.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-ldl], [+])])
    232. 

  232. AS_IF([test $ac_cv_lib_nsl_gethostbyname = yes],
    233. 

  233.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lnsl], [+])])
    234. 

  234. 

  235. AS_IF([test $ac_cv_lib_m_cosf = no && test $ac_cv_lib_mx_cosf = no],
    236. 

  236.     [CS_HEADER_PROPERTY([CS_USE_FAKE_MATH_H_FLOAT_FUNCS])])
    237. 

  237. 

  238. 

  239. 

  240. #------------------------------------------------------------------------------
    241. 

  241. # Check for pthread.  Also check if pthread implementation supports the
    242. 

  242. # recursive mutex extension.
    243. 

  243. #------------------------------------------------------------------------------
    244. 

  244. CS_CHECK_PTHREAD([cygwin*])
    245. 

  245. CS_EMIT_BUILD_RESULT([cs_cv_sys_pthread], [PTHREAD])
    246. 

  246. AS_IF([test $cs_cv_sys_pthread_recursive != no],
    247. 

  247.     [CS_HEADER_PROPERTY([CS_PTHREAD_MUTEX_RECURSIVE],
    248. 

  248. 	[$cs_cv_sys_pthread_recursive])])
    249. 

  249. 

  250. 

  251. 

  252. #------------------------------------------------------------------------------
    253. 

  253. # Check if RTLD_NOW dlopen() flag is available; some installations (OpenBSD,
    254. 

  254. # for example) provide only RTLD_LAZY.
    255. 

  255. #------------------------------------------------------------------------------
    256. 

  256. AC_DEFUN([CS_CHECK_RTLD],
    257. 

  257.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])
    258. 

  258.     CS_CHECK_BUILD([for RTLD_NOW], [cs_cv_sys_rtld_now],
    259. 

  259. 	[AC_LANG_PROGRAM([[#include <dlfcn.h>]], [dlopen(0, RTLD_NOW)])],
    260. 

  260. 	[], [], [CS_HEADER_PROPERTY([CS_RTLD_NOW_AVAILABLE])], [], [],
    261. 

  261. 	[], [], [$cs_cv_libdl_libs])])
    262. 

  262. 

  263. CS_CHECK_RTLD
    264. 

  264. 

  265. 

  266. #------------------------------------------------------------------------------
    267. 

  267. # Determine host platform.  Recognized families: Unix, Windows, MacOS/X.
    268. 

  268. #
    269. 

  269. # CS_CHECK_HOST
    270. 

  270. #	Sets the shell variables cs_host_target and cs_host_family.  Client
    271. 

  271. #	code can use these variables to emit appropriate Jam variables and
    272. 

  272. #	OS_FOO header define.
    273. 

  273. #------------------------------------------------------------------------------
    274. 

  274. AC_DEFUN([CS_CHECK_HOST],
    275. 

  275.     [AC_REQUIRE([AC_CANONICAL_HOST])
    276. 

  276.     cs_host_os_normalized=''
    277. 

  277.     case $host_os in
    278. 

  278. 	mingw*|cygwin*)
    279. 

  279. 	    cs_host_target=win32gcc
    280. 

  280. 	    cs_host_family=windows
    281. 

  281. 	    ;;
    282. 

  282. 	darwin*)
    283. 

  283. 	    _CS_CHECK_HOST_DARWIN
    284. 

  284. 	    ;;
    285. 

  285. 	*)
    286. 

  286. 	    # Everything else is assumed to be Unix or Unix-like.
    287. 

  287. 	    cs_host_target=unix
    288. 

  288. 	    cs_host_family=unix
    289. 

  289. 	    ;;
    290. 

  290.     esac])
    291. 

  291. 

  292. AC_DEFUN([_CS_CHECK_HOST_DARWIN],
    293. 

  293.     [AC_REQUIRE([AC_PROG_CC])
    294. 

  294.     AC_REQUIRE([AC_PROG_CXX])
    295. 

  295. 

  296.     # Both MacOS/X and Darwin are identified via $host_os as "darwin".  We need
    297. 

  297.     # a way to distinguish between the two.  If Carbon.h is present, then
    298. 

  298.     # assume MacOX/S; if not, assume Darwin.  If --with-x=yes was invoked, and
    299. 

  299.     # Carbon.h is present, then assume that user wants to cross-build for
    300. 

  300.     # Darwin even though build host is MacOS/X.  Implementation note: At least
    301. 

  301.     # one MacOS/X user switches between gcc 2.95 and gcc 3.3 with a script
    302. 

  302.     # which toggles the values of CC, CXX, and CPP.  Unfortunately, CPP was
    303. 

  303.     # being set to run the preprocessor directly ("cpp", for instance) rather
    304. 

  304.     # than running it via the compiler ("gcc -E", for instance).  The problem
    305. 

  305.     # with running the preprocessor directly is that __APPLE__ and __GNUC__ are
    306. 

  306.     # not defined, which causes the Carbon.h check to fail.  We avoid this
    307. 

  307.     # problem by supplying a non-empty fourth argument to AC_CHECK_HEADER(),
    308. 

  308.     # which causes it to test compile the header only (which is a more robust
    309. 

  309.     # test), rather than also testing it via the preprocessor.
    310. 

  310. 

  311.     AC_CHECK_HEADER([Carbon/Carbon.h],
    312. 

  312. 	[cs_host_macosx=yes], [cs_host_macosx=no], [/* force compile */])
    313. 

  313. 

  314.     AS_IF([test $cs_host_macosx = yes],
    315. 

  315. 	[AC_MSG_CHECKING([for --with-x])
    316. 

  316. 	AS_IF([test "${with_x+set}" = set && test "$with_x" = "yes"],
    317. 

  317. 	    [AC_MSG_RESULT([yes (assume Darwin)])
    318. 

  318. 	    cs_host_macosx=no],
    319. 

  319. 	    [AC_MSG_RESULT([no])])])
    320. 

  320. 

  321.     AS_IF([test $cs_host_macosx = yes],
    322. 

  322. 	[cs_host_target=macosx
    323. 

  323. 	cs_host_family=unix
    324. 

  324. 	cs_host_os_normalized='MacOS/X'
    325. 

  325. 

  326. 	CS_HEADER_PROPERTY([OS_MACOSX])
    327. 

  327. 	CS_HEADER_PROPERTY([CS_24BIT_PIXEL_LAYOUT], [CS_24BIT_PIXEL_ARGB])
    328. 

  328. 

  329. 	# We assume that we always have CoreAudio available on MacOS/X.
    330. 

  330. 	CS_EMIT_BUILD_PROPERTY([COREAUDIO.AVAILABLE], [yes])
    331. 

  331. 	CS_EMIT_BUILD_PROPERTY([COREAUDIO.LFLAGS], [-framework CoreAudio])
    332. 

  332. 

  333. 	AC_CACHE_CHECK([for Objective-C compiler], [cs_cv_prog_objc],
    334. 

  334. 	    [cs_cv_prog_objc="$CC"])
    335. 

  335. 	CS_EMIT_BUILD_PROPERTY([CMD.OBJC], [$cs_cv_prog_objc])
    336. 

  336. 	AC_CACHE_CHECK([for Objective-C++ compiler], [cs_cv_prog_objcxx],
    337. 

  337. 	    [cs_cv_prog_objcxx="$CXX"])
    338. 

  338. 	CS_EMIT_BUILD_PROPERTY([CMD.OBJC++], [$cs_cv_prog_objcxx])],
    339. 

  339. 

  340. 	[cs_host_target=unix
    341. 

  341. 	cs_host_family=unix])])
    342. 

  342. 

  343. CS_CHECK_HOST
    344. 

  344. 

  345. case $cs_host_family in
    346. 

  346.     windows)
    347. 

  347. 	CS_HEADER_PROPERTY([OS_WIN32])
    348. 

  348. 	AS_IF([test -z "$cs_host_os_normalized"],
    349. 

  349. 	    [cs_host_os_normalized='Win32'])
    350. 

  350. 	;;
    351. 

  351.     unix)
    352. 

  352. 	CS_HEADER_PROPERTY([OS_UNIX])
    353. 

  353. 	AS_IF([test -z "$cs_host_os_normalized"],
    354. 

  354. 	    [cs_host_os_normalized='Unix'])
    355. 

  355. 	;;
    356. 

  356. esac
    357. 

  357. 

  358. cs_host_os_normalized_uc="AS_TR_CPP([$cs_host_os_normalized])"
    359. 

  359. CS_EMIT_BUILD_PROPERTY([TARGET.OS], [$cs_host_os_normalized_uc])
    360. 

  360. CS_EMIT_BUILD_PROPERTY([TARGET.OS.NORMALIZED], [$cs_host_os_normalized])
    361. 

  361. CS_HEADER_PROPERTY([CS_PLATFORM_NAME],
    362. 

  362.     [AS_ESCAPE(["])$cs_host_os_normalized[]AS_ESCAPE(["])])
    363. 

  363. 

  364. 

  365. 

  366. #------------------------------------------------------------------------------
    367. 

  367. # Check if Perl SDK is installed and which compiler and linker flags are
    368. 

  368. # required to embed Perl.  Also determine if the glue file can be created with
    369. 

  369. # ExtUtils::Embed or if it must be created manually.
    370. 

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

  371. AC_CHECK_PROGS([PERL], [perl5 perl])
    372. 

  372. CS_EMIT_BUILD_PROPERTY([PERL5], [$PERL])
    373. 

  373. CS_EMIT_BUILD_PROPERTY([PERL], [$PERL])
    374. 

  374. CS_EMIT_BUILD_PROPERTY([CMD.PERL5], [$PERL])
    375. 

  375. 

  376. # csperl5 fails to build on many platforms, so default is NO for now.
    377. 

  377. AC_ARG_WITH([perl], [AC_HELP_STRING([--with-perl],
    378. 

  378.     [use Perl5 scripting interface (default NO)])])
    379. 

  379. AS_IF([test -z "$with_perl"], [with_perl=no])
    380. 

  380. 

  381. AS_IF([test -n "$PERL" && test "$with_perl" != no],
    382. 

  382.     [AC_CACHE_CHECK([for perl ExtUtils::Embed module], [cs_cv_perl_mod_embed],
    383. 

  383. 	[AS_IF([AC_RUN_LOG([$PERL -MExtUtils::Embed -e 0 1>&2])],
    384. 

  384. 	    [cs_cv_perl_mod_embed=yes], [cs_cv_perl_mod_embed=no])])
    385. 

  385. 

  386.     AS_IF([test $cs_cv_perl_mod_embed = yes],
    387. 

  387. 	[CS_EMIT_BUILD_PROPERTY([PERL5.EXTUTILS.EMBED.AVAILABLE], [yes])
    388. 

  388. 	AC_CACHE_CHECK([for perl DynaLoader module],
    389. 

  389. 	    [cs_cv_perl_mod_dynaloader],
    390. 

  390. 	    [AS_IF([AC_RUN_LOG([$PERL -MDynaLoader -e 0 1>&2])],
    391. 

  391. 		[cs_cv_perl_mod_dynaloader=yes],
    392. 

  392. 		[cs_cv_perl_mod_dynaloader=no])])
    393. 

  393. 	AS_IF([test $cs_cv_perl_mod_dynaloader = yes],
    394. 

  394. 	    [CS_EMIT_BUILD_PROPERTY([PERL5.DYNALOADER.AVAILABLE], [yes])])],
    395. 

  395. 	[# ExtUtils::Embed absent.
    396. 

  396. 	AC_MSG_NOTICE([Recommend you install a recent release of Perl 5.])
    397. 

  397. 	AC_MSG_NOTICE([http://www.perl.org/])
    398. 

  398. 	AC_CACHE_CHECK([for perl Config module], [cs_cv_perl_mod_config],
    399. 

  399. 	    [AS_IF([AC_RUN_LOG([$PERL -MConfig -e 0 1>&2])],
    400. 

  400. 		[cs_cv_perl_mod_config=yes], [cs_cv_perl_mod_config=no])])])
    401. 

  401. 

  402.     AS_VAR_SET_IF([cs_cv_perl_cflags], [],
    403. 

  403. 	[AS_IF([test $cs_cv_perl_mod_embed = yes],
    404. 

  404. 	    [cs_cv_perl_cflags=`AC_RUN_LOG(
    405. 

  405. 		[$PERL -MExtUtils::Embed -e ccopts])`
    406. 

  406. 	    cs_cv_perl_lflags=`AC_RUN_LOG(
    407. 

  407. 		[$PERL -MExtUtils::Embed -e ldopts])`
    408. 

  408. 	    cs_cv_perl_ext=`AC_RUN_LOG([$PERL -MConfig -e \
    409. 

  409. 		'$e = $Config{"dlext"} || $Config{"so"} || ""; print "$e"'])`],
    410. 

  410. 	    [AS_IF([test $cs_cv_perl_mod_config = yes],
    411. 

  411. 		[cs_perl_core=`AC_RUN_LOG(
    412. 

  412. 		    [$PERL -MConfig -e 'print $Config{archlib}'])`
    413. 

  413. 		cs_perl_core="${cs_perl_core}/CORE"
    414. 

  414. 		cs_cv_perl_cflags=`AC_RUN_LOG(
    415. 

  415. 		    [$PERL -MConfig -e 'print $Config{ccflags}'])`
    416. 

  416. 		cs_cv_perl_cflags="${cs_cv_perl_cflags} -I${cs_perl_core}"
    417. 

  417. 		cs_cv_perl_lflags=`AC_RUN_LOG([$PERL -MConfig -e \
    418. 

  418. 		    'print $Config{ldflags}, " ", $Config{libs}'])`
    419. 

  419. 		cs_cv_perl_lflags="${cs_cv_perl_lflags} -L${cs_perl_core}"
    420. 

  420. 		cs_cv_perl_ext=`AC_RUN_LOG([$PERL -MConfig -e \
    421. 

  421. 		    '$e = $Config{"dlext"}||$Config{"so"}||""; print "$e"'])`],
    422. 

  422. 		[cs_perl_core=`AC_RUN_LOG([$PERL -V:archlib | \
    423. 

  423. 		    $PERL -e '<STDIN> =~ m/\x27(.*)\x27/; print $1'])`
    424. 

  424. 		cs_perl_core="${cs_perl_core}/CORE"
    425. 

  425. 		cs_cv_perl_cflags=`AC_RUN_LOG([$PERL -V:ccflags | \
    426. 

  426. 		    $PERL -e '<STDIN> =~ m/\x27(.*)\x27/; print $1'])`
    427. 

  427. 		cs_cv_perl_cflags="${cs_cv_perl_cflags} -I${cs_perl_core}"
    428. 

  428. 		cs_cv_perl_lflags=`AC_RUN_LOG([$PERL -V:ldflags | \
    429. 

  429. 		    $PERL -e '<STDIN> =~ m/\x27(.*)\x27/; print $1'])`
    430. 

  430. 		cs_perl_lflags_tmp=`AC_RUN_LOG([$PERL -V:libs | \
    431. 

  431. 		    $PERL -e '<STDIN> =~ m/\x27(.*)\x27/; print $1'])`
    432. 

  432. 		cs_cv_perl_lflags="${cs_cv_perl_lflags} ${cs_perl_lflags_tmp}
    433. 

  433. 		    -L${cs_perl_core}"
    434. 

  434. 		cs_cv_perl_ext=`AC_RUN_LOG([$PERL -V:dlext | \
    435. 

  435. 		    $PERL -e '<STDIN> =~ m/\x27(.*)\x27/; print $1'])`])])
    436. 

  436. 	cs_cv_perl_cflags=CS_PATH_NORMALIZE([$cs_cv_perl_cflags])
    437. 

  437. 	cs_cv_perl_cflags=CS_TRIM([$cs_cv_perl_cflags])
    438. 

  438. 	cs_cv_perl_lflags=CS_PATH_NORMALIZE([$cs_cv_perl_lflags])
    439. 

  439. 	cs_cv_perl_lflags=CS_TRIM([$cs_cv_perl_lflags])])
    440. 

  440. 

  441.     AS_IF([test -n "$cs_cv_perl_cflags$cs_cv_perl_lflags"],
    442. 

  442. 	[CS_CHECK_BUILD([if Perl SDK is usable], [cs_cv_perl],
    443. 

  443. 	    [AC_LANG_PROGRAM(
    444. 

  444. 		[[#include <EXTERN.h>
    445. 

  445. 		#include <perl.h>]],
    446. 

  446. 		[perl_run(0);])],
    447. 

  447. 	    [CS_CREATE_TUPLE([$cs_cv_perl_cflags],[],[$cs_cv_perl_lflags])])
    448. 

  448. 	AS_IF([test $cs_cv_perl = yes],
    449. 

  449. 	    [CS_EMIT_BUILD_RESULT([cs_cv_perl], [PERL5])
    450. 

  450. 	    CS_EMIT_BUILD_PROPERTY([PERL5.MODULE_EXT],[.$cs_cv_perl_ext])])])])
    451. 

  451. 	
    452. 

  452. 

  453. 

  454. 

  455. #------------------------------------------------------------------------------
    456. 

  456. # Check if Python SDK is installed and which compiler and linker flags are
    457. 

  457. # required to embed Python.
    458. 

  458. #------------------------------------------------------------------------------
    459. 

  459. CS_EMIT_CHECK_PYTHON([], [Python scripting interface])
    460. 

  460. 

  461. 

  462. 

  463. #------------------------------------------------------------------------------
    464. 

  464. # Check if Java2 SDK is installed and which compiler and linker flags are
    465. 

  465. # needed.  Also check if Ant build tool, which is commonly used to build Java
    466. 

  466. # projects, is available.
    467. 

  467. #------------------------------------------------------------------------------
    468. 

  468. AC_DEFUN([CS_JAVA_HEADER_PATH],
    469. 

  469.     [AC_REQUIRE([AC_CANONICAL_HOST])
    470. 

  470.     AC_REQUIRE([CS_CHECK_HOST])
    471. 

  471.     AS_IF([test x$cs_host_macosx = xyes && # Not cross-building for Darwin.
    472. 

  472. 	test -r /System/Library/Frameworks/JavaVM.framework/Headers],
    473. 

  473. 	[cs_java_inc="-I/System/Library/Frameworks/JavaVM.framework/Headers"],
    474. 

  474. 	[AS_IF([test -n "$JAVA_HOME"],
    475. 

  475. 	    [cs_java_dir="$JAVA_HOME"],
    476. 

  476. 	    [AS_IF([test -n "$1"],
    477. 

  477. 		[cs_java_dir=`AS_DIRNAME([$1])`
    478. 

  478. 		cs_java_dir=`AS_DIRNAME([$cs_java_dir])`],
    479. 

  479. 		[cs_java_dir=''])])
    480. 

  480. 	AS_IF([test -n "$cs_java_dir"],
    481. 

  481. 	    [cs_java_inc="-I$cs_java_dir/include"
    482. 

  482. 	    case $host_os in
    483. 

  483. 		mingw*|cygwin*) cs_java_platform=win32 ;;
    484. 

  484. 		*) cs_java_platform=`echo $host_os |
    485. 

  485. 		    sed 's/^\([[^-]]*\).*$/\1/'` ;;
    486. 

  486. 	    esac
    487. 

  487. 	    AS_IF([test -n "$cs_java_platform"],
    488. 

  488. 		[cs_java_inc="$cs_java_inc
    489. 

  489. 		    $cs_java_inc/$cs_java_platform"])])])])
    490. 

    491. 

  491. AC_PATH_PROGS([JAVA], [java], [],
    492. 

  492.     [$PATH$PATH_SEPARATOR$JAVA_HOME/bin$PATH_SEPARATOR$JAVA_HOME/jre/bin])
    493. 

  493. CS_EMIT_BUILD_PROPERTY([JAVA], [$JAVA])
    494. 

  494. 

  495. AC_PATH_PROGS([JAVAC], [javac], [],
    496. 

  496.     [$PATH$PATH_SEPARATOR$JAVA_HOME/bin$PATH_SEPARATOR$JAVA_HOME/jre/bin])
    497. 

  497. CS_EMIT_BUILD_PROPERTY([JAVAC], [$JAVAC])
    498. 

  498. 

  499. AC_ARG_WITH([java], [AC_HELP_STRING([--with-java],
    500. 

  500.     [use Java scripting interface (default YES)])])
    501. 

  501. AS_IF([test -z "$with_java"], [with_java=yes])
    502. 

  502. 

  503. AS_IF([test "$with_java" != no && test -n "$JAVAC" && test -n "$JAVA"],
    504. 

  504.     [CS_JAVA_HEADER_PATH([$JAVAC])
    505. 

  505.     CS_CHECK_BUILD([if Java2 SDK is usable], [cs_cv_java],
    506. 

  506. 	[AC_LANG_PROGRAM(
    507. 

  507. 	    [[#include <jni.h>
    508. 

  508. 	    JNIEXPORT void JNICALL f(JNIEnv *env, jobject obj);]])],
    509. 

  509. 	[CS_CREATE_TUPLE() CS_CREATE_TUPLE([$cs_java_inc])], [],
    510. 

  510. 	[CS_EMIT_BUILD_RESULT([cs_cv_java], [JAVA])])])
    511. 

  511. 

  512. AC_PATH_PROGS([ANT], [ant], [], [$PATH$PATH_SEPARATOR$ANT_HOME/bin])
    513. 

  513. CS_EMIT_BUILD_PROPERTY([ANT], [$ANT])
    514. 

  514. 

  515. 

  516. 

  517. #------------------------------------------------------------------------------
    518. 

  518. # Use the CPPFLAGS, CXXFLAGS, CFLAGS, and LDFLAGS passed to configure.
    519. 

  519. # Further, Autoconf insists upon issuing optimization flags (-O) and debug
    520. 

  520. # flags (-g) at one and the same time, but this is not suitable for Crystal
    521. 

  521. # Space's build system, which makes a distinction between `optimize' and
    522. 

  522. # `debug' builds, so we must filter out these flags.
    523. 

  523. #------------------------------------------------------------------------------
    524. 

  524. CFLAGS=`echo "$CFLAGS" | sed 's/-O.//g;s/-g.//g'`
    525. 

  525. CXXFLAGS=`echo "$CXXFLAGS" | sed 's/-O.//g;s/-g.//g'`
    526. 

    527. 

  527. CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS], [$CPPFLAGS $CFLAGS], [+])
    528. 

  528. CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS], [$CPPFLAGS $CXXFLAGS], [+])
    529. 

  529. CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [$LDFLAGS], [+])
    530. 

    531. 

    532. 

    533. 

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

  534. # Check how to enable compilation warnings.  Note that on some platforms, it is
    535. 

  535. # more appropriate to use -Wmost rather than -Wall even if the compiler
    536. 

  536. # understands both, thus we attempt -Wmost before -Wall.
    537. 

  537. #------------------------------------------------------------------------------
    538. 

  538. CS_EMIT_BUILD_FLAGS([how to enable compilation warnings],
    539. 

  539.     [cs_cv_prog_cxx_enable_warnings],
    540. 

  540.     [CS_CREATE_TUPLE([-Wmost]) CS_CREATE_TUPLE([-Wall])], [C++],
    541. 

  541.     [COMPILER.CFLAGS], [+],
    542. 

  542.     [cs_prog_cxx_enable_warnings="$cs_cv_prog_cxx_enable_warnings"],
    543. 

  543.     [cs_prog_cxx_enable_warnings=''])
    544. 

    545. 

    546. 

    547. 

  547. #------------------------------------------------------------------------------
    548. 

  548. # Check how to make compiler treat warnings as errors.
    549. 

  549. #------------------------------------------------------------------------------
    550. 

  550. CS_CHECK_BUILD_FLAGS([how to treat warnings as errors],
    551. 

  551.     [cs_cv_prog_cxx_enable_errors], [CS_CREATE_TUPLE([-Werror])], [C++],
    552. 

  552.     [cs_prog_cxx_enable_errors="$cs_cv_prog_cxx_enable_errors"],
    553. 

  553.     [cs_prog_cxx_enable_errors=''])
    554. 

    555. 

    556. 

    557. 

  557. #------------------------------------------------------------------------------
    558. 

  558. # Check how to make compiler ignore unused variables and arguments.  This is
    559. 

  559. # needed for code generated by tools, such as Swig, Bison, and Flex, over which
    560. 

  560. # we have no control.
    561. 

  561. #------------------------------------------------------------------------------
    562. 

  562. CS_EMIT_BUILD_FLAGS([how to ignore unused variables],
    563. 

  563.     [cs_cv_prog_cxx_ignore_unused_variables],
    564. 

  564.     [CS_CREATE_TUPLE([-Wno-unused])], [C++],
    565. 

  565. 	[COMPILER.C++FLAGS.WARNING.NO_UNUSED])
    566. 

    567. 

    568. 

    569. 

  569. #------------------------------------------------------------------------------
    570. 

  570. # Check how to make compiler ignore uninitialized variables and arguments.
    571. 

  571. # This is needed for code generated by tools, such as Swig, Bison, and Flex,
    572. 

  572. # over which we have no control.
    573. 

  573. #------------------------------------------------------------------------------
    574. 

  574. CS_EMIT_BUILD_FLAGS([how to ignore uninitialized variables],
    575. 

  575.     [cs_cv_prog_cxx_ignore_uninitialized_variables],
    576. 

  576.     [CS_CREATE_TUPLE([-Wno-uninitialized])], [C++],
    577. 

  577.     [COMPILER.C++FLAGS.WARNING.NO_UNINITIALIZED])
    578. 

    579. 

    580. 

    581. 

  581. #------------------------------------------------------------------------------
    582. 

  582. # Check if warnings about unknown #pragmas can be disabled.  (MSVC and Borland
    583. 

  583. # use a number of pragmas not understood by GCC, for instance.)
    584. 

  584. #------------------------------------------------------------------------------
    585. 

  585. CS_EMIT_BUILD_FLAGS([[how to ignore unknown #pragma directives]],
    586. 

  586.     [cs_cv_prog_cxx_ignore_unknown_pragmas],
    587. 

  587.     [CS_CREATE_TUPLE([-Wno-unknown-pragmas])], [C++], [COMPILER.CFLAGS], [+])
    588. 

    589. 

    590. 

    591. 

  591. #------------------------------------------------------------------------------
    592. 

  592. # Check if C++ exceptions can be enabled and disabled.
    593. 

  593. #------------------------------------------------------------------------------
    594. 

  594. CS_EMIT_BUILD_FLAGS([how to enable C++ exceptions],
    595. 

  595.     [cs_cv_prog_cxx_enable_exceptions], [CS_CREATE_TUPLE([-fexceptions])],
    596. 

  596.     [C++], [COMPILER.C++FLAGS.EXCEPTIONS.ENABLE], [])
    597. 

    598. 

  598. CS_EMIT_BUILD_FLAGS([how to disable C++ exceptions],
    599. 

  599.     [cs_cv_prog_cxx_disable_exceptions], [CS_CREATE_TUPLE([-fno-exceptions])],
    600. 

  600.     [C++], [COMPILER.C++FLAGS.EXCEPTIONS.DISABLE], [],
    601. 

  601. 	[CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS],
    602. 

  602. 	    [$cs_cv_prog_cxx_disable_exceptions], [+])])
    603. 

    604. 

    605. 

    606. 

  606. #------------------------------------------------------------------------------
    607. 

  607. # Check if the linker recognizes "-multiply_defined suppress".  This is
    608. 

  608. # required for MacOS/X 10.1 to avoid warning messages when linking a program
    609. 

  609. # with "-framework Foundation" if that program does not actually employ any
    610. 

  610. # Objective-C.
    611. 

  611. #------------------------------------------------------------------------------
    612. 

  612. CS_EMIT_BUILD_FLAGS([if -multiply_defined suppress is needed],
    613. 

  613.     [cs_cv_prog_link_suppress_multiple],
    614. 

  614.     [CS_CREATE_TUPLE([], [-multiply_defined suppress])],
    615. 

  615.     [], [COMPILER.LFLAGS], [+])
    616. 

    617. 

    618. 

    619. 

  619. #------------------------------------------------------------------------------
    620. 

  620. # Check if the linker recognizes "-force_cpusubtype_ALL".  This is required on
    621. 

  621. # MacOS/X since the Crystal Space's PowerPC implementation of qsqrt() uses the
    622. 

  622. # `frsqrte' instruction which is only valid when the -force_cpusubtype_ALL flag
    623. 

  623. # is present.  This flag is marked "mandatory" because it is required even for
    624. 

  624. # external projects if they use qsqrt().
    625. 

  625. #------------------------------------------------------------------------------
    626. 

  626. AC_DEFUN([CS_CHECK_FORCE_CPUSUBTYPE_ALL],
    627. 

  627.     [CS_CHECK_BUILD_FLAGS([if -force_cpusubtype_ALL is needed],
    628. 

  628. 	[cs_cv_prog_cxx_force_cpusubtype_all],
    629. 

  629. 	[CS_CREATE_TUPLE([], [-force_cpusubtype_ALL])])])
    630. 

  630.     
    631. 

  631. CS_CHECK_FORCE_CPUSUBTYPE_ALL
    632. 

  632. AS_IF([test $cs_cv_prog_cxx_force_cpusubtype_all != no],
    633. 

  633.     [CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS.MANDATORY],
    634. 

  634. 	[$cs_cv_prog_cxx_force_cpusubtype_all], [+])])
    635. 

  635. 

  636. 

  637. 

  638. #------------------------------------------------------------------------------
    639. 

  639. # Check if the MacOS/X compiler recognizes "-fno-common".  This flag is needed
    640. 

  640. # when building plugin modules (and the libraries which are linked into
    641. 

  641. # plugins) prior to Apple's introduction of the two-level namespace symbol
    642. 

  642. # scheme in order to ensure that each plugin module gets its own copy of
    643. 

  643. # uninitialized global variables.
    644. 

  644. #------------------------------------------------------------------------------
    645. 

  645. AC_DEFUN([CS_CHECK_NO_COMMON],
    646. 

  646.     [AC_REQUIRE([AC_CANONICAL_HOST])
    647. 

  647.     case $host_os in
    648. 

  648. 	darwin*)
    649. 

  649. 	    CS_EMIT_BUILD_FLAGS([if -fno-common is needed],
    650. 

  650. 		[cs_cv_prog_cxx_no_common],
    651. 

  651. 		[CS_CREATE_TUPLE([], [-fno-common])], [C++],
    652. 

  652. 		[COMPILER.CFLAGS.MANDATORY], [+])
    653. 

  653. 	    ;;
    654. 

  654.     esac])
    655. 

  655. 

  656. CS_CHECK_NO_COMMON
    657. 

  657. 

  658. 

  659. 

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

  661. # Check if Mingw and Cygwin compilers recognize -fvtable-thunks.  As of gcc
    662. 

  662. # 3.x, this option is no longer supported.  Unfortunately, rather than
    663. 

  663. # returning an error code (as it does with other unrecognized options), the
    664. 

  664. # compiler merely prints a warning message when -fvtable-thunks is used, thus
    665. 

  665. # we use -Werror to turn the warning into an error.
    666. 

  666. #------------------------------------------------------------------------------
    667. 

  667. AC_DEFUN([CS_CHECK_VTABLE_THUNKS],
    668. 

  668.     [AC_REQUIRE([AC_CANONICAL_HOST])
    669. 

  669.     case $host_os in
    670. 

  670. 	mingw*|cygwin*)
    671. 

  671. 	    CS_CHECK_BUILD_FLAGS([if -fvtable-thunks is needed],
    672. 

  672. 		[cs_cv_prog_cxx_vtable_thunks],
    673. 

  673. 		[CS_CREATE_TUPLE([-fvtable-thunks])], [C++],
    674. 

  674. 		[CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS.MANDATORY],
    675. 

  675. 		    [$cs_cv_prog_cxx_vtable_thunks], [+])],
    676. 

  676. 		[], [$cs_prog_cxx_enable_errors])
    677. 

  677. 	    ;;
    678. 

  678.     esac])
    679. 

  679. 

  680. CS_CHECK_VTABLE_THUNKS
    681. 

  681. 

  682. 

  683. 

  684. #------------------------------------------------------------------------------
    685. 

  685. # Check if compiler recognizes -pipe directive.
    686. 

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

  687. CS_EMIT_BUILD_FLAGS([if -pipe is accepted], [cs_cv_prog_cxx_pipe],
    688. 

  688.    [CS_CREATE_TUPLE([-pipe])], [C++], [COMPILER.CFLAGS], [+])
    689. 

  689. 

  690. 

  691. 

  692. #------------------------------------------------------------------------------
    693. 

  693. # Check if compiler/linker recognizes -shared directive which is needed for
    694. 

  694. # linking plugin modules.  Unfortunately, the Apple compiler (and possibly
    695. 

  695. # others) require extra effort.  Even though the compiler does not recognize
    696. 

  696. # the -shared option, it nevertheless returns a "success" result after
    697. 

  697. # complaining that the option is unrecognized.  Worse, even -Werror fails to
    698. 

  698. # coerce the compiler into returning a "failure" result, so we must perform the
    699. 

  699. # additional task of checking the compiler's output for an appropriate error
    700. 

  700. # emission, such as "unrecognized option `-shared'".
    701. 

  701. #------------------------------------------------------------------------------
    702. 

  702. CS_CHECK_BUILD_FLAGS([if -shared is accepted], [cs_cv_prog_link_shared],
    703. 

  703.     [CS_CREATE_TUPLE([-shared])], [C++],
    704. 

  704.     [CS_EMIT_BUILD_PROPERTY([PLUGIN.LFLAGS], [-shared], [+])], [],
    705. 

  705.     [$cs_prog_cxx_enable_errors], [], [], [nrecognize])
    706. 

  706. 

  707. 

  708. 

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

  710. # Check if linker recognizes -soname which is used to assign a name internally
    711. 

  711. # to plugin modules.
    712. 

  712. #------------------------------------------------------------------------------
    713. 

  713. CS_CHECK_BUILD([if -soname is accepted], [cs_cv_prog_link_soname], [],
    714. 

  714.     [CS_CREATE_TUPLE([-Wl,-soname,foobar])], [C++],
    715. 

  715.     [CS_EMIT_BUILD_PROPERTY([PLUGIN.LFLAGS.USE_SONAME], [yes])])
    716. 

  716. 

  717. 

  718. 

  719. #------------------------------------------------------------------------------
    720. 

  720. # Check for compiler- and CPU-specific code generation flags.  These flags are
    721. 

  721. # mutually exclusive.  Exclusivity is enforced by the CS_CHECK_CODE_GEN_FLAG()
    722. 

  722. # macro.  Note that use of these flags typically means that the resulting
    723. 

  723. # binary will not be backward compatible.  For instance, if Pentium-specific
    724. 

  724. # instructions are used, the program will not work with earlier processors,
    725. 

  725. # such as the Intel 486.  Because these options are potentially dangerous,
    726. 

  726. # their use it controlled by the user via --enable-cpu-specific-optimizations
    727. 

  727. # which accepts "no" (same as "disable"), "minimum" (the default), and
    728. 

  728. # "maximum".  The "minimum" option selects optimizations which are likely to be
    729. 

  729. # supported by reasonably modern hardware, thus making the resulting
    730. 

  730. # executables fairly portable.
    731. 

  731. #
    732. 

  732. # CS_CHECK_CODE_GEN_FLAG(CPU-PATTERN, FLAGS, [LANGUAGE])
    733. 

  733. #	If compiler- and CPU-specific optimization flags have not already been
    734. 

  734. #	determined, and if the canonical host CPU matches CPU-PATTERN, try
    735. 

  735. #	using the provided compiler FLAGS with the compiler represented by
    736. 

  736. #	LANGUAGE (typically either "C" or "C++").  If language is omitted, C++
    737. 

  737. #	is used.  If the compiler accepts the flags, assign them to the shell
    738. 

  738. #	variable cs_cv_prog_cxx_code_gen.
    739. 

  739. #------------------------------------------------------------------------------
    740. 

  740. AC_DEFUN([CS_CHECK_CODE_GEN_FLAG],
    741. 

  741.     [AC_REQUIRE([AC_CANONICAL_HOST])
    742. 

  742.     AS_IF([test "$cs_cv_prog_cxx_code_gen" = no],
    743. 

  743. 	[case $host_cpu in
    744. 

  744. 	    $1) CS_BUILD_IFELSE([],
    745. 

  745. 		    [CS_CREATE_TUPLE([$2])], m4_default([$3],[C++]),
    746. 

  746. 		    [cs_cv_prog_cxx_code_gen=$cs_build_cflags], [])
    747. 

  747. 		;;
    748. 

  748. 	esac])])
    749. 

  749. 

  750. AC_MSG_CHECKING([whether to use CPU-specific optimizations])
    751. 

  751. AC_ARG_ENABLE([cpu-specific-optimizations],
    752. 

  752.     [AC_HELP_STRING([--enable-cpu-specific-optimizations=level],
    753. 

  753. 	[enable CPU-specific optimizations; recognized levels are `no',
    754. 

  754. 	`minimum' or `min', `maximum' or `max' (default MINIMUM); the `minimum'
    755. 

  755. 	option selects optimizations which are likely to be supported by
    756. 

  756. 	reasonably modern hardware, thus making the resulting executables
    757. 

  757. 	fairly portable; use the `maximum' option with caution since code for
    758. 

  758. 	one processor will not work with earlier processors (for example, Intel
    759. 

  759. 	686-specific code will not work with a 586)])],
    760. 

  760.     [case $enable_cpu_specific_optimizations in
    761. 

  761. 	yes|min) enable_cpu_specific_optimizations=minimum ;;
    762. 

  762. 	max) enable_cpu_specific_optimizations=maximum ;;
    763. 

  763.     esac],
    764. 

  764.     [enable_cpu_specific_optimizations=minimum])
    765. 

  765. AC_MSG_RESULT([$enable_cpu_specific_optimizations])
    766. 

    767. 

  767. case $enable_cpu_specific_optimizations in
    768. 

  768.     no|minimum|maximum) ;;
    769. 

  769.     *) CS_MSG_ERROR([unrecognized option; use `no', `minimum', or `maximum'])
    770. 

  770.        ;;
    771. 

  771. esac
    772. 

    773. 

  773. AS_IF([test $enable_cpu_specific_optimizations != no],
    774. 

  774.     [AC_CACHE_CHECK([for code generation flags], [cs_cv_prog_cxx_code_gen],
    775. 

  775. 	[cs_cv_prog_cxx_code_gen=no
    776. 

  776. 	AS_IF([test $enable_cpu_specific_optimizations = maximum],
    777. 

  777. 	    [CS_CHECK_CODE_GEN_FLAG([athlon], [-march=athlon])
    778. 

  778. 	    CS_CHECK_CODE_GEN_FLAG([athlon], [-mcpu=athlon -march=athlon])
    779. 

  779. 	    CS_CHECK_CODE_GEN_FLAG([athlon], [-mcpu=athlon])
    780. 

  780. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-march=i686])
    781. 

  781. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mcpu=pentiumpro -march=i686])
    782. 

  782. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mcpu=pentiumpro])
    783. 

  783. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mpentiumpro -march=i686])
    784. 

  784. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mpentiumpro])])
    785. 

  785. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-march=i586])
    786. 

  786. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-mcpu=pentium -march=i586])
    787. 

  787. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-mcpu=pentium])
    788. 

  788. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-mpentium -march=i586])
    789. 

  789. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-mpentium])
    790. 

  790. 	CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-mcpu=i486])
    791. 

  791. 	CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-m486])
    792. 

  792. 	CS_CHECK_CODE_GEN_FLAG([alpha], [-mieee])])
    793. 

    794. 

  794.     AS_IF([test "$cs_cv_prog_cxx_code_gen" != no],
    795. 

  795. 	[CS_EMIT_BUILD_PROPERTY(
    796. 

  796. 	    [COMPILER.CFLAGS], [$cs_cv_prog_cxx_code_gen], [+])])])
    797. 

    798. 

    799. 

    800. 

  800. #------------------------------------------------------------------------------
    801. 

  801. # Check for compiler optimization flags.
    802. 

  802. #------------------------------------------------------------------------------
    803. 

  803. AC_DEFUN([CS_CHECK_OPTIMIZE_FLAGS],
    804. 

  804.     [AC_REQUIRE([AC_PROG_CC])
    805. 

  805.     AC_REQUIRE([AC_PROG_CXX])
    806. 

    807. 

  807.     cs_optimize_flags=''
    808. 

    809. 

  809.     CS_EMIT_BUILD_FLAGS([how to enable optimizations],
    810. 

  810. 	[cs_cv_prog_cxx_optimize],
    811. 

  811. 	[CS_CREATE_TUPLE([-O3]) CS_CREATE_TUPLE([-O2]) CS_CREATE_TUPLE([-O])],
    812. 

  812. 	[C++], [COMPILER.CFLAGS.optimize], [+],
    813. 

  813. 	[cs_optimize_flags="$cs_optimize_flags $cs_cv_prog_cxx_optimize"])
    814. 

    815. 

  815.     CS_EMIT_BUILD_FLAGS([if $CXX recognizes -fomit-frame-pointer],
    816. 

  816. 	[cs_cv_prog_cxx_omit_frame_pointer],
    817. 

  817. 	[CS_CREATE_TUPLE([-fomit-frame-pointer])],
    818. 

  818. 	[C++], [COMPILER.CFLAGS.optimize], [+],
    819. 

  819. 	[cs_optimize_flags="$cs_optimize_flags \
    820. 

  820. 	    $cs_cv_prog_cxx_omit_frame_pointer"])
    821. 

    822. 

  822.     CS_EMIT_BUILD_FLAGS([if $CXX recognizes -ffast-math],
    823. 

  823. 	[cs_cv_prog_cxx_fast_math],
    824. 

  824. 	[CS_CREATE_TUPLE([-ffast-math])], [C++],
    825. 

  825. 	[COMPILER.CFLAGS.optimize], [+],
    826. 

  826. 	[cs_optimize_flags="$cs_optimize_flags $cs_cv_prog_cxx_fast_math"])])
    827. 

    828. 

  828. CS_CHECK_OPTIMIZE_FLAGS
    829. 

    830. 

    831. 

    832. 

  832. #------------------------------------------------------------------------------
    833. 

  833. # Check for compiler debug flags.
    834. 

  834. #------------------------------------------------------------------------------
    835. 

  835. CS_EMIT_BUILD_FLAGS([how to enable compiler debug output],
    836. 

  836.     [cs_cv_prog_cxx_debug],
    837. 

  837.     [CS_CREATE_TUPLE([-g3]) CS_CREATE_TUPLE([-g2]) CS_CREATE_TUPLE([-g])],
    838. 

  838.     [C++], [COMPILER.CFLAGS.debug], [+])
    839. 

  839. AS_IF([test $cs_cv_prog_cxx_debug != no],
    840. 

  840.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS.debug], [$cs_cv_prog_cxx_debug],
    841. 

  841. 	[+])])
    842. 

    843. 

    844. 

    845. 

  845. #------------------------------------------------------------------------------
    846. 

  846. # Check if compiler complains about adding /usr/local/include to the header
    847. 

  847. # search path.  If not, add it to the header search path since not all
    848. 

  848. # compilers search there by default.  Some compiler, on the other hand,
    849. 

  849. # complain if it is already in the built-in search path, and we would like to
    850. 

  850. # avoid the complaint, if possible.
    851. 

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

  852. AS_IF([test -d /usr/local/include],
    853. 

  853.     [CS_CHECK_BUILD_FLAGS([if -I/usr/local/include is usable],
    854. 

  854. 	[cs_cv_prog_cxx_local_include],
    855. 

  855. 	[CS_CREATE_TUPLE([-I/usr/local/include])], [C++],
    856. 

  856. 	[cs_cv_prog_cxx_local_include=yes],
    857. 

  857. 	[cs_cv_prog_cxx_local_include=no],
    858. 

  858. 	[$cs_prog_cxx_enable_warnings $cs_prog_cxx_enable_errors])],
    859. 

  859.     [cs_cv_prog_cxx_local_include=no])
    860. 

    861. 

  861. AS_IF([test $cs_cv_prog_cxx_local_include = yes],
    862. 

  862.     [CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS], [-I/usr/local/include], [+])
    863. 

  863.     CPPFLAGS="$CPPFLAGS -I/usr/local/include"])
    864. 

    865. 

  865. AS_IF([test -d /usr/local/lib],
    866. 

  866.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-L/usr/local/lib], [+])
    867. 

  867.     LDFLAGS="$LDFLAGS -L/usr/local/lib"])
    868. 

    869. 

    870. 

    871. 

  871. #------------------------------------------------------------------------------
    872. 

  872. # Check for X-Windows.  If the X-Windows implementation is XFree86, then also
    873. 

  873. # enable the `VideoMode' extension.
    874. 

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

  875. AC_DEFUN([CS_X_CHECK_PREPARE],
    876. 

  876.     [AC_REQUIRE([AC_CANONICAL_HOST])
    877. 

  877.     AC_REQUIRE([CS_CHECK_HOST])
    878. 

  878. 

  879.     # Explicitly disable X checking on Windows to avoid discovering XFree86 in
    880. 

  880.     # case Cygwin is installed.  Doing so allows us to avoid Mesa's OpenGL
    881. 

  881.     # headers during the OpenGL check, and prefer Microsoft's OpenGL headers.
    882. 

  882.     # The Mesa OpenGL headers cause link errors because they do not employ
    883. 

  883.     # __stdcall.
    884. 

  884.     case $host_os in
    885. 

  885. 	mingw*|cygwin*) with_x=no ;;
    886. 

  886.     esac
    887. 

  887. 

  888.     # Explicitly disable X checking on MacOS/X in case the optional XFree86 is
    889. 

  889.     # installed since we want to avoid an undesirable dependency upon XFree86
    890. 

  890.     # in the CS executables and plugins.  If the user is actually
    891. 

  891.     # cross-building for Darwin on MacOS/X, then the --with-x option will
    892. 

  892.     # override this test (by setting cs_host_macosx to "no").
    893. 

  893.     AS_IF([test x$cs_host_macosx = xyes], [with_x=no])])
    894. 

  894. 

  895. CS_X_CHECK_PREPARE
    896. 

  896. AC_PATH_X
    897. 

  897. AC_PATH_XTRA
    898. 

  898. 

  899. AS_IF([test "$no_x" != yes],
    900. 

  900.     [# We must be especially careful to instruct CS_EMIT_BUILD_PROPERTY() to
    901. 

  901.     # emit the following properties even if their values are empty.  This is
    902. 

  902.     # necessary because of the way that Jam performs "product-wise" variable
    903. 

  903.     # expansion.  For example, if X is "x" and Y is undefined, Jam will expand
    904. 

  904.     # "$(X) $(Y)" to "", whereas every other tool in the world will expand it
    905. 

  905.     # to "x ".  Since the emitted X11.CFLAGS, X11.LFLAGS, XFREE86VM.CFLAGS, and
    906. 

  906.     # XFREE86VM.LFLAGS properties reference the other variables by name, we
    907. 

  907.     # must ensure that those other variables are defined (even if only with an
    908. 

  908.     # empty string).
    909. 

  909.     CS_EMIT_BUILD_PROPERTY([X11.AVAILABLE], [yes])
    910. 

  910.     CS_EMIT_BUILD_PROPERTY([X_CFLAGS], [$X_CFLAGS], [], [Y])
    911. 

  911.     CS_EMIT_BUILD_PROPERTY([X_LIBS], [$X_LIBS], [], [Y])
    912. 

  912.     CS_EMIT_BUILD_PROPERTY([X_PRE_LIBS], [$X_PRE_LIBS], [], [Y])
    913. 

  913.     CS_EMIT_BUILD_PROPERTY([X_EXTRA_LIBS], [$X_EXTRA_LIBS], [], [Y])
    914. 

  914.     CS_EMIT_BUILD_PROPERTY([X11.CFLAGS], [AS_ESCAPE([$(X_CFLAGS)])])
    915. 

  915.     CS_EMIT_BUILD_PROPERTY([X11.LFLAGS],
    916. 

  916.       [AS_ESCAPE([$(X_PRE_LIBS) $(X_LIBS) -lXext -lX11 $(X_EXTRA_LIBS)])])
    917. 

  917. 

  918.     CS_CHECK_LIB_WITH([Xxf86vm],
    919. 

  919. 	[AC_LANG_PROGRAM(
    920. 

  920. 	    [[#define XK_MISCELLANY 1
    921. 

  921. 	    #include <X11/Xlib.h>
    922. 

  922. 	    #include <X11/Xutil.h>
    923. 

  923. 	    #include <X11/Xatom.h>
    924. 

  924. 	    #include <X11/extensions/xf86vmode.h>]],
    925. 

  925. 	    [XF86VidModeLockModeSwitch(0, 0, 0)])], [], [],
    926. 

  926. 	[CS_EMIT_BUILD_PROPERTY([XFREE86VM.AVAILABLE], [yes])
    927. 

  927. 	CS_EMIT_BUILD_PROPERTY([XFREE86VM.CFLAGS], [AS_ESCAPE([$(X_CFLAGS)])])
    928. 

  928. 	CS_EMIT_BUILD_PROPERTY([XFREE86VM.LFLAGS],
    929. 

  929. 	    [AS_ESCAPE([$(X_PRE_LIBS) $(X_LIBS) -lXxf86vm -lXext -lX11
    930. 

  930. 	    $(X_EXTRA_LIBS)])])], [],
    931. 

  931. 	[$X_CFLAGS], [], [$X_PRE_LIBS $X_LIBS -lX11 -lXext $X_EXTRA_LIBS])])
    932. 

  932. 

  933. 

  934. 

  935. #------------------------------------------------------------------------------
    936. 

  936. # Check for OpenGL and companions.  Also check if GLX extensions are supported
    937. 

  937. # and define the (backward) header property CSGL_EXT_STATIC_ASSERTION if they
    938. 

  938. # are _not_ supported.
    939. 

  939. #
    940. 

  940. # IMPLEMENTATION NOTES
    941. 

  941. #
    942. 

  942. # Some Mesa installations require pthread, so pthread flags are employed if
    943. 

  943. # available.
    944. 

  944. #
    945. 

  945. # The check for opengl32 needs to precede other checks because Cygwin users
    946. 

  946. # often have Mesa installed, and Mesa's OpenGL library is compiled without the
    947. 

  947. # __stdcall flags which results in link errors, whereas Microsoft's native
    948. 

  948. # opengl32 works fine.  Conversely, some Unix implementations have Wine
    949. 

  949. # installed (Windows emulation layer) which includes an opengl32.so library.
    950. 

  950. # We need to avoid detection of this library on Unix since it would cause an
    951. 

  951. # undesirable dependence upon Wine.
    952. 

  952. #
    953. 

  953. # Many OpenGL libraries on Unix already contain GLX, so there is no separate
    954. 

  954. # GLX library, thus we first check for GLX using the discovered OpenGL library
    955. 

  955. # before attempting to locate a separate GLX-specific library.  The same logic
    956. 

  956. # is also applied to GLU and GLUT checks.
    957. 

  957. #
    958. 

  958. # On MacOS/X, some users have XFree86 installed which creates a link from
    959. 

  959. # /usr/include/GL to /usr/X11R6/include/GL.  We want to ignore this directory
    960. 

  960. # and instead check for Apple's OpenGL.framework, if we are not cross-building
    961. 

  961. # for Darwin.  We accomplish this by placing the OpenGL.framework test ahead of
    962. 

  962. # the other tests.
    963. 

  963. #
    964. 

  964. # At least one user (Jorrit) has a strange installation in which inclusion of
    965. 

  965. # <windows.h> fails if an int32 is not present, thus we must take this into
    966. 

  966. # account.
    967. 

  967. #------------------------------------------------------------------------------
    968. 

  968. m4_define([cs_define_int32],
    969. 

  969.     [[#if !HAVE_TYPE_INT32
    970. 

  970.     typedef long int32;
    971. 

  971.     #endif
    972. 

  972.     ]])
    973. 

  973. 

  974. AC_DEFUN([CS_CHECK_GL_PREPARE],
    975. 

  975.     [AC_REQUIRE([CS_CHECK_HOST])
    976. 

  976.     AC_REQUIRE([CS_CHECK_COMMON_LIBS])
    977. 

  977.     AC_REQUIRE([CS_CHECK_PTHREAD])
    978. 

  978.     AC_REQUIRE([AC_PATH_X])
    979. 

  979.     AC_REQUIRE([AC_PATH_XTRA])
    980. 

  980.     AC_CHECK_TYPE([int32], [AC_DEFINE([HAVE_TYPE_INT32])], [])
    981. 

  981.     AC_CHECK_HEADERS([windows.h], [], [], [cs_define_int32])])
    982. 

  982. 

  983. # CS_GL_INCLUDE(CPP-MACRO,FALLBACK,HEADER)
    984. 

  984. AC_DEFUN([CS_GL_INCLUDE],
    985. 

  985.     [AC_REQUIRE([CS_CHECK_GL_PREPARE])
    986. 

  986.     [#if HAVE_WINDOWS_H
    987. 

  987.     #if !HAVE_TYPE_INT32
    988. 

  988.     typedef long int32;
    989. 

  989.     #endif
    990. 

  990.     #include <windows.h>
    991. 

  991.     #endif
    992. 

  992.     #ifndef CS_HEADER_GLOBAL
    993. 

  993.     #define CS_HEADER_GLOBAL(X,Y) CS_HEADER_GLOBAL_COMPOSE(X,Y)
    994. 

  994.     #define CS_HEADER_GLOBAL_COMPOSE(X,Y) <X/Y>
    995. 

  995.     #endif
    996. 

  996.     #ifdef $1
    997. 

  997.     #include CS_HEADER_GLOBAL($1,$3)
    998. 

  998.     #else
    999. 

  999.     #include <$2/$3>
    1000. 

  1000.     #endif]])
    1001. 

  1001. 

  1002. CS_CHECK_GL_PREPARE
    1003. 

  1003. 

  1004. # Apply plaform-specific flags if necessary.
    1005. 

  1005. cs_gl_plat_cflags=''
    1006. 

  1006. cs_gl_plat_lflags=''
    1007. 

  1007. cs_gl_plat_libs=''
    1008. 

  1008. AS_IF([test -n "$cs_cv_libm_cflags$cs_cv_libm_lflags$cs_cv_libm_libs"],
    1009. 

  1009.     [cs_gl_plat_cflags="$cs_cv_libm_cflags $cs_gl_plat_cflags"
    1010. 

  1010.     cs_gl_plat_lflags="$cs_cv_libm_lflags $cs_gl_plat_lflags"
    1011. 

  1011.     cs_gl_plat_libs="$cs_cv_libm_libs $cs_gl_plat_libs"])
    1012. 

  1012. AS_IF([test $cs_cv_sys_pthread = yes],
    1013. 

  1013.     [cs_gl_plat_cflags="$cs_cv_sys_pthread_cflags $cs_gl_plat_cflags"
    1014. 

  1014.     cs_gl_plat_lflags="$cs_cv_sys_pthread_lflags $cs_gl_plat_lflags"
    1015. 

  1015.     cs_gl_plat_libs="$cs_cv_sys_pthread_libs $cs_gl_plat_libs"])
    1016. 

  1016. AS_IF([test "$no_x" != yes],
    1017. 

  1017.     [cs_gl_plat_cflags="$X_CFLAGS $cs_gl_plat_cflags"
    1018. 

  1018.     cs_gl_plat_lflags="$cs_gl_plat_lflags"
    1019. 

  1019.     cs_gl_plat_libs="
    1020. 

  1020. 	$X_PRE_LIBS $X_LIBS -lX11 -lXext $X_EXTRA_LIBS $cs_gl_plat_libs"])
    1021. 

    1022. 

  1022. # Mesa requested?
    1023. 

  1023. AC_ARG_WITH([mesa], [AC_HELP_STRING([--with-mesa],
    1024. 

  1024. 	[use Mesa OpenGL library if available (default YES)])],
    1025. 

  1025. 	[], [with_mesa=yes])
    1026. 

  1026. 

  1027. AS_IF([test $with_mesa != no],
    1028. 

  1028.     [cs_mesa_gl=CS_CREATE_TUPLE([],[],[-lMesaGL])
    1029. 

  1029.     cs_mesa_glu=CS_CREATE_TUPLE([],[],[-lMesaGLU])
    1030. 

  1030.     cs_mesa_glx=CS_CREATE_TUPLE([],[],[-lMesaGLX])])
    1031. 

  1031. 

  1032. # MacOS/X or Darwin?
    1033. 

  1033. AS_IF([test "x$cs_host_macosx" = "xyes"],
    1034. 

  1034.     [cs_osx_gl=CS_CREATE_TUPLE([-DCS_OPENGL_PATH=OpenGL],[],
    1035. 

  1035. 	[-framework OpenGL])
    1036. 

  1036.     cs_osx_glu=CS_CREATE_TUPLE([-DCS_GLU_PATH=OpenGL],[],[-framework OpenGL])
    1037. 

  1037.     cs_osx_glut=CS_CREATE_TUPLE([-DCS_GLUT_PATH=GLUT],[],[-framework GLUT])])
    1038. 

  1038. 

  1039. # Windows?
    1040. 

  1040. case $host_os in
    1041. 

  1041.     mingw*|cygwin*)
    1042. 

  1042. 	cs_win32_gl=CS_CREATE_TUPLE([],[],[-lopengl32])
    1043. 

  1043. 	cs_win32_glu=CS_CREATE_TUPLE([],[],[-lglu32])
    1044. 

  1044. 	cs_win32_glut=CS_CREATE_TUPLE([],[],[-lglut32])
    1045. 

  1045.     ;;
    1046. 

  1046. esac
    1047. 

  1047. 

  1048. # Check for OpenGL.
    1049. 

  1049. CS_CHECK_BUILD([for OpenGL], [cs_cv_libgl],
    1050. 

  1050.     [AC_LANG_PROGRAM([CS_GL_INCLUDE([CS_OPENGL_PATH],[GL],[gl.h])],[glEnd()])],
    1051. 

  1051.     [$cs_win32_gl \
    1052. 

  1052.     $cs_osx_gl \
    1053. 

  1053.     CS_CREATE_TUPLE([],[],[-lGL]) \
    1054. 

  1054.     CS_CREATE_TUPLE([],[],[-lgl]) \
    1055. 

  1055.     $cs_mesa_gl], [],
    1056. 

  1056.     [CS_EMIT_BUILD_RESULT([cs_cv_libgl], [GL])], [], [],
    1057. 

  1057.     [$cs_gl_plat_cflags], [$cs_gl_plat_lflags], [$cs_gl_plat_libs])
    1058. 

  1058. 

  1059. AS_IF([test $cs_cv_libgl = yes],
    1060. 

  1060.     [# Check for GLU.
    1061. 

  1061.     CS_CHECK_BUILD([for GLU], [cs_cv_libglu],
    1062. 

  1062. 	[AC_LANG_PROGRAM(
    1063. 

  1063. 	    [CS_GL_INCLUDE([CS_GLU_PATH],[GL],[glu.h])], [gluNewQuadric()])],
    1064. 

  1064. 	[$cs_osx_glu \
    1065. 

  1065. 	CS_CREATE_TUPLE() \
    1066. 

  1066. 	$cs_win32_glu \
    1067. 

  1067. 	CS_CREATE_TUPLE([],[],[-lGLU]) \
    1068. 

  1068. 	CS_CREATE_TUPLE([],[],[-lglu]) \
    1069. 

  1069. 	$cs_mesa_glu], [],
    1070. 

  1070. 	[CS_EMIT_BUILD_RESULT([cs_cv_libglu], [GLU])], [], [],
    1071. 

  1071. 	[$cs_cv_libgl_cflags], [$cs_cv_libgl_lflags], [$cs_cv_libgl_libs])
    1072. 

  1072. 

  1073.     # Check for GLUT.
    1074. 

  1074.     CS_CHECK_BUILD([for GLUT], [cs_cv_libglut],
    1075. 

  1075. 	[AC_LANG_PROGRAM(
    1076. 

  1076. 	    [CS_GL_INCLUDE([CS_GLUT_PATH],[GL],[glut.h])], [glutSwapBuffers])],
    1077. 

  1077. 	[$cs_osx_glut \
    1078. 

  1078. 	CS_CREATE_TUPLE() \
    1079. 

  1079. 	$cs_win32_glut \
    1080. 

  1080. 	CS_CREATE_TUPLE([],[],[-lGLUT]) \
    1081. 

  1081. 	CS_CREATE_TUPLE([],[],[-lglut])], [],
    1082. 

  1082. 	[CS_EMIT_BUILD_RESULT([cs_cv_libglut], [GLUT])], [], [],
    1083. 

  1083. 	[$cs_cv_libgl_cflags], [$cs_cv_libgl_lflags], [$cs_cv_libgl_libs])
    1084. 

  1084. 

  1085.     # Check for GLX.
    1086. 

  1086.     CS_CHECK_BUILD([for GLX], [cs_cv_libglx],
    1087. 

  1087. 	[AC_LANG_PROGRAM([[#include <GL/glx.h>]], [glXWaitGL()])],
    1088. 

  1088. 	[CS_CREATE_TUPLE() \
    1089. 

  1089. 	CS_CREATE_TUPLE([],[],[-lGLX]) \
    1090. 

  1090. 	CS_CREATE_TUPLE([],[],[-lglx]) \
    1091. 

  1091. 	$cs_mesa_glx], [],
    1092. 

  1092. 	[CS_EMIT_BUILD_RESULT([cs_cv_libglx], [GLX])], [], [],
    1093. 

  1093. 	[$cs_cv_libgl_cflags], [$cs_cv_libgl_lflags], [$cs_cv_libgl_libs])
    1094. 

  1094. 

  1095.     # Check for GLX extensions.  Define CSGL_EXT_STATIC_ASSERTION if _not_
    1096. 

  1096.     # present.
    1097. 

  1097.     AS_IF([test $cs_cv_libglx = yes],
    1098. 

  1098. 	[CS_CHECK_BUILD([for GLX extensions], [cs_cv_libglx_extensions],
    1099. 

  1099. 	    [AC_LANG_PROGRAM(
    1100. 

  1100. 		[[#define GLX_GLXEXT_PROTOTYPES
    1101. 

  1101. 		#include <GL/glx.h>]],
    1102. 

  1102. 		[glXGetProcAddressARB(0)])],
    1103. 

  1103. 	    [CS_CREATE_TUPLE(
    1104. 

  1104. 		[$cs_cv_libglx_cflags],
    1105. 

  1105. 		[$cs_cv_libglx_lflags],
    1106. 

  1106. 		[$cs_cv_libglx_libs])],
    1107. 

  1107. 	    [], [], [CS_HEADER_PROPERTY([CSGL_EXT_STATIC_ASSERTION])])])])
    1108. 

  1108. 

  1109. 

  1110. 

  1111. #------------------------------------------------------------------------------
    1112. 

  1112. # Check for DirectDraw.  At least one user (Jorrit) has a strange installation
    1113. 

  1113. # in which inclusion of <windows.h> fails if an int32 is not present, thus we
    1114. 

  1114. # must take this into account.  With Cygwin, we must check for the DirectX
    1115. 

  1115. # headers in /usr/include/directx.
    1116. 

  1116. #------------------------------------------------------------------------------
    1117. 

  1117. AC_CHECK_TYPE([int32], [AC_DEFINE([HAVE_TYPE_INT32])], [])
    1118. 

  1118. CS_CHECK_BUILD([for DirectX], [cs_cv_libdirectx],
    1119. 

  1119.     [AC_LANG_PROGRAM(
    1120. 

  1120. 	[[#if !HAVE_TYPE_INT32
    1121. 

  1121. 	typedef long int32;
    1122. 

  1122. 	#endif
    1123. 

  1123. 	#include <windows.h>
    1124. 

  1124. 	#include <ddraw.h>
    1125. 

  1125. 	#include <dsound.h>
    1126. 

  1126. 	#include <dinput.h>]],
    1127. 

  1127. 	[DirectDrawCreate(0,0,0); 
    1128. 

  1128. 	 DirectSoundCreate(0,0,0); 
    1129. 

  1129. 	 DirectInputCreate(0,0,0,0)])],
    1130. 

  1130.     [CS_CREATE_TUPLE([],[],[-lddraw -ldsound -ldinput]) \
    1131. 

  1131.     CS_CREATE_TUPLE([-I/usr/include/directx],[],[-lddraw -ldsound -ldinput])], 
    1132. 

  1132.     [], [CS_EMIT_BUILD_RESULT([cs_cv_libdirectx], [DIRECTX])])
    1133. 

  1133. 

  1134. 

  1135. 

  1136. #------------------------------------------------------------------------------
    1137. 

  1137. # Check for the Windows Multimedia library, used by the 'sndwaveout' plugin.
    1138. 

  1138. #------------------------------------------------------------------------------
    1139. 

  1139. CS_CHECK_BUILD([for waveout], [cs_cv_libwaveout],
    1140. 

  1140.     [AC_LANG_PROGRAM(
    1141. 

  1141. 	[[#include <windows.h>
    1142. 

  1142. 	#include <mmsystem.h>]],
    1143. 

  1143. 	[waveOutOpen(0, 0, 0, 0, 0, 0)])],
    1144. 

  1144.     [CS_CREATE_TUPLE([],[],[-lwinmm])], 
    1145. 

  1145.     [], [CS_EMIT_BUILD_RESULT([cs_cv_libwaveout], [WAVEOUT])])
    1146. 

  1146. 

  1147. 

  1148. 

  1149. #------------------------------------------------------------------------------
    1150. 

  1150. # Check for zlib.  In addition to the standard installed locations, we also
    1151. 

  1151. # search CS/libs/zlib*.
    1152. 

  1152. #------------------------------------------------------------------------------
    1153. 

  1153. CS_CHECK_LIB_WITH([z],
    1154. 

  1154.     [AC_LANG_PROGRAM([[#include <zlib.h>]], [zlibVersion()])],
    1155. 

  1155.     [$srcdir/libs/zlib*], [], [CS_EMIT_BUILD_RESULT([cs_cv_libz], [ZLIB])],
    1156. 

  1156.     [CS_MSG_ERROR([zlib is essential for building CS.])], [], [], [], [zlib])
    1157. 

  1157. 

  1158. 

  1159. 

  1160. #------------------------------------------------------------------------------
    1161. 

  1161. # Check for libpng.  In addition to the standard installed locations, we also
    1162. 

  1162. # search CS/libs/libpng*.  Some platforms, such as RedHat 8.x require libm.a to
    1163. 

  1163. # be linked with libpng, so use libm.a if available.
    1164. 

  1164. #------------------------------------------------------------------------------
    1165. 

  1165. AC_DEFUN([CS_CHECK_LIBPNG_PREPARE],
    1166. 

  1166.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])])
    1167. 

  1167. 

  1168. AS_IF([test "$cs_cv_libz" = yes],
    1169. 

  1169.     [CS_CHECK_LIBPNG_PREPARE
    1170. 

  1170.     CS_CHECK_LIB_WITH([png],
    1171. 

  1171. 	[AC_LANG_PROGRAM([[#include <png.h>]],
    1172. 

  1172. 	    [png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0)])],
    1173. 

  1173. 	[$srcdir/libs/libpng*], [],
    1174. 

  1174. 	[CS_EMIT_BUILD_RESULT([cs_cv_libpng], [PNG])], [],
    1175. 

  1175. 	[$cs_cv_libz_cflags $cs_cv_libm_cflags],
    1176. 

  1176. 	[$cs_cv_libz_lflags $cs_cv_libm_lflags],
    1177. 

  1177. 	[$cs_cv_libz_libs $cs_cv_libm_libs], [libpng])])
    1178. 

  1178. 

  1179. 

  1180. 

  1181. #------------------------------------------------------------------------------
    1182. 

  1182. # Check for libjpeg.  In addition to the standard installed locations, we also
    1183. 

  1183. # search CS/libs/*jpeg*.
    1184. 

  1184. #------------------------------------------------------------------------------
    1185. 

  1185. CS_CHECK_LIB_WITH([jpeg],
    1186. 

  1186.     [AC_LANG_PROGRAM(
    1187. 

  1187. 	[[#include <stddef.h>
    1188. 

  1188. 	#include <stdio.h>
    1189. 

  1189. 	#include <jpeglib.h>]],
    1190. 

  1190. 	[jpeg_create_compress(0)])],
    1191. 

  1191.     [$srcdir/libs/*jpeg*], [], [CS_EMIT_BUILD_RESULT([cs_cv_libjpeg], [JPEG])],
    1192. 

  1192.     [], [], [], [], [libjpeg])
    1193. 

    1194. 

    1195. 

    1196. 

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

  1197. # Check for libmng.  In addition to the standard installed locations, we also
    1198. 

  1198. # search CS/libs/libmng*.
    1199. 

  1199. #------------------------------------------------------------------------------
    1200. 

  1200. AS_IF([test "$cs_cv_libz" = yes && test "$cs_cv_libjpeg" = yes],
    1201. 

  1201.     [CS_CHECK_LIB_WITH([mng],
    1202. 

  1202. 	[AC_LANG_PROGRAM([[#include <libmng.h>]], [mng_version_release()])],
    1203. 

  1203. 	[$srcdir/libs/libmng*], [],
    1204. 

  1204. 	[CS_EMIT_BUILD_RESULT([cs_cv_libmng], [MNG])], [],
    1205. 

  1205. 	[$cs_cv_libjpeg_cflags $cs_cv_libz_cflags],
    1206. 

  1206. 	[$cs_cv_libjpeg_lflags $cs_cv_libz_lflags],
    1207. 

  1207. 	[$cs_cv_libjpeg_libs $cs_cv_libz_libs], [libmng])])
    1208. 

    1209. 

    1210. 

    1211. 

  1211. #------------------------------------------------------------------------------
    1212. 

  1212. # Check for libmikmod.  In addition to the standard installed locations, we
    1213. 

  1213. # also search CS/libs/libmikmod*.
    1214. 

  1214. #------------------------------------------------------------------------------
    1215. 

  1215. CS_CHECK_LIB_WITH([mikmod],
    1216. 

  1216.     [AC_LANG_PROGRAM(
    1217. 

  1217. 	[[#include <mikmod.h>]],
    1218. 

  1218. 	[MikMod_Init("mikmodtest"); MikMod_Exit();])],
    1219. 

  1219.     [$srcdir/libs/libmikmod*], [],
    1220. 

  1220.     [CS_EMIT_BUILD_RESULT([cs_cv_libmikmod], [MIKMOD])], [],
    1221. 

  1221.     [$cs_cv_sys_pthread_cflags],
    1222. 

  1222.     [$cs_cv_sys_pthread_lflags],
    1223. 

  1223.     [$cs_cv_sys_pthread_libs])
    1224. 

    1225. 

    1226. 

    1227. 

  1227. #------------------------------------------------------------------------------
    1228. 

  1228. # Check for libogg/libvorbis/libvorbisfile.  In addition to the standard
    1229. 

  1229. # installed locations, we also search CS/libs/libogg*, CS/libs/libvorbis.*,
    1230. 

  1230. # CS/libs/libvorbisfile*.
    1231. 

  1231. #------------------------------------------------------------------------------
    1232. 

  1232. CS_CHECK_LIB_WITH([ogg],
    1233. 

  1233.     [AC_LANG_PROGRAM(
    1234. 

  1234. 	[[#include <ogg/ogg.h>]],
    1235. 

  1235. 	[ogg_sync_state state; ogg_sync_init(&state);])],
    1236. 

  1236.     [$srcdir/libs/libogg*], [],
    1237. 

  1237.     [CS_EMIT_BUILD_RESULT([cs_cv_libogg], [OGG])])
    1238. 

    1239. 

  1239. AS_IF([test "$cs_cv_libogg" = yes],
    1240. 

  1240.     [CS_CHECK_LIB_WITH([vorbis],
    1241. 

  1241. 	[AC_LANG_PROGRAM([[#include <vorbis/codec.h>]],
    1242. 

  1242. 	  [vorbis_info info; vorbis_info_init(&info);])],
    1243. 

  1243. 	[$srcdir/libs/libvorbis.*], [],
    1244. 

  1244. 	[CS_EMIT_BUILD_RESULT([cs_cv_libvorbis], [VORBIS])], [],
    1245. 

  1245. 	[$cs_cv_libogg_cflags],
    1246. 

  1246. 	[$cs_cv_libogg_lflags],
    1247. 

  1247. 	[$cs_cv_libogg_libs])])
    1248. 

    1249. 

  1249. AS_IF([test "$cs_cv_libvorbis" = yes],
    1250. 

  1250.     [CS_CHECK_LIB_WITH([vorbisfile],
    1251. 

  1251. 	[AC_LANG_PROGRAM(
    1252. 

  1252. 	    [[#include <vorbis/vorbisfile.h>
    1253. 

  1253. 	    #include <stdio.h>]],
    1254. 

  1254. 	    [OggVorbis_File file; ov_test(stdin, &file, "", 0);])],
    1255. 

  1255. 	[$srcdir/libs/libvorbisfile*], [],
    1256. 

  1256. 	[CS_EMIT_BUILD_RESULT([cs_cv_libvorbisfile], [VORBISFILE])], [],
    1257. 

  1257. 	[$cs_cv_libogg_cflags $cs_cv_libvorbis_cflags],
    1258. 

  1258. 	[$cs_cv_libogg_lflags $cs_cv_libvorbis_lflags],
    1259. 

  1259. 	[$cs_cv_libogg_libs $cs_cv_libvorbis_libs])])
    1260. 

    1261. 

    1262. 

    1263. 

  1263. #------------------------------------------------------------------------------
    1264. 

  1264. # Check for lib3ds.  In addition to the standard installed locations, we also
    1265. 

  1265. # search CS/libs/lib3ds*.
    1266. 

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

  1267. AC_DEFUN([CS_CHECK_LIB3DS_PREPARE],
    1268. 

  1268.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])])
    1269. 

    1270. 

  1270. CS_CHECK_LIB3DS_PREPARE
    1271. 

    1272. 

  1272. CS_CHECK_LIB_WITH([3ds],
    1273. 

  1273.     [AC_LANG_PROGRAM([[#include <lib3ds/file.h>]],[lib3ds_file_new();])],
    1274. 

  1274.     [$srcdir/libs/lib3ds*], [], [], [], [], [], [$cs_cv_libm_libs],
    1275. 

  1275.     [lib3ds-120])
    1276. 

    1277. 

  1277. AS_IF([test $cs_cv_lib3ds = yes],
    1278. 

  1278.     [CS_CHECK_BUILD([if lib3ds is sufficiently recent], [cs_cv_lib3ds_recent],
    1279. 

  1279. 	[AC_LANG_PROGRAM([[#include <lib3ds/io.h>]], [lib3ds_io_free(0);])],
    1280. 

  1280. 	[], [], [CS_EMIT_BUILD_RESULT([cs_cv_lib3ds], [3DS])], [], [],
    1281. 

  1281. 	[$cs_cv_lib3ds_cflags], [$cs_cv_lib3ds_lflags], [$cs_cv_lib3ds_libs])])
    1282. 

    1283. 

    1284. 

    1285. 

  1285. #------------------------------------------------------------------------------
    1286. 

  1286. # Check for libode.  In addition to the standard installed locations, we also
    1287. 

  1287. # search CS/libs/libode*.  Also check if it is a sufficiently recent version.
    1288. 

  1288. # Finally, the cs-win32libs package uses a slightly augmented libode in which
    1289. 

  1289. # functions are exported as `extern "C"' to avoid name mangling problems which
    1290. 

  1290. # would otherwise prevent the package from being used with different compilers.
    1291. 

  1291. # Therefore, we need to check if `extern "C"' is needed.
    1292. 

  1292. #------------------------------------------------------------------------------
    1293. 

  1293. CS_CHECK_LIB_WITH([ode],
    1294. 

  1294.     [AC_LANG_PROGRAM([[#include <ode/ode.h>]], [dWorldCreate()])],
    1295. 

  1295.     [$srcdir/libs/libode*], [C++])
    1296. 

    1297. 

  1297. AS_IF([test $cs_cv_libode = yes],
    1298. 

  1298.     [CS_CHECK_BUILD([if libode is sufficiently recent], [cs_cv_libode_recent],
    1299. 

  1299. 	[AC_LANG_PROGRAM(
    1300. 

  1300. 	    [[#include <ode/ode.h>]],
    1301. 

  1301. 	    [dWorldID w = dWorldCreate();
    1302. 

  1302. 	    dBodySetGravityMode(0,0);
    1303. 

  1303. 	    dWorldStepFast1(w,0,0);
    1304. 

  1304. 	    dCloseODE();])],
    1305. 

  1305. 	[], [C++], [CS_EMIT_BUILD_RESULT([cs_cv_libode], [ODE])], [], [],
    1306. 

  1306. 	[$cs_cv_libode_cflags], [$cs_cv_libode_lflags], [$cs_cv_libode_libs])],
    1307. 

  1307. 	[cs_cv_libode_recent=no])
    1308. 

    1309. 

  1309. AS_IF([test $cs_cv_libode_recent = yes],
    1310. 

  1310.     [CS_CHECK_BUILD([if extern "C" is needed with libode],
    1311. 

  1311. 	[cs_cv_libode_extern_c],
    1312. 

  1312. 	[AC_LANG_PROGRAM(
    1313. 

  1313. 	    [[#include <ode/ode.h>
    1314. 

  1314. 	    extern "C"
    1315. 

  1315. 	    int dCollideBoxPlane(dxGeom*,dxGeom*,int,dContactGeom*,int);]],
    1316. 

  1316. 	    [dCollideBoxPlane(0,0,0,0,0);])],
    1317. 

  1317. 	[], [C++], [CS_EMIT_BUILD_PROPERTY([ODE.EXTERN_C], [yes])], [], [],
    1318. 

  1318. 	[$cs_cv_libode_cflags], [$cs_cv_libode_lflags], [$cs_cv_libode_libs])])
    1319. 

    1320. 

    1321. 

    1322. 

  1322. #------------------------------------------------------------------------------
    1323. 

  1323. # Check for libopenal.
    1324. 

  1324. #------------------------------------------------------------------------------
    1325. 

  1325. # CS_AL_INCLUDE(CPP-MACRO,FALLBACK,HEADER)
    1326. 

  1326. AC_DEFUN([CS_AL_INCLUDE],
    1327. 

  1327.     [[#ifndef CS_HEADER_GLOBAL
    1328. 

  1328.     #define CS_HEADER_GLOBAL(X,Y) CS_HEADER_GLOBAL_COMPOSE(X,Y)
    1329. 

  1329.     #define CS_HEADER_GLOBAL_COMPOSE(X,Y) <X/Y>
    1330. 

  1330.     #endif
    1331. 

  1331.     #ifdef $1
    1332. 

  1332.     #include CS_HEADER_GLOBAL($1,$3)
    1333. 

  1333.     #else
    1334. 

  1334.     #include <$2/$3>
    1335. 

  1335.     #endif]])
    1336. 

    1337. 

  1337. AC_DEFUN([CS_CHECK_LIBOPENAL],
    1338. 

  1338.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])
    1339. 

  1339.     CS_CHECK_BUILD([for OpenAL], [cs_cv_libopenal],
    1340. 

  1340. 	[AC_LANG_PROGRAM(
    1341. 

  1341. 	    [CS_AL_INCLUDE([CS_OPENAL_PATH],[AL],[alut.h])],
    1342. 

  1342. 	    [alutInit(0,0);])],
    1343. 

  1343. 	[CS_CREATE_TUPLE([-DCS_OPENAL_PATH=OpenAL],[],[-framework OpenAL]) \
    1344. 

  1344. 	CS_CREATE_TUPLE([],[],[-lopenal]) \
    1345. 

  1345. 	CS_CREATE_TUPLE([],[],[-lopenal32]) \
    1346. 

  1346. 	CS_CREATE_TUPLE([],[],[-lalut -lopenal]) \
    1347. 

  1347. 	CS_CREATE_TUPLE([],[],[-lalut -lopenal32]) \
    1348. 

  1348. 	CS_CREATE_TUPLE([],[],[-lALut -lOpenAL32]) \
    1349. 

  1349. 	CS_CREATE_TUPLE([],[],[-lopenal -ldsound]) \
    1350. 

  1350. 	CS_CREATE_TUPLE([],[],[-lopenal32 -ldsound]) \
    1351. 

  1351. 	CS_CREATE_TUPLE([],[],[-lalut -lopenal -ldsound]) \
    1352. 

  1352. 	CS_CREATE_TUPLE([],[],[-lalut -lopenal32 -ldsound])], [],
    1353. 

  1353. 	[CS_EMIT_BUILD_RESULT([cs_cv_libopenal], [OPENAL])], [], [],
    1354. 

  1354. 	[$cs_cv_sys_pthread_cflags],
    1355. 

  1355. 	[$cs_cv_sys_pthread_lflags],
    1356. 

  1356. 	[$cs_cv_sys_pthread_libs $cs_cv_libdl_libs $cs_cv_libm_libs])])
    1357. 

    1358. 

  1358. CS_CHECK_LIBOPENAL
    1359. 

    1360. 

    1361. 

    1362. 

  1362. #------------------------------------------------------------------------------
    1363. 

  1363. # Check for FreeType2.
    1364. 

  1364. #------------------------------------------------------------------------------
    1365. 

  1365. AC_CHECK_TOOLS([FT2CONFIG], [freetype-config])
    1366. 

  1366. AC_CACHE_CHECK([for FreeType2], [cs_cv_libft2],
    1367. 

  1367.     [AS_IF([test -n "$FT2CONFIG"],
    1368. 

  1368. 	[cs_cv_libft2=yes
    1369. 

  1369. 	cs_cv_libft2_cflags=`AC_RUN_LOG([$FT2CONFIG --cflags])`
    1370. 

  1370. 	cs_cv_libft2_lflags=''
    1371. 

  1371. 	cs_cv_libft2_libs=`AC_RUN_LOG([$FT2CONFIG --libs])`],
    1372. 

  1372. 	[cs_cv_libft2=no])])
    1373. 

    1374. 

  1374. AS_IF([test $cs_cv_libft2 = yes],
    1375. 

  1375.     [CS_CHECK_BUILD([if freetype2 is sufficiently recent], [cs_cv_ft2_recent],
    1376. 

  1376. 	[AC_LANG_PROGRAM(
    1377. 

  1377. 	    [[#include <ft2build.h>
    1378. 

  1378. 	    #include FT_INTERNAL_OBJECTS_H
    1379. 

  1379. 	    #include FT_FREETYPE_H
    1380. 

  1380. 	    #include FT_GLYPH_H
    1381. 

  1381. 	    #include FT_MODULE_H]], [return
    1382. 

  1382. 	    FT_LOAD_TARGET_MONO|FT_RENDER_MODE_NORMAL|FT_ENCODING_UNICODE])],
    1383. 

  1383. 	[], [], [CS_EMIT_BUILD_RESULT([cs_cv_libft2], [FT2])], [], [],
    1384. 

  1384. 	[$cs_cv_libft2_cflags], [$cs_cv_libft2_lflags], [$cs_cv_libft2_libs])])
    1385. 

    1386. 

    1387. 

    1388. 

  1388. #------------------------------------------------------------------------------
    1389. 

  1389. # For Mingw, test if we need to link explicitly with libmingwex.a.  Older
    1390. 

  1390. # versions of Mingw did not have this library, whereas newer interim versions
    1391. 

  1391. # supply it but do not link automatically with it.  The very newest versions
    1392. 

  1392. # link with libmingwex.a automatically.  To see if libmingwex.a is required, we
    1393. 

  1393. # try calling opendir(), which exists in libming32.a for older releases, and in
    1394. 

  1394. # libmingwex.a for newer releases.
    1395. 

  1395. #------------------------------------------------------------------------------
    1396. 

  1396. AC_DEFUN([CS_CHECK_LIBMINGWX],
    1397. 

  1397.     [AC_REQUIRE([AC_CANONICAL_HOST])
    1398. 

  1398.     case $host_os in
    1399. 

  1399. 	mingw*)
    1400. 

  1400. 	    AC_CACHE_CHECK([for libmingwex], [cs_cv_libmingwex],
    1401. 

  1401. 		[CS_BUILD_IFELSE(
    1402. 

  1402. 		    [AC_LANG_PROGRAM([[#include <dirent.h>]], [opendir("");])],
    1403. 

  1403. 		    [CS_CREATE_TUPLE() CS_CREATE_TUPLE([],[],[-lmingwex])], [],
    1404. 

  1404. 		    [AS_IF([test -n "$cs_build_libs"],
    1405. 

  1405. 			[cs_cv_libmingwex=yes], [cs_cv_libmingwex=no])],
    1406. 

  1406. 		    [cs_cv_libmingwex=no])])
    1407. 

  1407. 	    ;;
    1408. 

  1408. 	*) cs_cv_libmingwex=no ;;
    1409. 

  1409.     esac])
    1410. 

    1411. 

  1411. CS_CHECK_LIBMINGWX
    1412. 

  1412. AS_IF([test $cs_cv_libmingwex = yes],
    1413. 

  1413.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lmingwex], [+])])
    1414. 

    1415. 

    1416. 

    1417. 

  1417. #------------------------------------------------------------------------------
    1418. 

  1418. # Check for cal3d.
    1419. 

  1419. #------------------------------------------------------------------------------
    1420. 

  1420. CS_CHECK_LIB_WITH([cal3d],
    1421. 

  1421.     [AC_LANG_PROGRAM([[#include <cal3d/cal3d.h>]],
    1422. 

  1422. 	[CalModel m; m.create(0); m.destroy();])], [], [C++])
    1423. 

    1424. 

  1424. AS_IF([test $cs_cv_libcal3d = yes],
    1425. 

  1425.     [CS_CHECK_BUILD([if cal3d is sufficiently recent], [cs_cv_cal3d_recent],
    1426. 

  1426. 	[AC_LANG_PROGRAM(
    1427. 

  1427. 	    [[#include <cal3d/cal3d.h>]],
    1428. 

  1428. 	    [CalModel m; m.getMixer()->removeAction(0);])],
    1429. 

  1429. 	[], [C++],
    1430. 

  1430. 	[CS_EMIT_BUILD_RESULT([cs_cv_libcal3d], [CAL3D])], [], [],
    1431. 

  1431. 	[$cs_cv_libcal3d_cflags],
    1432. 

  1432. 	[$cs_cv_libcal3d_lflags],
    1433. 

  1433. 	[$cs_cv_libcal3d_libs])])
    1434. 

    1435. 

  1435.     
    1436. 

    1437. 

  1437. #------------------------------------------------------------------------------
    1438. 

  1438. # Check for SDL.
    1439. 

  1439. #------------------------------------------------------------------------------
    1440. 

  1440. AC_CHECK_TOOLS([SDLCONFIG], [sdl12-config sdl11-config sdl-config])
    1441. 

    1442. 

  1442. AC_CACHE_CHECK([for SDL], [cs_cv_libsdl],
    1443. 

  1443.     [AS_IF([test -n "$SDLCONFIG"],
    1444. 

  1444. 	[cs_cv_libsdl=yes
    1445. 

  1445. 	cs_cv_libsdl_cflags=`AC_RUN_LOG([$SDLCONFIG --cflags])`
    1446. 

  1446. 	cs_cv_libsdl_lflags=''
    1447. 

  1447. 	cs_cv_libsdl_libs=`AC_RUN_LOG([$SDLCONFIG --libs])`],
    1448. 

  1448. 	[cs_cv_libsdl=no])])
    1449. 

    1450. 

  1450. AS_IF([test $cs_cv_libsdl = yes],
    1451. 

  1451.     [CS_CHECK_BUILD([if SDL is sufficiently recent], [cs_cv_sdl_recent],
    1452. 

  1452. 	[AC_LANG_PROGRAM([[#include <SDL.h>]], [SDL_EnableKeyRepeat(0,0)])],
    1453. 

  1453. 	[], [], [CS_EMIT_BUILD_RESULT([cs_cv_libsdl], [SDL])], [], [],
    1454. 

  1454. 	[$cs_cv_libsdl_cflags], [$cs_cv_libsdl_lflags], [$cs_cv_libsdl_libs])])
    1455. 

    1456. 

    1457. 

    1458. 

  1458. #------------------------------------------------------------------------------
    1459. 

  1459. # Check for VOS.
    1460. 

  1460. #------------------------------------------------------------------------------
    1461. 

  1461. AC_ARG_WITH([vos], [AC_HELP_STRING([--with-vos=dir],
    1462. 

  1462.     [specify location of VOS pkg-config files])])
    1463. 

  1463. AS_IF([test -z "$with_vos"], [with_vos=yes])
    1464. 

    1465. 

  1465. AS_IF([test "$with_vos" != no && test "$with_vos" != yes],
    1466. 

  1466.     [AS_IF([test -n "$PKG_CONFIG_PATH"],
    1467. 

  1467. 	[PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$with_vos"],
    1468. 

  1468. 	[PKG_CONFIG_PATH="$with_vos"])
    1469. 

  1469.     export PKG_CONFIG_PATH])
    1470. 

  1470. AC_CHECK_TOOLS([PKGCONFIG], [pkg-config])
    1471. 

    1472. 

  1472. m4_define([cs_vos_pkgs], [libmetaobject_a3dl libmetaobject_misc])
    1473. 

  1473. AS_IF([test "$with_vos" != no],
    1474. 

  1474.     [AC_CACHE_CHECK([for VOS], [cs_cv_libvos],
    1475. 

  1475. 	[AS_IF([test -n "$PKGCONFIG"],
    1476. 

  1476. 	    [AS_IF([AC_RUN_LOG([$PKGCONFIG --exists libmetaobject_a3dl])],
    1477. 

  1477. 		[cs_cv_libvos=yes
    1478. 

  1478. 		cs_cv_libvos_cflags="`AC_RUN_LOG(
    1479. 

  1479. 		    [$PKGCONFIG --cflags cs_vos_pkgs])`"
    1480. 

  1480. 		cs_cv_libvos_lflags=''
    1481. 

  1481. 		cs_cv_libvos_libs=`AC_RUN_LOG(
    1482. 

  1482. 		    [$PKGCONFIG --libs cs_vos_pkgs])`],
    1483. 

  1483. 		[cs_cv_libvos=no])],
    1484. 

  1484. 	    [cs_cv_libvos=no])])
    1485. 

  1485.     AS_IF([test $cs_cv_libvos = yes],
    1486. 

  1486. 	[CS_EMIT_BUILD_RESULT([cs_cv_libvos], [VOS])])])
    1487. 

    1488. 

    1489. 

    1490. 

  1490. #------------------------------------------------------------------------------
    1491. 

  1491. # Check if Linux joystick API is present.
    1492. 

  1492. #------------------------------------------------------------------------------
    1493. 

  1493. CS_CHECK_BUILD([for Linux joystick API], [cs_cv_sys_linux_joystick],
    1494. 

  1494.     [AC_LANG_PROGRAM(
    1495. 

  1495. 	[[#include <fcntl.h>
    1496. 

  1496. 	#include <sys/ioctl.h>
    1497. 

  1497. 	#include <linux/joystick.h>]],
    1498. 

  1498. 	[unsigned char axes;
    1499. 

  1499. 	unsigned char buttons;
    1500. 

  1500. 	int version;
    1501. 

  1501. 	char name[[[128]]];
    1502. 

  1502. 	int fd;
    1503. 

  1503. 	struct js_event js;
    1504. 

  1504. 	(void)js;
    1505. 

  1505. 	ioctl(fd, JSIOCGVERSION, &version);
    1506. 

  1506. 	ioctl(fd, JSIOCGAXES, &axes);
    1507. 

  1507. 	ioctl(fd, JSIOCGBUTTONS, &buttons);
    1508. 

  1508. 	ioctl(fd, JSIOCGNAME(128), name);])],
    1509. 

  1509.     [], [],
    1510. 

  1510.     [CS_EMIT_BUILD_PROPERTY([LINUXJOYSTICK.AVAILABLE], [yes])])
    1511. 

    1512. 

    1513. 

    1514. 

  1514. #------------------------------------------------------------------------------
    1515. 

  1515. # Check for Cg shader package.
    1516. 

  1516. #------------------------------------------------------------------------------
    1517. 

  1517. AC_CHECK_PROGS([CGC], [cgc])
    1518. 

  1518. CS_EMIT_BUILD_PROPERTY([CGC], [$CGC])
    1519. 

    1520. 

  1520. AC_DEFUN([CS_CHECK_LIBCG],
    1521. 

  1521.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])
    1522. 

  1522.     AC_REQUIRE([CS_CHECK_PTHREAD])
    1523. 

  1523.     CS_CHECK_LIB_WITH([Cg],
    1524. 

  1524. 	[AC_LANG_PROGRAM(
    1525. 

  1525. 	    [[#include <Cg/cg.h>]],
    1526. 

  1526. 	    [CGcontext c = cgCreateContext()])],
    1527. 

  1527. 	[], [], [], [],
    1528. 

  1528. 	[$cs_cv_libm_cflags $cs_cv_sys_pthread_cflags], 
    1529. 

  1529. 	[$cs_cv_libm_lflags $cs_cv_sys_pthread_lflags], 
    1530. 

  1530. 	[$cs_cv_libm_libs   $cs_cv_sys_pthread_libs],
    1531. 

  1531. 	[cg CG])
    1532. 

    1533. 

  1533.     AS_IF([test $cs_cv_libCg = yes],
    1534. 

  1534. 	[CS_CHECK_LIB_WITH([CgGL],
    1535. 

  1535. 	    [AC_LANG_PROGRAM(
    1536. 

  1536. 		[[#include <Cg/cg.h>
    1537. 

  1537. 		#include <Cg/cgGL.h>]],
    1538. 

  1538. 		[CGprogram p; cgGLBindProgram(p)])],
    1539. 

  1539. 	    [], [],
    1540. 

  1540. 	    [CS_EMIT_BUILD_RESULT([cs_cv_libCgGL], [CG])], [],
    1541. 

  1541. 	    [$cs_cv_libCg_cflags $cs_cv_libgl_cflags $cs_cv_libglu_cflags],
    1542. 

  1542. 	    [$cs_cv_libCg_lflags $cs_cv_libgl_lflags $cs_cv_libglu_lflags],
    1543. 

  1543. 	    [$cs_cv_libCg_libs   $cs_cv_libgl_libs   $cs_cv_libglu_libs],
    1544. 

  1544. 	    [cggl cgGL CGGL])])])
    1545. 

    1546. 

  1546. CS_CHECK_LIBCG
    1547. 

    1548. 

    1549. 

    1550. 

  1550. #------------------------------------------------------------------------------
    1551. 

  1551. # Check for OpenSoundSystem (OSS).
    1552. 

  1552. #------------------------------------------------------------------------------
    1553. 

  1553. AC_CHECK_HEADER([soundcard.h],
    1554. 

  1554.     [CS_HEADER_PROPERTY([CS_HAS_SOUNDCARD_H])
    1555. 

  1555.     cs_cv_header_soundcard_h=yes],
    1556. 

  1556.     [AC_CHECK_HEADER([sys/soundcard.h],
    1557. 

  1557. 	[CS_HEADER_PROPERTY([CS_HAS_SYS_SOUNDCARD_H])
    1558. 

  1558. 	cs_cv_header_soundcard_h=yes],
    1559. 

  1559. 	[AC_CHECK_HEADER([machine/soundcard.h],
    1560. 

  1560. 	      [CS_HEADER_PROPERTY([CS_HAS_MACHINE_SOUNDCARD_H])
    1561. 

  1561. 	      cs_cv_header_soundcard_h=yes],
    1562. 

  1562. 	      [cs_cv_header_soundcard_h=no])])])
    1563. 

    1564. 

  1564. AS_IF([test $cs_cv_header_soundcard_h = yes],
    1565. 

  1565.     [CS_EMIT_BUILD_PROPERTY([OSS.AVAILABLE], [yes])])
    1566. 

    1567. 

    1568. 

    1569. 

  1569. #------------------------------------------------------------------------------
    1570. 

  1570. # Check for Advanced Linux Sound Architecture (ALSA)
    1571. 

  1571. #------------------------------------------------------------------------------
    1572. 

  1572. CS_CHECK_LIB_WITH([asound],
    1573. 

  1573.     [AC_LANG_PROGRAM(
    1574. 

  1574. 	[[#include <alsa/asoundlib.h>]],
    1575. 

  1575. 	[snd_pcm_hw_params_t* p; snd_pcm_hw_params_alloca(&p);])],
    1576. 

  1576.     [], [], [CS_EMIT_BUILD_RESULT([cs_cv_libasound], [ALSA])])
    1577. 

    1578. 

    1579. 

    1580. 

  1580. #------------------------------------------------------------------------------
    1581. 

  1581. # Check for DivX4 or OpenDivX.
    1582. 

  1582. #------------------------------------------------------------------------------
    1583. 

  1583. CS_CHECK_BUILD([for DivX4], [cs_cv_libdivxdecore4],
    1584. 

  1584.     [AC_LANG_PROGRAM(
    1585. 

  1585. 	[[#include <divx4/decore.h>]],
    1586. 

  1586. 	[DEC_MEM_REQS r; decore(0, DEC_OPT_MEMORY_REQS, 0, &r);])],
    1587. 

  1587.     [CS_CREATE_TUPLE([],[],[-ldivxdecore])], [],
    1588. 

  1588.     [CS_EMIT_BUILD_RESULT([cs_cv_libdivxdecore4], [DIVX4])])
    1589. 

    1590. 

  1590. AS_IF([test $cs_cv_libdivxdecore4 != yes],
    1591. 

  1591.     [CS_CHECK_BUILD([for OpenDivX], [cs_cv_libdivxdecore],
    1592. 

  1592. 	[AC_LANG_PROGRAM(
    1593. 

  1593. 	    [[#include <decore.h>]],
    1594. 

  1594. 	    [decore(0, DEC_OPT_RELEASE, 0, 0);])],
    1595. 

  1595. 	[CS_CREATE_TUPLE([],[],[-ldivxdecore])])
    1596. 

  1596.     AS_IF([test $cs_cv_libdivxdecore = yes],
    1597. 

  1597. 	[CS_CHECK_BUILD([is OpenDivX is sufficiently recent],
    1598. 

  1598. 	    [cs_cv_libdivxdecore_recent],
    1599. 

  1599. 	    [AC_LANG_PROGRAM(
    1600. 

  1600. 		[[#include <decore.h>]],
    1601. 

  1601. 		[DEC_PARAM d; d.color_depth = 0;])],
    1602. 

  1602. 	    [], [],
    1603. 

  1603. 	    [CS_EMIT_BUILD_RESULT([cs_cv_libdivxdecore], [OPENDIVX])], [], [],
    1604. 

  1604. 	    [$cs_cv_libdivxdecore_cflags],
    1605. 

  1605. 	    [$cs_cv_libdivxdecore_lflags],
    1606. 

  1606. 	    [$cs_cv_libdivxdecore_libs])])])
    1607. 

    1608. 

    1609. 

    1610. 

  1610. #------------------------------------------------------------------------------
    1611. 

  1611. # Check if regular expressions are available.
    1612. 

  1612. #------------------------------------------------------------------------------
    1613. 

  1613. CS_CHECK_BUILD([for regexp support], [cs_cv_regexp],
    1614. 

  1614.     [AC_LANG_PROGRAM(
    1615. 

  1615. 	[[#ifdef HAVE_SYS_TYPES_H
    1616. 

  1616. 	#include <sys/types.h>
    1617. 

  1617. 	#endif
    1618. 

  1618. 	#include <regex.h>]],
    1619. 

  1619. 	[regex_t re; regcomp (&re, 0, 0); regexec (&re, 0, 0, 0, 0);])],
    1620. 

  1620.     [], [],
    1621. 

  1621.     [CS_HEADER_PROPERTY([CS_HAS_REGEX])
    1622. 

  1622.    
    1623.