Annotation of embedaddon/pcre/configure.ac, revision 1.1
1.1 ! misho 1: dnl Process this file with autoconf to produce a configure script.
! 2:
! 3: dnl NOTE FOR MAINTAINERS: Do not use minor version numbers 08 or 09 because
! 4: dnl the leading zeros may cause them to be treated as invalid octal constants
! 5: dnl if a PCRE user writes code that uses PCRE_MINOR as a number. There is now
! 6: dnl a check further down that throws an error if 08 or 09 are used.
! 7:
! 8: dnl The PCRE_PRERELEASE feature is for identifying release candidates. It might
! 9: dnl be defined as -RC2, for example. For real releases, it should be empty.
! 10:
! 11: m4_define(pcre_major, [8])
! 12: m4_define(pcre_minor, [21])
! 13: m4_define(pcre_prerelease, [])
! 14: m4_define(pcre_date, [2011-12-12])
! 15:
! 16: # Libtool shared library interface versions (current:revision:age)
! 17: m4_define(libpcre_version, [0:1:0])
! 18: m4_define(libpcreposix_version, [0:0:0])
! 19: m4_define(libpcrecpp_version, [0:0:0])
! 20:
! 21: AC_PREREQ(2.57)
! 22: AC_INIT(PCRE, pcre_major.pcre_minor[]pcre_prerelease, , pcre)
! 23: AC_CONFIG_SRCDIR([pcre.h.in])
! 24: AM_INIT_AUTOMAKE([dist-bzip2 dist-zip])
! 25: AC_CONFIG_HEADERS(config.h)
! 26:
! 27: # This was added at the suggestion of libtoolize (03-Jan-10)
! 28: AC_CONFIG_MACRO_DIR([m4])
! 29:
! 30: # The default CFLAGS and CXXFLAGS in Autoconf are "-g -O2" for gcc and just
! 31: # "-g" for any other compiler. There doesn't seem to be a standard way of
! 32: # getting rid of the -g (which I don't think is needed for a production
! 33: # library). This fudge seems to achieve the necessary. First, we remember the
! 34: # externally set values of CFLAGS and CXXFLAGS. Then call the AC_PROG_CC and
! 35: # AC_PROG_CXX macros to find the compilers - if CFLAGS and CXXFLAGS are not
! 36: # set, they will be set to Autoconf's defaults. Afterwards, if the original
! 37: # values were not set, remove the -g from the Autoconf defaults.
! 38: # (PH 02-May-07)
! 39:
! 40: remember_set_CFLAGS="$CFLAGS"
! 41: remember_set_CXXFLAGS="$CXXFLAGS"
! 42:
! 43: AC_PROG_CC
! 44: AC_PROG_CXX
! 45:
! 46: if test "x$remember_set_CFLAGS" = "x"
! 47: then
! 48: if test "$CFLAGS" = "-g -O2"
! 49: then
! 50: CFLAGS="-O2"
! 51: elif test "$CFLAGS" = "-g"
! 52: then
! 53: CFLAGS=""
! 54: fi
! 55: fi
! 56:
! 57: if test "x$remember_set_CXXFLAGS" = "x"
! 58: then
! 59: if test "$CXXFLAGS" = "-g -O2"
! 60: then
! 61: CXXFLAGS="-O2"
! 62: elif test "$CXXFLAGS" = "-g"
! 63: then
! 64: CXXFLAGS=""
! 65: fi
! 66: fi
! 67:
! 68: # AC_PROG_CXX will return "g++" even if no c++ compiler is installed.
! 69: # Check for that case, and just disable c++ code if g++ doesn't run.
! 70: AC_LANG_PUSH(C++)
! 71: AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],[])],, CXX=""; CXXCP=""; CXXFLAGS="")
! 72: AC_LANG_POP
! 73:
! 74: # Check for a 64-bit integer type
! 75: AC_TYPE_INT64_T
! 76:
! 77: AC_PROG_INSTALL
! 78: AC_LIBTOOL_WIN32_DLL
! 79: LT_INIT
! 80: AC_PROG_LN_S
! 81:
! 82: PCRE_MAJOR="pcre_major"
! 83: PCRE_MINOR="pcre_minor"
! 84: PCRE_PRERELEASE="pcre_prerelease"
! 85: PCRE_DATE="pcre_date"
! 86:
! 87: if test "$PCRE_MINOR" = "08" -o "$PCRE_MINOR" = "09"
! 88: then
! 89: echo "***"
! 90: echo "*** Minor version number $PCRE_MINOR must not be used. ***"
! 91: echo "*** Use only 01 to 07 or 10 onwards, to avoid octal issues. ***"
! 92: echo "***"
! 93: exit 1
! 94: fi
! 95:
! 96: AC_SUBST(PCRE_MAJOR)
! 97: AC_SUBST(PCRE_MINOR)
! 98: AC_SUBST(PCRE_PRERELEASE)
! 99: AC_SUBST(PCRE_DATE)
! 100:
! 101: # Set a more sensible default value for $(htmldir).
! 102: if test "x$htmldir" = 'x${docdir}'
! 103: then
! 104: htmldir='${docdir}/html'
! 105: fi
! 106:
! 107: # Handle --disable-cpp. The substitution of enable_cpp is needed for use in
! 108: # pcre-config.
! 109: AC_ARG_ENABLE(cpp,
! 110: AS_HELP_STRING([--disable-cpp],
! 111: [disable C++ support]),
! 112: , enable_cpp=yes)
! 113: AC_SUBST(enable_cpp)
! 114:
! 115: # Handle --enable-jit (disabled by default)
! 116: AC_ARG_ENABLE(jit,
! 117: AS_HELP_STRING([--enable-jit],
! 118: [enable Just-In-Time compiling support]),
! 119: , enable_jit=no)
! 120:
! 121: # Handle --disable-pcregrep-jit (enabled by default)
! 122: AC_ARG_ENABLE(pcregrep-jit,
! 123: AS_HELP_STRING([--disable-pcregrep-jit],
! 124: [disable JIT support in pcregrep]),
! 125: , enable_pcregrep_jit=yes)
! 126:
! 127: # Handle --enable-rebuild-chartables
! 128: AC_ARG_ENABLE(rebuild-chartables,
! 129: AS_HELP_STRING([--enable-rebuild-chartables],
! 130: [rebuild character tables in current locale]),
! 131: , enable_rebuild_chartables=no)
! 132:
! 133: # Handle --enable-utf8 (disabled by default)
! 134: AC_ARG_ENABLE(utf8,
! 135: AS_HELP_STRING([--enable-utf8],
! 136: [enable UTF-8 support (incompatible with --enable-ebcdic)]),
! 137: , enable_utf8=unset)
! 138:
! 139: # Handle --enable-unicode-properties
! 140: AC_ARG_ENABLE(unicode-properties,
! 141: AS_HELP_STRING([--enable-unicode-properties],
! 142: [enable Unicode properties support (implies --enable-utf8)]),
! 143: , enable_unicode_properties=no)
! 144:
! 145: # Handle --enable-newline=NL
! 146: dnl AC_ARG_ENABLE(newline,
! 147: dnl AS_HELP_STRING([--enable-newline=NL],
! 148: dnl [use NL as newline (lf, cr, crlf, anycrlf, any; default=lf)]),
! 149: dnl , enable_newline=lf)
! 150:
! 151: # Separate newline options
! 152: ac_pcre_newline=lf
! 153: AC_ARG_ENABLE(newline-is-cr,
! 154: AS_HELP_STRING([--enable-newline-is-cr],
! 155: [use CR as newline character]),
! 156: ac_pcre_newline=cr)
! 157: AC_ARG_ENABLE(newline-is-lf,
! 158: AS_HELP_STRING([--enable-newline-is-lf],
! 159: [use LF as newline character (default)]),
! 160: ac_pcre_newline=lf)
! 161: AC_ARG_ENABLE(newline-is-crlf,
! 162: AS_HELP_STRING([--enable-newline-is-crlf],
! 163: [use CRLF as newline sequence]),
! 164: ac_pcre_newline=crlf)
! 165: AC_ARG_ENABLE(newline-is-anycrlf,
! 166: AS_HELP_STRING([--enable-newline-is-anycrlf],
! 167: [use CR, LF, or CRLF as newline sequence]),
! 168: ac_pcre_newline=anycrlf)
! 169: AC_ARG_ENABLE(newline-is-any,
! 170: AS_HELP_STRING([--enable-newline-is-any],
! 171: [use any valid Unicode newline sequence]),
! 172: ac_pcre_newline=any)
! 173: enable_newline="$ac_pcre_newline"
! 174:
! 175: # Handle --enable-bsr-anycrlf
! 176: AC_ARG_ENABLE(bsr-anycrlf,
! 177: AS_HELP_STRING([--enable-bsr-anycrlf],
! 178: [\R matches only CR, LF, CRLF by default]),
! 179: , enable_bsr_anycrlf=no)
! 180:
! 181: # Handle --enable-ebcdic
! 182: AC_ARG_ENABLE(ebcdic,
! 183: AS_HELP_STRING([--enable-ebcdic],
! 184: [assume EBCDIC coding rather than ASCII; incompatible with --enable-utf8; use only in (uncommon) EBCDIC environments; it implies --enable-rebuild-chartables]),
! 185: , enable_ebcdic=no)
! 186:
! 187: # Handle --disable-stack-for-recursion
! 188: AC_ARG_ENABLE(stack-for-recursion,
! 189: AS_HELP_STRING([--disable-stack-for-recursion],
! 190: [don't use stack recursion when matching]),
! 191: , enable_stack_for_recursion=yes)
! 192:
! 193: # Handle --enable-pcregrep-libz
! 194: AC_ARG_ENABLE(pcregrep-libz,
! 195: AS_HELP_STRING([--enable-pcregrep-libz],
! 196: [link pcregrep with libz to handle .gz files]),
! 197: , enable_pcregrep_libz=no)
! 198:
! 199: # Handle --enable-pcregrep-libbz2
! 200: AC_ARG_ENABLE(pcregrep-libbz2,
! 201: AS_HELP_STRING([--enable-pcregrep-libbz2],
! 202: [link pcregrep with libbz2 to handle .bz2 files]),
! 203: , enable_pcregrep_libbz2=no)
! 204:
! 205: # Handle --with-pcregrep-bufsize=N
! 206: AC_ARG_WITH(pcregrep-bufsize,
! 207: AS_HELP_STRING([--with-pcregrep-bufsize=N],
! 208: [pcregrep buffer size (default=20480)]),
! 209: , with_pcregrep_bufsize=20480)
! 210:
! 211: # Handle --enable-pcretest-libreadline
! 212: AC_ARG_ENABLE(pcretest-libreadline,
! 213: AS_HELP_STRING([--enable-pcretest-libreadline],
! 214: [link pcretest with libreadline]),
! 215: , enable_pcretest_libreadline=no)
! 216:
! 217: # Handle --with-posix-malloc-threshold=NBYTES
! 218: AC_ARG_WITH(posix-malloc-threshold,
! 219: AS_HELP_STRING([--with-posix-malloc-threshold=NBYTES],
! 220: [threshold for POSIX malloc usage (default=10)]),
! 221: , with_posix_malloc_threshold=10)
! 222:
! 223: # Handle --with-link-size=N
! 224: AC_ARG_WITH(link-size,
! 225: AS_HELP_STRING([--with-link-size=N],
! 226: [internal link size (2, 3, or 4 allowed; default=2)]),
! 227: , with_link_size=2)
! 228:
! 229: # Handle --with-match-limit=N
! 230: AC_ARG_WITH(match-limit,
! 231: AS_HELP_STRING([--with-match-limit=N],
! 232: [default limit on internal looping (default=10000000)]),
! 233: , with_match_limit=10000000)
! 234:
! 235: # Handle --with-match-limit_recursion=N
! 236: #
! 237: # Note: In config.h, the default is to define MATCH_LIMIT_RECURSION
! 238: # symbolically as MATCH_LIMIT, which in turn is defined to be some numeric
! 239: # value (e.g. 10000000). MATCH_LIMIT_RECURSION can otherwise be set to some
! 240: # different numeric value (or even the same numeric value as MATCH_LIMIT,
! 241: # though no longer defined in terms of the latter).
! 242: #
! 243: AC_ARG_WITH(match-limit-recursion,
! 244: AS_HELP_STRING([--with-match-limit-recursion=N],
! 245: [default limit on internal recursion (default=MATCH_LIMIT)]),
! 246: , with_match_limit_recursion=MATCH_LIMIT)
! 247:
! 248: # Make sure that if enable_unicode_properties was set, that UTF-8 support
! 249: # is enabled.
! 250: #
! 251: if test "x$enable_unicode_properties" = "xyes"
! 252: then
! 253: if test "x$enable_utf8" = "xno"
! 254: then
! 255: AC_MSG_ERROR([support for Unicode properties requires UTF-8 support])
! 256: fi
! 257: enable_utf8=yes
! 258: fi
! 259:
! 260: if test "x$enable_utf8" = "xunset"
! 261: then
! 262: enable_utf8=no
! 263: fi
! 264:
! 265: # Make sure that if enable_ebcdic is set, rebuild_chartables is also enabled.
! 266: # Also check that UTF-8 support is not requested, because PCRE cannot handle
! 267: # EBCDIC and UTF-8 in the same build. To do so it would need to use different
! 268: # character constants depending on the mode.
! 269: #
! 270: if test "x$enable_ebcdic" = "xyes"
! 271: then
! 272: enable_rebuild_chartables=yes
! 273: if test "x$enable_utf8" = "xyes"
! 274: then
! 275: AC_MSG_ERROR([support for EBCDIC and UTF-8 cannot be enabled at the same time])
! 276: fi
! 277: fi
! 278:
! 279: # Convert the newline identifier into the appropriate integer value.
! 280: case "$enable_newline" in
! 281: lf) ac_pcre_newline_value=10 ;;
! 282: cr) ac_pcre_newline_value=13 ;;
! 283: crlf) ac_pcre_newline_value=3338 ;;
! 284: anycrlf) ac_pcre_newline_value=-2 ;;
! 285: any) ac_pcre_newline_value=-1 ;;
! 286: *)
! 287: AC_MSG_ERROR([invalid argument \"$enable_newline\" to --enable-newline option])
! 288: ;;
! 289: esac
! 290:
! 291: # Check argument to --with-link-size
! 292: case "$with_link_size" in
! 293: 2|3|4) ;;
! 294: *)
! 295: AC_MSG_ERROR([invalid argument \"$with_link_size\" to --with-link-size option])
! 296: ;;
! 297: esac
! 298:
! 299: AH_TOP([
! 300: /* On Unix-like systems config.h.in is converted by "configure" into config.h.
! 301: Some other environments also support the use of "configure". PCRE is written in
! 302: Standard C, but there are a few non-standard things it can cope with, allowing
! 303: it to run on SunOS4 and other "close to standard" systems.
! 304:
! 305: If you are going to build PCRE "by hand" on a system without "configure" you
! 306: should copy the distributed config.h.generic to config.h, and then set up the
! 307: macro definitions the way you need them. You must then add -DHAVE_CONFIG_H to
! 308: all of your compile commands, so that config.h is included at the start of
! 309: every source.
! 310:
! 311: Alternatively, you can avoid editing by using -D on the compiler command line
! 312: to set the macro values. In this case, you do not have to set -DHAVE_CONFIG_H.
! 313:
! 314: PCRE uses memmove() if HAVE_MEMMOVE is set to 1; otherwise it uses bcopy() if
! 315: HAVE_BCOPY is set to 1. If your system has neither bcopy() nor memmove(), set
! 316: them both to 0; an emulation function will be used. */])
! 317:
! 318: # Checks for header files.
! 319: AC_HEADER_STDC
! 320: AC_CHECK_HEADERS(limits.h sys/types.h sys/stat.h dirent.h windows.h)
! 321:
! 322: # The files below are C++ header files.
! 323: pcre_have_type_traits="0"
! 324: pcre_have_bits_type_traits="0"
! 325: if test "x$enable_cpp" = "xyes" -a -n "$CXX"
! 326: then
! 327: AC_LANG_PUSH(C++)
! 328:
! 329: # Older versions of pcre defined pcrecpp::no_arg, but in new versions
! 330: # it's called pcrecpp::RE::no_arg. For backwards ABI compatibility,
! 331: # we want to make one an alias for the other. Different systems do
! 332: # this in different ways. Some systems, for instance, can do it via
! 333: # a linker flag: -alias (for os x 10.5) or -i (for os x <=10.4).
! 334: OLD_LDFLAGS="$LDFLAGS"
! 335: for flag in "-alias,__ZN7pcrecpp2RE6no_argE,__ZN7pcrecpp6no_argE" \
! 336: "-i__ZN7pcrecpp6no_argE:__ZN7pcrecpp2RE6no_argE"; do
! 337: AC_MSG_CHECKING([for alias support in the linker])
! 338: LDFLAGS="$OLD_LDFLAGS -Wl,$flag"
! 339: # We try to run the linker with this new ld flag. If the link fails,
! 340: # we give up and remove the new flag from LDFLAGS.
! 341: AC_LINK_IFELSE([AC_LANG_PROGRAM([namespace pcrecpp {
! 342: class RE { static int no_arg; };
! 343: int RE::no_arg;
! 344: }],
! 345: [])],
! 346: [AC_MSG_RESULT([yes]);
! 347: EXTRA_LIBPCRECPP_LDFLAGS="$EXTRA_LIBPCRECPP_LDFLAGS -Wl,$flag";
! 348: break;],
! 349: AC_MSG_RESULT([no]))
! 350: done
! 351: LDFLAGS="$OLD_LDFLAGS"
! 352:
! 353: # We could be more clever here, given we're doing AC_SUBST with this
! 354: # (eg set a var to be the name of the include file we want). But we're not
! 355: # so it's easy to change back to 'regular' autoconf vars if we needed to.
! 356: AC_CHECK_HEADERS(string, [pcre_have_cpp_headers="1"],
! 357: [pcre_have_cpp_headers="0"])
! 358: AC_CHECK_HEADERS(bits/type_traits.h, [pcre_have_bits_type_traits="1"],
! 359: [pcre_have_bits_type_traits="0"])
! 360: AC_CHECK_HEADERS(type_traits.h, [pcre_have_type_traits="1"],
! 361: [pcre_have_type_traits="0"])
! 362:
! 363: # (This isn't c++-specific, but is only used in pcrecpp.cc, so try this
! 364: # in a c++ context. This matters becuase strtoimax is C99 and may not
! 365: # be supported by the C++ compiler.)
! 366: # Figure out how to create a longlong from a string: strtoll and
! 367: # equiv. It's not enough to call AC_CHECK_FUNCS: hpux has a
! 368: # strtoll, for instance, but it only takes 2 args instead of 3!
! 369: # We have to call AH_TEMPLATE since AC_DEFINE_UNQUOTED below is complex.
! 370: AH_TEMPLATE(HAVE_STRTOQ, [Define to 1 if you have `strtoq'.])
! 371: AH_TEMPLATE(HAVE_STRTOLL, [Define to 1 if you have `strtoll'.])
! 372: AH_TEMPLATE(HAVE__STRTOI64, [Define to 1 if you have `_strtoi64'.])
! 373: AH_TEMPLATE(HAVE_STRTOIMAX, [Define to 1 if you have `strtoimax'.])
! 374: have_strto_fn=0
! 375: for fn in strtoq strtoll _strtoi64 strtoimax; do
! 376: AC_MSG_CHECKING([for $fn])
! 377: if test "$fn" = strtoimax; then
! 378: include=stdint.h
! 379: else
! 380: include=stdlib.h
! 381: fi
! 382: AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <$include>],
! 383: [char* e; return $fn("100", &e, 10)])],
! 384: [AC_MSG_RESULT(yes)
! 385: AC_DEFINE_UNQUOTED(HAVE_`echo $fn | tr abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ`, 1,
! 386: [Define to 1 if you have `$fn'.])
! 387: have_strto_fn=1
! 388: break],
! 389: [AC_MSG_RESULT(no)])
! 390: done
! 391:
! 392: if test "$have_strto_fn" = 1; then
! 393: AC_CHECK_TYPES([long long],
! 394: [pcre_have_long_long="1"],
! 395: [pcre_have_long_long="0"])
! 396: AC_CHECK_TYPES([unsigned long long],
! 397: [pcre_have_ulong_long="1"],
! 398: [pcre_have_ulong_long="0"])
! 399: else
! 400: pcre_have_long_long="0"
! 401: pcre_have_ulong_long="0"
! 402: fi
! 403: AC_SUBST(pcre_have_long_long)
! 404: AC_SUBST(pcre_have_ulong_long)
! 405:
! 406: AC_LANG_POP
! 407: fi
! 408: # Using AC_SUBST eliminates the need to include config.h in a public .h file
! 409: AC_SUBST(pcre_have_type_traits)
! 410: AC_SUBST(pcre_have_bits_type_traits)
! 411:
! 412: # Conditional compilation
! 413: AM_CONDITIONAL(WITH_PCRE_CPP, test "x$enable_cpp" = "xyes")
! 414: AM_CONDITIONAL(WITH_REBUILD_CHARTABLES, test "x$enable_rebuild_chartables" = "xyes")
! 415: AM_CONDITIONAL(WITH_JIT, test "x$enable_jit" = "xyes")
! 416: AM_CONDITIONAL(WITH_UTF8, test "x$enable_utf8" = "xyes")
! 417:
! 418: # Checks for typedefs, structures, and compiler characteristics.
! 419:
! 420: AC_C_CONST
! 421: AC_TYPE_SIZE_T
! 422:
! 423: # Checks for library functions.
! 424:
! 425: AC_CHECK_FUNCS(bcopy memmove strerror)
! 426:
! 427: # Check for the availability of libz (aka zlib)
! 428:
! 429: AC_CHECK_HEADERS([zlib.h], [HAVE_ZLIB_H=1])
! 430: AC_CHECK_LIB([z], [gzopen], [HAVE_LIBZ=1])
! 431:
! 432: # Check for the availability of libbz2. Originally we just used AC_CHECK_LIB,
! 433: # as for libz. However, this had the following problem, diagnosed and fixed by
! 434: # a user:
! 435: #
! 436: # - libbz2 uses the Pascal calling convention (WINAPI) for the functions
! 437: # under Win32.
! 438: # - The standard autoconf AC_CHECK_LIB fails to include "bzlib.h",
! 439: # therefore missing the function definition.
! 440: # - The compiler thus generates a "C" signature for the test function.
! 441: # - The linker fails to find the "C" function.
! 442: # - PCRE fails to configure if asked to do so against libbz2.
! 443: #
! 444: # Solution:
! 445: #
! 446: # - Replace the AC_CHECK_LIB test with a custom test.
! 447:
! 448: AC_CHECK_HEADERS([bzlib.h], [HAVE_BZLIB_H=1])
! 449: # Original test
! 450: # AC_CHECK_LIB([bz2], [BZ2_bzopen], [HAVE_LIBBZ2=1])
! 451: #
! 452: # Custom test follows
! 453:
! 454: AC_MSG_CHECKING([for libbz2])
! 455: OLD_LIBS="$LIBS"
! 456: LIBS="$LIBS -lbz2"
! 457: AC_LINK_IFELSE([AC_LANG_PROGRAM([[
! 458: #ifdef HAVE_BZLIB_H
! 459: #include <bzlib.h>
! 460: #endif]],
! 461: [[return (int)BZ2_bzopen("conftest", "rb");]])],
! 462: [AC_MSG_RESULT([yes]);HAVE_LIBBZ2=1; break;],
! 463: AC_MSG_RESULT([no]))
! 464: LIBS="$OLD_LIBS"
! 465:
! 466: # Check for the availabiity of libreadline
! 467:
! 468: AC_CHECK_HEADERS([readline/readline.h], [HAVE_READLINE_H=1])
! 469: AC_CHECK_HEADERS([readline/history.h], [HAVE_HISTORY_H=1])
! 470: AC_CHECK_LIB([readline], [readline], [HAVE_LIB_READLINE=1])
! 471:
! 472: # This facilitates -ansi builds under Linux
! 473: dnl AC_DEFINE([_GNU_SOURCE], [], [Enable GNU extensions in glibc])
! 474:
! 475: PCRE_STATIC_CFLAG=""
! 476: if test "x$enable_shared" = "xno" ; then
! 477: AC_DEFINE([PCRE_STATIC], [1], [
! 478: Define if linking statically (TODO: make nice with Libtool)])
! 479: PCRE_STATIC_CFLAG="-DPCRE_STATIC"
! 480: fi
! 481: AC_SUBST(PCRE_STATIC_CFLAG)
! 482:
! 483: # Here is where pcre specific defines are handled
! 484:
! 485: if test "$enable_jit" = "yes"; then
! 486: AC_DEFINE([SUPPORT_JIT], [], [
! 487: Define to enable support for Just-In-Time compiling.])
! 488: else
! 489: enable_pcregrep_jit="no"
! 490: fi
! 491:
! 492: if test "$enable_pcregrep_jit" = "yes"; then
! 493: AC_DEFINE([SUPPORT_PCREGREP_JIT], [], [
! 494: Define to enable JIT support in pcregrep.])
! 495: fi
! 496:
! 497: if test "$enable_utf8" = "yes"; then
! 498: AC_DEFINE([SUPPORT_UTF8], [], [
! 499: Define to enable support for the UTF-8 Unicode encoding. This will
! 500: work even in an EBCDIC environment, but it is incompatible with
! 501: the EBCDIC macro. That is, PCRE can support *either* EBCDIC code
! 502: *or* ASCII/UTF-8, but not both at once.])
! 503: fi
! 504:
! 505: if test "$enable_unicode_properties" = "yes"; then
! 506: AC_DEFINE([SUPPORT_UCP], [], [
! 507: Define to enable support for Unicode properties.])
! 508: fi
! 509:
! 510: if test "$enable_stack_for_recursion" = "no"; then
! 511: AC_DEFINE([NO_RECURSE], [], [
! 512: PCRE uses recursive function calls to handle backtracking while
! 513: matching. This can sometimes be a problem on systems that have
! 514: stacks of limited size. Define NO_RECURSE to get a version that
! 515: doesn't use recursion in the match() function; instead it creates
! 516: its own stack by steam using pcre_recurse_malloc() to obtain memory
! 517: from the heap. For more detail, see the comments and other stuff
! 518: just above the match() function. On systems that support it,
! 519: "configure" can be used to set this in the Makefile
! 520: (use --disable-stack-for-recursion).])
! 521: fi
! 522:
! 523: if test "$enable_pcregrep_libz" = "yes"; then
! 524: AC_DEFINE([SUPPORT_LIBZ], [], [
! 525: Define to allow pcregrep to be linked with libz, so that it is
! 526: able to handle .gz files.])
! 527: fi
! 528:
! 529: if test "$enable_pcregrep_libbz2" = "yes"; then
! 530: AC_DEFINE([SUPPORT_LIBBZ2], [], [
! 531: Define to allow pcregrep to be linked with libbz2, so that it is
! 532: able to handle .bz2 files.])
! 533: fi
! 534:
! 535: if test $with_pcregrep_bufsize -lt 8192 ; then
! 536: with_pcregrep_bufsize="8192"
! 537: fi
! 538:
! 539: AC_DEFINE_UNQUOTED([PCREGREP_BUFSIZE], [$with_pcregrep_bufsize], [
! 540: The value of PCREGREP_BUFSIZE determines the size of buffer used by
! 541: pcregrep to hold parts of the file it is searching. On systems that
! 542: support it, "configure" can be used to override the default, which is
! 543: 8192. This is also the minimum value. The actual amount of memory used by
! 544: pcregrep is three times this number, because it allows for the buffering of
! 545: "before" and "after" lines.])
! 546:
! 547: if test "$enable_pcretest_libreadline" = "yes"; then
! 548: AC_DEFINE([SUPPORT_LIBREADLINE], [], [
! 549: Define to allow pcretest to be linked with libreadline.])
! 550: fi
! 551:
! 552: AC_DEFINE_UNQUOTED([NEWLINE], [$ac_pcre_newline_value], [
! 553: The value of NEWLINE determines the newline character sequence. On
! 554: systems that support it, "configure" can be used to override the
! 555: default, which is 10. The possible values are 10 (LF), 13 (CR),
! 556: 3338 (CRLF), -1 (ANY), or -2 (ANYCRLF).])
! 557:
! 558: if test "$enable_bsr_anycrlf" = "yes"; then
! 559: AC_DEFINE([BSR_ANYCRLF], [], [
! 560: By default, the \R escape sequence matches any Unicode line ending
! 561: character or sequence of characters. If BSR_ANYCRLF is defined, this is
! 562: changed so that backslash-R matches only CR, LF, or CRLF. The build-
! 563: time default can be overridden by the user of PCRE at runtime. On
! 564: systems that support it, "configure" can be used to override the
! 565: default.])
! 566: fi
! 567:
! 568: AC_DEFINE_UNQUOTED([LINK_SIZE], [$with_link_size], [
! 569: The value of LINK_SIZE determines the number of bytes used to store
! 570: links as offsets within the compiled regex. The default is 2, which
! 571: allows for compiled patterns up to 64K long. This covers the vast
! 572: majority of cases. However, PCRE can also be compiled to use 3 or 4
! 573: bytes instead. This allows for longer patterns in extreme cases. On
! 574: systems that support it, "configure" can be used to override this default.])
! 575:
! 576: AC_DEFINE_UNQUOTED([POSIX_MALLOC_THRESHOLD], [$with_posix_malloc_threshold], [
! 577: When calling PCRE via the POSIX interface, additional working storage
! 578: is required for holding the pointers to capturing substrings because
! 579: PCRE requires three integers per substring, whereas the POSIX
! 580: interface provides only two. If the number of expected substrings is
! 581: small, the wrapper function uses space on the stack, because this is
! 582: faster than using malloc() for each call. The threshold above which
! 583: the stack is no longer used is defined by POSIX_MALLOC_THRESHOLD. On
! 584: systems that support it, "configure" can be used to override this
! 585: default.])
! 586:
! 587: AC_DEFINE_UNQUOTED([MATCH_LIMIT], [$with_match_limit], [
! 588: The value of MATCH_LIMIT determines the default number of times the
! 589: internal match() function can be called during a single execution of
! 590: pcre_exec(). There is a runtime interface for setting a different
! 591: limit. The limit exists in order to catch runaway regular
! 592: expressions that take for ever to determine that they do not match.
! 593: The default is set very large so that it does not accidentally catch
! 594: legitimate cases. On systems that support it, "configure" can be
! 595: used to override this default default.])
! 596:
! 597: AC_DEFINE_UNQUOTED([MATCH_LIMIT_RECURSION], [$with_match_limit_recursion], [
! 598: The above limit applies to all calls of match(), whether or not they
! 599: increase the recursion depth. In some environments it is desirable
! 600: to limit the depth of recursive calls of match() more strictly, in
! 601: order to restrict the maximum amount of stack (or heap, if
! 602: NO_RECURSE is defined) that is used. The value of
! 603: MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
! 604: have any useful effect, it must be less than the value of
! 605: MATCH_LIMIT. The default is to use the same value as MATCH_LIMIT.
! 606: There is a runtime method for setting a different limit. On systems
! 607: that support it, "configure" can be used to override the default.])
! 608:
! 609: AC_DEFINE([MAX_NAME_SIZE], [32], [
! 610: This limit is parameterized just in case anybody ever wants to
! 611: change it. Care must be taken if it is increased, because it guards
! 612: against integer overflow caused by enormously large patterns.])
! 613:
! 614: AC_DEFINE([MAX_NAME_COUNT], [10000], [
! 615: This limit is parameterized just in case anybody ever wants to
! 616: change it. Care must be taken if it is increased, because it guards
! 617: against integer overflow caused by enormously large patterns.])
! 618:
! 619: AH_VERBATIM([PCRE_EXP_DEFN], [
! 620: /* If you are compiling for a system other than a Unix-like system or
! 621: Win32, and it needs some magic to be inserted before the definition
! 622: of a function that is exported by the library, define this macro to
! 623: contain the relevant magic. If you do not define this macro, it
! 624: defaults to "extern" for a C compiler and "extern C" for a C++
! 625: compiler on non-Win32 systems. This macro apears at the start of
! 626: every exported function that is part of the external API. It does
! 627: not appear on functions that are "external" in the C sense, but
! 628: which are internal to the library. */
! 629: #undef PCRE_EXP_DEFN])
! 630:
! 631: if test "$enable_ebcdic" = "yes"; then
! 632: AC_DEFINE_UNQUOTED([EBCDIC], [], [
! 633: If you are compiling for a system that uses EBCDIC instead of ASCII
! 634: character codes, define this macro as 1. On systems that can use
! 635: "configure", this can be done via --enable-ebcdic. PCRE will then
! 636: assume that all input strings are in EBCDIC. If you do not define
! 637: this macro, PCRE will assume input strings are ASCII or UTF-8 Unicode.
! 638: It is not possible to build a version of PCRE that supports both
! 639: EBCDIC and UTF-8.])
! 640: fi
! 641:
! 642: # Platform specific issues
! 643: NO_UNDEFINED=
! 644: EXPORT_ALL_SYMBOLS=
! 645: case $host_os in
! 646: cygwin* | mingw* )
! 647: if test X"$enable_shared" = Xyes; then
! 648: NO_UNDEFINED="-no-undefined"
! 649: EXPORT_ALL_SYMBOLS="-Wl,--export-all-symbols"
! 650: fi
! 651: ;;
! 652: esac
! 653:
! 654: # The extra LDFLAGS for each particular library
! 655: # (Note: The libpcre*_version bits are m4 variables, assigned above)
! 656:
! 657: EXTRA_LIBPCRE_LDFLAGS="$EXTRA_LIBPCRE_LDFLAGS \
! 658: $NO_UNDEFINED -version-info libpcre_version"
! 659:
! 660: EXTRA_LIBPCREPOSIX_LDFLAGS="$EXTRA_LIBPCREPOSIX_LDFLAGS \
! 661: $NO_UNDEFINED -version-info libpcreposix_version"
! 662:
! 663: EXTRA_LIBPCRECPP_LDFLAGS="$EXTRA_LIBPCRECPP_LDFLAGS \
! 664: $NO_UNDEFINED -version-info libpcrecpp_version \
! 665: $EXPORT_ALL_SYMBOLS"
! 666:
! 667: AC_SUBST(EXTRA_LIBPCRE_LDFLAGS)
! 668: AC_SUBST(EXTRA_LIBPCREPOSIX_LDFLAGS)
! 669: AC_SUBST(EXTRA_LIBPCRECPP_LDFLAGS)
! 670:
! 671: # When we run 'make distcheck', use these arguments.
! 672: DISTCHECK_CONFIGURE_FLAGS="--enable-jit --enable-cpp --enable-unicode-properties"
! 673: AC_SUBST(DISTCHECK_CONFIGURE_FLAGS)
! 674:
! 675: # Check that, if --enable-pcregrep-libz or --enable-pcregrep-libbz2 is
! 676: # specified, the relevant library is available.
! 677:
! 678: if test "$enable_pcregrep_libz" = "yes"; then
! 679: if test "$HAVE_ZLIB_H" != "1"; then
! 680: echo "** Cannot --enable-pcregrep-libz because zlib.h was not found"
! 681: exit 1
! 682: fi
! 683: if test "$HAVE_LIBZ" != "1"; then
! 684: echo "** Cannot --enable-pcregrep-libz because libz was not found"
! 685: exit 1
! 686: fi
! 687: LIBZ="-lz"
! 688: fi
! 689: AC_SUBST(LIBZ)
! 690:
! 691: if test "$enable_pcregrep_libbz2" = "yes"; then
! 692: if test "$HAVE_BZLIB_H" != "1"; then
! 693: echo "** Cannot --enable-pcregrep-libbz2 because bzlib.h was not found"
! 694: exit 1
! 695: fi
! 696: if test "$HAVE_LIBBZ2" != "1"; then
! 697: echo "** Cannot --enable-pcregrep-libbz2 because libbz2 was not found"
! 698: exit 1
! 699: fi
! 700: LIBBZ2="-lbz2"
! 701: fi
! 702: AC_SUBST(LIBBZ2)
! 703:
! 704: # Similarly for --enable-pcretest-readline
! 705:
! 706: if test "$enable_pcretest_libreadline" = "yes"; then
! 707: if test "$HAVE_READLINE_H" != "1"; then
! 708: echo "** Cannot --enable-pcretest-readline because readline/readline.h was not found."
! 709: exit 1
! 710: fi
! 711: if test "$HAVE_HISTORY_H" != "1"; then
! 712: echo "** Cannot --enable-pcretest-readline because readline/history.h was not found."
! 713: exit 1
! 714: fi
! 715: LIBREADLINE="-lreadline"
! 716: fi
! 717: AC_SUBST(LIBREADLINE)
! 718:
! 719: # Produce these files, in addition to config.h.
! 720: AC_CONFIG_FILES(
! 721: Makefile
! 722: libpcre.pc
! 723: libpcreposix.pc
! 724: libpcrecpp.pc
! 725: pcre-config
! 726: pcre.h
! 727: pcre_stringpiece.h
! 728: pcrecpparg.h
! 729: )
! 730:
! 731: # Make the generated script files executable.
! 732: AC_CONFIG_COMMANDS([script-chmod], [chmod a+x pcre-config])
! 733:
! 734: # Make sure that pcre_chartables.c is removed in case the method for
! 735: # creating it was changed by reconfiguration.
! 736: AC_CONFIG_COMMANDS([delete-old-chartables], [rm -f pcre_chartables.c])
! 737:
! 738: AC_OUTPUT
! 739:
! 740: # Print out a nice little message after configure is run displaying your
! 741: # chosen options.
! 742:
! 743: cat <<EOF
! 744:
! 745: $PACKAGE-$VERSION configuration summary:
! 746:
! 747: Install prefix .................. : ${prefix}
! 748: C preprocessor .................. : ${CPP}
! 749: C compiler ...................... : ${CC}
! 750: C++ preprocessor ................ : ${CXXCPP}
! 751: C++ compiler .................... : ${CXX}
! 752: Linker .......................... : ${LD}
! 753: C preprocessor flags ............ : ${CPPFLAGS}
! 754: C compiler flags ................ : ${CFLAGS}
! 755: C++ compiler flags .............. : ${CXXFLAGS}
! 756: Linker flags .................... : ${LDFLAGS}
! 757: Extra libraries ................. : ${LIBS}
! 758:
! 759: Build C++ library ............... : ${enable_cpp}
! 760: Enable JIT compiling support .... : ${enable_jit}
! 761: Enable UTF-8 support ............ : ${enable_utf8}
! 762: Unicode properties .............. : ${enable_unicode_properties}
! 763: Newline char/sequence ........... : ${enable_newline}
! 764: \R matches only ANYCRLF ......... : ${enable_bsr_anycrlf}
! 765: EBCDIC coding ................... : ${enable_ebcdic}
! 766: Rebuild char tables ............. : ${enable_rebuild_chartables}
! 767: Use stack recursion ............. : ${enable_stack_for_recursion}
! 768: POSIX mem threshold ............. : ${with_posix_malloc_threshold}
! 769: Internal link size .............. : ${with_link_size}
! 770: Match limit ..................... : ${with_match_limit}
! 771: Match limit recursion ........... : ${with_match_limit_recursion}
! 772: Build shared libs ............... : ${enable_shared}
! 773: Build static libs ............... : ${enable_static}
! 774: Use JIT in pcregrep ............. : ${enable_pcregrep_jit}
! 775: Buffer size for pcregrep ........ : ${with_pcregrep_bufsize}
! 776: Link pcregrep with libz ......... : ${enable_pcregrep_libz}
! 777: Link pcregrep with libbz2 ....... : ${enable_pcregrep_libbz2}
! 778: Link pcretest with libreadline .. : ${enable_pcretest_libreadline}
! 779:
! 780: EOF
! 781:
! 782: dnl end configure.ac
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to configure.ac CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre