| 1 |
dnl Process this file with autoconf to produce a configure script.
|
| 2 |
|
| 3 |
dnl NOTE FOR MAINTAINERS: Do not use major or minor version numbers with
|
| 4 |
dnl leading zeros, because they may be treated as octal constants. The
|
| 5 |
dnl PCRE_PRERELEASE feature is for identifying release candidates. It might
|
| 6 |
dnl be defined as -RC2, for example. For real releases, it should be defined
|
| 7 |
dnl empty.
|
| 8 |
|
| 9 |
m4_define(pcre_major, [7])
|
| 10 |
m4_define(pcre_minor, [1])
|
| 11 |
m4_define(pcre_prerelease, [-RC1])
|
| 12 |
m4_define(pcre_date, [2007-03-05])
|
| 13 |
|
| 14 |
# Libtool shared library interface versions (current:revision:age)
|
| 15 |
m4_define(libpcre_version, [0:1:0])
|
| 16 |
m4_define(libpcreposix_version, [0:0:0])
|
| 17 |
m4_define(libpcrecpp_version, [0:0:0])
|
| 18 |
|
| 19 |
AC_PREREQ(2.57)
|
| 20 |
AC_INIT(PCRE, pcre_major.pcre_minor[]pcre_prerelease, , pcre)
|
| 21 |
AC_CONFIG_SRCDIR([pcre.h.in])
|
| 22 |
AM_INIT_AUTOMAKE([dist-bzip2 dist-zip])
|
| 23 |
AC_CONFIG_HEADERS(config.h)
|
| 24 |
AC_PROG_CC
|
| 25 |
AC_PROG_CXX
|
| 26 |
AC_PROG_INSTALL
|
| 27 |
AC_LIBTOOL_WIN32_DLL
|
| 28 |
AC_PROG_LIBTOOL
|
| 29 |
|
| 30 |
PCRE_MAJOR="pcre_major"
|
| 31 |
PCRE_MINOR="pcre_minor"
|
| 32 |
PCRE_PRERELEASE="pcre_prerelease"
|
| 33 |
PCRE_DATE="pcre_date"
|
| 34 |
|
| 35 |
AC_SUBST(PCRE_MAJOR)
|
| 36 |
AC_SUBST(PCRE_MINOR)
|
| 37 |
AC_SUBST(PCRE_PRERELEASE)
|
| 38 |
AC_SUBST(PCRE_DATE)
|
| 39 |
|
| 40 |
# Set a more sensible default value for $(htmldir).
|
| 41 |
if test "x$htmldir" = 'x${docdir}'
|
| 42 |
then
|
| 43 |
htmldir='${docdir}/html'
|
| 44 |
fi
|
| 45 |
|
| 46 |
# Handle --disable-cpp
|
| 47 |
AC_ARG_ENABLE(cpp,
|
| 48 |
AS_HELP_STRING([--disable-cpp],
|
| 49 |
[disable C++ support]),
|
| 50 |
, enable_cpp=yes)
|
| 51 |
|
| 52 |
# Handle --enable-utf8 (disabled by default)
|
| 53 |
AC_ARG_ENABLE(utf8,
|
| 54 |
AS_HELP_STRING([--enable-utf8],
|
| 55 |
[enable UTF-8 support]),
|
| 56 |
, enable_utf8=unset)
|
| 57 |
|
| 58 |
# Handle --enable-unicode-properties
|
| 59 |
AC_ARG_ENABLE(unicode-properties,
|
| 60 |
AS_HELP_STRING([--enable-unicode-properties],
|
| 61 |
[enable Unicode properties support (implies --enable-utf8)]),
|
| 62 |
, enable_unicode_properties=no)
|
| 63 |
|
| 64 |
# Handle --enable-newline=NL
|
| 65 |
dnl AC_ARG_ENABLE(newline,
|
| 66 |
dnl AS_HELP_STRING([--enable-newline=NL],
|
| 67 |
dnl [use NL as newline (lf, cr, crlf, any; default=lf)]),
|
| 68 |
dnl , enable_newline=lf)
|
| 69 |
|
| 70 |
# Separate newline options
|
| 71 |
ac_pcre_newline=lf
|
| 72 |
AC_ARG_ENABLE(newline-is-cr,
|
| 73 |
AS_HELP_STRING([--enable-newline-is-cr],
|
| 74 |
[use CR as newline character]),
|
| 75 |
ac_pcre_newline=cr)
|
| 76 |
AC_ARG_ENABLE(newline-is-lf,
|
| 77 |
AS_HELP_STRING([--enable-newline-is-lf],
|
| 78 |
[use LF as newline character (default)]),
|
| 79 |
ac_pcre_newline=lf)
|
| 80 |
AC_ARG_ENABLE(newline-is-crlf,
|
| 81 |
AS_HELP_STRING([--enable-newline-is-crlf],
|
| 82 |
[use CRLF as newline sequence]),
|
| 83 |
ac_pcre_newline=crlf)
|
| 84 |
AC_ARG_ENABLE(newline-is-any,
|
| 85 |
AS_HELP_STRING([--enable-newline-is-any],
|
| 86 |
[use any valid Unicode newline sequence]),
|
| 87 |
ac_pcre_newline=any)
|
| 88 |
enable_newline="$ac_pcre_newline"
|
| 89 |
|
| 90 |
# Handle --enable-ebcdic
|
| 91 |
AC_ARG_ENABLE(ebcdic,
|
| 92 |
AS_HELP_STRING([--enable-ebcdic],
|
| 93 |
[assume EBCDIC coding rather than ASCII]),
|
| 94 |
, enable_ebcdic=no)
|
| 95 |
|
| 96 |
# Handle --disable-stack-for-recursion
|
| 97 |
AC_ARG_ENABLE(stack-for-recursion,
|
| 98 |
AS_HELP_STRING([--disable-stack-for-recursion],
|
| 99 |
[don't use stack recursion when matching]),
|
| 100 |
, enable_stack_for_recursion=yes)
|
| 101 |
|
| 102 |
# Handle --with-posix-malloc-threshold=NBYTES
|
| 103 |
AC_ARG_WITH(posix-malloc-threshold,
|
| 104 |
AS_HELP_STRING([--with-posix-malloc-threshold=NBYTES],
|
| 105 |
[threshold for POSIX malloc usage (default=10)]),
|
| 106 |
, with_posix_malloc_threshold=10)
|
| 107 |
|
| 108 |
# Handle --with-link-size=N
|
| 109 |
AC_ARG_WITH(link-size,
|
| 110 |
AS_HELP_STRING([--with-link-size=N],
|
| 111 |
[internal link size (2, 3, or 4 allowed; default=2)]),
|
| 112 |
, with_link_size=2)
|
| 113 |
|
| 114 |
# Handle --with-match-limit=N
|
| 115 |
AC_ARG_WITH(match-limit,
|
| 116 |
AS_HELP_STRING([--with-match-limit=N],
|
| 117 |
[default limit on internal looping (default=10000000)]),
|
| 118 |
, with_match_limit=10000000)
|
| 119 |
|
| 120 |
# Handle --with-match-limit_recursion=N
|
| 121 |
#
|
| 122 |
# Note: In config.h, the default is to define MATCH_LIMIT_RECURSION
|
| 123 |
# symbolically as MATCH_LIMIT, which in turn is defined to be some numeric
|
| 124 |
# value (e.g. 10000000). MATCH_LIMIT_RECURSION can otherwise be set to some
|
| 125 |
# different numeric value (or even the same numeric value as MATCH_LIMIT,
|
| 126 |
# though no longer defined in terms of the latter).
|
| 127 |
#
|
| 128 |
AC_ARG_WITH(match-limit-recursion,
|
| 129 |
AS_HELP_STRING([--with-match-limit-recursion=N],
|
| 130 |
[default limit on internal recursion (default=MATCH_LIMIT)]),
|
| 131 |
, with_match_limit_recursion=MATCH_LIMIT)
|
| 132 |
|
| 133 |
# Make sure that if enable_unicode_properties was set, that UTF-8 support
|
| 134 |
# is enabled.
|
| 135 |
#
|
| 136 |
if test "x$enable_unicode_properties" = "xyes"
|
| 137 |
then
|
| 138 |
if test "x$enable_utf8" = "xno"
|
| 139 |
then
|
| 140 |
AC_MSG_ERROR([support for Unicode properties requires UTF-8 support])
|
| 141 |
fi
|
| 142 |
enable_utf8=yes
|
| 143 |
fi
|
| 144 |
|
| 145 |
if test "x$enable_utf8" = "xunset"
|
| 146 |
then
|
| 147 |
enable_utf8=no
|
| 148 |
fi
|
| 149 |
|
| 150 |
# Convert the newline identifier into the appropriate integer value.
|
| 151 |
case "$enable_newline" in
|
| 152 |
lf) ac_pcre_newline_value=10 ;;
|
| 153 |
cr) ac_pcre_newline_value=13 ;;
|
| 154 |
crlf) ac_pcre_newline_value=3338 ;;
|
| 155 |
any) ac_pcre_newline_value=-1 ;;
|
| 156 |
*)
|
| 157 |
AC_MSG_ERROR([invalid argument \"$enable_newline\" to --enable-newline option])
|
| 158 |
;;
|
| 159 |
esac
|
| 160 |
|
| 161 |
# Check argument to --with-link-size
|
| 162 |
case "$with_link_size" in
|
| 163 |
2|3|4) ;;
|
| 164 |
*)
|
| 165 |
AC_MSG_ERROR([invalid argument \"$with_link_size\" to --with-link-size option])
|
| 166 |
;;
|
| 167 |
esac
|
| 168 |
|
| 169 |
AH_TOP([
|
| 170 |
/* On Unix-like systems config.h.in is converted by "configure" into config.h.
|
| 171 |
Some other environments also support the use of "configure". PCRE is written in
|
| 172 |
Standard C, but there are a few non-standard things it can cope with, allowing
|
| 173 |
it to run on SunOS4 and other "close to standard" systems.
|
| 174 |
|
| 175 |
On a system without "configure" you should use the distributed config.h, and
|
| 176 |
set up the macros the way you need them.
|
| 177 |
|
| 178 |
If your system has bcopy() and not memmove(), change the definitions of
|
| 179 |
HAVE_BCOPY and HAVE_MEMMOVE. If your system has neither bcopy() nor memmove(),
|
| 180 |
leave them both undefined; an emulation function will be used. */])
|
| 181 |
|
| 182 |
# Checks for header files.
|
| 183 |
AC_HEADER_STDC
|
| 184 |
AC_CHECK_HEADERS(limits.h sys/types.h sys/stat.h dirent.h windows.h)
|
| 185 |
|
| 186 |
# The files below are C++ header files.
|
| 187 |
pcre_have_type_traits="0"
|
| 188 |
pcre_have_bits_type_traits="0"
|
| 189 |
if test "x$enable_cpp" = "xyes" -a -n "$CXX"
|
| 190 |
then
|
| 191 |
AC_LANG_PUSH(C++)
|
| 192 |
|
| 193 |
# We could be more clever here, given we're doing AC_SUBST with this
|
| 194 |
# (eg set a var to be the name of the include file we want). But we're not
|
| 195 |
# so it's easy to change back to 'regular' autoconf vars if we needed to.
|
| 196 |
AC_CHECK_HEADERS(string, [pcre_have_cpp_headers="1"],
|
| 197 |
[pcre_have_cpp_headers="0"])
|
| 198 |
AC_CHECK_HEADERS(bits/type_traits.h, [pcre_have_bits_type_traits="1"],
|
| 199 |
[pcre_have_bits_type_traits="0"])
|
| 200 |
AC_CHECK_HEADERS(type_traits.h, [pcre_have_type_traits="1"],
|
| 201 |
[pcre_have_type_traits="0"])
|
| 202 |
AC_LANG_POP
|
| 203 |
fi
|
| 204 |
# Using AC_SUBST eliminates the need to include config.h in a public .h file
|
| 205 |
AC_SUBST(pcre_have_type_traits)
|
| 206 |
AC_SUBST(pcre_have_bits_type_traits)
|
| 207 |
|
| 208 |
# Conditional compilation
|
| 209 |
AM_CONDITIONAL(WITH_PCRE_CPP, test "x$enable_cpp" = "xyes")
|
| 210 |
|
| 211 |
# Checks for typedefs, structures, and compiler characteristics.
|
| 212 |
|
| 213 |
AC_C_CONST
|
| 214 |
AC_TYPE_SIZE_T
|
| 215 |
|
| 216 |
AC_CHECK_TYPES([long long],
|
| 217 |
[pcre_have_long_long="1"],
|
| 218 |
[pcre_have_long_long="0"])
|
| 219 |
AC_CHECK_TYPES([unsigned long long],
|
| 220 |
[pcre_have_ulong_long="1"],
|
| 221 |
[pcre_have_ulong_long="0"])
|
| 222 |
AC_SUBST(pcre_have_long_long)
|
| 223 |
AC_SUBST(pcre_have_ulong_long)
|
| 224 |
|
| 225 |
# Checks for library functions.
|
| 226 |
|
| 227 |
AC_CHECK_FUNCS(bcopy memmove strerror strtoq strtoll)
|
| 228 |
|
| 229 |
# This facilitates -ansi builds under Linux
|
| 230 |
dnl AC_DEFINE([_GNU_SOURCE], [], [Enable GNU extensions in glibc])
|
| 231 |
|
| 232 |
if test "x$enable_shared" = "xno" ; then
|
| 233 |
AC_DEFINE([PCRE_STATIC], [1], [
|
| 234 |
Define if linking statically (TODO: make nice with Libtool)])
|
| 235 |
fi
|
| 236 |
|
| 237 |
# Here is where pcre specific defines are handled
|
| 238 |
|
| 239 |
if test "$enable_utf8" = "yes"; then
|
| 240 |
AC_DEFINE([SUPPORT_UTF8], [], [
|
| 241 |
Define to enable support for the UTF-8 Unicode encoding.])
|
| 242 |
fi
|
| 243 |
|
| 244 |
if test "$enable_unicode_properties" = "yes"; then
|
| 245 |
AC_DEFINE([SUPPORT_UCP], [], [
|
| 246 |
Define to enable support for Unicode properties])
|
| 247 |
fi
|
| 248 |
|
| 249 |
if test "$enable_stack_for_recursion" = "no"; then
|
| 250 |
AC_DEFINE([NO_RECURSE], [], [
|
| 251 |
PCRE uses recursive function calls to handle backtracking while
|
| 252 |
matching. This can sometimes be a problem on systems that have
|
| 253 |
stacks of limited size. Define NO_RECURSE to get a version that
|
| 254 |
doesn't use recursion in the match() function; instead it creates
|
| 255 |
its own stack by steam using pcre_recurse_malloc() to obtain memory
|
| 256 |
from the heap. For more detail, see the comments and other stuff
|
| 257 |
just above the match() function. On systems that support it,
|
| 258 |
"configure" can be used to set this in the Makefile
|
| 259 |
(use --disable-stack-for-recursion).])
|
| 260 |
fi
|
| 261 |
|
| 262 |
AC_DEFINE_UNQUOTED([NEWLINE], [$ac_pcre_newline_value], [
|
| 263 |
The value of NEWLINE determines the newline character. On Unix-like
|
| 264 |
systems, "configure" can be used to override the default.])
|
| 265 |
|
| 266 |
AC_DEFINE_UNQUOTED([LINK_SIZE], [$with_link_size], [
|
| 267 |
The value of LINK_SIZE determines the number of bytes used to store
|
| 268 |
links as offsets within the compiled regex. The default is 2, which
|
| 269 |
allows for compiled patterns up to 64K long. This covers the vast
|
| 270 |
majority of cases. However, PCRE can also be compiled to use 3 or 4
|
| 271 |
bytes instead. This allows for longer patterns in extreme cases. On
|
| 272 |
systems that support it, "configure" can be used to override this default.])
|
| 273 |
|
| 274 |
AC_DEFINE_UNQUOTED([POSIX_MALLOC_THRESHOLD], [$with_posix_malloc_threshold], [
|
| 275 |
When calling PCRE via the POSIX interface, additional working storage
|
| 276 |
is required for holding the pointers to capturing substrings because
|
| 277 |
PCRE requires three integers per substring, whereas the POSIX
|
| 278 |
interface provides only two. If the number of expected substrings is
|
| 279 |
small, the wrapper function uses space on the stack, because this is
|
| 280 |
faster than using malloc() for each call. The threshold above which
|
| 281 |
the stack is no longer used is defined by POSIX_MALLOC_THRESHOLD. On
|
| 282 |
systems that support it, "configure" can be used to override this
|
| 283 |
default.])
|
| 284 |
|
| 285 |
AC_DEFINE_UNQUOTED([MATCH_LIMIT], [$with_match_limit], [
|
| 286 |
The value of MATCH_LIMIT determines the default number of times the
|
| 287 |
internal match() function can be called during a single execution of
|
| 288 |
pcre_exec(). There is a runtime interface for setting a different
|
| 289 |
limit. The limit exists in order to catch runaway regular
|
| 290 |
expressions that take for ever to determine that they do not match.
|
| 291 |
The default is set very large so that it does not accidentally catch
|
| 292 |
legitimate cases. On systems that support it, "configure" can be
|
| 293 |
used to override this default default.])
|
| 294 |
|
| 295 |
AC_DEFINE_UNQUOTED([MATCH_LIMIT_RECURSION], [$with_match_limit_recursion], [
|
| 296 |
The above limit applies to all calls of match(), whether or not they
|
| 297 |
increase the recursion depth. In some environments it is desirable
|
| 298 |
to limit the depth of recursive calls of match() more strictly, in
|
| 299 |
order to restrict the maximum amount of stack (or heap, if
|
| 300 |
NO_RECURSE is defined) that is used. The value of
|
| 301 |
MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
|
| 302 |
have any useful effect, it must be less than the value of
|
| 303 |
MATCH_LIMIT. The default is to use the same value as MATCH_LIMIT.
|
| 304 |
There is a runtime method for setting a different limit. On systems
|
| 305 |
that support it, "configure" can be used to override the default.])
|
| 306 |
|
| 307 |
AC_DEFINE([MAX_NAME_SIZE], [32], [
|
| 308 |
This limit is parameterized just in case anybody ever wants to
|
| 309 |
change it. Care must be taken if it is increased, because it guards
|
| 310 |
against integer overflow caused by enormously large patterns.])
|
| 311 |
|
| 312 |
AC_DEFINE([MAX_NAME_COUNT], [10000], [
|
| 313 |
This limit is parameterized just in case anybody ever wants to
|
| 314 |
change it. Care must be taken if it is increased, because it guards
|
| 315 |
against integer overflow caused by enormously large patterns.])
|
| 316 |
|
| 317 |
AC_DEFINE([MAX_DUPLENGTH], [30000], [
|
| 318 |
This limit is parameterized just in case anybody ever wants to
|
| 319 |
change it. Care must be taken if it is increased, because it guards
|
| 320 |
against integer overflow caused by enormously large patterns.])
|
| 321 |
|
| 322 |
AH_VERBATIM([PCRE_DATA_SCOPE], [
|
| 323 |
/* If you are compiling for a system other than a Unix-like system or
|
| 324 |
Win32, and it needs some magic to be inserted before the definition
|
| 325 |
of a function that is exported by the library, define this macro to
|
| 326 |
contain the relevant magic. If you do not define this macro, it
|
| 327 |
defaults to "extern" for a C compiler and "extern C" for a C++
|
| 328 |
compiler on non-Win32 systems. This macro apears at the start of
|
| 329 |
every exported function that is part of the external API. It does
|
| 330 |
not appear on functions that are "external" in the C sense, but
|
| 331 |
which are internal to the library. */
|
| 332 |
#undef PCRE_DATA_SCOPE])
|
| 333 |
|
| 334 |
if test "$enable_ebcdic" = "yes"; then
|
| 335 |
AC_DEFINE_UNQUOTED([EBCDIC], [], [
|
| 336 |
If you are compiling for a system that uses EBCDIC instead of ASCII
|
| 337 |
character codes, define this macro as 1. On systems that can use
|
| 338 |
"configure", this can be done via --enable-ebcdic.])
|
| 339 |
fi
|
| 340 |
|
| 341 |
# Here is where pcre specific substs are handled
|
| 342 |
# These 3 are only used by RunTest.in.
|
| 343 |
# TODO: remove once RunTest uses pcretest -C instead.
|
| 344 |
AC_SUBST(LINK_SIZE, $with_link_size)
|
| 345 |
AC_SUBST(UTF8, $enable_utf8)
|
| 346 |
AC_SUBST(UCP, $enable_unicode_properties)
|
| 347 |
|
| 348 |
# Platform specific issues
|
| 349 |
NO_UNDEFINED=
|
| 350 |
EXPORT_ALL_SYMBOLS=
|
| 351 |
case $host_os in
|
| 352 |
cygwin* | mingw* )
|
| 353 |
if test X"$enable_shared" = Xyes; then
|
| 354 |
NO_UNDEFINED="-no-undefined"
|
| 355 |
EXPORT_ALL_SYMBOLS="-Wl,--export-all-symbols"
|
| 356 |
fi
|
| 357 |
;;
|
| 358 |
esac
|
| 359 |
|
| 360 |
# The extra LDFLAGS for each particular library
|
| 361 |
# (Note: The libpcre*_version bits are m4 variables, assigned above)
|
| 362 |
|
| 363 |
EXTRA_LIBPCRE_LDFLAGS="$NO_UNDEFINED -version-info libpcre_version"
|
| 364 |
|
| 365 |
EXTRA_LIBPCREPOSIX_LDFLAGS="$NO_UNDEFINED -version-info libpcreposix_version"
|
| 366 |
|
| 367 |
EXTRA_LIBPCRECPP_LDFLAGS="$NO_UNDEFINED $EXPORT_ALL_SYMBOLS -version-info libpcrecpp_version"
|
| 368 |
|
| 369 |
AC_SUBST(EXTRA_LIBPCRE_LDFLAGS)
|
| 370 |
AC_SUBST(EXTRA_LIBPCREPOSIX_LDFLAGS)
|
| 371 |
AC_SUBST(EXTRA_LIBPCRECPP_LDFLAGS)
|
| 372 |
|
| 373 |
# When we run 'make distcheck', use these arguments.
|
| 374 |
DISTCHECK_CONFIGURE_FLAGS="--enable-cpp --enable-unicode-properties"
|
| 375 |
AC_SUBST(DISTCHECK_CONFIGURE_FLAGS)
|
| 376 |
|
| 377 |
# Produce these files, in addition to config.h.
|
| 378 |
AC_CONFIG_FILES(
|
| 379 |
Makefile
|
| 380 |
RunGrepTest
|
| 381 |
RunTest
|
| 382 |
libpcre.pc
|
| 383 |
libpcrecpp.pc
|
| 384 |
pcre-config
|
| 385 |
pcre.h
|
| 386 |
pcre_stringpiece.h
|
| 387 |
pcrecpparg.h
|
| 388 |
)
|
| 389 |
|
| 390 |
# Make the generated script files executable.
|
| 391 |
AC_CONFIG_COMMANDS([script-chmod], [chmod a+x RunTest RunGrepTest pcre-config])
|
| 392 |
|
| 393 |
AC_OUTPUT
|
| 394 |
|
| 395 |
# Print out a nice little message after configure is run displaying your
|
| 396 |
# chosen options.
|
| 397 |
#
|
| 398 |
cat <<EOF
|
| 399 |
|
| 400 |
$PACKAGE-$VERSION configuration summary:
|
| 401 |
|
| 402 |
Install prefix ......... : ${prefix}
|
| 403 |
C preprocessor ......... : ${CPP}
|
| 404 |
C compiler ............. : ${CC}
|
| 405 |
C++ preprocessor ....... : ${CXXCPP}
|
| 406 |
C++ compiler ........... : ${CXX}
|
| 407 |
Linker ................. : ${LD}
|
| 408 |
C preprocessor flags ... : ${CPPFLAGS}
|
| 409 |
C compiler flags ....... : ${CFLAGS}
|
| 410 |
C++ compiler flags ..... : ${CXXFLAGS}
|
| 411 |
Linker flags ........... : ${LDFLAGS}
|
| 412 |
Extra libraries ........ : ${LIBS}
|
| 413 |
|
| 414 |
Build C++ library ...... : ${enable_cpp}
|
| 415 |
Enable UTF-8 support ... : ${enable_utf8}
|
| 416 |
Unicode properties ..... : ${enable_unicode_properties}
|
| 417 |
Newline char/sequence .. : ${enable_newline}
|
| 418 |
EBCDIC coding .......... : ${enable_ebcdic}
|
| 419 |
Use stack recursion .... : ${enable_stack_for_recursion}
|
| 420 |
POSIX mem threshold .... : ${with_posix_malloc_threshold}
|
| 421 |
Internal link size ..... : ${with_link_size}
|
| 422 |
Match limit ............ : ${with_match_limit}
|
| 423 |
Match limit recursion .. : ${with_match_limit_recursion}
|
| 424 |
Build shared libs ...... : ${enable_shared}
|
| 425 |
Build static libs ...... : ${enable_static}
|
| 426 |
|
| 427 |
EOF
|
| 428 |
|
| 429 |
dnl end configure.ac
|
Parent Directory
| 
Revision Log