tags/pcre-7.7/configure.ac

dnl Process this file with autoconf to produce a configure script.

dnl NOTE FOR MAINTAINERS: Do not use major or minor version numbers with
dnl leading zeros, because they may be treated as octal constants. The
dnl PCRE_PRERELEASE feature is for identifying release candidates. It might
dnl be defined as -RC2, for example. For real releases, it should be defined
dnl empty.

m4_define(pcre_major, [7])
m4_define(pcre_minor, [4])
m4_define(pcre_prerelease, [-RC1])
m4_define(pcre_date, [2007-09-10])

# Libtool shared library interface versions (current:revision:age)
m4_define(libpcre_version, [0:1:0])
m4_define(libpcreposix_version, [0:0:0])
m4_define(libpcrecpp_version, [0:0:0])

AC_PREREQ(2.57)
AC_INIT(PCRE, pcre_major.pcre_minor[]pcre_prerelease, , pcre)
AC_CONFIG_SRCDIR([pcre.h.in])
AM_INIT_AUTOMAKE([dist-bzip2 dist-zip])
AC_CONFIG_HEADERS(config.h)

# The default CFLAGS and CXXFLAGS in Autoconf are "-g -O2" for gcc and just
# "-g" for any other compiler. There doesn't seem to be a standard way of
# getting rid of the -g (which I don't think is needed for a production
# library). This fudge seems to achieve the necessary. First, we remember the
# externally set values of CFLAGS and CXXFLAGS. Then call the AC_PROG_CC and
# AC_PROG_CXX macros to find the compilers - if CFLAGS and CXXFLAGS are not
# set, they will be set to Autoconf's defaults. Afterwards, if the original
# values were not set, remove the -g from the Autoconf defaults.
# (PH 02-May-07)

remember_set_CFLAGS="$CFLAGS"
remember_set_CXXFLAGS="$CXXFLAGS"

AC_PROG_CC
AC_PROG_CXX

if test "x$remember_set_CFLAGS" = "x"
then
  if test "$CFLAGS" = "-g -O2"
  then
    CFLAGS="-O2"
  elif test "$CFLAGS" = "-g"
  then
    CFLAGS=""
  fi
fi

if test "x$remember_set_CXXFLAGS" = "x"
then
  if test "$CXXFLAGS" = "-g -O2"
  then
    CXXFLAGS="-O2"
  elif test "$CXXFLAGS" = "-g"
  then
    CXXFLAGS=""
  fi
fi


AC_PROG_INSTALL
AC_LIBTOOL_WIN32_DLL
AC_PROG_LIBTOOL
AC_PROG_LN_S

PCRE_MAJOR="pcre_major"
PCRE_MINOR="pcre_minor"
PCRE_PRERELEASE="pcre_prerelease"
PCRE_DATE="pcre_date"

AC_SUBST(PCRE_MAJOR)
AC_SUBST(PCRE_MINOR)
AC_SUBST(PCRE_PRERELEASE)
AC_SUBST(PCRE_DATE)

# Set a more sensible default value for $(htmldir).
if test "x$htmldir" = 'x${docdir}'
then
  htmldir='${docdir}/html'
fi

# Handle --disable-cpp
AC_ARG_ENABLE(cpp,
              AS_HELP_STRING([--disable-cpp],
                             [disable C++ support]),
              , enable_cpp=yes)

# Handle --enable-rebuild-chartables
AC_ARG_ENABLE(rebuild-chartables,
              AS_HELP_STRING([--enable-rebuild-chartables],
                             [rebuild character tables in current locale]),
              , enable_rebuild_chartables=no)

# Handle --enable-utf8 (disabled by default)
AC_ARG_ENABLE(utf8,
              AS_HELP_STRING([--enable-utf8],
                             [enable UTF-8 support]),
              , enable_utf8=unset)

# Handle --enable-unicode-properties
AC_ARG_ENABLE(unicode-properties,
              AS_HELP_STRING([--enable-unicode-properties],
                             [enable Unicode properties support (implies --enable-utf8)]),
              , enable_unicode_properties=no)

# Handle --enable-newline=NL
dnl AC_ARG_ENABLE(newline,
dnl               AS_HELP_STRING([--enable-newline=NL],
dnl                              [use NL as newline (lf, cr, crlf, anycrlf, any; default=lf)]),
dnl               , enable_newline=lf)

# Separate newline options
ac_pcre_newline=lf
AC_ARG_ENABLE(newline-is-cr,
              AS_HELP_STRING([--enable-newline-is-cr],
                             [use CR as newline character]),
              ac_pcre_newline=cr)
AC_ARG_ENABLE(newline-is-lf,
              AS_HELP_STRING([--enable-newline-is-lf],
                             [use LF as newline character (default)]),
              ac_pcre_newline=lf)
AC_ARG_ENABLE(newline-is-crlf,
              AS_HELP_STRING([--enable-newline-is-crlf],
                             [use CRLF as newline sequence]),
              ac_pcre_newline=crlf)
AC_ARG_ENABLE(newline-is-anycrlf,
              AS_HELP_STRING([--enable-newline-is-anycrlf],
                             [use CR, LF, or CRLF as newline sequence]),
              ac_pcre_newline=anycrlf)
AC_ARG_ENABLE(newline-is-any,
              AS_HELP_STRING([--enable-newline-is-any],
                             [use any valid Unicode newline sequence]),
              ac_pcre_newline=any)
enable_newline="$ac_pcre_newline"

# Handle --enable-ebcdic
AC_ARG_ENABLE(ebcdic,
              AS_HELP_STRING([--enable-ebcdic],
                             [assume EBCDIC coding rather than ASCII; use this only in (uncommon) EBCDIC environments; it implies --enable-rebuild-chartables]),
              , enable_ebcdic=no)

# Handle --disable-stack-for-recursion
AC_ARG_ENABLE(stack-for-recursion,
              AS_HELP_STRING([--disable-stack-for-recursion],
                             [don't use stack recursion when matching]),
              , enable_stack_for_recursion=yes)

# Handle --with-posix-malloc-threshold=NBYTES
AC_ARG_WITH(posix-malloc-threshold,
            AS_HELP_STRING([--with-posix-malloc-threshold=NBYTES],
                           [threshold for POSIX malloc usage (default=10)]),
            , with_posix_malloc_threshold=10)

# Handle --with-link-size=N
AC_ARG_WITH(link-size,
            AS_HELP_STRING([--with-link-size=N],
                           [internal link size (2, 3, or 4 allowed; default=2)]),
            , with_link_size=2)

# Handle --with-match-limit=N
AC_ARG_WITH(match-limit,
            AS_HELP_STRING([--with-match-limit=N],
                           [default limit on internal looping (default=10000000)]),
            , with_match_limit=10000000)

# Handle --with-match-limit_recursion=N
#
# Note: In config.h, the default is to define MATCH_LIMIT_RECURSION
# symbolically as MATCH_LIMIT, which in turn is defined to be some numeric
# value (e.g. 10000000). MATCH_LIMIT_RECURSION can otherwise be set to some
# different numeric value (or even the same numeric value as MATCH_LIMIT,
# though no longer defined in terms of the latter).
#
AC_ARG_WITH(match-limit-recursion,
            AS_HELP_STRING([--with-match-limit-recursion=N],
                           [default limit on internal recursion (default=MATCH_LIMIT)]),
            , with_match_limit_recursion=MATCH_LIMIT)

# Make sure that if enable_unicode_properties was set, that UTF-8 support
# is enabled.
#
if test "x$enable_unicode_properties" = "xyes"
then
  if test "x$enable_utf8" = "xno"
  then
    AC_MSG_ERROR([support for Unicode properties requires UTF-8 support])
  fi
  enable_utf8=yes
fi

if test "x$enable_utf8" = "xunset"
then
  enable_utf8=no
fi

# Make sure that if enable_ebcdic is set, rebuild_chartables is also enabled.
#
if test "x$enable_ebcdic" = "xyes"
then
  enable_rebuild_chartables=yes
fi

# Convert the newline identifier into the appropriate integer value.
case "$enable_newline" in
  lf)      ac_pcre_newline_value=10   ;;
  cr)      ac_pcre_newline_value=13   ;;
  crlf)    ac_pcre_newline_value=3338 ;;
  anycrlf) ac_pcre_newline_value=-2   ;;
  any)     ac_pcre_newline_value=-1   ;;
  *)
  AC_MSG_ERROR([invalid argument \"$enable_newline\" to --enable-newline option])
  ;;
esac

# Check argument to --with-link-size
case "$with_link_size" in
  2|3|4) ;;
  *)
  AC_MSG_ERROR([invalid argument \"$with_link_size\" to --with-link-size option])
  ;;
esac

AH_TOP([
/* On Unix-like systems config.h.in is converted by "configure" into config.h.
Some other environments also support the use of "configure". PCRE is written in
Standard C, but there are a few non-standard things it can cope with, allowing
it to run on SunOS4 and other "close to standard" systems.

If you are going to build PCRE "by hand" on a system without "configure" you
should copy the distributed config.h.generic to config.h, and then set up the
macros the way you need them. Alternatively, you can avoid editing by using -D
on the compiler command line to set the macro values.

PCRE uses memmove() if HAVE_MEMMOVE is set to 1; otherwise it uses bcopy() if
HAVE_BCOPY is set to 1. If your system has neither bcopy() nor memmove(), set
them both to 0; an emulation function will be used. */])

# Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS(limits.h sys/types.h sys/stat.h dirent.h windows.h)

# The files below are C++ header files.
pcre_have_type_traits="0"
pcre_have_bits_type_traits="0"
if test "x$enable_cpp" = "xyes" -a -n "$CXX"
then
AC_LANG_PUSH(C++)

# We could be more clever here, given we're doing AC_SUBST with this
# (eg set a var to be the name of the include file we want). But we're not
# so it's easy to change back to 'regular' autoconf vars if we needed to.
AC_CHECK_HEADERS(string, [pcre_have_cpp_headers="1"],
                         [pcre_have_cpp_headers="0"])
AC_CHECK_HEADERS(bits/type_traits.h, [pcre_have_bits_type_traits="1"],
                                     [pcre_have_bits_type_traits="0"])
AC_CHECK_HEADERS(type_traits.h, [pcre_have_type_traits="1"],
                                [pcre_have_type_traits="0"])
AC_LANG_POP
fi
# Using AC_SUBST eliminates the need to include config.h in a public .h file
AC_SUBST(pcre_have_type_traits)
AC_SUBST(pcre_have_bits_type_traits)

# Conditional compilation
AM_CONDITIONAL(WITH_PCRE_CPP, test "x$enable_cpp" = "xyes")
AM_CONDITIONAL(WITH_REBUILD_CHARTABLES, test "x$enable_rebuild_chartables" = "xyes")

# Checks for typedefs, structures, and compiler characteristics.

AC_C_CONST
AC_TYPE_SIZE_T

AC_CHECK_TYPES([long long],
               [pcre_have_long_long="1"],
               [pcre_have_long_long="0"])
AC_CHECK_TYPES([unsigned long long],
               [pcre_have_ulong_long="1"],
               [pcre_have_ulong_long="0"])
AC_SUBST(pcre_have_long_long)
AC_SUBST(pcre_have_ulong_long)

# Checks for library functions.

AC_CHECK_FUNCS(bcopy memmove strerror strtoq strtoll)

# This facilitates -ansi builds under Linux
dnl AC_DEFINE([_GNU_SOURCE], [], [Enable GNU extensions in glibc])

if test "x$enable_shared" = "xno" ; then
  AC_DEFINE([PCRE_STATIC], [1], [
    Define if linking statically (TODO: make nice with Libtool)])
fi

# Here is where pcre specific defines are handled

if test "$enable_utf8" = "yes"; then
  AC_DEFINE([SUPPORT_UTF8], [], [
    Define to enable support for the UTF-8 Unicode encoding.])
fi

if test "$enable_unicode_properties" = "yes"; then
  AC_DEFINE([SUPPORT_UCP], [], [
    Define to enable support for Unicode properties])
fi

if test "$enable_stack_for_recursion" = "no"; then
  AC_DEFINE([NO_RECURSE], [], [
    PCRE uses recursive function calls to handle backtracking while
    matching. This can sometimes be a problem on systems that have
    stacks of limited size. Define NO_RECURSE to get a version that
    doesn't use recursion in the match() function; instead it creates
    its own stack by steam using pcre_recurse_malloc() to obtain memory
    from the heap. For more detail, see the comments and other stuff
    just above the match() function. On systems that support it,
    "configure" can be used to set this in the Makefile
    (use --disable-stack-for-recursion).])
fi

AC_DEFINE_UNQUOTED([NEWLINE], [$ac_pcre_newline_value], [
  The value of NEWLINE determines the newline character sequence. On
  Unix-like systems, "configure" can be used to override the default,
  which is 10. The possible values are 10 (LF), 13 (CR), 3338 (CRLF),
  -1 (ANY), or -2 (ANYCRLF).])

AC_DEFINE_UNQUOTED([LINK_SIZE], [$with_link_size], [
  The value of LINK_SIZE determines the number of bytes used to store
  links as offsets within the compiled regex. The default is 2, which
  allows for compiled patterns up to 64K long. This covers the vast
  majority of cases. However, PCRE can also be compiled to use 3 or 4
  bytes instead. This allows for longer patterns in extreme cases. On
  systems that support it, "configure" can be used to override this default.])

AC_DEFINE_UNQUOTED([POSIX_MALLOC_THRESHOLD], [$with_posix_malloc_threshold], [
  When calling PCRE via the POSIX interface, additional working storage
  is required for holding the pointers to capturing substrings because
  PCRE requires three integers per substring, whereas the POSIX
  interface provides only two. If the number of expected substrings is
  small, the wrapper function uses space on the stack, because this is
  faster than using malloc() for each call. The threshold above which
  the stack is no longer used is defined by POSIX_MALLOC_THRESHOLD. On
  systems that support it, "configure" can be used to override this
  default.])

AC_DEFINE_UNQUOTED([MATCH_LIMIT], [$with_match_limit], [
  The value of MATCH_LIMIT determines the default number of times the
  internal match() function can be called during a single execution of
  pcre_exec(). There is a runtime interface for setting a different
  limit. The limit exists in order to catch runaway regular
  expressions that take for ever to determine that they do not match.
  The default is set very large so that it does not accidentally catch
  legitimate cases. On systems that support it, "configure" can be
  used to override this default default.])

AC_DEFINE_UNQUOTED([MATCH_LIMIT_RECURSION], [$with_match_limit_recursion], [
  The above limit applies to all calls of match(), whether or not they
  increase the recursion depth. In some environments it is desirable
  to limit the depth of recursive calls of match() more strictly, in
  order to restrict the maximum amount of stack (or heap, if
  NO_RECURSE is defined) that is used. The value of
  MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
  have any useful effect, it must be less than the value of
  MATCH_LIMIT. The default is to use the same value as MATCH_LIMIT.
  There is a runtime method for setting a different limit. On systems
  that support it, "configure" can be used to override the default.])

AC_DEFINE([MAX_NAME_SIZE], [32], [
  This limit is parameterized just in case anybody ever wants to
  change it. Care must be taken if it is increased, because it guards
  against integer overflow caused by enormously large patterns.])

AC_DEFINE([MAX_NAME_COUNT], [10000], [
  This limit is parameterized just in case anybody ever wants to
  change it. Care must be taken if it is increased, because it guards
  against integer overflow caused by enormously large patterns.])

AH_VERBATIM([PCRE_EXP_DEFN], [
/* If you are compiling for a system other than a Unix-like system or
   Win32, and it needs some magic to be inserted before the definition
   of a function that is exported by the library, define this macro to
   contain the relevant magic. If you do not define this macro, it
   defaults to "extern" for a C compiler and "extern C" for a C++
   compiler on non-Win32 systems. This macro apears at the start of
   every exported function that is part of the external API. It does
   not appear on functions that are "external" in the C sense, but
   which are internal to the library. */
#undef PCRE_EXP_DEFN])

if test "$enable_ebcdic" = "yes"; then
  AC_DEFINE_UNQUOTED([EBCDIC], [], [
    If you are compiling for a system that uses EBCDIC instead of ASCII
    character codes, define this macro as 1. On systems that can use
    "configure", this can be done via --enable-ebcdic.])
fi

# Platform specific issues
NO_UNDEFINED=
EXPORT_ALL_SYMBOLS=
case $host_os in
  cygwin* | mingw* )
    if test X"$enable_shared" = Xyes; then
      NO_UNDEFINED="-no-undefined"
      EXPORT_ALL_SYMBOLS="-Wl,--export-all-symbols"
    fi
    ;;
esac

# The extra LDFLAGS for each particular library
# (Note: The libpcre*_version bits are m4 variables, assigned above)

EXTRA_LIBPCRE_LDFLAGS="$NO_UNDEFINED -version-info libpcre_version"

EXTRA_LIBPCREPOSIX_LDFLAGS="$NO_UNDEFINED -version-info libpcreposix_version"

EXTRA_LIBPCRECPP_LDFLAGS="$NO_UNDEFINED $EXPORT_ALL_SYMBOLS -version-info libpcrecpp_version"

AC_SUBST(EXTRA_LIBPCRE_LDFLAGS)
AC_SUBST(EXTRA_LIBPCREPOSIX_LDFLAGS)
AC_SUBST(EXTRA_LIBPCRECPP_LDFLAGS)

# When we run 'make distcheck', use these arguments.
DISTCHECK_CONFIGURE_FLAGS="--enable-cpp --enable-unicode-properties"
AC_SUBST(DISTCHECK_CONFIGURE_FLAGS)

# Produce these files, in addition to config.h.
AC_CONFIG_FILES(
        Makefile
        libpcre.pc
        libpcrecpp.pc
        pcre-config
        pcre.h
        pcre_stringpiece.h
        pcrecpparg.h
)

# Make the generated script files executable.
AC_CONFIG_COMMANDS([script-chmod], [chmod a+x pcre-config])

# Make sure that pcre_chartables.c is removed in case the method for
# creating it was changed by reconfiguration.
AC_CONFIG_COMMANDS([delete-old-chartables], [rm -f pcre_chartables.c])

AC_OUTPUT

# Print out a nice little message after configure is run displaying your
# chosen options.
#
cat <<EOF

$PACKAGE-$VERSION configuration summary:

    Install prefix ......... : ${prefix}
    C preprocessor ......... : ${CPP}
    C compiler ............. : ${CC}
    C++ preprocessor ....... : ${CXXCPP}
    C++ compiler ........... : ${CXX}
    Linker ................. : ${LD}
    C preprocessor flags ... : ${CPPFLAGS}
    C compiler flags ....... : ${CFLAGS}
    C++ compiler flags ..... : ${CXXFLAGS}
    Linker flags ........... : ${LDFLAGS}
    Extra libraries ........ : ${LIBS}

    Build C++ library ...... : ${enable_cpp}
    Enable UTF-8 support ... : ${enable_utf8}
    Unicode properties ..... : ${enable_unicode_properties}
    Newline char/sequence .. : ${enable_newline}
    EBCDIC coding .......... : ${enable_ebcdic}
    Rebuild char tables .... : ${enable_rebuild_chartables}
    Use stack recursion .... : ${enable_stack_for_recursion}
    POSIX mem threshold .... : ${with_posix_malloc_threshold}
    Internal link size ..... : ${with_link_size}
    Match limit ............ : ${with_match_limit}
    Match limit recursion .. : ${with_match_limit_recursion}
    Build shared libs ...... : ${enable_shared}
    Build static libs ...... : ${enable_static}

EOF

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