/[pcre]/code/branches/pcre16/configure.ac
ViewVC logotype

Diff of /code/branches/pcre16/configure.ac

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 87 by nigel, Sat Feb 24 21:41:21 2007 UTC revision 244 by ph10, Fri Sep 14 09:14:24 2007 UTC
# Line 1  Line 1 
1  dnl Process this file with autoconf to produce a configure script.  dnl Process this file with autoconf to produce a configure script.
2    
3  dnl This configure.in file has been hacked around quite a lot as a result of  dnl NOTE FOR MAINTAINERS: Do not use major or minor version numbers with
4  dnl patches that various people have sent to me (PH). Sometimes the information  dnl leading zeros, because they may be treated as octal constants. The
5  dnl I get is contradictory. I've tried to put in comments that explain things,  dnl PCRE_PRERELEASE feature is for identifying release candidates. It might
6  dnl but in some cases the information is second-hand and I have no way of  dnl be defined as -RC2, for example. For real releases, it should be defined
7  dnl verifying it. I am not an autoconf or libtool expert!  dnl empty.
8    
9    m4_define(pcre_major, [7])
10    m4_define(pcre_minor, [4])
11    m4_define(pcre_prerelease, [-RC2])
12    m4_define(pcre_date, [2007-09-10])
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  dnl This is required at the start; the name is the name of a file  AC_PREREQ(2.57)
20  dnl it should be seeing, to verify it is in the same directory.  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    
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  AC_INIT(dftables.c)  remember_set_CFLAGS="$CFLAGS"
36    remember_set_CXXFLAGS="$CXXFLAGS"
37    
38  dnl A safety precaution  AC_PROG_CC
39    AC_PROG_CXX
40    
41  AC_PREREQ(2.57)  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  dnl Arrange to build config.h from config.h.in.  if test "x$remember_set_CXXFLAGS" = "x"
53  dnl Manual says this macro should come right after AC_INIT.  then
54  AC_CONFIG_HEADER(config.h)    if test "$CXXFLAGS" = "-g -O2"
55      then
56        CXXFLAGS="-O2"
57      elif test "$CXXFLAGS" = "-g"
58      then
59        CXXFLAGS=""
60      fi
61    fi
62    
 dnl Default values for miscellaneous macros  
63    
64  POSIX_MALLOC_THRESHOLD=-DPOSIX_MALLOC_THRESHOLD=10  AC_PROG_INSTALL
65    AC_LIBTOOL_WIN32_DLL
66    AC_PROG_LIBTOOL
67    AC_PROG_LN_S
68    
69  dnl Provide versioning information for libtool shared libraries that  PCRE_MAJOR="pcre_major"
70  dnl are built by default on Unix systems.  PCRE_MINOR="pcre_minor"
71    PCRE_PRERELEASE="pcre_prerelease"
72    PCRE_DATE="pcre_date"
73    
74    AC_SUBST(PCRE_MAJOR)
75    AC_SUBST(PCRE_MINOR)
76    AC_SUBST(PCRE_PRERELEASE)
77    AC_SUBST(PCRE_DATE)
78    
79  PCRE_LIB_VERSION=0:1:0  # Set a more sensible default value for $(htmldir).
80  PCRE_POSIXLIB_VERSION=0:0:0  if test "x$htmldir" = 'x${docdir}'
81  PCRE_CPPLIB_VERSION=0:0:0  then
82      htmldir='${docdir}/html'
83    fi
84    
85  dnl Find the PCRE version from the pcre.h file. The PCRE_VERSION variable is  # Handle --disable-cpp
86  dnl substituted in pcre-config.in.  AC_ARG_ENABLE(cpp,
87                  AS_HELP_STRING([--disable-cpp],
88                                 [disable C++ support]),
89                  , enable_cpp=yes)
90    
91    # 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  PCRE_MAJOR=`grep '#define PCRE_MAJOR' ./pcre.h | cut -c 29-`  # Handle --enable-utf8 (disabled by default)
98  PCRE_MINOR=`grep '#define PCRE_MINOR' ./pcre.h | cut -c 29-`  AC_ARG_ENABLE(utf8,
99  PCRE_PRERELEASE=`grep '#define PCRE_PRERELEASE' ./pcre.h | cut -c 29-`                AS_HELP_STRING([--enable-utf8],
100  PCRE_VERSION=${PCRE_MAJOR}.${PCRE_MINOR}${PCRE_PRERELEASE}                               [enable UTF-8 support]),
101                  , enable_utf8=unset)
102    
103  dnl Handle --disable-cpp  # 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    
109    # Handle --enable-newline=NL
110    dnl AC_ARG_ENABLE(newline,
111    dnl               AS_HELP_STRING([--enable-newline=NL],
112    dnl                              [use NL as newline (lf, cr, crlf, anycrlf, any; default=lf)]),
113    dnl               , enable_newline=lf)
114    
115  AC_ARG_ENABLE(cpp,  # Separate newline options
116  [  --disable-cpp           disable C++ support],  ac_pcre_newline=lf
117  want_cpp="$enableval", want_cpp=yes)  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    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    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    
139    # Handle --enable-bsr-anycrlf
140    AC_ARG_ENABLE(bsr-anycrlf,
141                  AS_HELP_STRING([--enable-bsr-anycrlf],
142                                 [\R matches only CR, LF, CRLF by default]),
143                  , enable_bsr_anycrlf=no)
144    
145  dnl Checks for programs.  # Handle --enable-ebcdic
146    AC_ARG_ENABLE(ebcdic,
147                  AS_HELP_STRING([--enable-ebcdic],
148                                 [assume EBCDIC coding rather than ASCII; use this only in (uncommon) EBCDIC environments; it implies --enable-rebuild-chartables]),
149                  , enable_ebcdic=no)
150    
151  AC_PROG_CC  # Handle --disable-stack-for-recursion
152    AC_ARG_ENABLE(stack-for-recursion,
153                  AS_HELP_STRING([--disable-stack-for-recursion],
154                                 [don't use stack recursion when matching]),
155                  , enable_stack_for_recursion=yes)
156    
157  dnl Test for C++ for the C++ wrapper libpcrecpp. It seems, however, that  # Handle --with-posix-malloc-threshold=NBYTES
158  dnl AC_PROC_CXX will set $CXX to "g++" when no C++ compiler is installed, even  AC_ARG_WITH(posix-malloc-threshold,
159  dnl though that is completely bogus. (This may happen only on certain systems              AS_HELP_STRING([--with-posix-malloc-threshold=NBYTES],
160  dnl with certain versions of autoconf, of course.) An attempt to include this                             [threshold for POSIX malloc usage (default=10)]),
161  dnl test inside a check for want_cpp was criticized by a libtool expert, who              , with_posix_malloc_threshold=10)
 dnl tells me that it isn't allowed.  
162    
163  AC_PROG_CXX  # Handle --with-link-size=N
164    AC_ARG_WITH(link-size,
165                AS_HELP_STRING([--with-link-size=N],
166                               [internal link size (2, 3, or 4 allowed; default=2)]),
167                , with_link_size=2)
168    
169  dnl The icc compiler has the same options as gcc, so let the rest of the  # Handle --with-match-limit=N
170  dnl configure script think it has gcc when setting up dnl options etc.  AC_ARG_WITH(match-limit,
171  dnl This is a nasty hack which no longer seems necessary with the update              AS_HELP_STRING([--with-match-limit=N],
172  dnl to the latest libtool files, so I have commented it out.                             [default limit on internal looping (default=10000000)]),
173  dnl              , with_match_limit=10000000)
174  dnl if test "$CC" = "icc" ; then GCC=yes ; fi  
175    # Handle --with-match-limit_recursion=N
176    #
177    # Note: In config.h, the default is to define MATCH_LIMIT_RECURSION
178    # symbolically as MATCH_LIMIT, which in turn is defined to be some numeric
179    # value (e.g. 10000000). MATCH_LIMIT_RECURSION can otherwise be set to some
180    # different numeric value (or even the same numeric value as MATCH_LIMIT,
181    # though no longer defined in terms of the latter).
182    #
183    AC_ARG_WITH(match-limit-recursion,
184                AS_HELP_STRING([--with-match-limit-recursion=N],
185                               [default limit on internal recursion (default=MATCH_LIMIT)]),
186                , with_match_limit_recursion=MATCH_LIMIT)
187    
188    # Make sure that if enable_unicode_properties was set, that UTF-8 support
189    # is enabled.
190    #
191    if test "x$enable_unicode_properties" = "xyes"
192    then
193      if test "x$enable_utf8" = "xno"
194      then
195        AC_MSG_ERROR([support for Unicode properties requires UTF-8 support])
196      fi
197      enable_utf8=yes
198    fi
199    
200  AC_PROG_INSTALL  if test "x$enable_utf8" = "xunset"
201  AC_LIBTOOL_WIN32_DLL  then
202  AC_PROG_LIBTOOL    enable_utf8=no
203    fi
204    
205  dnl We need to find a compiler for compiling a program to run on the local host  # Make sure that if enable_ebcdic is set, rebuild_chartables is also enabled.
206  dnl while building. It needs to be different from CC when cross-compiling.  #
207  dnl There is a macro called AC_PROG_CC_FOR_BUILD in the GNU archive for  if test "x$enable_ebcdic" = "xyes"
208  dnl figuring this out automatically. Unfortunately, it does not work with the  then
209  dnl latest versions of autoconf. So for the moment, we just default to the    enable_rebuild_chartables=yes
210  dnl same values as the "main" compiler. People who are cross-compiling will  fi
 dnl just have to adjust the Makefile by hand or set these values when they  
 dnl run "configure".  
   
 CC_FOR_BUILD=${CC_FOR_BUILD:-'$(CC)'}  
 CXX_FOR_BUILD=${CXX_FOR_BUILD:-'$(CXX)'}  
 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD:-'$(CFLAGS)'}  
 CPPFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD:-'$(CPPFLAGS)'}  
 CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD:-'$(CXXFLAGS)'}  
 BUILD_EXEEXT=${BUILD_EXEEXT:-'$(EXEEXT)'}  
 BUILD_OBJEXT=${BUILD_OBJEXT:-'$(OBJEXT)'}  
211    
212  dnl Checks for header files.  # Convert the newline identifier into the appropriate integer value.
213    case "$enable_newline" in
214      lf)      ac_pcre_newline_value=10   ;;
215      cr)      ac_pcre_newline_value=13   ;;
216      crlf)    ac_pcre_newline_value=3338 ;;
217      anycrlf) ac_pcre_newline_value=-2   ;;
218      any)     ac_pcre_newline_value=-1   ;;
219      *)
220      AC_MSG_ERROR([invalid argument \"$enable_newline\" to --enable-newline option])
221      ;;
222    esac
223    
224  AC_HEADER_STDC  # Check argument to --with-link-size
225  AC_CHECK_HEADERS(limits.h)  case "$with_link_size" in
226      2|3|4) ;;
227      *)
228      AC_MSG_ERROR([invalid argument \"$with_link_size\" to --with-link-size option])
229      ;;
230    esac
231    
232  dnl The files below are C++ header files. One person told me (PH) that  AH_TOP([
233  dnl AC_LANG_CPLUSPLUS unsets CXX if it was explicitly set to something which  /* On Unix-like systems config.h.in is converted by "configure" into config.h.
234  dnl doesn't work. However, this doesn't always seem to be the case.  Some other environments also support the use of "configure". PCRE is written in
235    Standard C, but there are a few non-standard things it can cope with, allowing
236    it to run on SunOS4 and other "close to standard" systems.
237    
238    If you are going to build PCRE "by hand" on a system without "configure" you
239    should copy the distributed config.h.generic to config.h, and then set up the
240    macro definitions the way you need them. You must then add -DHAVE_CONFIG_H to
241    all of your compile commands, so that config.h is included at the start of
242    every source.
243    
244    Alternatively, you can avoid editing by using -D on the compiler command line
245    to set the macro values. In this case, you do not have to set -DHAVE_CONFIG_H.
246    
247    PCRE uses memmove() if HAVE_MEMMOVE is set to 1; otherwise it uses bcopy() if
248    HAVE_BCOPY is set to 1. If your system has neither bcopy() nor memmove(), set
249    them both to 0; an emulation function will be used. */])
250    
251  if test "x$want_cpp" = "xyes" -a -n "$CXX"  # Checks for header files.
252    AC_HEADER_STDC
253    AC_CHECK_HEADERS(limits.h sys/types.h sys/stat.h dirent.h windows.h)
254    
255    # The files below are C++ header files.
256    pcre_have_type_traits="0"
257    pcre_have_bits_type_traits="0"
258    if test "x$enable_cpp" = "xyes" -a -n "$CXX"
259  then  then
260  AC_LANG_SAVE  AC_LANG_PUSH(C++)
 AC_LANG_CPLUSPLUS  
261    
262  dnl We could be more clever here, given we're doing AC_SUBST with this  # We could be more clever here, given we're doing AC_SUBST with this
263  dnl (eg set a var to be the name of the include file we want).  But we're not  # (eg set a var to be the name of the include file we want). But we're not
264  dnl so it's easy to change back to 'regular' autoconf vars if we needed to.  # so it's easy to change back to 'regular' autoconf vars if we needed to.
265  AC_CHECK_HEADERS(string, [pcre_have_cpp_headers="1"],  AC_CHECK_HEADERS(string, [pcre_have_cpp_headers="1"],
266                           [pcre_have_cpp_headers="0"])                           [pcre_have_cpp_headers="0"])
267  AC_CHECK_HEADERS(bits/type_traits.h, [pcre_have_bits_type_traits="1"],  AC_CHECK_HEADERS(bits/type_traits.h, [pcre_have_bits_type_traits="1"],
268                                       [pcre_have_bits_type_traits="0"])                                       [pcre_have_bits_type_traits="0"])
269  AC_CHECK_HEADERS(type_traits.h, [pcre_have_type_traits="1"],  AC_CHECK_HEADERS(type_traits.h, [pcre_have_type_traits="1"],
270                                  [pcre_have_type_traits="0"])                                  [pcre_have_type_traits="0"])
271  dnl Using AC_SUBST eliminates the need to include config.h in a public .h file  AC_LANG_POP
 AC_SUBST(pcre_have_bits_type_traits)  
 AC_SUBST(pcre_have_type_traits)  
 AC_LANG_RESTORE  
272  fi  fi
273    # Using AC_SUBST eliminates the need to include config.h in a public .h file
274    AC_SUBST(pcre_have_type_traits)
275    AC_SUBST(pcre_have_bits_type_traits)
276    
277  dnl From the above, we now have enough info to know if C++ is fully installed  # Conditional compilation
278  if test "x$want_cpp" = "xyes" -a -n "$CXX" -a "$pcre_have_cpp_headers" = 1; then  AM_CONDITIONAL(WITH_PCRE_CPP, test "x$enable_cpp" = "xyes")
279    MAYBE_CPP_TARGETS='$(CPP_TARGETS)'  AM_CONDITIONAL(WITH_REBUILD_CHARTABLES, test "x$enable_rebuild_chartables" = "xyes")
   HAVE_CPP=  
 else  
   MAYBE_CPP_TARGETS=  
   HAVE_CPP="#"  
 fi  
 AC_SUBST(MAYBE_CPP_TARGETS)  
 AC_SUBST(HAVE_CPP)  
280    
281  dnl Checks for typedefs, structures, and compiler characteristics.  # Checks for typedefs, structures, and compiler characteristics.
282    
283  AC_C_CONST  AC_C_CONST
284  AC_TYPE_SIZE_T  AC_TYPE_SIZE_T
285    
286  AC_CHECK_TYPES([long long], [pcre_have_long_long="1"], [pcre_have_long_long="0"])  AC_CHECK_TYPES([long long],
287  AC_CHECK_TYPES([unsigned long long], [pcre_have_ulong_long="1"], [pcre_have_ulong_long="0"])                 [pcre_have_long_long="1"],
288                   [pcre_have_long_long="0"])
289    AC_CHECK_TYPES([unsigned long long],
290                   [pcre_have_ulong_long="1"],
291                   [pcre_have_ulong_long="0"])
292  AC_SUBST(pcre_have_long_long)  AC_SUBST(pcre_have_long_long)
293  AC_SUBST(pcre_have_ulong_long)  AC_SUBST(pcre_have_ulong_long)
294    
295  dnl Checks for library functions.  # Checks for library functions.
296    
297  AC_CHECK_FUNCS(bcopy memmove strerror strtoq strtoll)  AC_CHECK_FUNCS(bcopy memmove strerror strtoq strtoll)
298    
299  dnl Handle --enable-utf8  # This facilitates -ansi builds under Linux
300    dnl AC_DEFINE([_GNU_SOURCE], [], [Enable GNU extensions in glibc])
301    
302  AC_ARG_ENABLE(utf8,  if test "x$enable_shared" = "xno" ; then
303  [  --enable-utf8           enable UTF8 support],    AC_DEFINE([PCRE_STATIC], [1], [
304  if test "$enableval" = "yes"; then      Define if linking statically (TODO: make nice with Libtool)])
   UTF8=-DSUPPORT_UTF8  
305  fi  fi
 )  
306    
307  dnl Handle --enable-unicode-properties  # Here is where pcre specific defines are handled
308    
309  AC_ARG_ENABLE(unicode-properties,  if test "$enable_utf8" = "yes"; then
310  [  --enable-unicode-properties  enable Unicode properties support],    AC_DEFINE([SUPPORT_UTF8], [], [
311  if test "$enableval" = "yes"; then      Define to enable support for the UTF-8 Unicode encoding.])
   UCP=-DSUPPORT_UCP  
312  fi  fi
 )  
   
 dnl Handle --enable-newline-is-cr  
313    
314  AC_ARG_ENABLE(newline-is-cr,  if test "$enable_unicode_properties" = "yes"; then
315  [  --enable-newline-is-cr  use CR as the newline character],    AC_DEFINE([SUPPORT_UCP], [], [
316  if test "$enableval" = "yes"; then      Define to enable support for Unicode properties])
   NEWLINE=-DNEWLINE=13  
317  fi  fi
 )  
   
 dnl Handle --enable-newline-is-lf  
318    
319  AC_ARG_ENABLE(newline-is-lf,  if test "$enable_stack_for_recursion" = "no"; then
320  [  --enable-newline-is-lf  use LF as the newline character],    AC_DEFINE([NO_RECURSE], [], [
321  if test "$enableval" = "yes"; then      PCRE uses recursive function calls to handle backtracking while
322    NEWLINE=-DNEWLINE=10      matching. This can sometimes be a problem on systems that have
323        stacks of limited size. Define NO_RECURSE to get a version that
324        doesn't use recursion in the match() function; instead it creates
325        its own stack by steam using pcre_recurse_malloc() to obtain memory
326        from the heap. For more detail, see the comments and other stuff
327        just above the match() function. On systems that support it,
328        "configure" can be used to set this in the Makefile
329        (use --disable-stack-for-recursion).])
330  fi  fi
 )  
   
 dnl Handle --enable-ebcdic  
331    
332  AC_ARG_ENABLE(ebcdic,  AC_DEFINE_UNQUOTED([NEWLINE], [$ac_pcre_newline_value], [
333  [  --enable-ebcdic         assume EBCDIC coding rather than ASCII],    The value of NEWLINE determines the newline character sequence. On
334  if test "$enableval" == "yes"; then    systems that support it, "configure" can be used to override the
335    EBCDIC=-DEBCDIC=1    default, which is 10. The possible values are 10 (LF), 13 (CR),
336      3338 (CRLF), -1 (ANY), or -2 (ANYCRLF).])
337    
338    if test "$enable_bsr_anycrlf" = "yes"; then
339      AC_DEFINE([BSR_ANYCRLF], [], [
340        By default, the \R escape sequence matches any Unicode line ending
341        character or sequence of characters. If BSR_ANYCRLF is defined, this is
342        changed so that backslash-R matches only CR, LF, or CRLF. The build-
343        time default can be overridden by the user of PCRE at runtime. On
344        systems that support it, "configure" can be used to override the
345        default.])
346  fi  fi
 )  
   
 dnl Handle --disable-stack-for-recursion  
347    
348  AC_ARG_ENABLE(stack-for-recursion,  AC_DEFINE_UNQUOTED([LINK_SIZE], [$with_link_size], [
349  [  --disable-stack-for-recursion  disable use of stack recursion when matching],    The value of LINK_SIZE determines the number of bytes used to store
350  if test "$enableval" = "no"; then    links as offsets within the compiled regex. The default is 2, which
351    NO_RECURSE=-DNO_RECURSE    allows for compiled patterns up to 64K long. This covers the vast
352      majority of cases. However, PCRE can also be compiled to use 3 or 4
353      bytes instead. This allows for longer patterns in extreme cases. On
354      systems that support it, "configure" can be used to override this default.])
355    
356    AC_DEFINE_UNQUOTED([POSIX_MALLOC_THRESHOLD], [$with_posix_malloc_threshold], [
357      When calling PCRE via the POSIX interface, additional working storage
358      is required for holding the pointers to capturing substrings because
359      PCRE requires three integers per substring, whereas the POSIX
360      interface provides only two. If the number of expected substrings is
361      small, the wrapper function uses space on the stack, because this is
362      faster than using malloc() for each call. The threshold above which
363      the stack is no longer used is defined by POSIX_MALLOC_THRESHOLD. On
364      systems that support it, "configure" can be used to override this
365      default.])
366    
367    AC_DEFINE_UNQUOTED([MATCH_LIMIT], [$with_match_limit], [
368      The value of MATCH_LIMIT determines the default number of times the
369      internal match() function can be called during a single execution of
370      pcre_exec(). There is a runtime interface for setting a different
371      limit. The limit exists in order to catch runaway regular
372      expressions that take for ever to determine that they do not match.
373      The default is set very large so that it does not accidentally catch
374      legitimate cases. On systems that support it, "configure" can be
375      used to override this default default.])
376    
377    AC_DEFINE_UNQUOTED([MATCH_LIMIT_RECURSION], [$with_match_limit_recursion], [
378      The above limit applies to all calls of match(), whether or not they
379      increase the recursion depth. In some environments it is desirable
380      to limit the depth of recursive calls of match() more strictly, in
381      order to restrict the maximum amount of stack (or heap, if
382      NO_RECURSE is defined) that is used. The value of
383      MATCH_LIMIT_RECURSION applies only to recursive calls of match(). To
384      have any useful effect, it must be less than the value of
385      MATCH_LIMIT. The default is to use the same value as MATCH_LIMIT.
386      There is a runtime method for setting a different limit. On systems
387      that support it, "configure" can be used to override the default.])
388    
389    AC_DEFINE([MAX_NAME_SIZE], [32], [
390      This limit is parameterized just in case anybody ever wants to
391      change it. Care must be taken if it is increased, because it guards
392      against integer overflow caused by enormously large patterns.])
393    
394    AC_DEFINE([MAX_NAME_COUNT], [10000], [
395      This limit is parameterized just in case anybody ever wants to
396      change it. Care must be taken if it is increased, because it guards
397      against integer overflow caused by enormously large patterns.])
398    
399    AH_VERBATIM([PCRE_EXP_DEFN], [
400    /* If you are compiling for a system other than a Unix-like system or
401       Win32, and it needs some magic to be inserted before the definition
402       of a function that is exported by the library, define this macro to
403       contain the relevant magic. If you do not define this macro, it
404       defaults to "extern" for a C compiler and "extern C" for a C++
405       compiler on non-Win32 systems. This macro apears at the start of
406       every exported function that is part of the external API. It does
407       not appear on functions that are "external" in the C sense, but
408       which are internal to the library. */
409    #undef PCRE_EXP_DEFN])
410    
411    if test "$enable_ebcdic" = "yes"; then
412      AC_DEFINE_UNQUOTED([EBCDIC], [], [
413        If you are compiling for a system that uses EBCDIC instead of ASCII
414        character codes, define this macro as 1. On systems that can use
415        "configure", this can be done via --enable-ebcdic.])
416  fi  fi
 )  
   
 dnl There doesn't seem to be a straightforward way of having parameters  
 dnl that set values, other than fudging the --with thing. So that's what  
 dnl I've done.  
417    
418  dnl Handle --with-posix-malloc-threshold=n  # Platform specific issues
419    NO_UNDEFINED=
420  AC_ARG_WITH(posix-malloc-threshold,  EXPORT_ALL_SYMBOLS=
421  [  --with-posix-malloc-threshold=10  threshold for POSIX malloc usage],  case $host_os in
422    POSIX_MALLOC_THRESHOLD=-DPOSIX_MALLOC_THRESHOLD=$withval    cygwin* | mingw* )
423  )      if test X"$enable_shared" = Xyes; then
424          NO_UNDEFINED="-no-undefined"
425          EXPORT_ALL_SYMBOLS="-Wl,--export-all-symbols"
426        fi
427        ;;
428    esac
429    
430  dnl Handle --with-link-size=n  # The extra LDFLAGS for each particular library
431    # (Note: The libpcre*_version bits are m4 variables, assigned above)
432    
433  AC_ARG_WITH(link-size,  EXTRA_LIBPCRE_LDFLAGS="$NO_UNDEFINED -version-info libpcre_version"
 [  --with-link-size=2    internal link size (2, 3, or 4 allowed)],  
   LINK_SIZE=-DLINK_SIZE=$withval  
 )  
434    
435  dnl Handle --with-match-limit=n  EXTRA_LIBPCREPOSIX_LDFLAGS="$NO_UNDEFINED -version-info libpcreposix_version"
436    
437  AC_ARG_WITH(match-limit,  EXTRA_LIBPCRECPP_LDFLAGS="$NO_UNDEFINED $EXPORT_ALL_SYMBOLS -version-info libpcrecpp_version"
 [  --with-match-limit=10000000  default limit on internal looping],  
   MATCH_LIMIT=-DMATCH_LIMIT=$withval  
 )  
   
 dnl Handle --with-match-limit_recursion=n  
438    
439  AC_ARG_WITH(match-limit-recursion,  AC_SUBST(EXTRA_LIBPCRE_LDFLAGS)
440  [  --with-match-limit-recursion=10000000  default limit on internal recursion],  AC_SUBST(EXTRA_LIBPCREPOSIX_LDFLAGS)
441    MATCH_LIMIT_RECURSION=-DMATCH_LIMIT_RECURSION=$withval  AC_SUBST(EXTRA_LIBPCRECPP_LDFLAGS)
442    
443    # When we run 'make distcheck', use these arguments.
444    DISTCHECK_CONFIGURE_FLAGS="--enable-cpp --enable-unicode-properties"
445    AC_SUBST(DISTCHECK_CONFIGURE_FLAGS)
446    
447    # Produce these files, in addition to config.h.
448    AC_CONFIG_FILES(
449            Makefile
450            libpcre.pc
451            libpcrecpp.pc
452            pcre-config
453            pcre.h
454            pcre_stringpiece.h
455            pcrecpparg.h
456  )  )
457    
458  dnl Unicode character property support implies UTF-8 support  # Make the generated script files executable.
459    AC_CONFIG_COMMANDS([script-chmod], [chmod a+x pcre-config])
460    
461  if test "$UCP" != "" ; then  # Make sure that pcre_chartables.c is removed in case the method for
462    UTF8=-DSUPPORT_UTF8  # creating it was changed by reconfiguration.
463  fi  AC_CONFIG_COMMANDS([delete-old-chartables], [rm -f pcre_chartables.c])
464    
465    AC_OUTPUT
466    
467    # Print out a nice little message after configure is run displaying your
468    # chosen options.
469    #
470    cat <<EOF
471    
472    $PACKAGE-$VERSION configuration summary:
473    
474        Install prefix ........... : ${prefix}
475        C preprocessor ........... : ${CPP}
476        C compiler ............... : ${CC}
477        C++ preprocessor ......... : ${CXXCPP}
478        C++ compiler ............. : ${CXX}
479        Linker ................... : ${LD}
480        C preprocessor flags ..... : ${CPPFLAGS}
481        C compiler flags ......... : ${CFLAGS}
482        C++ compiler flags ....... : ${CXXFLAGS}
483        Linker flags ............. : ${LDFLAGS}
484        Extra libraries .......... : ${LIBS}
485    
486        Build C++ library ........ : ${enable_cpp}
487        Enable UTF-8 support ..... : ${enable_utf8}
488        Unicode properties ....... : ${enable_unicode_properties}
489        Newline char/sequence .... : ${enable_newline}
490        \R matches only ANYCRLF .. : ${enable_bsr_anycrlf}
491        EBCDIC coding ............ : ${enable_ebcdic}
492        Rebuild char tables ...... : ${enable_rebuild_chartables}
493        Use stack recursion ...... : ${enable_stack_for_recursion}
494        POSIX mem threshold ...... : ${with_posix_malloc_threshold}
495        Internal link size ....... : ${with_link_size}
496        Match limit .............. : ${with_match_limit}
497        Match limit recursion .... : ${with_match_limit_recursion}
498        Build shared libs ........ : ${enable_shared}
499        Build static libs ........ : ${enable_static}
500    
501  dnl "Export" these variables  EOF
   
 AC_SUBST(BUILD_EXEEXT)  
 AC_SUBST(BUILD_OBJEXT)  
 AC_SUBST(CC_FOR_BUILD)  
 AC_SUBST(CXX_FOR_BUILD)  
 AC_SUBST(CFLAGS_FOR_BUILD)  
 AC_SUBST(CXXFLAGS_FOR_BUILD)  
 AC_SUBST(CXXLDFLAGS)  
 AC_SUBST(EBCDIC)  
 AC_SUBST(HAVE_MEMMOVE)  
 AC_SUBST(HAVE_STRERROR)  
 AC_SUBST(LINK_SIZE)  
 AC_SUBST(MATCH_LIMIT)  
 AC_SUBST(MATCH_LIMIT_RECURSION)  
 AC_SUBST(NEWLINE)  
 AC_SUBST(NO_RECURSE)  
 AC_SUBST(PCRE_LIB_VERSION)  
 AC_SUBST(PCRE_POSIXLIB_VERSION)  
 AC_SUBST(PCRE_CPPLIB_VERSION)  
 AC_SUBST(PCRE_VERSION)  
 AC_SUBST(POSIX_MALLOC_THRESHOLD)  
 AC_SUBST(UCP)  
 AC_SUBST(UTF8)  
   
 dnl Stuff to make MinGW work better. Special treatment is no longer  
 dnl needed for Cygwin.  
   
 case $host_os in  
 mingw* )  
     POSIX_OBJ=pcreposix.o  
     POSIX_LOBJ=pcreposix.lo  
     POSIX_LIB=  
     ON_WINDOWS=  
     NOT_ON_WINDOWS="#"  
     WIN_PREFIX=  
     ;;  
 * )  
     ON_WINDOWS="#"  
     NOT_ON_WINDOWS=  
     POSIX_OBJ=  
     POSIX_LOBJ=  
     POSIX_LIB=libpcreposix.la  
     WIN_PREFIX=  
     ;;  
 esac  
 AC_SUBST(WIN_PREFIX)  
 AC_SUBST(ON_WINDOWS)  
 AC_SUBST(NOT_ON_WINDOWS)  
 AC_SUBST(POSIX_OBJ)  
 AC_SUBST(POSIX_LOBJ)  
 AC_SUBST(POSIX_LIB)  
   
 if test "x$enable_shared" = "xno" ; then  
     AC_DEFINE([PCRE_STATIC],[1],[to link statically])  
 fi  
502    
503  dnl This must be last; it determines what files are written as well as config.h  dnl end configure.ac
 AC_OUTPUT(Makefile pcre-config:pcre-config.in libpcre.pc:libpcre.pc.in pcrecpparg.h:pcrecpparg.h.in pcre_stringpiece.h:pcre_stringpiece.h.in RunGrepTest:RunGrepTest.in RunTest:RunTest.in,[chmod a+x RunTest RunGrepTest pcre-config])  

Legend:
Removed from v.87  
changed lines
  Added in v.244

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12