PageRenderTime 56ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 1ms

/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

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

    

  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.

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