PageRenderTime 63ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 1ms

/aclocal.m4

https://bitbucket.org/mike_php_net/libmysqludf
m4 | 9557 lines | 6697 code | 959 blank | 1901 comment | 0 complexity | c3a04dbb2215820c0b858232a286c3ca MD5 | raw file
Possible License(s): BSD-2-Clause

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

    

  1. # generated automatically by aclocal 1.11.2 -*- Autoconf -*-
    2. 

  2. 

  3. # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
    4. 

  4. # 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
    5. 

  5. # Inc.
    6. 

  6. # This file is free software; the Free Software Foundation
    7. 

  7. # gives unlimited permission to copy and/or distribute it,
    8. 

  8. # with or without modifications, as long as this notice is preserved.
    9. 

  9. 

  10. # This program is distributed in the hope that it will be useful,
    11. 

  11. # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
    12. 

  12. # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
    13. 

  13. # PARTICULAR PURPOSE.
    14. 

  14. 

  15. m4_ifndef([AC_AUTOCONF_VERSION],
    16. 

  16.   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
    17. 

  17. m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.68],,
    18. 

  18. [m4_warning([this file was generated for autoconf 2.68.
    19. 

  19. You have another version of autoconf.  It may work, but is not guaranteed to.
    20. 

  20. If you have problems, you may need to regenerate the build system entirely.
    21. 

  21. To do so, use the procedure documented by the package, typically `autoreconf'.])])
    22. 

    23. 

  23. # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
    24. 

  24. #
    25. 

  25. #   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
    26. 

  26. #                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
    27. 

  27. #                 Foundation, Inc.
    28. 

  28. #   Written by Gordon Matzigkeit, 1996
    29. 

  29. #
    30. 

  30. # This file is free software; the Free Software Foundation gives
    31. 

  31. # unlimited permission to copy and/or distribute it, with or without
    32. 

  32. # modifications, as long as this notice is preserved.
    33. 

    34. 

  34. m4_define([_LT_COPYING], [dnl
    35. 

  35. #   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
    36. 

  36. #                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
    37. 

  37. #                 Foundation, Inc.
    38. 

  38. #   Written by Gordon Matzigkeit, 1996
    39. 

  39. #
    40. 

  40. #   This file is part of GNU Libtool.
    41. 

  41. #
    42. 

  42. # GNU Libtool is free software; you can redistribute it and/or
    43. 

  43. # modify it under the terms of the GNU General Public License as
    44. 

  44. # published by the Free Software Foundation; either version 2 of
    45. 

  45. # the License, or (at your option) any later version.
    46. 

  46. #
    47. 

  47. # As a special exception to the GNU General Public License,
    48. 

  48. # if you distribute this file as part of a program or library that
    49. 

  49. # is built using GNU Libtool, you may include this file under the
    50. 

  50. # same distribution terms that you use for the rest of that program.
    51. 

  51. #
    52. 

  52. # GNU Libtool is distributed in the hope that it will be useful,
    53. 

  53. # but WITHOUT ANY WARRANTY; without even the implied warranty of
    54. 

  54. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    55. 

  55. # GNU General Public License for more details.
    56. 

  56. #
    57. 

  57. # You should have received a copy of the GNU General Public License
    58. 

  58. # along with GNU Libtool; see the file COPYING.  If not, a copy
    59. 

  59. # can be downloaded from http://www.gnu.org/licenses/gpl.html, or
    60. 

  60. # obtained by writing to the Free Software Foundation, Inc.,
    61. 

  61. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
    62. 

  62. ])
    63. 

    64. 

  64. # serial 57 LT_INIT
    65. 

    66. 

    67. 

  67. # LT_PREREQ(VERSION)
    68. 

  68. # ------------------
    69. 

  69. # Complain and exit if this libtool version is less that VERSION.
    70. 

  70. m4_defun([LT_PREREQ],
    71. 

  71. [m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
    72. 

  72.        [m4_default([$3],
    73. 

  73. 		   [m4_fatal([Libtool version $1 or higher is required],
    74. 

  74. 		             63)])],
    75. 

  75.        [$2])])
    76. 

    77. 

    78. 

  78. # _LT_CHECK_BUILDDIR
    79. 

  79. # ------------------
    80. 

  80. # Complain if the absolute build directory name contains unusual characters
    81. 

  81. m4_defun([_LT_CHECK_BUILDDIR],
    82. 

  82. [case `pwd` in
    83. 

  83.   *\ * | *\	*)
    84. 

  84.     AC_MSG_WARN([Libtool does not cope well with whitespace in `pwd`]) ;;
    85. 

  85. esac
    86. 

  86. ])
    87. 

    88. 

    89. 

  89. # LT_INIT([OPTIONS])
    90. 

  90. # ------------------
    91. 

  91. AC_DEFUN([LT_INIT],
    92. 

  92. [AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
    93. 

  93. AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT])dnl
    94. 

  94. AC_BEFORE([$0], [LT_LANG])dnl
    95. 

  95. AC_BEFORE([$0], [LT_OUTPUT])dnl
    96. 

  96. AC_BEFORE([$0], [LTDL_INIT])dnl
    97. 

  97. m4_require([_LT_CHECK_BUILDDIR])dnl
    98. 

    99. 

  99. dnl Autoconf doesn't catch unexpanded LT_ macros by default:
    100. 

  100. m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
    101. 

  101. m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW|LT_MULTI_MODULE)$])dnl
    102. 

  102. dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
    103. 

  103. dnl unless we require an AC_DEFUNed macro:
    104. 

  104. AC_REQUIRE([LTOPTIONS_VERSION])dnl
    105. 

  105. AC_REQUIRE([LTSUGAR_VERSION])dnl
    106. 

  106. AC_REQUIRE([LTVERSION_VERSION])dnl
    107. 

  107. AC_REQUIRE([LTOBSOLETE_VERSION])dnl
    108. 

  108. m4_require([_LT_PROG_LTMAIN])dnl
    109. 

    110. 

  110. _LT_SHELL_INIT([SHELL=${CONFIG_SHELL-/bin/sh}])
    111. 

    112. 

  112. dnl Parse OPTIONS
    113. 

  113. _LT_SET_OPTIONS([$0], [$1])
    114. 

    115. 

  115. # This can be used to rebuild libtool when needed
    116. 

  116. LIBTOOL_DEPS="$ltmain"
    117. 

    118. 

  118. # Always use our own libtool.
    119. 

  119. LIBTOOL='$(SHELL) $(top_builddir)/libtool'
    120. 

  120. AC_SUBST(LIBTOOL)dnl
    121. 

    122. 

  122. _LT_SETUP
    123. 

    124. 

  124. # Only expand once:
    125. 

  125. m4_define([LT_INIT])
    126. 

  126. ])# LT_INIT
    127. 

    128. 

  128. # Old names:
    129. 

  129. AU_ALIAS([AC_PROG_LIBTOOL], [LT_INIT])
    130. 

  130. AU_ALIAS([AM_PROG_LIBTOOL], [LT_INIT])
    131. 

  131. dnl aclocal-1.4 backwards compatibility:
    132. 

  132. dnl AC_DEFUN([AC_PROG_LIBTOOL], [])
    133. 

  133. dnl AC_DEFUN([AM_PROG_LIBTOOL], [])
    134. 

    135. 

    136. 

  136. # _LT_CC_BASENAME(CC)
    137. 

  137. # -------------------
    138. 

  138. # Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
    139. 

  139. m4_defun([_LT_CC_BASENAME],
    140. 

  140. [for cc_temp in $1""; do
    141. 

  141.   case $cc_temp in
    142. 

  142.     compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
    143. 

  143.     distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
    144. 

  144.     \-*) ;;
    145. 

  145.     *) break;;
    146. 

  146.   esac
    147. 

  147. done
    148. 

  148. cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
    149. 

  149. ])
    150. 

    151. 

    152. 

  152. # _LT_FILEUTILS_DEFAULTS
    153. 

  153. # ----------------------
    154. 

  154. # It is okay to use these file commands and assume they have been set
    155. 

  155. # sensibly after `m4_require([_LT_FILEUTILS_DEFAULTS])'.
    156. 

  156. m4_defun([_LT_FILEUTILS_DEFAULTS],
    157. 

  157. [: ${CP="cp -f"}
    158. 

  158. : ${MV="mv -f"}
    159. 

  159. : ${RM="rm -f"}
    160. 

  160. ])# _LT_FILEUTILS_DEFAULTS
    161. 

  161. 

  162. 

  163. # _LT_SETUP
    164. 

  164. # ---------
    165. 

  165. m4_defun([_LT_SETUP],
    166. 

  166. [AC_REQUIRE([AC_CANONICAL_HOST])dnl
    167. 

  167. AC_REQUIRE([AC_CANONICAL_BUILD])dnl
    168. 

  168. AC_REQUIRE([_LT_PREPARE_SED_QUOTE_VARS])dnl
    169. 

  169. AC_REQUIRE([_LT_PROG_ECHO_BACKSLASH])dnl
    170. 

  170. 

  171. _LT_DECL([], [PATH_SEPARATOR], [1], [The PATH separator for the build system])dnl
    172. 

  172. dnl
    173. 

  173. _LT_DECL([], [host_alias], [0], [The host system])dnl
    174. 

  174. _LT_DECL([], [host], [0])dnl
    175. 

  175. _LT_DECL([], [host_os], [0])dnl
    176. 

  176. dnl
    177. 

  177. _LT_DECL([], [build_alias], [0], [The build system])dnl
    178. 

  178. _LT_DECL([], [build], [0])dnl
    179. 

  179. _LT_DECL([], [build_os], [0])dnl
    180. 

  180. dnl
    181. 

  181. AC_REQUIRE([AC_PROG_CC])dnl
    182. 

  182. AC_REQUIRE([LT_PATH_LD])dnl
    183. 

  183. AC_REQUIRE([LT_PATH_NM])dnl
    184. 

  184. dnl
    185. 

  185. AC_REQUIRE([AC_PROG_LN_S])dnl
    186. 

  186. test -z "$LN_S" && LN_S="ln -s"
    187. 

  187. _LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
    188. 

  188. dnl
    189. 

  189. AC_REQUIRE([LT_CMD_MAX_LEN])dnl
    190. 

  190. _LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
    191. 

  191. _LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
    192. 

  192. dnl
    193. 

  193. m4_require([_LT_FILEUTILS_DEFAULTS])dnl
    194. 

  194. m4_require([_LT_CHECK_SHELL_FEATURES])dnl
    195. 

  195. m4_require([_LT_PATH_CONVERSION_FUNCTIONS])dnl
    196. 

  196. m4_require([_LT_CMD_RELOAD])dnl
    197. 

  197. m4_require([_LT_CHECK_MAGIC_METHOD])dnl
    198. 

  198. m4_require([_LT_CHECK_SHAREDLIB_FROM_LINKLIB])dnl
    199. 

  199. m4_require([_LT_CMD_OLD_ARCHIVE])dnl
    200. 

  200. m4_require([_LT_CMD_GLOBAL_SYMBOLS])dnl
    201. 

  201. m4_require([_LT_WITH_SYSROOT])dnl
    202. 

  202. 

  203. _LT_CONFIG_LIBTOOL_INIT([
    204. 

  204. # See if we are running on zsh, and set the options which allow our
    205. 

  205. # commands through without removal of \ escapes INIT.
    206. 

  206. if test -n "\${ZSH_VERSION+set}" ; then
    207. 

  207.    setopt NO_GLOB_SUBST
    208. 

  208. fi
    209. 

  209. ])
    210. 

  210. if test -n "${ZSH_VERSION+set}" ; then
    211. 

  211.    setopt NO_GLOB_SUBST
    212. 

  212. fi
    213. 

  213. 

  214. _LT_CHECK_OBJDIR
    215. 

  215. 

  216. m4_require([_LT_TAG_COMPILER])dnl
    217. 

  217. 

  218. case $host_os in
    219. 

  219. aix3*)
    220. 

  220.   # AIX sometimes has problems with the GCC collect2 program.  For some
    221. 

  221.   # reason, if we set the COLLECT_NAMES environment variable, the problems
    222. 

  222.   # vanish in a puff of smoke.
    223. 

  223.   if test "X${COLLECT_NAMES+set}" != Xset; then
    224. 

  224.     COLLECT_NAMES=
    225. 

  225.     export COLLECT_NAMES
    226. 

  226.   fi
    227. 

  227.   ;;
    228. 

  228. esac
    229. 

  229. 

  230. # Global variables:
    231. 

  231. ofile=libtool
    232. 

  232. can_build_shared=yes
    233. 

  233. 

  234. # All known linkers require a `.a' archive for static linking (except MSVC,
    235. 

  235. # which needs '.lib').
    236. 

  236. libext=a
    237. 

    238. 

  238. with_gnu_ld="$lt_cv_prog_gnu_ld"
    239. 

    240. 

  240. old_CC="$CC"
    241. 

  241. old_CFLAGS="$CFLAGS"
    242. 

    243. 

  243. # Set sane defaults for various variables
    244. 

  244. test -z "$CC" && CC=cc
    245. 

  245. test -z "$LTCC" && LTCC=$CC
    246. 

  246. test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
    247. 

  247. test -z "$LD" && LD=ld
    248. 

  248. test -z "$ac_objext" && ac_objext=o
    249. 

    250. 

  250. _LT_CC_BASENAME([$compiler])
    251. 

    252. 

  252. # Only perform the check for file, if the check method requires it
    253. 

  253. test -z "$MAGIC_CMD" && MAGIC_CMD=file
    254. 

  254. case $deplibs_check_method in
    255. 

  255. file_magic*)
    256. 

  256.   if test "$file_magic_cmd" = '$MAGIC_CMD'; then
    257. 

  257.     _LT_PATH_MAGIC
    258. 

  258.   fi
    259. 

  259.   ;;
    260. 

  260. esac
    261. 

    262. 

  262. # Use C for the default configuration in the libtool script
    263. 

  263. LT_SUPPORTED_TAG([CC])
    264. 

  264. _LT_LANG_C_CONFIG
    265. 

  265. _LT_LANG_DEFAULT_CONFIG
    266. 

  266. _LT_CONFIG_COMMANDS
    267. 

  267. ])# _LT_SETUP
    268. 

    269. 

    270. 

  270. # _LT_PREPARE_SED_QUOTE_VARS
    271. 

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

  272. # Define a few sed substitution that help us do robust quoting.
    273. 

  273. m4_defun([_LT_PREPARE_SED_QUOTE_VARS],
    274. 

  274. [# Backslashify metacharacters that are still active within
    275. 

  275. # double-quoted strings.
    276. 

  276. sed_quote_subst='s/\([["`$\\]]\)/\\\1/g'
    277. 

    278. 

  278. # Same as above, but do not quote variable references.
    279. 

  279. double_quote_subst='s/\([["`\\]]\)/\\\1/g'
    280. 

  280. 

  281. # Sed substitution to delay expansion of an escaped shell variable in a
    282. 

  282. # double_quote_subst'ed string.
    283. 

  283. delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
    284. 

  284. 

  285. # Sed substitution to delay expansion of an escaped single quote.
    286. 

  286. delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
    287. 

    288. 

  288. # Sed substitution to avoid accidental globbing in evaled expressions
    289. 

  289. no_glob_subst='s/\*/\\\*/g'
    290. 

  290. ])
    291. 

  291. 

  292. # _LT_PROG_LTMAIN
    293. 

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

  294. # Note that this code is called both from `configure', and `config.status'
    295. 

  295. # now that we use AC_CONFIG_COMMANDS to generate libtool.  Notably,
    296. 

  296. # `config.status' has no value for ac_aux_dir unless we are using Automake,
    297. 

  297. # so we pass a copy along to make sure it has a sensible value anyway.
    298. 

  298. m4_defun([_LT_PROG_LTMAIN],
    299. 

  299. [m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([ltmain.sh])])dnl
    300. 

  300. _LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
    301. 

  301. ltmain="$ac_aux_dir/ltmain.sh"
    302. 

  302. ])# _LT_PROG_LTMAIN
    303. 

    304. 

    305. 

    306. 

  306. # So that we can recreate a full libtool script including additional
    307. 

  307. # tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
    308. 

  308. # in macros and then make a single call at the end using the `libtool'
    309. 

  309. # label.
    310. 

  310. 

  311. 

  312. # _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
    313. 

  313. # ----------------------------------------
    314. 

  314. # Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
    315. 

  315. m4_define([_LT_CONFIG_LIBTOOL_INIT],
    316. 

  316. [m4_ifval([$1],
    317. 

  317.           [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
    318. 

  318.                      [$1
    319. 

  319. ])])])
    320. 

  320. 

  321. # Initialize.
    322. 

  322. m4_define([_LT_OUTPUT_LIBTOOL_INIT])
    323. 

  323. 

  324. 

  325. # _LT_CONFIG_LIBTOOL([COMMANDS])
    326. 

  326. # ------------------------------
    327. 

  327. # Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
    328. 

  328. m4_define([_LT_CONFIG_LIBTOOL],
    329. 

  329. [m4_ifval([$1],
    330. 

  330.           [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
    331. 

  331.                      [$1
    332. 

  332. ])])])
    333. 

  333. 

  334. # Initialize.
    335. 

  335. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
    336. 

  336. 

  337. 

  338. # _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
    339. 

  339. # -----------------------------------------------------
    340. 

  340. m4_defun([_LT_CONFIG_SAVE_COMMANDS],
    341. 

  341. [_LT_CONFIG_LIBTOOL([$1])
    342. 

  342. _LT_CONFIG_LIBTOOL_INIT([$2])
    343. 

  343. ])
    344. 

  344. 

  345. 

  346. # _LT_FORMAT_COMMENT([COMMENT])
    347. 

  347. # -----------------------------
    348. 

  348. # Add leading comment marks to the start of each line, and a trailing
    349. 

  349. # full-stop to the whole comment if one is not present already.
    350. 

  350. m4_define([_LT_FORMAT_COMMENT],
    351. 

  351. [m4_ifval([$1], [
    352. 

  352. m4_bpatsubst([m4_bpatsubst([$1], [^ *], [# ])],
    353. 

  353.               [['`$\]], [\\\&])]m4_bmatch([$1], [[!?.]$], [], [.])
    354. 

  354. )])
    355. 

  355. 

  356. 

  357. 

  358. 

  359. 

  360. # _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
    361. 

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

  362. # CONFIGNAME is the name given to the value in the libtool script.
    363. 

  363. # VARNAME is the (base) name used in the configure script.
    364. 

  364. # VALUE may be 0, 1 or 2 for a computed quote escaped value based on
    365. 

  365. # VARNAME.  Any other value will be used directly.
    366. 

  366. m4_define([_LT_DECL],
    367. 

  367. [lt_if_append_uniq([lt_decl_varnames], [$2], [, ],
    368. 

  368.     [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
    369. 

  369. 	[m4_ifval([$1], [$1], [$2])])
    370. 

  370.     lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
    371. 

  371.     m4_ifval([$4],
    372. 

  372. 	[lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
    373. 

  373.     lt_dict_add_subkey([lt_decl_dict], [$2],
    374. 

  374. 	[tagged?], [m4_ifval([$5], [yes], [no])])])
    375. 

  375. ])
    376. 

  376. 

  377. 

  378. # _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
    379. 

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

  380. m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
    381. 

  381. 

  382. 

  383. # lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
    384. 

  384. # ------------------------------------------------
    385. 

  385. m4_define([lt_decl_tag_varnames],
    386. 

  386. [_lt_decl_filter([tagged?], [yes], $@)])
    387. 

  387. 

  388. 

  389. # _lt_decl_filter(SUBKEY, VALUE, [SEPARATOR], [VARNAME1..])
    390. 

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

  391. m4_define([_lt_decl_filter],
    392. 

  392. [m4_case([$#],
    393. 

  393.   [0], [m4_fatal([$0: too few arguments: $#])],
    394. 

  394.   [1], [m4_fatal([$0: too few arguments: $#: $1])],
    395. 

  395.   [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
    396. 

  396.   [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
    397. 

  397.   [lt_dict_filter([lt_decl_dict], $@)])[]dnl
    398. 

  398. ])
    399. 

  399. 

  400. 

  401. # lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
    402. 

  402. # --------------------------------------------------
    403. 

  403. m4_define([lt_decl_quote_varnames],
    404. 

  404. [_lt_decl_filter([value], [1], $@)])
    405. 

  405. 

  406. 

  407. # lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
    408. 

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

  409. m4_define([lt_decl_dquote_varnames],
    410. 

  410. [_lt_decl_filter([value], [2], $@)])
    411. 

  411. 

  412. 

  413. # lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
    414. 

  414. # ---------------------------------------------------
    415. 

  415. m4_define([lt_decl_varnames_tagged],
    416. 

  416. [m4_assert([$# <= 2])dnl
    417. 

  417. _$0(m4_quote(m4_default([$1], [[, ]])),
    418. 

  418.     m4_ifval([$2], [[$2]], [m4_dquote(lt_decl_tag_varnames)]),
    419. 

  419.     m4_split(m4_normalize(m4_quote(_LT_TAGS)), [ ]))])
    420. 

  420. m4_define([_lt_decl_varnames_tagged],
    421. 

  421. [m4_ifval([$3], [lt_combine([$1], [$2], [_], $3)])])
    422. 

  422. 

  423. 

  424. # lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
    425. 

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

  426. m4_define([lt_decl_all_varnames],
    427. 

  427. [_$0(m4_quote(m4_default([$1], [[, ]])),
    428. 

  428.      m4_if([$2], [],
    429. 

  429. 	   m4_quote(lt_decl_varnames),
    430. 

  430. 	m4_quote(m4_shift($@))))[]dnl
    431. 

  431. ])
    432. 

  432. m4_define([_lt_decl_all_varnames],
    433. 

  433. [lt_join($@, lt_decl_varnames_tagged([$1],
    434. 

  434. 			lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
    435. 

  435. ])
    436. 

  436. 

  437. 

  438. # _LT_CONFIG_STATUS_DECLARE([VARNAME])
    439. 

  439. # ------------------------------------
    440. 

  440. # Quote a variable value, and forward it to `config.status' so that its
    441. 

  441. # declaration there will have the same value as in `configure'.  VARNAME
    442. 

  442. # must have a single quote delimited value for this to work.
    443. 

  443. m4_define([_LT_CONFIG_STATUS_DECLARE],
    444. 

  444. [$1='`$ECHO "$][$1" | $SED "$delay_single_quote_subst"`'])
    445. 

  445. 

  446. 

  447. # _LT_CONFIG_STATUS_DECLARATIONS
    448. 

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

  449. # We delimit libtool config variables with single quotes, so when
    450. 

  450. # we write them to config.status, we have to be sure to quote all
    451. 

  451. # embedded single quotes properly.  In configure, this macro expands
    452. 

  452. # each variable declared with _LT_DECL (and _LT_TAGDECL) into:
    453. 

  453. #
    454. 

  454. #    <var>='`$ECHO "$<var>" | $SED "$delay_single_quote_subst"`'
    455. 

  455. m4_defun([_LT_CONFIG_STATUS_DECLARATIONS],
    456. 

  456. [m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
    457. 

  457.     [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
    458. 

  458. 

  459. 

  460. # _LT_LIBTOOL_TAGS
    461. 

  461. # ----------------
    462. 

  462. # Output comment and list of tags supported by the script
    463. 

  463. m4_defun([_LT_LIBTOOL_TAGS],
    464. 

  464. [_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
    465. 

  465. available_tags="_LT_TAGS"dnl
    466. 

  466. ])
    467. 

  467. 

  468. 

  469. # _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
    470. 

  470. # -----------------------------------
    471. 

  471. # Extract the dictionary values for VARNAME (optionally with TAG) and
    472. 

  472. # expand to a commented shell variable setting:
    473. 

  473. #
    474. 

  474. #    # Some comment about what VAR is for.
    475. 

  475. #    visible_name=$lt_internal_name
    476. 

  476. m4_define([_LT_LIBTOOL_DECLARE],
    477. 

  477. [_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
    478. 

  478. 					   [description])))[]dnl
    479. 

  479. m4_pushdef([_libtool_name],
    480. 

  480.     m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
    481. 

  481. m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
    482. 

  482.     [0], [_libtool_name=[$]$1],
    483. 

  483.     [1], [_libtool_name=$lt_[]$1],
    484. 

  484.     [2], [_libtool_name=$lt_[]$1],
    485. 

  485.     [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
    486. 

  486. m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
    487. 

  487. ])
    488. 

  488. 

  489. 

  490. # _LT_LIBTOOL_CONFIG_VARS
    491. 

  491. # -----------------------
    492. 

  492. # Produce commented declarations of non-tagged libtool config variables
    493. 

  493. # suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
    494. 

  494. # script.  Tagged libtool config variables (even for the LIBTOOL CONFIG
    495. 

  495. # section) are produced by _LT_LIBTOOL_TAG_VARS.
    496. 

  496. m4_defun([_LT_LIBTOOL_CONFIG_VARS],
    497. 

  497. [m4_foreach([_lt_var],
    498. 

  498.     m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
    499. 

  499.     [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
    500. 

    501. 

    502. 

  502. # _LT_LIBTOOL_TAG_VARS(TAG)
    503. 

  503. # -------------------------
    504. 

  504. m4_define([_LT_LIBTOOL_TAG_VARS],
    505. 

  505. [m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
    506. 

  506.     [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
    507. 

    508. 

    509. 

  509. # _LT_TAGVAR(VARNAME, [TAGNAME])
    510. 

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

  511. m4_define([_LT_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
    512. 

    513. 

    514. 

  514. # _LT_CONFIG_COMMANDS
    515. 

  515. # -------------------
    516. 

  516. # Send accumulated output to $CONFIG_STATUS.  Thanks to the lists of
    517. 

  517. # variables for single and double quote escaping we saved from calls
    518. 

  518. # to _LT_DECL, we can put quote escaped variables declarations
    519. 

  519. # into `config.status', and then the shell code to quote escape them in
    520. 

  520. # for loops in `config.status'.  Finally, any additional code accumulated
    521. 

  521. # from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
    522. 

  522. m4_defun([_LT_CONFIG_COMMANDS],
    523. 

  523. [AC_PROVIDE_IFELSE([LT_OUTPUT],
    524. 

  524. 	dnl If the libtool generation code has been placed in $CONFIG_LT,
    525. 

  525. 	dnl instead of duplicating it all over again into config.status,
    526. 

  526. 	dnl then we will have config.status run $CONFIG_LT later, so it
    527. 

  527. 	dnl needs to know what name is stored there:
    528. 

  528.         [AC_CONFIG_COMMANDS([libtool],
    529. 

  529.             [$SHELL $CONFIG_LT || AS_EXIT(1)], [CONFIG_LT='$CONFIG_LT'])],
    530. 

  530.     dnl If the libtool generation code is destined for config.status,
    531. 

  531.     dnl expand the accumulated commands and init code now:
    532. 

  532.     [AC_CONFIG_COMMANDS([libtool],
    533. 

  533.         [_LT_OUTPUT_LIBTOOL_COMMANDS], [_LT_OUTPUT_LIBTOOL_COMMANDS_INIT])])
    534. 

  534. ])#_LT_CONFIG_COMMANDS
    535. 

    536. 

    537. 

  537. # Initialize.
    538. 

  538. m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS_INIT],
    539. 

  539. [
    540. 

    541. 

  541. # The HP-UX ksh and POSIX shell print the target directory to stdout
    542. 

  542. # if CDPATH is set.
    543. 

  543. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
    544. 

    545. 

  545. sed_quote_subst='$sed_quote_subst'
    546. 

  546. double_quote_subst='$double_quote_subst'
    547. 

  547. delay_variable_subst='$delay_variable_subst'
    548. 

  548. _LT_CONFIG_STATUS_DECLARATIONS
    549. 

  549. LTCC='$LTCC'
    550. 

  550. LTCFLAGS='$LTCFLAGS'
    551. 

  551. compiler='$compiler_DEFAULT'
    552. 

    553. 

  553. # A function that is used when there is no print builtin or printf.
    554. 

  554. func_fallback_echo ()
    555. 

  555. {
    556. 

  556.   eval 'cat <<_LTECHO_EOF
    557. 

  557. \$[]1
    558. 

  558. _LTECHO_EOF'
    559. 

  559. }
    560. 

    561. 

  561. # Quote evaled strings.
    562. 

  562. for var in lt_decl_all_varnames([[ \
    563. 

  563. ]], lt_decl_quote_varnames); do
    564. 

  564.     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
    565. 

  565.     *[[\\\\\\\`\\"\\\$]]*)
    566. 

  566.       eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
    567. 

  567.       ;;
    568. 

  568.     *)
    569. 

  569.       eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
    570. 

  570.       ;;
    571. 

  571.     esac
    572. 

  572. done
    573. 

  573. 

  574. # Double-quote double-evaled strings.
    575. 

  575. for var in lt_decl_all_varnames([[ \
    576. 

  576. ]], lt_decl_dquote_varnames); do
    577. 

  577.     case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
    578. 

  578.     *[[\\\\\\\`\\"\\\$]]*)
    579. 

  579.       eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
    580. 

  580.       ;;
    581. 

  581.     *)
    582. 

  582.       eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
    583. 

  583.       ;;
    584. 

  584.     esac
    585. 

  585. done
    586. 

    587. 

  587. _LT_OUTPUT_LIBTOOL_INIT
    588. 

  588. ])
    589. 

    590. 

  590. # _LT_GENERATED_FILE_INIT(FILE, [COMMENT])
    591. 

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

  592. # Generate a child script FILE with all initialization necessary to
    593. 

  593. # reuse the environment learned by the parent script, and make the
    594. 

  594. # file executable.  If COMMENT is supplied, it is inserted after the
    595. 

  595. # `#!' sequence but before initialization text begins.  After this
    596. 

  596. # macro, additional text can be appended to FILE to form the body of
    597. 

  597. # the child script.  The macro ends with non-zero status if the
    598. 

  598. # file could not be fully written (such as if the disk is full).
    599. 

  599. m4_ifdef([AS_INIT_GENERATED],
    600. 

  600. [m4_defun([_LT_GENERATED_FILE_INIT],[AS_INIT_GENERATED($@)])],
    601. 

  601. [m4_defun([_LT_GENERATED_FILE_INIT],
    602. 

  602. [m4_require([AS_PREPARE])]dnl
    603. 

  603. [m4_pushdef([AS_MESSAGE_LOG_FD])]dnl
    604. 

  604. [lt_write_fail=0
    605. 

  605. cat >$1 <<_ASEOF || lt_write_fail=1
    606. 

  606. #! $SHELL
    607. 

  607. # Generated by $as_me.
    608. 

  608. $2
    609. 

  609. SHELL=\${CONFIG_SHELL-$SHELL}
    610. 

  610. export SHELL
    611. 

  611. _ASEOF
    612. 

  612. cat >>$1 <<\_ASEOF || lt_write_fail=1
    613. 

  613. AS_SHELL_SANITIZE
    614. 

  614. _AS_PREPARE
    615. 

  615. exec AS_MESSAGE_FD>&1
    616. 

  616. _ASEOF
    617. 

  617. test $lt_write_fail = 0 && chmod +x $1[]dnl
    618. 

  618. m4_popdef([AS_MESSAGE_LOG_FD])])])# _LT_GENERATED_FILE_INIT
    619. 

  619. 

  620. # LT_OUTPUT
    621. 

  621. # ---------
    622. 

  622. # This macro allows early generation of the libtool script (before
    623. 

  623. # AC_OUTPUT is called), incase it is used in configure for compilation
    624. 

  624. # tests.
    625. 

  625. AC_DEFUN([LT_OUTPUT],
    626. 

  626. [: ${CONFIG_LT=./config.lt}
    627. 

  627. AC_MSG_NOTICE([creating $CONFIG_LT])
    628. 

  628. _LT_GENERATED_FILE_INIT(["$CONFIG_LT"],
    629. 

  629. [# Run this file to recreate a libtool stub with the current configuration.])
    630. 

  630. 

  631. cat >>"$CONFIG_LT" <<\_LTEOF
    632. 

  632. lt_cl_silent=false
    633. 

  633. exec AS_MESSAGE_LOG_FD>>config.log
    634. 

  634. {
    635. 

  635.   echo
    636. 

  636.   AS_BOX([Running $as_me.])
    637. 

  637. } >&AS_MESSAGE_LOG_FD
    638. 

  638. 

  639. lt_cl_help="\
    640. 

  640. \`$as_me' creates a local libtool stub from the current configuration,
    641. 

  641. for use in further configure time tests before the real libtool is
    642. 

  642. generated.
    643. 

    644. 

  644. Usage: $[0] [[OPTIONS]]
    645. 

    646. 

  646.   -h, --help      print this help, then exit
    647. 

  647.   -V, --version   print version number, then exit
    648. 

  648.   -q, --quiet     do not print progress messages
    649. 

  649.   -d, --debug     don't remove temporary files
    650. 

    651. 

  651. Report bugs to <bug-libtool@gnu.org>."
    652. 

    653. 

  653. lt_cl_version="\
    654. 

  654. m4_ifset([AC_PACKAGE_NAME], [AC_PACKAGE_NAME ])config.lt[]dnl
    655. 

  655. m4_ifset([AC_PACKAGE_VERSION], [ AC_PACKAGE_VERSION])
    656. 

  656. configured by $[0], generated by m4_PACKAGE_STRING.
    657. 

    658. 

  658. Copyright (C) 2011 Free Software Foundation, Inc.
    659. 

  659. This config.lt script is free software; the Free Software Foundation
    660. 

  660. gives unlimited permision to copy, distribute and modify it."
    661. 

    662. 

  662. while test $[#] != 0
    663. 

  663. do
    664. 

  664.   case $[1] in
    665. 

  665.     --version | --v* | -V )
    666. 

  666.       echo "$lt_cl_version"; exit 0 ;;
    667. 

  667.     --help | --h* | -h )
    668. 

  668.       echo "$lt_cl_help"; exit 0 ;;
    669. 

  669.     --debug | --d* | -d )
    670. 

  670.       debug=: ;;
    671. 

  671.     --quiet | --q* | --silent | --s* | -q )
    672. 

  672.       lt_cl_silent=: ;;
    673. 

    674. 

  674.     -*) AC_MSG_ERROR([unrecognized option: $[1]
    675. 

  675. Try \`$[0] --help' for more information.]) ;;
    676. 

    677. 

  677.     *) AC_MSG_ERROR([unrecognized argument: $[1]
    678. 

  678. Try \`$[0] --help' for more information.]) ;;
    679. 

  679.   esac
    680. 

  680.   shift
    681. 

  681. done
    682. 

    683. 

  683. if $lt_cl_silent; then
    684. 

  684.   exec AS_MESSAGE_FD>/dev/null
    685. 

  685. fi
    686. 

  686. _LTEOF
    687. 

    688. 

  688. cat >>"$CONFIG_LT" <<_LTEOF
    689. 

  689. _LT_OUTPUT_LIBTOOL_COMMANDS_INIT
    690. 

  690. _LTEOF
    691. 

    692. 

  692. cat >>"$CONFIG_LT" <<\_LTEOF
    693. 

  693. AC_MSG_NOTICE([creating $ofile])
    694. 

  694. _LT_OUTPUT_LIBTOOL_COMMANDS
    695. 

  695. AS_EXIT(0)
    696. 

  696. _LTEOF
    697. 

  697. chmod +x "$CONFIG_LT"
    698. 

    699. 

  699. # configure is writing to config.log, but config.lt does its own redirection,
    700. 

  700. # appending to config.log, which fails on DOS, as config.log is still kept
    701. 

  701. # open by configure.  Here we exec the FD to /dev/null, effectively closing
    702. 

  702. # config.log, so it can be properly (re)opened and appended to by config.lt.
    703. 

  703. lt_cl_success=:
    704. 

  704. test "$silent" = yes &&
    705. 

  705.   lt_config_lt_args="$lt_config_lt_args --quiet"
    706. 

  706. exec AS_MESSAGE_LOG_FD>/dev/null
    707. 

  707. $SHELL "$CONFIG_LT" $lt_config_lt_args || lt_cl_success=false
    708. 

  708. exec AS_MESSAGE_LOG_FD>>config.log
    709. 

  709. $lt_cl_success || AS_EXIT(1)
    710. 

  710. ])# LT_OUTPUT
    711. 

    712. 

    713. 

  713. # _LT_CONFIG(TAG)
    714. 

  714. # ---------------
    715. 

  715. # If TAG is the built-in tag, create an initial libtool script with a
    716. 

  716. # default configuration from the untagged config vars.  Otherwise add code
    717. 

  717. # to config.status for appending the configuration named by TAG from the
    718. 

  718. # matching tagged config vars.
    719. 

  719. m4_defun([_LT_CONFIG],
    720. 

  720. [m4_require([_LT_FILEUTILS_DEFAULTS])dnl
    721. 

  721. _LT_CONFIG_SAVE_COMMANDS([
    722. 

  722.   m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
    723. 

  723.   m4_if(_LT_TAG, [C], [
    724. 

  724.     # See if we are running on zsh, and set the options which allow our
    725. 

  725.     # commands through without removal of \ escapes.
    726. 

  726.     if test -n "${ZSH_VERSION+set}" ; then
    727. 

  727.       setopt NO_GLOB_SUBST
    728. 

  728.     fi
    729. 

    730. 

  730.     cfgfile="${ofile}T"
    731. 

  731.     trap "$RM \"$cfgfile\"; exit 1" 1 2 15
    732. 

  732.     $RM "$cfgfile"
    733. 

    734. 

  734.     cat <<_LT_EOF >> "$cfgfile"
    735. 

  735. #! $SHELL
    736. 

    737. 

  737. # `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
    738. 

  738. # Generated automatically by $as_me ($PACKAGE$TIMESTAMP) $VERSION
    739. 

  739. # Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
    740. 

  740. # NOTE: Changes made to this file will be lost: look at ltmain.sh.
    741. 

  741. #
    742. 

  742. _LT_COPYING
    743. 

  743. _LT_LIBTOOL_TAGS
    744. 

    745. 

  745. # ### BEGIN LIBTOOL CONFIG
    746. 

  746. _LT_LIBTOOL_CONFIG_VARS
    747. 

  747. _LT_LIBTOOL_TAG_VARS
    748. 

  748. # ### END LIBTOOL CONFIG
    749. 

    750. 

  750. _LT_EOF
    751. 

    752. 

  752.   case $host_os in
    753. 

  753.   aix3*)
    754. 

  754.     cat <<\_LT_EOF >> "$cfgfile"
    755. 

  755. # AIX sometimes has problems with the GCC collect2 program.  For some
    756. 

  756. # reason, if we set the COLLECT_NAMES environment variable, the problems
    757. 

  757. # vanish in a puff of smoke.
    758. 

  758. if test "X${COLLECT_NAMES+set}" != Xset; then
    759. 

  759.   COLLECT_NAMES=
    760. 

  760.   export COLLECT_NAMES
    761. 

  761. fi
    762. 

  762. _LT_EOF
    763. 

  763.     ;;
    764. 

  764.   esac
    765. 

    766. 

  766.   _LT_PROG_LTMAIN
    767. 

    768. 

  768.   # We use sed instead of cat because bash on DJGPP gets confused if
    769. 

  769.   # if finds mixed CR/LF and LF-only lines.  Since sed operates in
    770. 

  770.   # text mode, it properly converts lines to CR/LF.  This bash problem
    771. 

  771.   # is reportedly fixed, but why not run on old versions too?
    772. 

  772.   sed '$q' "$ltmain" >> "$cfgfile" \
    773. 

  773.      || (rm -f "$cfgfile"; exit 1)
    774. 

    775. 

  775.   _LT_PROG_REPLACE_SHELLFNS
    776. 

    777. 

  777.    mv -f "$cfgfile" "$ofile" ||
    778. 

  778.     (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
    779. 

  779.   chmod +x "$ofile"
    780. 

  780. ],
    781. 

  781. [cat <<_LT_EOF >> "$ofile"
    782. 

    783. 

  783. dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
    784. 

  784. dnl in a comment (ie after a #).
    785. 

  785. # ### BEGIN LIBTOOL TAG CONFIG: $1
    786. 

  786. _LT_LIBTOOL_TAG_VARS(_LT_TAG)
    787. 

  787. # ### END LIBTOOL TAG CONFIG: $1
    788. 

  788. _LT_EOF
    789. 

  789. ])dnl /m4_if
    790. 

  790. ],
    791. 

  791. [m4_if([$1], [], [
    792. 

  792.     PACKAGE='$PACKAGE'
    793. 

  793.     VERSION='$VERSION'
    794. 

  794.     TIMESTAMP='$TIMESTAMP'
    795. 

  795.     RM='$RM'
    796. 

  796.     ofile='$ofile'], [])
    797. 

  797. ])dnl /_LT_CONFIG_SAVE_COMMANDS
    798. 

  798. ])# _LT_CONFIG
    799. 

    800. 

    801. 

  801. # LT_SUPPORTED_TAG(TAG)
    802. 

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

  803. # Trace this macro to discover what tags are supported by the libtool
    804. 

  804. # --tag option, using:
    805. 

  805. #    autoconf --trace 'LT_SUPPORTED_TAG:$1'
    806. 

  806. AC_DEFUN([LT_SUPPORTED_TAG], [])
    807. 

    808. 

    809. 

  809. # C support is built-in for now
    810. 

  810. m4_define([_LT_LANG_C_enabled], [])
    811. 

  811. m4_define([_LT_TAGS], [])
    812. 

    813. 

    814. 

  814. # LT_LANG(LANG)
    815. 

  815. # -------------
    816. 

  816. # Enable libtool support for the given language if not already enabled.
    817. 

  817. AC_DEFUN([LT_LANG],
    818. 

  818. [AC_BEFORE([$0], [LT_OUTPUT])dnl
    819. 

  819. m4_case([$1],
    820. 

  820.   [C],			[_LT_LANG(C)],
    821. 

  821.   [C++],		[_LT_LANG(CXX)],
    822. 

  822.   [Go],			[_LT_LANG(GO)],
    823. 

  823.   [Java],		[_LT_LANG(GCJ)],
    824. 

  824.   [Fortran 77],		[_LT_LANG(F77)],
    825. 

  825.   [Fortran],		[_LT_LANG(FC)],
    826. 

  826.   [Windows Resource],	[_LT_LANG(RC)],
    827. 

  827.   [m4_ifdef([_LT_LANG_]$1[_CONFIG],
    828. 

  828.     [_LT_LANG($1)],
    829. 

  829.     [m4_fatal([$0: unsupported language: "$1"])])])dnl
    830. 

  830. ])# LT_LANG
    831. 

    832. 

    833. 

  833. # _LT_LANG(LANGNAME)
    834. 

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

  835. m4_defun([_LT_LANG],
    836. 

  836. [m4_ifdef([_LT_LANG_]$1[_enabled], [],
    837. 

  837.   [LT_SUPPORTED_TAG([$1])dnl
    838. 

  838.   m4_append([_LT_TAGS], [$1 ])dnl
    839. 

  839.   m4_define([_LT_LANG_]$1[_enabled], [])dnl
    840. 

  840.   _LT_LANG_$1_CONFIG($1)])dnl
    841. 

  841. ])# _LT_LANG
    842. 

    843. 

    844. 

  844. m4_ifndef([AC_PROG_GO], [
    845. 

  845. # NOTE: This macro has been submitted for inclusion into   #
    846. 

  846. #  GNU Autoconf as AC_PROG_GO.  When it is available in    #
    847. 

  847. #  a released version of Autoconf we should remove this    #
    848. 

  848. #  macro and use it instead.                               #
    849. 

  849. m4_defun([AC_PROG_GO],
    850. 

  850. [AC_LANG_PUSH(Go)dnl
    851. 

  851. AC_ARG_VAR([GOC],     [Go compiler command])dnl
    852. 

  852. AC_ARG_VAR([GOFLAGS], [Go compiler flags])dnl
    853. 

  853. _AC_ARG_VAR_LDFLAGS()dnl
    854. 

  854. AC_CHECK_TOOL(GOC, gccgo)
    855. 

  855. if test -z "$GOC"; then
    856. 

  856.   if test -n "$ac_tool_prefix"; then
    857. 

  857.     AC_CHECK_PROG(GOC, [${ac_tool_prefix}gccgo], [${ac_tool_prefix}gccgo])
    858. 

  858.   fi
    859. 

  859. fi
    860. 

  860. if test -z "$GOC"; then
    861. 

  861.   AC_CHECK_PROG(GOC, gccgo, gccgo, false)
    862. 

  862. fi
    863. 

  863. ])#m4_defun
    864. 

  864. ])#m4_ifndef
    865. 

    866. 

    867. 

  867. # _LT_LANG_DEFAULT_CONFIG
    868. 

  868. # -----------------------
    869. 

  869. m4_defun([_LT_LANG_DEFAULT_CONFIG],
    870. 

  870. [AC_PROVIDE_IFELSE([AC_PROG_CXX],
    871. 

  871.   [LT_LANG(CXX)],
    872. 

  872.   [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
    873. 

    874. 

  874. AC_PROVIDE_IFELSE([AC_PROG_F77],
    875. 

  875.   [LT_LANG(F77)],
    876. 

  876.   [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
    877. 

    878. 

  878. AC_PROVIDE_IFELSE([AC_PROG_FC],
    879. 

  879.   [LT_LANG(FC)],
    880. 

  880.   [m4_define([AC_PROG_FC], defn([AC_PROG_FC])[LT_LANG(FC)])])
    881. 

    882. 

  882. dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
    883. 

  883. dnl pulling things in needlessly.
    884. 

  884. AC_PROVIDE_IFELSE([AC_PROG_GCJ],
    885. 

  885.   [LT_LANG(GCJ)],
    886. 

  886.   [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
    887. 

  887.     [LT_LANG(GCJ)],
    888. 

  888.     [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
    889. 

  889.       [LT_LANG(GCJ)],
    890. 

  890.       [m4_ifdef([AC_PROG_GCJ],
    891. 

  891. 	[m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
    892. 

  892.        m4_ifdef([A][M_PROG_GCJ],
    893. 

  893. 	[m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
    894. 

  894.        m4_ifdef([LT_PROG_GCJ],
    895. 

  895. 	[m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
    896. 

    897. 

  897. AC_PROVIDE_IFELSE([AC_PROG_GO],
    898. 

  898.   [LT_LANG(GO)],
    899. 

  899.   [m4_define([AC_PROG_GO], defn([AC_PROG_GO])[LT_LANG(GO)])])
    900. 

    901. 

  901. AC_PROVIDE_IFELSE([LT_PROG_RC],
    902. 

  902.   [LT_LANG(RC)],
    903. 

  903.   [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
    904. 

  904. ])# _LT_LANG_DEFAULT_CONFIG
    905. 

    906. 

  906. # Obsolete macros:
    907. 

  907. AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
    908. 

  908. AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
    909. 

  909. AU_DEFUN([AC_LIBTOOL_FC], [LT_LANG(Fortran)])
    910. 

  910. AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java)])
    911. 

  911. AU_DEFUN([AC_LIBTOOL_RC], [LT_LANG(Windows Resource)])
    912. 

  912. dnl aclocal-1.4 backwards compatibility:
    913. 

  913. dnl AC_DEFUN([AC_LIBTOOL_CXX], [])
    914. 

  914. dnl AC_DEFUN([AC_LIBTOOL_F77], [])
    915. 

  915. dnl AC_DEFUN([AC_LIBTOOL_FC], [])
    916. 

  916. dnl AC_DEFUN([AC_LIBTOOL_GCJ], [])
    917. 

  917. dnl AC_DEFUN([AC_LIBTOOL_RC], [])
    918. 

    919. 

    920. 

  920. # _LT_TAG_COMPILER
    921. 

  921. # ----------------
    922. 

  922. m4_defun([_LT_TAG_COMPILER],
    923. 

  923. [AC_REQUIRE([AC_PROG_CC])dnl
    924. 

    925. 

  925. _LT_DECL([LTCC], [CC], [1], [A C compiler])dnl
    926. 

  926. _LT_DECL([LTCFLAGS], [CFLAGS], [1], [LTCC compiler flags])dnl
    927. 

  927. _LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
    928. 

  928. _LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU compiler?])dnl
    929. 

    930. 

  930. # If no C compiler was specified, use CC.
    931. 

  931. LTCC=${LTCC-"$CC"}
    932. 

    933. 

  933. # If no C compiler flags were specified, use CFLAGS.
    934. 

  934. LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
    935. 

    936. 

  936. # Allow CC to be a program name with arguments.
    937. 

  937. compiler=$CC
    938. 

  938. ])# _LT_TAG_COMPILER
    939. 

    940. 

    941. 

  941. # _LT_COMPILER_BOILERPLATE
    942. 

  942. # ------------------------
    943. 

  943. # Check for compiler boilerplate output or warnings with
    944. 

  944. # the simple compiler test code.
    945. 

  945. m4_defun([_LT_COMPILER_BOILERPLATE],
    946. 

  946. [m4_require([_LT_DECL_SED])dnl
    947. 

  947. ac_outfile=conftest.$ac_objext
    948. 

  948. echo "$lt_simple_compile_test_code" >conftest.$ac_ext
    949. 

  949. eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
    950. 

  950. _lt_compiler_boilerplate=`cat conftest.err`
    951. 

  951. $RM conftest*
    952. 

  952. ])# _LT_COMPILER_BOILERPLATE
    953. 

    954. 

    955. 

  955. # _LT_LINKER_BOILERPLATE
    956. 

  956. # ----------------------
    957. 

  957. # Check for linker boilerplate output or warnings with
    958. 

  958. # the simple link test code.
    959. 

  959. m4_defun([_LT_LINKER_BOILERPLATE],
    960. 

  960. [m4_require([_LT_DECL_SED])dnl
    961. 

  961. ac_outfile=conftest.$ac_objext
    962. 

  962. echo "$lt_simple_link_test_code" >conftest.$ac_ext
    963. 

  963. eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
    964. 

  964. _lt_linker_boilerplate=`cat conftest.err`
    965. 

  965. $RM -r conftest*
    966. 

  966. ])# _LT_LINKER_BOILERPLATE
    967. 

    968. 

  968. # _LT_REQUIRED_DARWIN_CHECKS
    969. 

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

  970. m4_defun_once([_LT_REQUIRED_DARWIN_CHECKS],[
    971. 

  971.   case $host_os in
    972. 

  972.     rhapsody* | darwin*)
    973. 

  973.     AC_CHECK_TOOL([DSYMUTIL], [dsymutil], [:])
    974. 

  974.     AC_CHECK_TOOL([NMEDIT], [nmedit], [:])
    975. 

  975.     AC_CHECK_TOOL([LIPO], [lipo], [:])
    976. 

  976.     AC_CHECK_TOOL([OTOOL], [otool], [:])
    977. 

  977.     AC_CHECK_TOOL([OTOOL64], [otool64], [:])
    978. 

  978.     _LT_DECL([], [DSYMUTIL], [1],
    979. 

  979.       [Tool to manipulate archived DWARF debug symbol files on Mac OS X])
    980. 

  980.     _LT_DECL([], [NMEDIT], [1],
    981. 

  981.       [Tool to change global to local symbols on Mac OS X])
    982. 

  982.     _LT_DECL([], [LIPO], [1],
    983. 

  983.       [Tool to manipulate fat objects and archives on Mac OS X])
    984. 

  984.     _LT_DECL([], [OTOOL], [1],
    985. 

  985.       [ldd/readelf like tool for Mach-O binaries on Mac OS X])
    986. 

  986.     _LT_DECL([], [OTOOL64], [1],
    987. 

  987.       [ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4])
    988. 

    989. 

  989.     AC_CACHE_CHECK([for -single_module linker flag],[lt_cv_apple_cc_single_mod],
    990. 

  990.       [lt_cv_apple_cc_single_mod=no
    991. 

  991.       if test -z "${LT_MULTI_MODULE}"; then
    992. 

  992. 	# By default we will add the -single_module flag. You can override
    993. 

  993. 	# by either setting the environment variable LT_MULTI_MODULE
    994. 

  994. 	# non-empty at configure time, or by adding -multi_module to the
    995. 

  995. 	# link flags.
    996. 

  996. 	rm -rf libconftest.dylib*
    997. 

  997. 	echo "int foo(void){return 1;}" > conftest.c
    998. 

  998. 	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
    999. 

  999. -dynamiclib -Wl,-single_module conftest.c" >&AS_MESSAGE_LOG_FD
    1000. 

  1000. 	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
    1001. 

  1001. 	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
    1002. 

  1002.         _lt_result=$?
    1003. 

  1003. 	# If there is a non-empty error log, and "single_module"
    1004. 

  1004. 	# appears in it, assume the flag caused a linker warning
    1005. 

  1005.         if test -s conftest.err && $GREP single_module conftest.err; then
    1006. 

  1006. 	  cat conftest.err >&AS_MESSAGE_LOG_FD
    1007. 

  1007. 	# Otherwise, if the output was created with a 0 exit code from
    1008. 

  1008. 	# the compiler, it worked.
    1009. 

  1009. 	elif test -f libconftest.dylib && test $_lt_result -eq 0; then
    1010. 

  1010. 	  lt_cv_apple_cc_single_mod=yes
    1011. 

  1011. 	else
    1012. 

  1012. 	  cat conftest.err >&AS_MESSAGE_LOG_FD
    1013. 

  1013. 	fi
    1014. 

  1014. 	rm -rf libconftest.dylib*
    1015. 

  1015. 	rm -f conftest.*
    1016. 

  1016.       fi])
    1017. 

    1018. 

  1018.     AC_CACHE_CHECK([for -exported_symbols_list linker flag],
    1019. 

  1019.       [lt_cv_ld_exported_symbols_list],
    1020. 

  1020.       [lt_cv_ld_exported_symbols_list=no
    1021. 

  1021.       save_LDFLAGS=$LDFLAGS
    1022. 

  1022.       echo "_main" > conftest.sym
    1023. 

  1023.       LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
    1024. 

  1024.       AC_LINK_IFELSE([AC_LANG_PROGRAM([],[])],
    1025. 

  1025. 	[lt_cv_ld_exported_symbols_list=yes],
    1026. 

  1026. 	[lt_cv_ld_exported_symbols_list=no])
    1027. 

  1027. 	LDFLAGS="$save_LDFLAGS"
    1028. 

  1028.     ])
    1029. 

    1030. 

  1030.     AC_CACHE_CHECK([for -force_load linker flag],[lt_cv_ld_force_load],
    1031. 

  1031.       [lt_cv_ld_force_load=no
    1032. 

  1032.       cat > conftest.c << _LT_EOF
    1033. 

  1033. int forced_loaded() { return 2;}
    1034. 

  1034. _LT_EOF
    1035. 

  1035.       echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
    1036. 

  1036.       $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
    1037. 

  1037.       echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
    1038. 

  1038.       $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
    1039. 

  1039.       echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
    1040. 

  1040.       $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
    1041. 

  1041.       cat > conftest.c << _LT_EOF
    1042. 

  1042. int main() { return 0;}
    1043. 

  1043. _LT_EOF
    1044. 

  1044.       echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&AS_MESSAGE_LOG_FD
    1045. 

  1045.       $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
    1046. 

  1046.       _lt_result=$?
    1047. 

  1047.       if test -s conftest.err && $GREP force_load conftest.err; then
    1048. 

  1048. 	cat conftest.err >&AS_MESSAGE_LOG_FD
    1049. 

  1049.       elif test -f conftest && test $_lt_result -eq 0 && $GREP forced_load conftest >/dev/null 2>&1 ; then
    1050. 

  1050. 	lt_cv_ld_force_load=yes
    1051. 

  1051.       else
    1052. 

  1052. 	cat conftest.err >&AS_MESSAGE_LOG_FD
    1053. 

  1053.       fi
    1054. 

  1054.         rm -f conftest.err libconftest.a conftest conftest.c
    1055. 

  1055.         rm -rf conftest.dSYM
    1056. 

  1056.     ])
    1057. 

  1057.     case $host_os in
    1058. 

  1058.     rhapsody* | darwin1.[[012]])
    1059. 

  1059.       _lt_dar_allow_undefined='${wl}-undefined ${wl}suppress' ;;
    1060. 

  1060.     darwin1.*)
    1061. 

  1061.       _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
    1062. 

  1062.     darwin*) # darwin 5.x on
    1063. 

  1063.       # if running on 10.5 or later, the deployment target defaults
    1064. 

  1064.       # to the OS version, if on x86, and 10.4, the deployment
    1065. 

  1065.       # target defaults to 10.4. Don't you love it?
    1066. 

  1066.       case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
    1067. 

  1067. 	10.0,*86*-darwin8*|10.0,*-darwin[[91]]*)
    1068. 

  1068. 	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
    1069. 

  1069. 	10.[[012]]*)
    1070. 

  1070. 	  _lt_dar_allow_undefined='${wl}-flat_namespace ${wl}-undefined ${wl}suppress' ;;
    1071. 

  1071. 	10.*)
    1072. 

  1072. 	  _lt_dar_allow_undefined='${wl}-undefined ${wl}dynamic_lookup' ;;
    1073. 

  1073.       esac
    1074. 

  1074.     ;;
    1075. 

  1075.   esac
    1076. 

  1076.     if test "$lt_cv_apple_cc_single_mod" = "yes"; then
    1077. 

  1077.       _lt_dar_single_mod='$single_module'
    1078. 

  1078.     fi
    1079. 

  1079.     if test "$lt_cv_ld_exported_symbols_list" = "yes"; then
    1080. 

  1080.       _lt_dar_export_syms=' ${wl}-exported_symbols_list,$output_objdir/${libname}-symbols.expsym'
    1081. 

  1081.     else
    1082. 

  1082.       _lt_dar_export_syms='~$NMEDIT -s $output_objdir/${libname}-symbols.expsym ${lib}'
    1083. 

  1083.     fi
    1084. 

  1084.     if test "$DSYMUTIL" != ":" && test "$lt_cv_ld_force_load" = "no"; then
    1085. 

  1085.       _lt_dsymutil='~$DSYMUTIL $lib || :'
    1086. 

  1086.     else
    1087. 

  1087.       _lt_dsymutil=
    1088. 

  1088.     fi
    1089. 

  1089.     ;;
    1090. 

  1090.   esac
    1091. 

  1091. ])
    1092. 

    1093. 

    1094. 

  1094. # _LT_DARWIN_LINKER_FEATURES([TAG])
    1095. 

  1095. # ---------------------------------
    1096. 

  1096. # Checks for linker and compiler features on darwin
    1097. 

  1097. m4_defun([_LT_DARWIN_LINKER_FEATURES],
    1098. 

  1098. [
    1099. 

  1099.   m4_require([_LT_REQUIRED_DARWIN_CHECKS])
    1100. 

  1100.   _LT_TAGVAR(archive_cmds_need_lc, $1)=no
    1101. 

  1101.   _LT_TAGVAR(hardcode_direct, $1)=no
    1102. 

  1102.   _LT_TAGVAR(hardcode_automatic, $1)=yes
    1103. 

  1103.   _LT_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
    1104. 

  1104.   if test "$lt_cv_ld_force_load" = "yes"; then
    1105. 

  1105.     _LT_TAGVAR(whole_archive_flag_spec, $1)='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience ${wl}-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
    1106. 

  1106.     m4_case([$1], [F77], [_LT_TAGVAR(compiler_needs_object, $1)=yes],
    1107. 

  1107.                   [FC],  [_LT_TAGVAR(compiler_needs_object, $1)=yes])
    1108. 

  1108.   else
    1109. 

  1109.     _LT_TAGVAR(whole_archive_flag_spec, $1)=''
    1110. 

  1110.   fi
    1111. 

  1111.   _LT_TAGVAR(link_all_deplibs, $1)=yes
    1112. 

  1112.   _LT_TAGVAR(allow_undefined_flag, $1)="$_lt_dar_allow_undefined"
    1113. 

  1113.   case $cc_basename in
    1114. 

  1114.      ifort*) _lt_dar_can_shared=yes ;;
    1115. 

  1115.      *) _lt_dar_can_shared=$GCC ;;
    1116. 

  1116.   esac
    1117. 

  1117.   if test "$_lt_dar_can_shared" = "yes"; then
    1118. 

  1118.     output_verbose_link_cmd=func_echo_all
    1119. 

  1119.     _LT_TAGVAR(archive_cmds, $1)="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod${_lt_dsymutil}"
    1120. 

  1120.     _LT_TAGVAR(module_cmds, $1)="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dsymutil}"
    1121. 

  1121.     _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring ${_lt_dar_single_mod}${_lt_dar_export_syms}${_lt_dsymutil}"
    1122. 

  1122.     _LT_TAGVAR(module_expsym_cmds, $1)="sed -e 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags${_lt_dar_export_syms}${_lt_dsymutil}"
    1123. 

  1123.     m4_if([$1], [CXX],
    1124. 

  1124. [   if test "$lt_cv_apple_cc_single_mod" != "yes"; then
    1125. 

  1125.       _LT_TAGVAR(archive_cmds, $1)="\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dsymutil}"
    1126. 

  1126.       _LT_TAGVAR(archive_expsym_cmds, $1)="sed 's,^,_,' < \$export_symbols > \$output_objdir/\${libname}-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \${lib}-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \${lib}-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring${_lt_dar_export_syms}${_lt_dsymutil}"
    1127. 

  1127.     fi
    1128. 

  1128. ],[])
    1129. 

  1129.   else
    1130. 

  1130.   _LT_TAGVAR(ld_shlibs, $1)=no
    1131. 

  1131.   fi
    1132. 

  1132. ])
    1133. 

  1133. 

  1134. # _LT_SYS_MODULE_PATH_AIX([TAGNAME])
    1135. 

  1135. # ----------------------------------
    1136. 

  1136. # Links a minimal program and checks the executable
    1137. 

  1137. # for the system default hardcoded library path. In most cases,
    1138. 

  1138. # this is /usr/lib:/lib, but when the MPI compilers are used
    1139. 

  1139. # the location of the communication and MPI libs are included too.
    1140. 

  1140. # If we don't find anything, use the default library path according
    1141. 

  1141. # to the aix ld manual.
    1142. 

  1142. # Store the results from the different compilers for each TAGNAME.
    1143. 

  1143. # Allow to override them for all tags through lt_cv_aix_libpath.
    1144. 

  1144. m4_defun([_LT_SYS_MODULE_PATH_AIX],
    1145. 

  1145. [m4_require([_LT_DECL_SED])dnl
    1146. 

  1146. if test "${lt_cv_aix_libpath+set}" = set; then
    1147. 

  1147.   aix_libpath=$lt_cv_aix_libpath
    1148. 

  1148. else
    1149. 

  1149.   AC_CACHE_VAL([_LT_TAGVAR([lt_cv_aix_libpath_], [$1])],
    1150. 

  1150.   [AC_LINK_IFELSE([AC_LANG_PROGRAM],[
    1151. 

  1151.   lt_aix_libpath_sed='[
    1152. 

  1152.       /Import File Strings/,/^$/ {
    1153. 

  1153. 	  /^0/ {
    1154. 

  1154. 	      s/^0  *\([^ ]*\) *$/\1/
    1155. 

  1155. 	      p
    1156. 

  1156. 	  }
    1157. 

  1157.       }]'
    1158. 

  1158.   _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
    1159. 

  1159.   # Check for a 64-bit object if we didn't find anything.
    1160. 

  1160.   if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
    1161. 

  1161.     _LT_TAGVAR([lt_cv_aix_libpath_], [$1])=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
    1162. 

  1162.   fi],[])
    1163. 

  1163.   if test -z "$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])"; then
    1164. 

  1164.     _LT_TAGVAR([lt_cv_aix_libpath_], [$1])="/usr/lib:/lib"
    1165. 

  1165.   fi
    1166. 

  1166.   ])
    1167. 

  1167.   aix_libpath=$_LT_TAGVAR([lt_cv_aix_libpath_], [$1])
    1168. 

  1168. fi
    1169. 

  1169. ])# _LT_SYS_MODULE_PATH_AIX
    1170. 

  1170. 

  1171. 

  1172. # _LT_SHELL_INIT(ARG)
    1173. 

  1173. # -------------------
    1174. 

  1174. m4_define([_LT_SHELL_INIT],
    1175. 

  1175. [m4_divert_text([M4SH-INIT], [$1
    1176. 

  1176. ])])# _LT_SHELL_INIT
    1177. 

  1177. 

  1178. 

  1179. 

  1180. # _LT_PROG_ECHO_BACKSLASH
    1181. 

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

  1182. # Find how we can fake an echo command that does not interpret backslash.
    1183. 

  1183. # In particular, with Autoconf 2.60 or later we add some code to the start
    1184. 

  1184. # of the generated configure script which will find a shell with a builtin
    1185. 

  1185. # printf (which we can use as an echo command).
    1186. 

  1186. m4_defun([_LT_PROG_ECHO_BACKSLASH],
    1187. 

  1187. [ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    1188. 

  1188. ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
    1189. 

  1189. ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
    1190. 

  1190. 

  1191. AC_MSG_CHECKING([how to print strings])
    1192. 

  1192. # Test print first, because it will be a builtin if present.
    1193. 

  1193. if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
    1194. 

  1194.    test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
    1195. 

  1195.   ECHO='print -r --'
    1196. 

  1196. elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
    1197. 

  1197.   ECHO='printf %s\n'
    1198. 

  1198. else
    1199. 

  1199.   # Use this function as a fallback that always works.
    1200. 

  1200.   func_fallback_echo ()
    1201. 

  1201.   {
    1202. 

  1202.     eval 'cat <<_LTECHO_EOF
    1203. 

  1203. $[]1
    1204. 

  1204. _LTECHO_EOF'
    1205. 

  1205.   }
    1206. 

  1206.   ECHO='func_fallback_echo'
    1207. 

  1207. fi
    1208. 

  1208. 

  1209. # func_echo_all arg...
    1210. 

  1210. # Invoke $ECHO with all args, space-separated.
    1211. 

  1211. func_echo_all ()
    1212. 

  1212. {
    1213. 

  1213.     $ECHO "$*" 
    1214. 

  1214. }
    1215. 

  1215. 

  1216. case "$ECHO" in
    1217. 

  1217.   printf*) AC_MSG_RESULT([printf]) ;;
    1218. 

  1218.   print*) AC_MSG_RESULT([print -r]) ;;
    1219. 

  1219.   *) AC_MSG_RESULT([cat]) ;;
    1220. 

  1220. esac
    1221. 

  1221. 

  1222. m4_ifdef([_AS_DETECT_SUGGESTED],
    1223. 

  1223. [_AS_DETECT_SUGGESTED([
    1224. 

  1224.   test -n "${ZSH_VERSION+set}${BASH_VERSION+set}" || (
    1225. 

  1225.     ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    1226. 

  1226.     ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
    1227. 

  1227.     ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
    1228. 

  1228.     PATH=/empty FPATH=/empty; export PATH FPATH
    1229. 

  1229.     test "X`printf %s $ECHO`" = "X$ECHO" \
    1230. 

  1230.       || test "X`print -r -- $ECHO`" = "X$ECHO" )])])
    1231. 

  1231. 

  1232. _LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
    1233. 

  1233. _LT_DECL([], [ECHO], [1], [An echo program that protects backslashes])
    1234. 

  1234. ])# _LT_PROG_ECHO_BACKSLASH
    1235. 

  1235. 

  1236. 

  1237. # _LT_WITH_SYSROOT
    1238. 

  1238. # ----------------
    1239. 

  1239. AC_DEFUN([_LT_WITH_SYSROOT],
    1240. 

  1240. [AC_MSG_CHECKING([for sysroot])
    1241. 

  1241. AC_ARG_WITH([sysroot],
    1242. 

  1242. [  --with-sysroot[=DIR] Search for dependent libraries within DIR
    1243. 

  1243.                         (or the compiler's sysroot if not specified).],
    1244. 

  1244. [], [with_sysroot=no])
    1245. 

  1245. 

  1246. dnl lt_sysroot will always be passed unquoted.  We quote it here
    1247. 

  1247. dnl in case the user passed a directory name.
    1248. 

  1248. lt_sysroot=
    1249. 

  1249. case ${with_sysroot} in #(
    1250. 

  1250.  yes)
    1251. 

  1251.    if test "$GCC" = yes; then
    1252. 

  1252.      lt_sysroot=`$CC --print-sysroot 2>/dev/null`
    1253. 

  1253.    fi
    1254. 

  1254.    ;; #(
    1255. 

  1255.  /*)
    1256. 

  1256.    lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
    1257. 

  1257.    ;; #(
    1258. 

  1258.  no|'')
    1259. 

  1259.    ;; #(
    1260. 

  1260.  *)
    1261. 

  1261.    AC_MSG_RESULT([${with_sysroot}])
    1262. 

  1262.    AC_MSG_ERROR([The sysroot must be an absolute path.])
    1263. 

  1263.    ;;
    1264. 

  1264. esac
    1265. 

    1266. 

  1266.  AC_MSG_RESULT([${lt_sysroot:-no}])
    1267. 

  1267. _LT_DECL([], [lt_sysroot], [0], [The root where to search for ]dnl
    1268. 

  1268. [dependent libraries, and in which our libraries should be installed.])])
    1269. 

    1270. 

  1270. # _LT_ENABLE_LOCK
    1271. 

  1271. # ---------------
    1272. 

  1272. m4_defun([_LT_ENABLE_LOCK],
    1273. 

  1273. [AC_ARG_ENABLE([libtool-lock],
    1274. 

  1274.   [AS_HELP_STRING([--disable-libtool-lock],
    1275. 

  1275.     [avoid locking (might break parallel builds)])])
    1276. 

  1276. test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
    1277. 

    1278. 

  1278. # Some flags need to be propagated to the compiler or linker for good
    1279. 

  1279. # libtool support.
    1280. 

  1280. case $host in
    1281. 

  1281. ia64-*-hpux*)
    1282. 

  1282.   # Find out which ABI we are using.
    1283. 

  1283.   echo 'int i;' > conftest.$ac_ext
    1284. 

  1284.   if AC_TRY_EVAL(ac_compile); then
    1285. 

  1285.     case `/usr/bin/file conftest.$ac_objext` in
    1286. 

  1286.       *ELF-32*)
    1287. 

  1287. 	HPUX_IA64_MODE="32"
    1288. 

  1288. 	;;
    1289. 

  1289.       *ELF-64*)
    1290. 

  1290. 	HPUX_IA64_MODE="64"
    1291. 

  1291. 	;;
    1292. 

  1292.     esac
    1293. 

  1293.   fi
    1294. 

  1294.   rm -rf conftest*
    1295. 

  1295.   ;;
    1296. 

  1296. *-*-irix6*)
    1297. 

  1297.   # Find out which ABI we are using.
    1298. 

  1298.   echo '[#]line '$LINENO' "configure"' > conftest.$ac_ext
    1299. 

  1299.   if AC_TRY_EVAL(ac_compile); then
    1300. 

  1300.     if test "$lt_cv_prog_gnu_ld" = yes; then
    1301. 

  1301.       case `/usr/bin/file conftest.$ac_objext` in
    1302. 

  1302. 	*32-bit*)
    1303. 

  1303. 	  LD="${LD-ld} -melf32bsmip"
    1304. 

  1304. 	  ;;
    1305. 

  1305. 	*N32*)
    1306. 

  1306. 	  LD="${LD-ld} -melf32bmipn32"
    1307. 

  1307. 	  ;;
    1308. 

  1308. 	*64-bit*)
    1309. 

  1309. 	  LD="${LD-ld} -melf64bmip"
    1310. 

  1310. 	;;
    1311. 

  1311.       esac
    1312. 

  1312.     else
    1313. 

  1313.       case `/usr/bin/file conftest.$ac_objext` in
    1314. 

  1314. 	*32-bit*)
    1315. 

  1315. 	  LD="${LD-ld} -32"
    1316. 

  1316. 	  ;;
    1317. 

  1317. 	*N32*)
    1318. 

  1318. 	  LD="${LD-ld} -n32"
    1319. 

  1319. 	  ;;
    1320. 

  1320. 	*64-bit*)
    1321. 

  1321. 	  LD="${LD-ld} -64"
    1322. 

  1322. 	  ;;
    1323. 

  1323.       esac
    1324. 

  1324.     fi
    1325. 

  1325.   fi
    1326. 

  1326.   rm -rf conftest*
    1327. 

  1327.   ;;
    1328. 

    1329. 

  1329. x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
    1330. 

  1330. s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
    1331. 

  1331.   # Find out which ABI we are using.
    1332. 

  1332.   echo 'int i;' > conftest.$ac_ext
    1333. 

  1333.   if AC_TRY_EVAL(ac_compile); then
    1334. 

  1334.     case `/usr/bin/file conftest.o` in
    1335. 

  1335.       *32-bit*)
    1336. 

  1336. 	case $host in
    1337. 

  1337. 	  x86_64-*kfreebsd*-gnu)
    1338. 

  1338. 	    LD="${LD-ld} -m elf_i386_fbsd"
    1339. 

  1339. 	    ;;
    1340. 

  1340. 	  x86_64-*linux*)
    1341. 

  1341. 	    LD="${LD-ld} -m elf_i386"
    1342. 

  1342. 	    ;;
    1343. 

  1343. 	  ppc64-*linux*|powerpc64-*linux*)
    1344. 

  1344. 	    LD="${LD-ld} -m elf32ppclinux"
    1345. 

  1345. 	    ;;
    1346. 

  1346. 	  s390x-*linux*)
    1347. 

  1347. 	    LD="${LD-ld} -m elf_s390"
    1348. 

  1348. 	    ;;
    1349. 

  1349. 	  sparc64-*linux*)
    1350. 

  1350. 	    LD="${LD-ld} -m elf32_sparc"
    1351. 

  1351. 	    ;;
    1352. 

  1352. 	esac
    1353. 

  1353. 	;;
    1354. 

  1354.       *64-bit*)
    1355. 

  1355. 	case $host in
    1356. 

  1356. 	  x86_64-*kfreebsd*-gnu)
    1357. 

  1357. 	    LD="${LD-ld} -m elf_x86_64_fbsd"
    1358. 

  1358. 	    ;;
    1359. 

  1359. 	  x86_64-*linux*)
    1360. 

  1360. 	    LD="${LD-ld} -m elf_x86_64"
    1361. 

  1361. 	    ;;
    1362. 

  1362. 	  ppc*-*linux*|powerpc*-*linux*)
    1363. 

  1363. 	    LD="${LD-ld} -m elf64ppc"
    1364. 

  1364. 	    ;;
    1365. 

  1365. 	  s390*-*linux*|s390*-*tpf*)
    1366. 

  1366. 	    LD="${LD-ld} -m elf64_s390"
    1367. 

  1367. 	    ;;
    1368. 

  1368. 	  sparc*-*linux*)
    1369. 

  1369. 	    LD="${LD-ld} -m elf64_sparc"
    1370. 

  1370. 	    ;;
    1371. 

  1371. 	esac
    1372. 

  1372. 	;;
    1373. 

  1373.     esac
    1374. 

  1374.   fi
    1375. 

  1375.   rm -rf conftest*
    1376. 

  1376.   ;;
    1377. 

    1378. 

  1378. *-*-sco3.2v5*)
    1379. 

  1379.   # On SCO OpenServer 5, we need -belf to get full-featured binaries.
    1380. 

  1380.   SAVE_CFLAGS="$CFLAGS"
    1381. 

  1381.   CFLAGS="$CFLAGS -belf"
    1382. 

  1382.   AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
    1383. 

  1383.     [AC_LANG_PUSH(C)
    1384. 

  1384.      AC_LINK_IFELSE([AC_LANG_PROGRAM([[]],[[]])],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
    1385. 

  1385.      AC_LANG_POP])
    1386. 

  1386.   if test x"$lt_cv_cc_needs_belf" != x"yes"; then
    1387. 

  1387.     # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
    1388. 

  1388.     CFLAGS="$SAVE_CFLAGS"
    1389. 

  1389.   fi
    1390. 

  1390.   ;;
    1391. 

  1391. *-*solaris*)
    1392. 

  1392.   # Find out which ABI we are using.
    1393. 

  1393.   echo 'int i;' > conftest.$ac_ext
    1394. 

  1394.   if AC_TRY_EVAL(ac_compile); then
    1395. 

  1395.     case `/usr/bin/file conftest.o` in
    1396. 

  1396.     *64-bit*)
    1397. 

  1397.       case $lt_cv_prog_gnu_ld in
    1398. 

  1398.       yes*)
    1399. 

  1399.         case $host in
    1400. 

  1400.         i?86-*-solaris*)
    1401. 

  1401.           LD="${LD-ld} -m elf_x86_64"
    1402. 

  1402.           ;;
    1403. 

  1403.         sparc*-*-solaris*)
    1404. 

  1404.           LD="${LD-ld} -m elf64_sparc"
    1405. 

  1405.           ;;
    1406. 

  1406.         esac
    1407. 

  1407.         # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
    1408. 

  1408.         if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
    1409. 

  1409.           LD="${LD-ld}_sol2"
    1410. 

  1410.         fi
    1411. 

  1411.         ;;
    1412. 

  1412.       *)
    1413. 

  1413. 	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
    1414. 

  1414. 	  LD="${LD-ld} -64"
    1415. 

  1415. 	fi
    1416. 

  1416. 	;;
    1417. 

  1417.       esac
    1418. 

  1418.       ;;
    1419. 

  1419.     esac
    1420. 

  1420.   fi
    1421. 

  1421.   rm -rf conftest*
    1422. 

  1422.   ;;
    1423. 

  1423. esac
    1424. 

    1425. 

  1425. need_locks="$enable_libtool_lock"
    1426. 

  1426. ])# _LT_ENABLE_LOCK
    1427. 

    1428. 

    1429. 

  1429. # _LT_PROG_AR
    1430. 

  1430. # -----------
    1431. 

  1431. m4_defun([_LT_PROG_AR],
    1432. 

  1432. [AC_CHECK_TOOLS(AR, [ar], false)
    1433. 

  1433. : ${AR=ar}
    1434. 

  1434. : ${AR_FLAGS=cru}
    1435. 

  1435. _LT_DECL([], [AR], [1], [The archiver])
    1436. 

  1436. _LT_DECL([], [AR_FLAGS], [1], [Flags to create an archive])
    1437. 

    1438. 

  1438. AC_CACHE_CHECK([for archiver @FILE support], [lt_cv_ar_at_file],
    1439. 

  1439.   [lt_cv_ar_at_file=no
    1440. 

  1440.    AC_COMPILE_IFELSE([AC_LANG_PROGRAM],
    1441. 

  1441.      [echo conftest.$ac_objext > conftest.lst
    1442. 

  1442.       lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&AS_MESSAGE_LOG_FD'
    1443. 

  1443.       AC_TRY_EVAL([lt_ar_try])
    1444. 

  1444.       if test "$ac_status" -eq 0; then
    1445. 

  1445. 	# Ensure the archiver fails upon bogus file names.
    1446. 

  1446. 	rm -f conftest.$ac_objext libconftest.a
    1447. 

  1447. 	AC_TRY_EVAL([lt_ar_try])
    1448. 

  1448. 	if test "$ac_status" -ne 0; then
    1449. 

  1449.           lt_cv_ar_at_file=@
    1450. 

  1450.         fi
    1451. 

  1451.       fi
    1452. 

  1452.       rm -f conftest.* libconftest.a
    1453. 

  1453.      ])
    1454. 

  1454.   ])
    1455. 

    1456. 

  1456. if test "x$lt_cv_ar_at_file" = xno; then
    1457. 

  1457.   archiver_list_spec=
    1458. 

  1458. else
    1459. 

  1459.   archiver_list_spec=$lt_cv_ar_at_file
    1460. 

  1460. fi
    1461. 

  1461. _LT_DECL([], [archiver_list_spec], [1],
    1462. 

  1462.   [How to feed a file listing to the archiver])
    1463. 

  1463. ])# _LT_PROG_AR
    1464. 

    1465. 

    1466. 

  1466. # _LT_CMD_OLD_ARCHIVE
    1467. 

  1467. # -------------------
    1468. 

  1468. m4_defun([_LT_CMD_OLD_ARCHIVE],
    1469. 

  1469. [_LT_PROG_AR
    1470. 

    1471. 

  1471. AC_CHECK_TOOL(STRIP, strip, :)
    1472. 

  1472. test -z "$STRIP" && STRIP=:
    1473. 

  1473. _LT_DECL([], [STRIP], [1], [A symbol stripping program])
    1474. 

    1475. 

  1475. AC_CHECK_TOOL(RANLIB, ranlib, :)
    1476. 

  1476. test -z "$RANLIB" && RANLIB=:
    1477. 

  1477. _LT_DECL([], [RANLIB], [1],
    1478. 

  1478.     [Commands used to install an old-style archive])
    1479. 

    1480. 

  1480. # Determine commands to create old-style static archives.
    1481. 

  1481. old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
    1482. 

  1482. old_postinstall_cmds='chmod 644 $oldlib'
    1483. 

  1483. old_postuninstall_cmds=
    1484. 

    1485. 

  1485. if test -n "$RANLIB"; then
    1486. 

  1486.   case $host_os in
    1487. 

  1487.   openbsd*)
    1488. 

  1488.     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
    1489. 

  1489.     ;;
    1490. 

  1490.   *)
    1491. 

  1491.     old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
    1492. 

  1492.     ;;
    1493. 

  1493.   esac
    1494. 

  1494.   old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
    1495. 

  1495. fi
    1496. 

    1497. 

  1497. case $host_os in
    1498. 

  1498.   darwin*)
    1499. 

  1499.     lock_old_archive_extraction=yes ;;
    1500. 

  1500.   *)
    1501. 

  1501.     lock_old_archive_extraction=no ;;
    1502. 

  1502. esac
    1503. 

  1503. _LT_DECL([], [old_postinstall_cmds], [2])
    1504. 

  1504. _LT_DECL([], [old_postuninstall_cmds], [2])
    1505. 

  1505. _LT_TAGDECL([], [old_archive_cmds], [2],
    1506. 

  1506.     [Commands used to build an old-style archive])
    1507. 

  1507. _LT_DECL([], [lock_old_archive_extraction], [0],
    1508. 

  1508.     [Whether to use a lock for old archive extraction])
    1509. 

  1509. ])# _LT_CMD_OLD_ARCHIVE
    1510. 

    1511. 

    1512. 

  1512. # _LT_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
    1513. 

  1513. #		[OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
    1514. 

  1514. # ----------------------------------------------------------------
    1515. 

  1515. # Check whether the given compiler option works
    1516. 

  1516. AC_DEFUN([_LT_COMPILER_OPTION],
    1517. 

  1517. [m4_require([_LT_FILEUTILS_DEFAULTS])dnl
    1518. 

  1518. m4_require([_LT_DECL_SED])dnl
    1519. 

  1519. AC_CACHE_CHECK([$1], [$2],
    1520. 

  1520.   [$2=no
    1521. 

  1521.    m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
    1522. 

  1522.    echo "$lt_simple_compile_test_code" > conftest.$ac_ext
    1523. 

  1523.    lt_compiler_flag="$3"
    1524. 

  1524.    # Insert the option either (1) after the last *FLAGS variable, or
    1525. 

  1525.    # (2) before a word containing "conftest.", or (3) at the end.
    1526. 

  1526.    # Note that $ac_compile itself does not contain backslashes and begins
    1527. 

  1527.    # with a dollar sign (not a hyphen), so the echo should work correctly.
    1528. 

  1528.    # The option is referenced via a variable to avoid confusing sed.
    1529. 

  1529.    lt_compile=`echo "$ac_compile" | $SED \
    1530. 

  1530.    -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
    1531. 

  1531.    -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
    1532. 

  1532.    -e 's:$: $lt_compiler_flag:'`
    1533. 

  1533.    (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
    1534. 

  1534.    (eval "$lt_compile" 2>conftest.err)
    1535. 

  1535.    ac_status=$?
    1536. 

  1536.    cat conftest.err >&AS_MESSAGE_LOG_FD
    1537. 

  1537.    echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
    1538. 

  1538.    if (exit $ac_status) && test -s "$ac_outfile"; then
    1539. 

  1539.      # The compiler can only warn and ignore the option if not recognized
    1540. 

  1540.      # So say no i…
    1541.

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