PageRenderTime 61ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/CS/migrated/tags/PRE_MAP2CS_REMOVAL/configure.ac

#
m4 | 1592 lines | 865 code | 267 blank | 460 comment | 0 complexity | 89444d5a9608ac647cf5e4be43766e1d MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, LGPL-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. # configure.ac                                                 -*- Autoconf -*-
    2. 

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

  3. # Copyright (C)2003-2006 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.99])
    16. 

  16. 

  17. 

  18. 

  19. #==============================================================================
    20. 

  20. # INITIALIZATION
    21. 

  21. #==============================================================================
    22. 

  22. AC_INIT([crystalspace], [cs_version_number],
    23. 

  23.         [crystal-main@lists.sourceforge.net])
    24. 

  24. CS_PACKAGEINFO([Crystal Space],
    25. 

  25.     [Copyright (C)1998-2005 Jorrit Tyberghein and others],
    26. 

  26.     [http://www.crystalspace3d.org/])
    27. 

  27. AC_CONFIG_SRCDIR([libs/Jamfile])
    28. 

  28. AC_CONFIG_AUX_DIR([mk/autoconf])
    29. 

  29. AC_CANONICAL_HOST
    30. 

  30. 

  31. 

  32. 

  33. #------------------------------------------------------------------------------
    34. 

  34. # Check for compilers and linker.
    35. 

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

  36. CS_PROG_CC
    37. 

  37. CS_PROG_CXX
    38. 

  38. CS_PROG_LINK
    39. 

  39. 

  40. AC_PROG_CXXCPP
    41. 

  41. CS_EMIT_BUILD_PROPERTY([CMD.C++CPP], [$CXXCPP])
    42. 

  42. 

  43. AS_IF([test $ac_compiler_gnu = yes],
    44. 

  44.     [cs_compiler_name=GCC CS_HEADER_PROPERTY([CS_COMPILER_GCC])],
    45. 

  45.     [cs_compiler_name="AS_TR_CPP([$CXX])"])
    46. 

  46. CS_EMIT_BUILD_PROPERTY([COMPILER.TYPE], [$cs_compiler_name])
    47. 

  47. CS_HEADER_PROPERTY([CS_COMPILER_NAME],
    48. 

  48.     [AS_ESCAPE(["])$cs_compiler_name[]AS_ESCAPE(["])])
    49. 

  49. 

  50. 

  51. 

  52. #------------------------------------------------------------------------------
    53. 

  53. # Check for common tools.
    54. 

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

  55. CS_CHECK_COMMON_TOOLS_LINK
    56. 

  56. CS_CHECK_COMMON_TOOLS_BASIC
    57. 

  57. CS_CHECK_COMMON_TOOLS_DOC_TEXINFO
    58. 

  58. CS_CHECK_COMMON_TOOLS_DOC_DOXYGEN
    59. 

  59. 

  60. CS_CHECK_PROGS([FLEX], [flex])
    61. 

  61. CS_EMIT_BUILD_PROPERTY([CMD.FLEX], [$FLEX])
    62. 

  62. 

  63. CS_CHECK_PROGS([BISON], [bison])
    64. 

  64. AS_IF([test -n "$BISON"],
    65. 

  65.     [CS_CHECK_PROG_VERSION([bison], [$BISON --version], [1.35], [9.9],
    66. 

  66. 	[CS_EMIT_BUILD_PROPERTY([CMD.BISON], [$BISON])])])
    67. 

  67. 

  68. CS_CHECK_TOOLS([HHC], [hhc])
    69. 

  69. CS_EMIT_BUILD_PROPERTY([CMD.HHC], [$HHC])
    70. 

  70. 

  71. CS_CHECK_PROGS([SWIG], [swig])
    72. 

  72. AS_IF([test -n "$SWIG"],
    73. 

  73.     [CS_CHECK_PROG_VERSION([swig], [$SWIG -version 2>&1], [1.3.21],
    74. 

  74. 	[9.9|.9], [CS_EMIT_BUILD_PROPERTY([CMD.SWIG], [$SWIG])])])
    75. 

  75. 

  76. 

  77. 

  78. #------------------------------------------------------------------------------
    79. 

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

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

  81. # from local sources, and to place the executable in the root of the build
    82. 

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

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

  84. # configure run.
    85. 

  85. #
    86. 

  86. # IMPLEMENTATION NOTES
    87. 

  87. #
    88. 

  88. # The Crystal Space build system supports Jam versions starting with 2.4.
    89. 

  89. # Earlier versions are rejected. Examples of rejected versions include Apple's
    90. 

  90. # highly modified Jam (based upon 2.2.1), and ftjam (based upon
    91. 

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

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

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

  94. #
    95. 

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

  96. #------------------------------------------------------------------------------
    97. 

  97. m4_define([cs_jam_local_exe], [jam$EXEEXT])
    98. 

  98. 

  99. CS_PATH_PROGS([JAM], [jam], [], [$PATH$PATH_SEPARATOR.])
    100. 

  100. AS_IF([test -n "$JAM"],
    101. 

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

  102. 	[cs_prog_jam_okay=yes], [cs_prog_jam_okay=no])],
    103. 

  103.     [cs_prog_jam_okay=no])
    104. 

  104. 

  105. AS_IF([test $cs_prog_jam_okay != yes],
    106. 

  106.     [JAM=./cs_jam_local_exe CS_NEED_LOCAL_JAM=yes])
    107. 

  107. CS_EMIT_BUILD_PROPERTY([JAM], [$JAM])
    108. 

  108. 

  109. CS_CHECK_PROGS([MAKE], [gnumake gmake make])
    110. 

  110. 

  111. 

  112. 

  113. #------------------------------------------------------------------------------
    114. 

  114. # The cs-win32libs package is a convenience archive made available to Windows
    115. 

  115. # users of Crystal Space.  It contains common libraries, headers, and tools
    116. 

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

  117. # users.  It saves users the bother of having to install these packages
    118. 

  118. # manually one at a time.
    119. 

  119. #------------------------------------------------------------------------------
    120. 

  120. CS_CHECK_CSWIN32LIBS
    121. 

  121. 

  122. 

  123. #------------------------------------------------------------------------------
    124. 

  124. # Use the CPPFLAGS, CXXFLAGS, CFLAGS, and LDFLAGS passed to configure, as well
    125. 

  125. # as any additional flags provided by cs-win32libs.
    126. 

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

  127. CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS], [$CPPFLAGS $CFLAGS], [+])
    128. 

  128. CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS], [$CPPFLAGS $CXXFLAGS], [+])
    129. 

  129. CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [$LDFLAGS], [+])
    130. 

  130. 

  131. 

  132. 

  133. #------------------------------------------------------------------------------
    134. 

  134. # Check for typical required libraries (libm, libmx, libdl, libnsl).
    135. 

  135. #------------------------------------------------------------------------------
    136. 

  136. AC_LANG_PUSH([C++])
    137. 

  137. AC_CHECK_HEADERS([cmath], [CS_HEADER_PROPERTY([CS_HAVE_CMATH_H])])
    138. 

  138. AC_CHECK_HEADERS([math.h], [CS_HEADER_PROPERTY([CS_HAVE_MATH_H])])
    139. 

  139. AC_LANG_POP([C++])
    140. 

  140. 

  141. CS_CHECK_COMMON_LIBS
    142. 

  142. 

  143. AS_IF([test $ac_cv_lib_m_pow = yes || test $ac_cv_lib_m_cosf = yes],
    144. 

  144.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lm], [+])])
    145. 

  145. AS_IF([test $ac_cv_lib_mx_cosf = yes],
    146. 

  146.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lmx], [+])])
    147. 

  147. AS_IF([test $ac_cv_lib_dl_dlopen = yes],
    148. 

  148.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-ldl], [+])])
    149. 

  149. AS_IF([test $ac_cv_lib_nsl_gethostbyname = yes],
    150. 

  150.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS], [-lnsl], [+])])
    151. 

  151. 

  152. AS_IF([test $ac_cv_lib_m_cosf != no || test $ac_cv_lib_mx_cosf != no],
    153. 

  153.     [CS_HEADER_PROPERTY([CS_HAVE_MATH_H_FLOAT_FUNCS])])
    154. 

  154. 

  155. 

  156. 

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

  158. # Check for pthread.  Also check if pthread implementation supports the
    159. 

  159. # recursive mutex extension.
    160. 

  160. #------------------------------------------------------------------------------
    161. 

  161. CS_CHECK_PTHREAD([cygwin*])
    162. 

  162. CS_EMIT_BUILD_RESULT([cs_cv_sys_pthread], [PTHREAD])
    163. 

  163. AS_IF([test $cs_cv_sys_pthread_mutex_recursive != no],
    164. 

  164.     [CS_HEADER_PROPERTY([CS_PTHREAD_MUTEX_RECURSIVE],
    165. 

  165. 	[$cs_cv_sys_pthread_mutex_recursive])])
    166. 

  166. 

  167. 

  168. 

  169. #------------------------------------------------------------------------------
    170. 

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

  171. # for example) provide only RTLD_LAZY.
    172. 

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

  173. AC_DEFUN([CS_CHECK_RTLD],
    174. 

  174.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])
    175. 

  175.     CS_CHECK_BUILD([for RTLD_NOW], [cs_cv_sys_rtld_now],
    176. 

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

  177. 	[], [], [CS_HEADER_PROPERTY([CS_HAVE_RTLD_NOW])], [], [],
    178. 

  178. 	[], [], [$cs_cv_libdl_libs])])
    179. 

  179. 

  180. CS_CHECK_RTLD
    181. 

  181. 

  182. 

  183. 

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

  185. # Determine host platform.  Recognized families: Unix, Windows, MacOS/X.
    186. 

  186. #
    187. 

  187. # CS_CHECK_HOST
    188. 

  188. #	Sets the shell variables cs_host_target and cs_host_family.  Client
    189. 

  189. #	code can use these variables to emit appropriate Jam variables and
    190. 

  190. #	CS_PLATFORM_FOO header define.
    191. 

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

  192. CS_CHECK_HOST
    193. 

  193. AS_IF([test "x$cs_host_macosx" = "xyes"],
    194. 

  194.     [# We assume that we always have CoreAudio available on MacOS/X.
    195. 

  195.     CS_EMIT_BUILD_PROPERTY([COREAUDIO.AVAILABLE], [yes])
    196. 

  196.     CS_EMIT_BUILD_PROPERTY([COREAUDIO.LFLAGS], [-framework CoreAudio -framework AudioToolbox])
    197. 

  197.     CS_HEADER_PROPERTY([CS_PLATFORM_MACOSX])],
    198. 

  198.     [case $cs_host_family in
    199. 

  199. 	windows)
    200. 

  200. 	    CS_HEADER_PROPERTY([CS_PLATFORM_WIN32])
    201. 

  201. 	    ;;
    202. 

  202. 	unix)
    203. 

  203. 	    CS_HEADER_PROPERTY([CS_PLATFORM_UNIX])
    204. 

  204.     esac])
    205. 

  205. CS_HEADER_PROPERTY([CS_PLATFORM_NAME],
    206. 

  206.     [AS_ESCAPE(["])$cs_host_os_normalized[]AS_ESCAPE(["])])
    207. 

  207. 

  208. 

  209. 

  210. #------------------------------------------------------------------------------
    211. 

  211. # Check if Perl SDK is installed and which compiler and linker flags are
    212. 

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

  213. # ExtUtils::Embed or if it must be created manually.
    214. 

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

  215. CS_CHECK_PROGS([PERL], [perl5 perl])
    216. 

  216. CS_EMIT_BUILD_PROPERTY([PERL5], [$PERL])
    217. 

  217. CS_EMIT_BUILD_PROPERTY([PERL], [$PERL])
    218. 

  218. CS_EMIT_BUILD_PROPERTY([CMD.PERL5], [$PERL])
    219. 

  219. 

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

  221. AC_ARG_WITH([perl], [AC_HELP_STRING([--with-perl],
    222. 

  222.     [use Perl5 scripting interface (default NO)])])
    223. 

  223. AS_IF([test -z "$with_perl"], [with_perl=no])
    224. 

  224. 

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

  226.     [AC_CACHE_CHECK([for perl ExtUtils::Embed module], [cs_cv_perl_mod_embed],
    227. 

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

  228. 	    [cs_cv_perl_mod_embed=yes], [cs_cv_perl_mod_embed=no])])
    229. 

  229. 

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

  231. 	[CS_EMIT_BUILD_PROPERTY([PERL5.EXTUTILS.EMBED.AVAILABLE], [yes])
    232. 

  232. 	AC_CACHE_CHECK([for perl DynaLoader module],
    233. 

  233. 	    [cs_cv_perl_mod_dynaloader],
    234. 

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

  235. 		[cs_cv_perl_mod_dynaloader=yes],
    236. 

  236. 		[cs_cv_perl_mod_dynaloader=no])])
    237. 

  237. 	AS_IF([test $cs_cv_perl_mod_dynaloader = yes],
    238. 

  238. 	    [CS_EMIT_BUILD_PROPERTY([PERL5.DYNALOADER.AVAILABLE], [yes])])],
    239. 

  239. 	[# ExtUtils::Embed absent.
    240. 

  240. 	AC_MSG_NOTICE([Recommend you install a recent release of Perl 5.])
    241. 

  241. 	AC_MSG_NOTICE([http://www.perl.org/])
    242. 

  242. 	AC_CACHE_CHECK([for perl Config module], [cs_cv_perl_mod_config],
    243. 

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

  244. 		[cs_cv_perl_mod_config=yes], [cs_cv_perl_mod_config=no])])])
    245. 

  245. 

  246.     AS_VAR_SET_IF([cs_cv_perl_cflags], [],
    247. 

  247. 	[AS_IF([test $cs_cv_perl_mod_embed = yes],
    248. 

  248. 	    [cs_cv_perl_cflags=`AC_RUN_LOG(
    249. 

  249. 		[$PERL -MExtUtils::Embed -e ccopts])`
    250. 

  250. 	    cs_cv_perl_lflags=`AC_RUN_LOG(
    251. 

  251. 		[$PERL -MExtUtils::Embed -e ldopts])`
    252. 

  252. 	    cs_cv_perl_ext=`AC_RUN_LOG([$PERL -MConfig -e \
    253. 

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

  254. 	    [AS_IF([test $cs_cv_perl_mod_config = yes],
    255. 

  255. 		[cs_perl_core=`AC_RUN_LOG(
    256. 

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

  257. 		cs_perl_core="${cs_perl_core}/CORE"
    258. 

  258. 		cs_cv_perl_cflags=`AC_RUN_LOG(
    259. 

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

  260. 		cs_cv_perl_cflags="${cs_cv_perl_cflags} -I${cs_perl_core}"
    261. 

  261. 		cs_cv_perl_lflags=`AC_RUN_LOG([$PERL -MConfig -e \
    262. 

  262. 		    'print $Config{ldflags}, " ", $Config{libs}'])`
    263. 

  263. 		cs_cv_perl_lflags="${cs_cv_perl_lflags} -L${cs_perl_core}"
    264. 

  264. 		cs_cv_perl_ext=`AC_RUN_LOG([$PERL -MConfig -e \
    265. 

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

  266. 		[cs_perl_core=`AC_RUN_LOG([$PERL -V:archlib | \
    267. 

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

  268. 		cs_perl_core="${cs_perl_core}/CORE"
    269. 

  269. 		cs_cv_perl_cflags=`AC_RUN_LOG([$PERL -V:ccflags | \
    270. 

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

  271. 		cs_cv_perl_cflags="${cs_cv_perl_cflags} -I${cs_perl_core}"
    272. 

  272. 		cs_cv_perl_lflags=`AC_RUN_LOG([$PERL -V:ldflags | \
    273. 

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

  274. 		cs_perl_lflags_tmp=`AC_RUN_LOG([$PERL -V:libs | \
    275. 

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

  276. 		cs_cv_perl_lflags="${cs_cv_perl_lflags} ${cs_perl_lflags_tmp}
    277. 

  277. 		    -L${cs_perl_core}"
    278. 

  278. 		cs_cv_perl_ext=`AC_RUN_LOG([$PERL -V:dlext | \
    279. 

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

  280. 	cs_cv_perl_cflags=CS_PATH_NORMALIZE([$cs_cv_perl_cflags])
    281. 

  281. 	cs_cv_perl_lflags=CS_PATH_NORMALIZE([$cs_cv_perl_lflags])])
    282. 

  282. 

  283.     AS_IF([test -n "$cs_cv_perl_cflags$cs_cv_perl_lflags"],
    284. 

  284. 	[CS_CHECK_BUILD([if Perl SDK is usable], [cs_cv_perl],
    285. 

  285. 	    [AC_LANG_PROGRAM(
    286. 

  286. 		[[#include <EXTERN.h>
    287. 

  287. 		#include <perl.h>]],
    288. 

  288. 		[perl_run(0);])],
    289. 

  289. 	    [CS_CREATE_TUPLE([$cs_cv_perl_cflags],[],[$cs_cv_perl_lflags])])
    290. 

  290. 	AS_IF([test $cs_cv_perl = yes],
    291. 

  291. 	    [CS_EMIT_BUILD_RESULT([cs_cv_perl], [PERL5])
    292. 

  292. 	    CS_EMIT_BUILD_PROPERTY([PERL5.MODULE_EXT],[.$cs_cv_perl_ext])])])])
    293. 

  293. 	
    294. 

  294. 

  295. 

  296. #------------------------------------------------------------------------------
    297. 

  297. # Check if Python SDK is installed and which compiler and linker flags are
    298. 

  298. # required to embed Python.
    299. 

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

  300. CS_CHECK_PYTHON([emit], [], [Python scripting interface])
    301. 

  301. 

  302. 

  303. 

  304. #------------------------------------------------------------------------------
    305. 

  305. # Check if Java2 SDK is installed and which compiler and linker flags are
    306. 

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

  307. # projects, is available.
    308. 

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

  309. AC_DEFUN([CS_JAVA_FLAGS],
    310. 

  310.     [AC_REQUIRE([AC_CANONICAL_HOST])
    311. 

  311.     AC_REQUIRE([CS_CHECK_HOST])
    312. 

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

  313. 	test -r /System/Library/Frameworks/JavaVM.framework/Headers],
    314. 

  314. 	[$1_cflags="-I/System/Library/Frameworks/JavaVM.framework/Headers"
    315. 

  315. 	$1_libs="-framework JavaVM"],
    316. 

  316. 	[AS_IF([test -n "$JAVA_HOME"],
    317. 

  317. 	    [$1_dir="$JAVA_HOME"],
    318. 

  318. 	    [AS_IF([test -n "$2"],
    319. 

  319. 		[$1_dir=`AS_DIRNAME([$2])`
    320. 

  320. 		$1_dir=`AS_DIRNAME([$$1_dir])`],
    321. 

  321. 		[$1_dir=''])])
    322. 

  322. 	AS_IF([test -n "$$1_dir"],
    323. 

  323. 	    [$1_cflags="-I$$1_dir/include"
    324. 

  324. 	    case $host_os in
    325. 

  325. 		mingw*|cygwin*) cs_java_platform=win32 ;;
    326. 

  326. 		*) cs_java_platform=`echo $host_os |
    327. 

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

  328. 	    esac
    329. 

  329. 	    AS_IF([test -n "$cs_java_platform"],
    330. 

  330. 		[$1_cflags="$$1_cflags
    331. 

  331. 		    $$1_cflags/$cs_java_platform"])
    332. 

  332. 	    $1_cflags=CS_PATH_NORMALIZE([$$1_cflags])])])])
    333. 

  333. 

  334. JAVA_HOME=CS_PATH_NORMALIZE([$JAVA_HOME])
    335. 

  335. 

  336. AS_IF([test -z "$JAVA" && test -n "$JAVACMD"],
    337. 

  337.     [JAVA=CS_PATH_NORMALIZE([$JAVACMD])])
    338. 

  338. CS_PATH_PROGS([JAVA], [java], [],
    339. 

  339.     [$JAVA_HOME/bin$PATH_SEPARATOR$JAVA_HOME/jre/bin$PATH_SEPARATOR$PATH])
    340. 

  340. CS_EMIT_BUILD_PROPERTY([JAVA], [$JAVA])
    341. 

  341. 

  342. CS_PATH_PROGS([JAVAC], [javac], [],
    343. 

  343.     [$JAVA_HOME/bin$PATH_SEPARATOR$JAVA_HOME/jre/bin$PATH_SEPARATOR$PATH])
    344. 

  344. CS_EMIT_BUILD_PROPERTY([JAVAC], [$JAVAC])
    345. 

  345. 

  346. AC_ARG_WITH([java], [AC_HELP_STRING([--with-java],
    347. 

  347.     [use Java scripting interface (default YES)])])
    348. 

  348. AS_IF([test -z "$with_java"], [with_java=yes])
    349. 

  349. 

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

  351.     [CS_JAVA_FLAGS([cs_java], [$JAVAC])
    352. 

  352.     CS_CHECK_BUILD([if Java2 SDK is usable], [cs_cv_java],
    353. 

  353. 	[AC_LANG_PROGRAM(
    354. 

  354. 	    [[#include <jni.h>
    355. 

  355. 	    JNIEXPORT void JNICALL f(JNIEnv *env, jobject obj);]])],
    356. 

  356. 	[CS_CREATE_TUPLE() \
    357. 

  357.         CS_CREATE_TUPLE([$cs_java_cflags],[$cs_java_lflags],[$cs_java_libs])],
    358. 

  358. 	[], [CS_EMIT_BUILD_RESULT([cs_cv_java], [JAVA])])])
    359. 

  359. 

  360. CS_PATH_PROGS([ANT], [ant], [], [$PATH$PATH_SEPARATOR$ANT_HOME/bin])
    361. 

  361. CS_EMIT_BUILD_PROPERTY([ANT], [$ANT])
    362. 

  362. 

  363. 

  364. 

  365. #------------------------------------------------------------------------------
    366. 

  366. # Check if STL is available. Although STL is not used heavily in Crystal Space,
    367. 

  367. # a few plugin modules take advantage of it, so they need to know if it is
    368. 

  368. # available.
    369. 

  369. #------------------------------------------------------------------------------
    370. 

  370. CS_CHECK_BUILD([for STL], [cs_cv_libstl],
    371. 

  371.     [AC_LANG_PROGRAM(
    372. 

  372. 	[[#include <map>
    373. 

  373. 	#include <string>]],
    374. 

  374. 	[[std::map<std::string,int> m; m.begin();]])],
    375. 

  375.     [], [C++], [CS_EMIT_BUILD_RESULT([cs_cv_libstl], [STL])])
    376. 

  376. 

  377. 

  378. 

  379. #------------------------------------------------------------------------------
    380. 

  380. # Check how to enable and disable compilation warnings, and how to promote
    381. 

  381. # diagnostics from warning to error status.
    382. 

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

  383. CS_COMPILER_WARNINGS([C++], [cs_cv_prog_cxx_enable_warnings],
    384. 

  384.     [CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS],
    385. 

  385. 	[$cs_cv_prog_cxx_enable_warnings], [+])])
    386. 

  386. 

  387. CS_COMPILER_ERRORS([C++], [cs_cv_prog_cxx_enable_errors])
    388. 

  388. 

  389. CS_COMPILER_IGNORE_UNUSED([C++], [cs_cv_prog_cxx_ignore_unused],
    390. 

  390.     [CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS.WARNING.NO_UNUSED],
    391. 

  391. 	[$cs_cv_prog_cxx_ignore_unused])])
    392. 

  392. 

  393. CS_COMPILER_IGNORE_UNINITIALIZED([C++], [cs_cv_prog_cxx_ignore_uninitialized],
    394. 

  394.     [CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS.WARNING.NO_UNINITIALIZED],
    395. 

  395. 	[$cs_cv_prog_cxx_ignore_uninitialized])])
    396. 

  396. 

  397. CS_COMPILER_IGNORE_PRAGMAS([C++], [cs_cv_prog_cxx_ignore_unknown_pragmas],
    398. 

  398.     [CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS],
    399. 

  399. 	[$cs_cv_prog_cxx_ignore_unknown_pragmas], [+])])
    400. 

  400. 

  401. # On MacOS/X, use of `long double' in csutil/formatter.h causes complaints.
    402. 

  402. CS_COMPILER_IGNORE_LONG_DOUBLE([C++], [cs_cv_prog_cxx_ignore_long_double],
    403. 

  403.     [CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS.MANDATORY],
    404. 

  404. 	[$cs_cv_prog_cxx_ignore_long_double], [+])])
    405. 

    406. 

    407. 

    408. 

  408. #------------------------------------------------------------------------------
    409. 

  409. # Check for option to disable strict-aliasing (enabled by gcc on higher 
    410. 

  410. # optimization levels). This is needed for some code we don't have
    411. 

  411. # control over (e.g. SWIG-generated code) that breaks strict-aliasing rules.
    412. 

  412. #------------------------------------------------------------------------------
    413. 

  413. CS_CHECK_BUILD_FLAGS([for flag to disable string-aliasing],
    414. 

  414.     [cs_cv_prog_cxx_no_strict_aliasing],
    415. 

  415.     [CS_CREATE_TUPLE([-fno-strict-aliasing])], [C++])
    416. 

    417. 

  417. AS_IF([test $cs_cv_prog_cxx_no_strict_aliasing != no],
    418. 

  418.     [CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS.STRICTALIASING.DISABLE],
    419. 

  419. 	[$cs_cv_prog_cxx_no_strict_aliasing], [+])])
    420. 

    421. 

    422. 

    423. 

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

  424. # Check if C++ exceptions can be enabled and disabled.
    425. 

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

  426. CS_EMIT_BUILD_FLAGS([how to enable C++ exceptions],
    427. 

  427.     [cs_cv_prog_cxx_enable_exceptions],
    428. 

  428.     [CS_CREATE_TUPLE([-fexceptions -fno-omit-frame-pointer]) \
    429. 

  429.     CS_CREATE_TUPLE([-fexceptions])],
    430. 

  430.     [C++], [COMPILER.C++FLAGS.EXCEPTIONS.ENABLE])
    431. 

    432. 

  432. CS_EMIT_BUILD_FLAGS([how to disable C++ exceptions],
    433. 

  433.     [cs_cv_prog_cxx_disable_exceptions], [CS_CREATE_TUPLE([-fno-exceptions])],
    434. 

  434.     [C++], [COMPILER.C++FLAGS.EXCEPTIONS.DISABLE], [],
    435. 

  435.     [CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS],
    436. 

  436. 	[$cs_cv_prog_cxx_disable_exceptions], [+])])
    437. 

    438. 

    439. 

    440. 

  440. #------------------------------------------------------------------------------
    441. 

  441. # Check how to make compiler comply strongly with the official C++ language
    442. 

  442. # specification. Crystal Space itself can not abide 100% by the standard (for
    443. 

  443. # instance, we employ `long long', which is not part of the present
    444. 

  444. # specification), however, some external projects do so (by using gcc's -ansi
    445. 

  445. # and -pedantic options, for instance). Because such projects may utilize
    446. 

  446. # Crystal Space, we must ensure that our public headers likewise comply with
    447. 

  447. # the official specification.
    448. 

  448. #------------------------------------------------------------------------------
    449. 

  449. CS_EMIT_BUILD_FLAGS([how to enforce C++ standards conformance],
    450. 

  450.     [cs_cv_prog_cxx_enable_pedantic], [CS_CREATE_TUPLE([-ansi -pedantic])],
    451. 

  451.     [C++], [COMPILER.C++FLAGS.PEDANTIC.ENABLE])
    452. 

  452. 

  453. 

  454. 

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

  456. # Check if the linker recognizes "-multiply_defined suppress".  This is
    457. 

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

  458. # with "-framework Foundation" if that program does not actually employ any
    459. 

  459. # Objective-C. Note that we first attempt the uglier equivalent
    460. 

  460. # "-Wl,-multiply_defined,suppress" in order to make life simpler for external
    461. 

  461. # projects using cs-config (which reports this linker option in response to
    462. 

  462. # --libs) in conjunction with GNU libtool. The problem with "-multiply_defined
    463. 

  463. # suppress" for GNU libtool users is that libtool re-orders linker arguments,
    464. 

  464. # not realizing that "suppress" must follow immediately after
    465. 

  465. # "-multiply_defined". The uglier equivalent does not suffer from this problem
    466. 

  466. # in the hands of libtool since it contains no whitespace.
    467. 

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

  468. CS_EMIT_BUILD_FLAGS([if -multiply_defined suppress is needed],
    469. 

  469.     [cs_cv_prog_link_suppress_multiple],
    470. 

  470.     [CS_CREATE_TUPLE([], [-Wl,-multiply_defined,suppress]) \
    471. 

  471.     CS_CREATE_TUPLE([], [-multiply_defined suppress])],
    472. 

  472.     [], [COMPILER.LFLAGS], [+])
    473. 

  473. 

  474. 

  475. 

  476. #------------------------------------------------------------------------------
    477. 

  477. # Check if the linker recognizes "-force_cpusubtype_ALL".  This is required on
    478. 

  478. # MacOS/X since the Crystal Space's PowerPC implementation of csQsqrt() uses
    479. 

  479. # the `frsqrte' instruction which is only valid when the -force_cpusubtype_ALL
    480. 

  480. # flag is present.  This flag is marked "mandatory" because it is required even
    481. 

  481. # for external projects if they use csQsqrt().
    482. 

  482. #------------------------------------------------------------------------------
    483. 

  483. AC_DEFUN([CS_CHECK_FORCE_CPUSUBTYPE_ALL],
    484. 

  484.     [CS_CHECK_BUILD_FLAGS([if -force_cpusubtype_ALL is needed],
    485. 

  485. 	[cs_cv_prog_cxx_force_cpusubtype_all],
    486. 

  486. 	[CS_CREATE_TUPLE([], [-force_cpusubtype_ALL])])])
    487. 

  487.     
    488. 

  488. CS_CHECK_FORCE_CPUSUBTYPE_ALL
    489. 

  489. CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS.MANDATORY],
    490. 

  490.     [$cs_cv_prog_cxx_force_cpusubtype_all], [+])
    491. 

    492. 

    493. 

    494. 

  494. #------------------------------------------------------------------------------
    495. 

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

  496. # when building plugin modules (and the libraries which are linked into
    497. 

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

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

  499. # uninitialized global variables.
    500. 

  500. #------------------------------------------------------------------------------
    501. 

  501. AC_DEFUN([CS_CHECK_NO_COMMON],
    502. 

  502.     [AC_REQUIRE([AC_CANONICAL_HOST])
    503. 

  503.     case $host_os in
    504. 

  504. 	darwin*)
    505. 

  505. 	    CS_EMIT_BUILD_FLAGS([if -fno-common is needed],
    506. 

  506. 		[cs_cv_prog_cxx_no_common],
    507. 

  507. 		[CS_CREATE_TUPLE([], [-fno-common])], [C++],
    508. 

  508. 		[COMPILER.CFLAGS.MANDATORY], [+])
    509. 

  509. 	    ;;
    510. 

  510.     esac])
    511. 

    512. 

  512. CS_CHECK_NO_COMMON
    513. 

    514. 

    515. 

    516. 

  516. #------------------------------------------------------------------------------
    517. 

  517. # Check if Mingw and Cygwin compilers recognize -fvtable-thunks.  As of gcc
    518. 

  518. # 3.x, this option is no longer supported.  Unfortunately, rather than
    519. 

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

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

  521. # we use -Werror to turn the warning into an error.
    522. 

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

  523. AC_DEFUN([CS_CHECK_VTABLE_THUNKS],
    524. 

  524.     [AC_REQUIRE([AC_CANONICAL_HOST])
    525. 

  525.     case $host_os in
    526. 

  526. 	mingw*|cygwin*)
    527. 

  527. 	    CS_CHECK_BUILD_FLAGS([if -fvtable-thunks is needed],
    528. 

  528. 		[cs_cv_prog_cxx_vtable_thunks],
    529. 

  529. 		[CS_CREATE_TUPLE([-fvtable-thunks])], [C++],
    530. 

  530. 		[CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS.MANDATORY],
    531. 

  531. 		    [$cs_cv_prog_cxx_vtable_thunks], [+])],
    532. 

  532. 		[], [$cs_cv_prog_cxx_enable_errors])
    533. 

  533. 	    ;;
    534. 

  534.     esac])
    535. 

    536. 

  536. CS_CHECK_VTABLE_THUNKS
    537. 

    538. 

    539. 

    540. 

  540. #------------------------------------------------------------------------------
    541. 

  541. # Check how to ask the linker to export all dynamic symbols in debug mode to
    542. 

  542. # allow the backtrace() callstack creation code to obtain symbols in all cases.
    543. 

  543. #------------------------------------------------------------------------------
    544. 

  544. CS_EMIT_BUILD_FLAGS([how to export all dynamic symbols],
    545. 

  545.     [cs_cv_prog_link_export_dynamic], [CS_CREATE_TUPLE([-Wl,-E])],
    546. 

  546.     [C++], [COMPILER.LFLAGS.debug], [+])
    547. 

    548. 

    549. 

    550. 

  550. #------------------------------------------------------------------------------
    551. 

  551. # Check if linker recognizes --kill-at which is needed to make csjava.dll
    552. 

  552. # usable by JNI on Windows.  Without this, JNI is unable to find the exported
    553. 

  553. # JNI glue functions in csjava.dll.
    554. 

  554. #------------------------------------------------------------------------------
    555. 

  555. CS_CHECK_BUILD([if --kill-at is accepted], [cs_cv_prog_link_kill_at], [],
    556. 

  556.     [CS_CREATE_TUPLE([],[-Wl,--kill-at])], [C++],
    557. 

  557.     [CS_EMIT_BUILD_PROPERTY([CSJAVA.LFLAGS], [-Wl,--kill-at])])
    558. 

    559. 

    560. 

    561. 

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

  562. # Check if C++ function inlining can be enabled and disabled. Apparently, with
    563. 

  563. # some versions of GNU build tools on Windows, the Crystal Space Python plugin
    564. 

  564. # fails to link and emits the error message "Error: 0-bit reloc in dll". In
    565. 

  565. # particular, this occurs with optimizations (such as -O3) enabled. We can
    566. 

  566. # avoid the error by disabling function inlining.
    567. 

  567. #------------------------------------------------------------------------------
    568. 

  568. CS_EMIT_BUILD_FLAGS([how to disable function inlining],
    569. 

  569.     [cs_cv_prog_cxx_disable_inlining],
    570. 

  570.     [CS_CREATE_TUPLE([-fno-inline-functions])],
    571. 

  571.     [C++], [COMPILER.C++FLAGS.INLINING.DISABLE])
    572. 

    573. 

    574. 

    575. 

  575. #------------------------------------------------------------------------------
    576. 

  576. # Check if "hidden" visibilty for inline functions is supported.
    577. 

  577. #
    578. 

  578. # IMPLEMENTATION NOTES
    579. 

  579. #
    580. 

  580. # There is an obscure bug in gcc 3.4.x and 4.0.x where
    581. 

  581. # -fvisibility-inlines-hidden on AMD64 in combination with -fPIC and -shared
    582. 

  582. # flags causes the linker to fail with a bogus error stating that the target
    583. 

  583. # library needs to be built with -fPIC even when it has been built using that
    584. 

  584. # option. On such installations, if Crystal Space is built with
    585. 

  585. # -fvisibility-inlines-hidden, then clients liking against Crystal Space
    586. 

  586. # experience this bogus error.  Normally, we would test for this anomaly by
    587. 

  587. # manipulating a std::basic_string<> in a test program, and avoid
    588. 

  588. # -fvisibility-inlines-hidden if the test program fails to link, however,
    589. 

  589. # practical experience has shown that this test is not 100% reliable for all
    590. 

  590. # such installations. Instead, for simplicity, we disable this flag presently
    591. 

  591. # for all versions of gcc on AMD64.  References:
    592. 

  592. #
    593. 

  593. #     http://dev.gentoo.org/~kugelfang/pappy-visibility.txt
    594. 

  594. #     http://www.gnu.org/software/gcc/gcc-4.0/changes.html#visibility
    595. 

  595. #     http://www.nedprod.com/programs/gccvisibility.html
    596. 

  596. #     http://bugs.gentoo.org/show_bug.cgi?id=78720
    597. 

  597. #
    598. 

  598. # Furthermore, there seems to be a bug on MacOS/X with gcc 4.0.x where use of
    599. 

  599. # -fvisibility-inlines-hidden causes link problems with external clients which
    600. 

  600. # do not specify this flag.  For this reason, we also disable this flag on
    601. 

  601. # MacOS/X.  In particular, clients receive errors of this sort:
    602. 

  602. #
    603. 

  603. #    /usr/bin/ld: libcrystalspace.a(scf.o) malformed object, illegal
    604. 

  604. #        reference for -dynamic code (reference to a coalesced section
    605. 

  605. #        (__TEXT,__textcoal_nt) from section (__TEXT,__text) relocation
    606. 

  606. #        entry (1))
    607. 

  607. #------------------------------------------------------------------------------
    608. 

  608. CS_CHECK_BUILD_FLAGS([for inline visibility flag],
    609. 

  609.     [cs_cv_prog_cxx_visibility_inlines_hidden],
    610. 

  610.     [CS_CREATE_TUPLE([-fvisibility-inlines-hidden])],[C++])
    611. 

    612. 

  612. AS_IF([test -n "$cs_cv_prog_cxx_visibility_inlines_hidden"],
    613. 

  613.     [AC_CACHE_CHECK([if $cs_cv_prog_cxx_visibility_inlines_hidden is buggy],
    614. 

  614. 	[cs_cv_prog_cxx_visibility_inlines_hidden_buggy],
    615. 

  615. 	[AS_IF([test $ac_compiler_gnu = yes],
    616. 

  616. 	    [AS_IF([test $host_cpu = x86_64 || test x$cs_host_macosx = xyes],
    617. 

  617. 		[cs_cv_prog_cxx_visibility_inlines_hidden_buggy=yes],
    618. 

  618. 		[cs_cv_prog_cxx_visibility_inlines_hidden_buggy=no])],
    619. 

  619. 	    [cs_cv_prog_cxx_visibility_inlines_hidden_buggy=no])])],
    620. 

  620.     [cs_cv_prog_cxx_visibility_inlines_hidden_buggy=no])
    621. 

    622. 

  622. AS_IF([test $cs_cv_prog_cxx_visibility_inlines_hidden_buggy != yes],
    623. 

  623.     [CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS],
    624. 

  624. 	[$cs_cv_prog_cxx_visibility_inlines_hidden], [+])])
    625. 

    626. 

    627. 

    628. 

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

  629. # Check how to set default symbol visibility, and how to override the setting
    630. 

  630. # in code.
    631. 

  631. #------------------------------------------------------------------------------
    632. 

  632. CS_CHECK_BUILD_FLAGS([for symbol visibility flag],
    633. 

  633.     [cs_cv_prog_cxx_visibility_hidden],
    634. 

  634.     [CS_CREATE_TUPLE([-fvisibility=hidden])], [C++])
    635. 

    636. 

  636. CS_SYMBOL_QUALIFIER([how to declare default visibility],
    637. 

  637.     [cs_cv_prog_cxx_declare_visible_def],
    638. 

  638.     [__attribute__((visibility("default")))], [], [C++])
    639. 

    640. 

  640. AS_IF([test $cs_cv_prog_cxx_declare_visible_def != no && \
    641. 

  641.     test -n "$cs_cv_prog_cxx_visibility_hidden"],
    642. 

  642.     [CS_EMIT_BUILD_PROPERTY([COMPILER.C++FLAGS], 
    643. 

  643. 	[$cs_cv_prog_cxx_visibility_hidden], [+])
    644. 

  644.     CS_HEADER_PROPERTY([CS_VISIBILITY_DEFAULT],
    645. 

  645. 	[$cs_cv_prog_cxx_declare_visible_def])])
    646. 

    647. 

    648. 

    649. 

  649. #------------------------------------------------------------------------------
    650. 

  650. # Check for compiler- and CPU-specific code generation flags.  These flags are
    651. 

  651. # mutually exclusive.  Exclusivity is enforced by the CS_CHECK_CODE_GEN_FLAG()
    652. 

  652. # macro.  Note that use of these flags typically means that the resulting
    653. 

  653. # binary will not be backward compatible.  For instance, if Pentium-specific
    654. 

  654. # instructions are used, the program will not work with earlier processors,
    655. 

  655. # such as the Intel 486.  Because these options are potentially dangerous,
    656. 

  656. # their use it controlled by the user via --enable-cpu-specific-optimizations
    657. 

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

  658. # "maximum".  The "minimum" option selects optimizations which are likely to be
    659. 

  659. # supported by reasonably modern hardware, thus making the resulting
    660. 

  660. # executables fairly portable.
    661. 

  661. #
    662. 

  662. # CS_CHECK_CODE_GEN_FLAG(CPU-PATTERN, FLAGS, [LANGUAGE])
    663. 

  663. #	If compiler- and CPU-specific optimization flags have not already been
    664. 

  664. #	determined, and if the canonical host CPU matches CPU-PATTERN, try
    665. 

  665. #	using the provided compiler FLAGS with the compiler represented by
    666. 

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

  667. #	is used.  If the compiler accepts the flags, assign them to the shell
    668. 

  668. #	variable cs_cv_prog_cxx_code_gen.
    669. 

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

  670. AC_DEFUN([CS_CHECK_CODE_GEN_FLAG],
    671. 

  671.     [AC_REQUIRE([AC_CANONICAL_HOST])
    672. 

  672.     AS_IF([test "$cs_cv_prog_cxx_code_gen" = no],
    673. 

  673. 	[case $host_cpu in
    674. 

  674. 	    $1) CS_BUILD_IFELSE([],
    675. 

  675. 		    [CS_CREATE_TUPLE([$2])], m4_default([$3],[C++]),
    676. 

  676. 		    [cs_cv_prog_cxx_code_gen=$cs_build_cflags], [])
    677. 

  677. 		;;
    678. 

  678. 	esac])])
    679. 

    680. 

  680. AC_MSG_CHECKING([whether to use CPU-specific optimizations])
    681. 

  681. AC_ARG_ENABLE([cpu-specific-optimizations],
    682. 

  682.     [AC_HELP_STRING([--enable-cpu-specific-optimizations=level],
    683. 

  683. 	[enable CPU-specific optimizations; recognized levels are `no',
    684. 

  684. 	`minimum' or `min', `maximum' or `max' (default MINIMUM); the `minimum'
    685. 

  685. 	option selects optimizations which are likely to be supported by
    686. 

  686. 	reasonably modern hardware, thus making the resulting executables
    687. 

  687. 	fairly portable; use the `maximum' option with caution since code for
    688. 

  688. 	one processor will not work with earlier processors (for example, Intel
    689. 

  689. 	686-specific code will not work with a 586)])],
    690. 

  690.     [case $enable_cpu_specific_optimizations in
    691. 

  691. 	yes|min) enable_cpu_specific_optimizations=minimum ;;
    692. 

  692. 	max) enable_cpu_specific_optimizations=maximum ;;
    693. 

  693.     esac],
    694. 

  694.     [enable_cpu_specific_optimizations=minimum])
    695. 

  695. AC_MSG_RESULT([$enable_cpu_specific_optimizations])
    696. 

    697. 

  697. case $enable_cpu_specific_optimizations in
    698. 

  698.     no|minimum|maximum) ;;
    699. 

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

  700.        ;;
    701. 

  701. esac
    702. 

    703. 

  703. AS_IF([test $enable_cpu_specific_optimizations != no],
    704. 

  704.     [AC_CACHE_CHECK([for code generation flags], [cs_cv_prog_cxx_code_gen],
    705. 

  705. 	[cs_cv_prog_cxx_code_gen=no
    706. 

  706. 	AS_IF([test $enable_cpu_specific_optimizations = maximum],
    707. 

  707. 	    [CS_CHECK_CODE_GEN_FLAG([athlon], [-march=athlon])
    708. 

  708. 	    CS_CHECK_CODE_GEN_FLAG([athlon], [-mcpu=athlon -march=athlon])
    709. 

  709. 	    CS_CHECK_CODE_GEN_FLAG([athlon], [-mcpu=athlon])
    710. 

  710. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-march=i686])
    711. 

  711. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mcpu=pentiumpro -march=i686])
    712. 

  712. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mcpu=pentiumpro])
    713. 

  713. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mpentiumpro -march=i686])
    714. 

  714. 	    CS_CHECK_CODE_GEN_FLAG([*686], [-mpentiumpro])])
    715. 

  715. 	AS_IF([test $host_vendor = apple],
    716. 

  716. 	    [# Work around issue on intel macs, where "-fpmath=sse" is on by
    717. 

  717. 	     # default, but this breaks compilation when combined with 
    718. 

  718. 	     # the "-march=i586" selected below. So the "minimum" optimization
    719. 

  719. 	     # on x86 Apples is -march=i686.
    720. 

  720. 	    CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-march=i686])])
    721. 

  721. 	CS_CHECK_CODE_GEN_FLAG([x86_64], [-march=k8])
    722. 

  722. 	CS_CHECK_CODE_GEN_FLAG([x86_64], [-mtune=k8])
    723. 

  723. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-march=i586])
    724. 

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

  725. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-mcpu=pentium])
    726. 

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

  727. 	CS_CHECK_CODE_GEN_FLAG([[*[5-6]86]], [-mpentium])
    728. 

  728. 	CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-march=i486])
    729. 

  729. 	CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-mcpu=i486 -march=i486])
    730. 

  730. 	CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-mcpu=i486])
    731. 

  731. 	CS_CHECK_CODE_GEN_FLAG([[*[3-9]86]], [-m486])
    732. 

  732. 	CS_CHECK_CODE_GEN_FLAG([alpha], [-mieee])])
    733. 

    734. 

  734.     AS_IF([test "$cs_cv_prog_cxx_code_gen" != no],
    735. 

  735. 	[CS_EMIT_BUILD_PROPERTY(
    736. 

  736. 	    [COMPILER.CFLAGS], [$cs_cv_prog_cxx_code_gen], [+])])])
    737. 

    738. 

    739. 

    740. 

  740. #------------------------------------------------------------------------------
    741. 

  741. # Check if byteswap.h is available, which contains optimized byte swapping
    742. 

  742. # functiosn (used for endian conversion).
    743. 

  743. #------------------------------------------------------------------------------
    744. 

  744. AC_CHECK_HEADERS([byteswap.h],
    745. 

  745.     [CS_HEADER_PROPERTY([CS_HAVE_BYTESWAP_H])])
    746. 

    747. 

    748. 

    749. 

  749. #------------------------------------------------------------------------------
    750. 

  750. # Check for compiler optimization flags.
    751. 

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

  752. AC_DEFUN([CS_CHECK_OPTIMIZE_FLAGS],
    753. 

  753.     [AC_REQUIRE([AC_PROG_CC])
    754. 

  754.     AC_REQUIRE([AC_PROG_CXX])
    755. 

    756. 

  756.     cs_optimize_flags=''
    757. 

    758. 

  758.     CS_EMIT_BUILD_FLAGS([how to enable optimizations],
    759. 

  759. 	[cs_cv_prog_cxx_optimize],
    760. 

  760. 	[CS_CREATE_TUPLE([-O3]) CS_CREATE_TUPLE([-O2]) CS_CREATE_TUPLE([-O])],
    761. 

  761. 	[C++], [COMPILER.CFLAGS.optimize], [+],
    762. 

  762. 	[cs_optimize_flags="$cs_optimize_flags $cs_cv_prog_cxx_optimize"])
    763. 

    764. 

  764.     CS_EMIT_BUILD_FLAGS([if -fomit-frame-pointer is accepted],
    765. 

  765. 	[cs_cv_prog_cxx_omit_frame_pointer],
    766. 

  766. 	[CS_CREATE_TUPLE([-fomit-frame-pointer])],
    767. 

  767. 	[C++], [COMPILER.CFLAGS.optimize], [+],
    768. 

  768. 	[cs_optimize_flags="$cs_optimize_flags \
    769. 

  769. 	    $cs_cv_prog_cxx_omit_frame_pointer"])
    770. 

    771. 

  771.     CS_EMIT_BUILD_FLAGS([if -ffast-math is accepted],
    772. 

  772. 	[cs_cv_prog_cxx_fast_math],
    773. 

  773. 	[CS_CREATE_TUPLE([-ffast-math])], [C++],
    774. 

  774. 	[COMPILER.CFLAGS.optimize], [+],
    775. 

  775. 	[cs_optimize_flags="$cs_optimize_flags $cs_cv_prog_cxx_fast_math"])])
    776. 

    777. 

  777. CS_CHECK_OPTIMIZE_FLAGS
    778. 

    779. 

    780. 

    781. 

  781. #------------------------------------------------------------------------------
    782. 

  782. # Check for compiler debug flags.
    783. 

  783. #------------------------------------------------------------------------------
    784. 

  784. CS_EMIT_BUILD_FLAGS([how to enable compiler debug output],
    785. 

  785.     [cs_cv_prog_cxx_debug],
    786. 

  786.     [CS_CREATE_TUPLE([-g3]) CS_CREATE_TUPLE([-g2]) CS_CREATE_TUPLE([-g])],
    787. 

  787.     [C++], [COMPILER.CFLAGS.debug], [+],
    788. 

  788.     [CS_EMIT_BUILD_PROPERTY([COMPILER.LFLAGS.debug],
    789. 

  789. 	[$cs_cv_prog_cxx_debug], [+])])
    790. 

    791. 

    792. 

    793. 

  793. #------------------------------------------------------------------------------
    794. 

  794. # Check if compiler complains about adding /usr/local/include to the header
    795. 

  795. # search path.  If not, add it to the header search path since not all
    796. 

  796. # compilers search there by default.  Some compiler, on the other hand,
    797. 

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

  798. # avoid the complaint, if possible.
    799. 

  799. #
    800. 

  800. # Furthermore, add a -L entry to LDFLAGS for /usr/local/lib if present.
    801. 

  801. # Finally, add /usr/local/lib to LD_LIBRARY_PATH if present since not all
    802. 

  802. # platforms do so by default. This will allow some tests to succeed which would
    803. 

  803. # otherwise fail. An example is the sizeof(wchar_t) check on Solaris, which
    804. 

  804. # attempts to run a test program. Without augmenting LD_LIBRARY_PATH, the test
    805. 

  805. # program would fail to run, citing inability to locate libstdc++.so.
    806. 

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

  807. AS_IF([test -d /usr/local/include],
    808. 

  808.     [CS_CHECK_BUILD_FLAGS([if -I/usr/local/include is usable],
    809. 

  809. 	[cs_cv_prog_cpp_local_include],
    810. 

  810. 	[CS_CREATE_TUPLE([-I/usr/local/include])], [C++], [], [],
    811. 

  811. 	[$cs_cv_prog_cxx_enable_warnings $cs_cv_prog_cxx_enable_errors])],
    812. 

  812.     [cs_cv_prog_cpp_local_include=''])
    813. 

    814. 

  814. AS_IF([test -n "$cs_cv_prog_cpp_local_include"],
    815. 

  815.     [CS_EMIT_BUILD_PROPERTY([COMPILER.CFLAGS],
    816. 

  816. 	[$cs_cv_prog_cpp_local_include], [+])
    817. 

  817.     CPPFLAGS="$CPPFLAGS $cs_cv_prog_cpp_local_include"])
    818. 

    819. 

  819. AS_IF([test -d /usr/local/lib],
    820. 

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

  821.     LDFLAGS="$LDFLAGS -L/usr/local/lib"
    822. 

  822.     LD_LIBRARY_PATH="$LD_LIBRARY_PATH$PATH_SEPARATOR/usr/local/lib"
    823. 

  823.     export LD_LIBRARY_PATH])
    824. 

    825. 

    826. 

    827. 

  827. #------------------------------------------------------------------------------
    828. 

  828. # Check if va_copy() or __va_copy() is available. 
    829. 

  829. #------------------------------------------------------------------------------
    830. 

  830. # CS_CHECK_VA_COPY(FUNCTION)
    831. 

  831. AC_DEFUN([CS_CHECK_VA_COPY],
    832. 

  832.     [CS_CHECK_BUILD([for $1], [cs_cv_func_$1],
    833. 

  833. 	[AC_LANG_PROGRAM(
    834. 

  834. 	    [[#include <stdio.h>
    835. 

  835. 	    #include <stdarg.h>]],
    836. 

  836. 	    [va_list ap1; va_list ap2; $1(ap1,ap2)])],
    837. 

  837. 	[], [], [CS_HEADER_PROPERTY(AS_TR_CPP([CS_HAVE_$1]))], [], [],
    838. 

  838. 	[$cs_cv_prog_cxx_enable_pedantic])])
    839. 

    840. 

  840. CS_CHECK_VA_COPY([va_copy])
    841. 

  841. CS_CHECK_VA_COPY([__va_copy])
    842. 

    843. 

    844. 

    845. 

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

  846. # Check for X-Windows.  If the X-Windows implementation is XFree86, then also
    847. 

  847. # enable the `VideoMode' extension.
    848. 

  848. #------------------------------------------------------------------------------
    849. 

  849. AC_DEFUN([CS_X_CHECK_PREPARE],
    850. 

  850.     [AC_REQUIRE([AC_CANONICAL_HOST])
    851. 

  851.     AC_REQUIRE([CS_CHECK_HOST])
    852. 

  852. 

  853.     # Explicitly disable X checking on Windows to avoid discovering XFree86 in
    854. 

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

  855.     # headers during the OpenGL check, and prefer Microsoft's OpenGL headers.
    856. 

  856.     # The Mesa OpenGL headers cause link errors because they do not employ
    857. 

  857.     # __stdcall.
    858. 

  858.     case $host_os in
    859. 

  859. 	mingw*|cygwin*) with_x=no ;;
    860. 

  860.     esac
    861. 

  861. 

  862.     # Explicitly disable X checking on MacOS/X in case the optional XFree86 is
    863. 

  863.     # installed since we want to avoid an undesirable dependency upon XFree86
    864. 

  864.     # in the CS executables and plugins.  If the user is actually
    865. 

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

  866.     # override this test (by setting cs_host_macosx to "no").
    867. 

  867.     AS_IF([test x$cs_host_macosx = xyes], [with_x=no])])
    868. 

  868. 

  869. CS_X_CHECK_PREPARE
    870. 

  870. AC_PATH_X
    871. 

  871. AC_PATH_XTRA
    872. 

  872. 

  873. AS_IF([test "$no_x" != yes],
    874. 

  874.     [# We must be especially careful to instruct CS_EMIT_BUILD_PROPERTY() to
    875. 

  875.     # emit the following properties even if their values are empty.  This is
    876. 

  876.     # necessary because of the way that Jam performs "product-wise" variable
    877. 

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

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

  879.     # to "x ".  Since the emitted X11.CFLAGS, X11.LFLAGS, XFREE86VM.CFLAGS, and
    880. 

  880.     # XFREE86VM.LFLAGS properties reference the other variables by name, we
    881. 

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

  882.     # empty string).
    883. 

  883.     CS_EMIT_BUILD_PROPERTY([X11.AVAILABLE], [yes])
    884. 

  884.     CS_EMIT_BUILD_PROPERTY([X_CFLAGS], [$X_CFLAGS], [], [Y])
    885. 

  885.     CS_EMIT_BUILD_PROPERTY([X_LIBS], [$X_LIBS], [], [Y])
    886. 

  886.     CS_EMIT_BUILD_PROPERTY([X_PRE_LIBS], [$X_PRE_LIBS], [], [Y])
    887. 

  887.     CS_EMIT_BUILD_PROPERTY([X_EXTRA_LIBS], [$X_EXTRA_LIBS], [], [Y])
    888. 

  888.     CS_EMIT_BUILD_PROPERTY([X11.CFLAGS], [AS_ESCAPE([$(X_CFLAGS)])])
    889. 

  889.     CS_EMIT_BUILD_PROPERTY([X11.LFLAGS],
    890. 

  890.       [AS_ESCAPE([$(X_PRE_LIBS) $(X_LIBS) -lXext -lX11 $(X_EXTRA_LIBS)])])
    891. 

  891. 

  892.     CS_CHECK_LIB_WITH([Xxf86vm],
    893. 

  893. 	[AC_LANG_PROGRAM(
    894. 

  894. 	    [[#define XK_MISCELLANY 1
    895. 

  895. 	    #include <X11/Xlib.h>
    896. 

  896. 	    #include <X11/Xutil.h>
    897. 

  897. 	    #include <X11/Xatom.h>
    898. 

  898. 	    #include <X11/extensions/xf86vmode.h>]],
    899. 

  899. 	    [XF86VidModeLockModeSwitch(0, 0, 0)])], [], [],
    900. 

  900. 	[CS_EMIT_BUILD_PROPERTY([XFREE86VM.AVAILABLE], [yes])
    901. 

  901. 	CS_EMIT_BUILD_PROPERTY([XFREE86VM.CFLAGS], [AS_ESCAPE([$(X_CFLAGS)])])
    902. 

  902. 	CS_EMIT_BUILD_PROPERTY([XFREE86VM.LFLAGS],
    903. 

  903. 	    [AS_ESCAPE([$(X_PRE_LIBS) $(X_LIBS) -lXxf86vm -lXext -lX11
    904. 

  904. 	    $(X_EXTRA_LIBS)])])], [],
    905. 

  905. 	[$X_CFLAGS], [], [$X_PRE_LIBS $X_LIBS -lX11 -lXext $X_EXTRA_LIBS])
    906. 

  906. 

  907.     CS_CHECK_LIB_WITH([Xaw],
    908. 

  908. 	[AC_LANG_PROGRAM(
    909. 

  909. 	    [[#include <X11/Shell.h>
    910. 

  910. 	    #include <X11/Xaw/Form.h>]],
    911. 

  911. 	    [XtVaGetValues(0,0,0,0)])],
    912. 

  912. 	[], [],	[CS_EMIT_BUILD_RESULT([cs_cv_libXaw], [XAW])], [],
    913. 

  913. 	[$X_CFLAGS], [], [$X_PRE_LIBS $X_LIBS -lX11 $X_EXTRA_LIBS])])
    914. 

  914. 

  915. 

  916. 

  917. #------------------------------------------------------------------------------
    918. 

  918. # Check for OpenGL and companions.  Also check if GLX extensions are supported
    919. 

  919. # and define the (backward) header property CSGL_EXT_STATIC_ASSERTION if they
    920. 

  920. # are _not_ supported. Finally, check if the type GLhandleARB is exported by
    921. 

  921. # the GL headers. It is starting to show up in very modern headers, but is
    922. 

  922. # absent from most.
    923. 

  923. #
    924. 

  924. # IMPLEMENTATION NOTES
    925. 

  925. #
    926. 

  926. # GLU is not required or used by CrystalSpace itself, but certain 3rd party
    927. 

  927. # libraries may depend on it (notably Cg).
    928. 

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

  929. CS_CHECK_OPENGL
    930. 

  930. AS_IF([test $cs_cv_libgl = yes],
    931. 

  931.     [# Check for GLhandleARB.
    932. 

  932.     CS_CHECK_BUILD([for GLhandleARB], [cs_cv_libgl_glhandlearb],
    933. 

  933. 	[AC_LANG_PROGRAM(
    934. 

  934. 	    [CS_GL_INCLUDE([CS_OPENGL_PATH],[GL],[gl.h])],
    935. 

  935. 	    [GLhandleARB x; (void)x;])],
    936. 

  936. 	[], [],	[CS_HEADER_PROPERTY([CS_HAVE_GLHANDLEARB_T])], [], [],
    937. 

  937. 	[$cs_cv_libgl_cflags], [$cs_cv_libgl_lflags], [$cs_cv_libgl_libs])])
    938. 

  938. CS_CHECK_GLX
    939. 

  939. # Check for GLX extensions.  Define CSGL_EXT_STATIC_ASSERTION if _not_
    940. 

  940. # present.
    941. 

  941. CS_CHECK_GLXEXT([], [CS_HEADER_PROPERTY([CSGL_EXT_STATIC_ASSERTION])])
    942. 

  942. 

  943. 

  944. #------------------------------------------------------------------------------
    945. 

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

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

  947. # must take this into account.  With Cygwin, we must check for the DirectX
    948. 

  948. # headers in /usr/include/directx.
    949. 

  949. #------------------------------------------------------------------------------
    950. 

  950. # CS_CHECK_DIRECTX([DSOUND-VERSION])
    951. 

  951. AC_DEFUN([CS_CHECK_DIRECTX],
    952. 

  952.     [CS_CHECK_BUILD([for DirectX$1], [cs_cv_libdirectx$1],
    953. 

  953. 	[AC_LANG_PROGRAM(
    954. 

  954. 	    [[#if !HAVE_TYPE_INT32
    955. 

  955. 	    typedef long int32;
    956. 

  956. 	    #endif
    957. 

  957. 	    #define DIRECTINPUT_VERSION 0x0500
    958. 

  958. 	    #include <windows.h>
    959. 

  959. 	    #include <ddraw.h>
    960. 

  960. 	    #include <dsound.h>
    961. 

  961. 	    #include <dinput.h>]],
    962. 

  962. 	    [DirectDrawCreate(0,0,0); 
    963. 

  963. 	     DirectSoundCreate$1(0,0,0); 
    964. 

  964. 	     DirectInputCreate(0,0,0,0)])],
    965. 

  965. 	[CS_CREATE_TUPLE([],[],[-lddraw -ldsound -ldinput]) \
    966. 

  966. 	CS_CREATE_TUPLE([-I/usr/include/directx],[],
    967. 

  967. 	    [-lddraw -ldsound -ldinput])], 
    968. 

  968. 	[C++], [CS_EMIT_BUILD_RESULT([cs_cv_libdirectx$1], [DIRECTX$1])])])
    969. 

  969. 

  970. AS_IF([test $cs_host_family = windows],
    971. 

  971.     [AC_CHECK_TYPE([int32], [AC_DEFINE([HAVE_TYPE_INT32])], [])
    972. 

  972.     CS_CHECK_DIRECTX([])
    973. 

  973.     CS_CHECK_DIRECTX([8])])
    974. 

  974. 

  975. 

  976. 

  977. #------------------------------------------------------------------------------
    978. 

  978. # Check for the Windows Multimedia library, used by the 'sndwaveout' plugin.
    979. 

  979. #------------------------------------------------------------------------------
    980. 

  980. AS_IF([test $cs_host_family = windows],
    981. 

  981.     [CS_CHECK_BUILD([for waveout], [cs_cv_libwaveout],
    982. 

  982. 	[AC_LANG_PROGRAM(
    983. 

  983. 	    [[#include <windows.h>
    984. 

  984. 	    #include <mmsystem.h>]],
    985. 

  985. 	    [waveOutOpen(0, 0, 0, 0, 0, 0)])],
    986. 

  986. 	[CS_CREATE_TUPLE([],[],[-lwinmm])], 
    987. 

  987. 	[], [CS_EMIT_BUILD_RESULT([cs_cv_libwaveout], [WAVEOUT])])])
    988. 

  988. 

  989. 

  990. 

  991. #------------------------------------------------------------------------------
    992. 

  992. # Check for zlib.  In addition to the standard installed locations, we also
    993. 

  993. # search CS/libs/zlib*.
    994. 

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

  995. CS_CHECK_LIB_WITH([z],
    996. 

  996.     [AC_LANG_PROGRAM([[#include <zlib.h>]], [zlibVersion()])],
    997. 

  997.     [$srcdir/libs/zlib*], [], [CS_EMIT_BUILD_RESULT([cs_cv_libz], [ZLIB])],
    998. 

  998.     [AC_MSG_NOTICE([*** zlib not found; VFS will be unusable])], 
    999. 

  999.     [], [], [], [zlib])
    1000. 

  1000. 

  1001. 

  1002. 

  1003. #------------------------------------------------------------------------------
    1004. 

  1004. # Check for libpng.  In addition to the standard installed locations, we also
    1005. 

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

  1006. # be linked with libpng, so use libm.a if available.
    1007. 

  1007. #------------------------------------------------------------------------------
    1008. 

  1008. AC_DEFUN([CS_CHECK_LIBPNG_PREPARE],
    1009. 

  1009.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])])
    1010. 

  1010. 

  1011. AS_IF([test "$cs_cv_libz" = yes],
    1012. 

  1012.     [CS_CHECK_LIBPNG_PREPARE
    1013. 

  1013.     CS_CHECK_LIB_WITH([png],
    1014. 

  1014. 	[AC_LANG_PROGRAM([[#include <png.h>]],
    1015. 

  1015. 	    [png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0)])],
    1016. 

  1016. 	[$srcdir/libs/libpng*], [],
    1017. 

  1017. 	[CS_EMIT_BUILD_RESULT([cs_cv_libpng], [PNG])], [],
    1018. 

  1018. 	[$cs_cv_libz_cflags $cs_cv_libm_cflags],
    1019. 

  1019. 	[$cs_cv_libz_lflags $cs_cv_libm_lflags],
    1020. 

  1020. 	[$cs_cv_libz_libs $cs_cv_libm_libs], [libpng])])
    1021. 

  1021. 

  1022. 

  1023. 

  1024. #------------------------------------------------------------------------------
    1025. 

  1025. # Check for libjpeg.  In addition to the standard installed locations, we also
    1026. 

  1026. # search CS/libs/*jpeg*.
    1027. 

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

  1028. CS_CHECK_LIB_WITH([jpeg],
    1029. 

  1029.     [AC_LANG_PROGRAM(
    1030. 

  1030. 	[[#include <stddef.h>
    1031. 

  1031. 	#include <stdio.h>
    1032. 

  1032. 	#include <jpeglib.h>]],
    1033. 

  1033. 	[jpeg_create_compress(0)])],
    1034. 

  1034.     [$srcdir/libs/*jpeg*], [], [CS_EMIT_BUILD_RESULT([cs_cv_libjpeg], [JPEG])],
    1035. 

  1035.     [], [], [], [], [libjpeg])
    1036. 

    1037. 

    1038. 

    1039. 

  1039. #------------------------------------------------------------------------------
    1040. 

  1040. # Check for libmng.  In addition to the standard installed locations, we also
    1041. 

  1041. # search CS/libs/libmng*. Note that libmng on some OpenBSD installations has a
    1042. 

  1042. # dependency on lcms (http://www.littlecms.com/), so we must check for this
    1043. 

  1043. # library, and utilize it explicitly if present.
    1044. 

  1044. #------------------------------------------------------------------------------
    1045. 

  1045. CS_CHECK_LIB_WITH([lcms],
    1046. 

  1046.     [AC_LANG_PROGRAM([[#include <lcms.h>]],
    1047. 

  1047. 	[LPLUT p = cmsAllocLUT(); cmsFreeLUT(p);])],
    1048. 

  1048. 	[/usr/include/lcms| /usr/local/include/lcms|])
    1049. 

    1050. 

  1050. CS_CHECK_LIB_WITH([mng],
    1051. 

  1051.     [AC_LANG_PROGRAM([[#include <libmng.h>]], [mng_version_release()])],
    1052. 

  1052.     [$srcdir/libs/libmng*], [],
    1053. 

  1053.     [CS_EMIT_BUILD_RESULT([cs_cv_libmng], [MNG])], [],
    1054. 

  1054.     [$cs_cv_liblcms_cflags $cs_cv_libjpeg_cflags $cs_cv_libz_cflags],
    1055. 

  1055.     [$cs_cv_liblcms_lflags $cs_cv_libjpeg_lflags $cs_cv_libz_lflags],
    1056. 

  1056.     [$cs_cv_liblcms_libs $cs_cv_libjpeg_libs $cs_cv_libz_libs],
    1057. 

  1057.     [libmng])
    1058. 

    1059. 

    1060. 

    1061. 

  1061. #------------------------------------------------------------------------------
    1062. 

  1062. # Check for MikMod.  In addition to the standard installed locations, we also
    1063. 

  1063. # search CS/libs/libmikmod*.
    1064. 

  1064. #------------------------------------------------------------------------------
    1065. 

  1065. CS_CHECK_LIB_WITH([mikmod],
    1066. 

  1066.     [AC_LANG_PROGRAM(
    1067. 

  1067. 	[[#include <mikmod.h>]],
    1068. 

  1068. 	[MikMod_Init("mikmodtest"); MikMod_Exit();])],
    1069. 

  1069.     [$srcdir/libs/libmikmod*], [],
    1070. 

  1070.     [CS_EMIT_BUILD_RESULT([cs_cv_libmikmod], [MIKMOD])], [],
    1071. 

  1071.     [$cs_cv_sys_pthread_cflags],
    1072. 

  1072.     [$cs_cv_sys_pthread_lflags],
    1073. 

  1073.     [$cs_cv_sys_pthread_libs])
    1074. 

    1075. 

    1076. 

    1077. 

  1077. #------------------------------------------------------------------------------
    1078. 

  1078. # Check for Ogg/Vorbis.  In addition to the standard installed locations, we
    1079. 

  1079. # also search CS/libs/libogg*, CS/libs/libvorbis.*, CS/libs/libvorbisfile*.
    1080. 

  1080. #------------------------------------------------------------------------------
    1081. 

  1081. CS_CHECK_LIB_WITH([ogg],
    1082. 

  1082.     [AC_LANG_PROGRAM(
    1083. 

  1083. 	[[#include <ogg/ogg.h>]],
    1084. 

  1084. 	[ogg_sync_state state; ogg_sync_init(&state);])],
    1085. 

  1085.     [$srcdir/libs/libogg*], [],
    1086. 

  1086.     [CS_EMIT_BUILD_RESULT([cs_cv_libogg], [OGG])])
    1087. 

    1088. 

  1088. AS_IF([test "$cs_cv_libogg" = yes],
    1089. 

  1089.     [CS_CHECK_LIB_WITH([vorbis],
    1090. 

  1090. 	[AC_LANG_PROGRAM([[#include <vorbis/codec.h>]],
    1091. 

  1091. 	  [vorbis_info info; vorbis_info_init(&info);])],
    1092. 

  1092. 	[$srcdir/libs/libvorbis.*], [],
    1093. 

  1093. 	[CS_EMIT_BUILD_RESULT([cs_cv_libvorbis], [VORBIS])], [],
    1094. 

  1094. 	[$cs_cv_libogg_cflags],
    1095. 

  1095. 	[$cs_cv_libogg_lflags],
    1096. 

  1096. 	[$cs_cv_libogg_libs])])
    1097. 

    1098. 

  1098. AS_IF([test "$cs_cv_libvorbis" = yes],
    1099. 

  1099.     [CS_CHECK_LIB_WITH([vorbisfile],
    1100. 

  1100. 	[AC_LANG_PROGRAM(
    1101. 

  1101. 	    [[#include <vorbis/vorbisfile.h>
    1102. 

  1102. 	    #include <stdio.h>]],
    1103. 

  1103. 	    [OggVorbis_File file; ov_test(stdin, &file, "", 0);])],
    1104. 

  1104. 	[$srcdir/libs/libvorbisfile*], [],
    1105. 

  1105. 	[CS_EMIT_BUILD_RESULT([cs_cv_libvorbisfile], [VORBISFILE])], [],
    1106. 

  1106. 	[$cs_cv_libogg_cflags $cs_cv_libvorbis_cflags],
    1107. 

  1107. 	[$cs_cv_libogg_lflags $cs_cv_libvorbis_lflags],
    1108. 

  1108. 	[$cs_cv_libogg_libs $cs_cv_libvorbis_libs])])
    1109. 

    1110. 

    1111. 

    1112. 

  1112. #------------------------------------------------------------------------------
    1113. 

  1113. # Check for lib3ds.  In addition to the standard installed locations, we also
    1114. 

  1114. # search CS/libs/lib3ds*.
    1115. 

  1115. #------------------------------------------------------------------------------
    1116. 

  1116. AC_DEFUN([CS_CHECK_LIB3DS_PREPARE],
    1117. 

  1117.     [AC_REQUIRE([CS_CHECK_COMMON_LIBS])])
    1118. 

    1119. 

  1119. CS_CHECK_LIB3DS_PREPARE
    1120. 

    1121. 

  1121. CS_CHECK_LIB_WITH([3ds],
    1122. 

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

  1123.     [$srcdir/libs/lib3ds*], [], [], [], [], [], [$cs_cv_libm_libs],
    1124. 

  1124.     [lib3ds, lib3ds-120])
    1125. 

    1126. 

  1126. AS_IF([test $cs_cv_lib3ds = yes],
    1127. 

  1127.     [CS_CHECK_BUILD([if lib3ds is sufficiently recent], [cs_cv_lib3ds_recent],
    1128. 

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

  1129. 	[], [], [CS_EMIT_BUILD_RESULT([cs_cv_lib3ds], [3DS])], [], [],
    1130. 

  1130. 	[$cs_cv_lib3ds_cflags], [$cs_cv_lib3ds_lflags], [$cs_cv_lib3ds_libs])])
    1131. 

    1132. 

    1133. 

    1134. 

  1134. #------------------------------------------------------------------------------
    1135. 

  1135. # Check for ODE.  In addition to the standard installed locations, we also
    1136. 

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

  1137. #------------------------------------------------------------------------------
    1138. 

  1138. CS_CHECK_LIB_WITH([ode],
    1139. 

  1139.     [AC_LANG_PROGRAM([[#include <ode/ode.h>]], [dWorldCreate()])],
    1140. 

  1140.     [$srcdir/libs/libode*], [C++])
    1141. 

    1142. 

  1142. AS_IF([test $cs_cv_libode = yes],
    1143. 

  1143.     [CS_CHECK_BUILD([if libode is built with OPCODE support],
    1144. 

  1144. 	[cs_cv_libode_opcode],
    1145. 

  1145. 	[AC_LANG_PROGRAM(
    1146. 

  1146. 	    [[#include <ode/ode.h>]],
    1147. 

  1147. 	    [dGeomTriMeshDataCreate();])],
    1148. 

  1148. 	[], [C++], [], [], [],
    1149. 

  1149. 	[$cs_cv_libode_cflags], [$cs_cv_libode_lflags], [$cs_cv_libode_libs])],
    1150. 

  1150. 	[cs_cv_libode_opcode=no])
    1151. 

    1152. 

  1152. AS_IF([test $cs_cv_libode_opcode = yes],
    1153. 

  1153.     [CS_CHECK_BUILD([if libode is sufficiently recent], [cs_cv_libode_recent],
    1154. 

  1154. 	[AC_LANG_PROGRAM(
    1155. 

  1155. 	    [[#include <ode/ode.h>]],
    1156. 

  1156. 	    [dGeomTriMeshGetTriangleCount(0);])],
    1157. 

  1157. …
    1158.

Large files files are truncated, but you can click here to view the full file