Commit | Line | Data |
---|---|---|
eb4a14ed LC |
1 | # serial 60 |
2 | ||
3 | # Copyright (C) 1996-2001, 2003-2012 Free Software Foundation, Inc. | |
4 | # | |
5 | # This file is free software; the Free Software Foundation | |
6 | # gives unlimited permission to copy and/or distribute it, | |
7 | # with or without modifications, as long as this notice is preserved. | |
8 | ||
9 | dnl Initially derived from code in GNU grep. | |
10 | dnl Mostly written by Jim Meyering. | |
11 | ||
12 | AC_PREREQ([2.50]) | |
13 | ||
14 | AC_DEFUN([gl_REGEX], | |
15 | [ | |
16 | AC_ARG_WITH([included-regex], | |
17 | [AS_HELP_STRING([--without-included-regex], | |
18 | [don't compile regex; this is the default on systems | |
19 | with recent-enough versions of the GNU C Library | |
20 | (use with caution on other systems).])]) | |
21 | ||
22 | case $with_included_regex in #( | |
23 | yes|no) ac_use_included_regex=$with_included_regex | |
24 | ;; | |
25 | '') | |
26 | # If the system regex support is good enough that it passes the | |
27 | # following run test, then default to *not* using the included regex.c. | |
28 | # If cross compiling, assume the test would fail and use the included | |
29 | # regex.c. | |
30 | AC_CACHE_CHECK([for working re_compile_pattern], | |
31 | [gl_cv_func_re_compile_pattern_working], | |
32 | [AC_RUN_IFELSE( | |
33 | [AC_LANG_PROGRAM( | |
34 | [AC_INCLUDES_DEFAULT[ | |
35 | #include <locale.h> | |
36 | #include <limits.h> | |
37 | #include <regex.h> | |
38 | ]], | |
39 | [[int result = 0; | |
40 | static struct re_pattern_buffer regex; | |
41 | unsigned char folded_chars[UCHAR_MAX + 1]; | |
42 | int i; | |
43 | const char *s; | |
44 | struct re_registers regs; | |
45 | ||
46 | /* http://sourceware.org/ml/libc-hacker/2006-09/msg00008.html | |
47 | This test needs valgrind to catch the bug on Debian | |
48 | GNU/Linux 3.1 x86, but it might catch the bug better | |
49 | on other platforms and it shouldn't hurt to try the | |
50 | test here. */ | |
51 | if (setlocale (LC_ALL, "en_US.UTF-8")) | |
52 | { | |
53 | static char const pat[] = "insert into"; | |
54 | static char const data[] = | |
55 | "\xFF\0\x12\xA2\xAA\xC4\xB1,K\x12\xC4\xB1*\xACK"; | |
56 | re_set_syntax (RE_SYNTAX_GREP | RE_HAT_LISTS_NOT_NEWLINE | |
57 | | RE_ICASE); | |
58 | memset (®ex, 0, sizeof regex); | |
59 | s = re_compile_pattern (pat, sizeof pat - 1, ®ex); | |
60 | if (s) | |
61 | result |= 1; | |
62 | else if (re_search (®ex, data, sizeof data - 1, | |
63 | 0, sizeof data - 1, ®s) | |
64 | != -1) | |
65 | result |= 1; | |
66 | if (! setlocale (LC_ALL, "C")) | |
67 | return 1; | |
68 | } | |
69 | ||
70 | /* This test is from glibc bug 3957, reported by Andrew Mackey. */ | |
71 | re_set_syntax (RE_SYNTAX_EGREP | RE_HAT_LISTS_NOT_NEWLINE); | |
72 | memset (®ex, 0, sizeof regex); | |
73 | s = re_compile_pattern ("a[^x]b", 6, ®ex); | |
74 | if (s) | |
75 | result |= 2; | |
76 | /* This should fail, but succeeds for glibc-2.5. */ | |
77 | else if (re_search (®ex, "a\nb", 3, 0, 3, ®s) != -1) | |
78 | result |= 2; | |
79 | ||
80 | /* This regular expression is from Spencer ere test number 75 | |
81 | in grep-2.3. */ | |
82 | re_set_syntax (RE_SYNTAX_POSIX_EGREP); | |
83 | memset (®ex, 0, sizeof regex); | |
84 | for (i = 0; i <= UCHAR_MAX; i++) | |
85 | folded_chars[i] = i; | |
86 | regex.translate = folded_chars; | |
87 | s = re_compile_pattern ("a[[:@:>@:]]b\n", 11, ®ex); | |
88 | /* This should fail with _Invalid character class name_ error. */ | |
89 | if (!s) | |
90 | result |= 4; | |
91 | ||
92 | /* Ensure that [b-a] is diagnosed as invalid, when | |
93 | using RE_NO_EMPTY_RANGES. */ | |
94 | re_set_syntax (RE_SYNTAX_POSIX_EGREP | RE_NO_EMPTY_RANGES); | |
95 | memset (®ex, 0, sizeof regex); | |
96 | s = re_compile_pattern ("a[b-a]", 6, ®ex); | |
97 | if (s == 0) | |
98 | result |= 8; | |
99 | ||
100 | /* This should succeed, but does not for glibc-2.1.3. */ | |
101 | memset (®ex, 0, sizeof regex); | |
102 | s = re_compile_pattern ("{1", 2, ®ex); | |
103 | if (s) | |
104 | result |= 8; | |
105 | ||
106 | /* The following example is derived from a problem report | |
107 | against gawk from Jorge Stolfi <stolfi@ic.unicamp.br>. */ | |
108 | memset (®ex, 0, sizeof regex); | |
109 | s = re_compile_pattern ("[an\371]*n", 7, ®ex); | |
110 | if (s) | |
111 | result |= 8; | |
112 | /* This should match, but does not for glibc-2.2.1. */ | |
113 | else if (re_match (®ex, "an", 2, 0, ®s) != 2) | |
114 | result |= 8; | |
115 | ||
116 | memset (®ex, 0, sizeof regex); | |
117 | s = re_compile_pattern ("x", 1, ®ex); | |
118 | if (s) | |
119 | result |= 8; | |
120 | /* glibc-2.2.93 does not work with a negative RANGE argument. */ | |
121 | else if (re_search (®ex, "wxy", 3, 2, -2, ®s) != 1) | |
122 | result |= 8; | |
123 | ||
124 | /* The version of regex.c in older versions of gnulib | |
125 | ignored RE_ICASE. Detect that problem too. */ | |
126 | re_set_syntax (RE_SYNTAX_EMACS | RE_ICASE); | |
127 | memset (®ex, 0, sizeof regex); | |
128 | s = re_compile_pattern ("x", 1, ®ex); | |
129 | if (s) | |
130 | result |= 16; | |
131 | else if (re_search (®ex, "WXY", 3, 0, 3, ®s) < 0) | |
132 | result |= 16; | |
133 | ||
134 | /* Catch a bug reported by Vin Shelton in | |
135 | http://lists.gnu.org/archive/html/bug-coreutils/2007-06/msg00089.html | |
136 | */ | |
137 | re_set_syntax (RE_SYNTAX_POSIX_BASIC | |
138 | & ~RE_CONTEXT_INVALID_DUP | |
139 | & ~RE_NO_EMPTY_RANGES); | |
140 | memset (®ex, 0, sizeof regex); | |
141 | s = re_compile_pattern ("[[:alnum:]_-]\\\\+$", 16, ®ex); | |
142 | if (s) | |
143 | result |= 32; | |
144 | ||
145 | /* REG_STARTEND was added to glibc on 2004-01-15. | |
146 | Reject older versions. */ | |
147 | if (! REG_STARTEND) | |
148 | result |= 64; | |
149 | ||
150 | #if 0 | |
151 | /* It would be nice to reject hosts whose regoff_t values are too | |
152 | narrow (including glibc on hosts with 64-bit ptrdiff_t and | |
153 | 32-bit int), but we should wait until glibc implements this | |
154 | feature. Otherwise, support for equivalence classes and | |
155 | multibyte collation symbols would always be broken except | |
156 | when compiling --without-included-regex. */ | |
157 | if (sizeof (regoff_t) < sizeof (ptrdiff_t) | |
158 | || sizeof (regoff_t) < sizeof (ssize_t)) | |
159 | result |= 64; | |
160 | #endif | |
161 | ||
162 | return result; | |
163 | ]])], | |
164 | [gl_cv_func_re_compile_pattern_working=yes], | |
165 | [gl_cv_func_re_compile_pattern_working=no], | |
166 | dnl When crosscompiling, assume it is not working. | |
167 | [gl_cv_func_re_compile_pattern_working=no])]) | |
168 | case $gl_cv_func_re_compile_pattern_working in #( | |
169 | yes) ac_use_included_regex=no;; #( | |
170 | no) ac_use_included_regex=yes;; | |
171 | esac | |
172 | ;; | |
173 | *) AC_MSG_ERROR([Invalid value for --with-included-regex: $with_included_regex]) | |
174 | ;; | |
175 | esac | |
176 | ||
177 | if test $ac_use_included_regex = yes; then | |
178 | AC_DEFINE([_REGEX_LARGE_OFFSETS], [1], | |
179 | [Define if you want regoff_t to be at least as wide POSIX requires.]) | |
180 | AC_DEFINE([re_syntax_options], [rpl_re_syntax_options], | |
181 | [Define to rpl_re_syntax_options if the replacement should be used.]) | |
182 | AC_DEFINE([re_set_syntax], [rpl_re_set_syntax], | |
183 | [Define to rpl_re_set_syntax if the replacement should be used.]) | |
184 | AC_DEFINE([re_compile_pattern], [rpl_re_compile_pattern], | |
185 | [Define to rpl_re_compile_pattern if the replacement should be used.]) | |
186 | AC_DEFINE([re_compile_fastmap], [rpl_re_compile_fastmap], | |
187 | [Define to rpl_re_compile_fastmap if the replacement should be used.]) | |
188 | AC_DEFINE([re_search], [rpl_re_search], | |
189 | [Define to rpl_re_search if the replacement should be used.]) | |
190 | AC_DEFINE([re_search_2], [rpl_re_search_2], | |
191 | [Define to rpl_re_search_2 if the replacement should be used.]) | |
192 | AC_DEFINE([re_match], [rpl_re_match], | |
193 | [Define to rpl_re_match if the replacement should be used.]) | |
194 | AC_DEFINE([re_match_2], [rpl_re_match_2], | |
195 | [Define to rpl_re_match_2 if the replacement should be used.]) | |
196 | AC_DEFINE([re_set_registers], [rpl_re_set_registers], | |
197 | [Define to rpl_re_set_registers if the replacement should be used.]) | |
198 | AC_DEFINE([re_comp], [rpl_re_comp], | |
199 | [Define to rpl_re_comp if the replacement should be used.]) | |
200 | AC_DEFINE([re_exec], [rpl_re_exec], | |
201 | [Define to rpl_re_exec if the replacement should be used.]) | |
202 | AC_DEFINE([regcomp], [rpl_regcomp], | |
203 | [Define to rpl_regcomp if the replacement should be used.]) | |
204 | AC_DEFINE([regexec], [rpl_regexec], | |
205 | [Define to rpl_regexec if the replacement should be used.]) | |
206 | AC_DEFINE([regerror], [rpl_regerror], | |
207 | [Define to rpl_regerror if the replacement should be used.]) | |
208 | AC_DEFINE([regfree], [rpl_regfree], | |
209 | [Define to rpl_regfree if the replacement should be used.]) | |
210 | fi | |
211 | ]) | |
212 | ||
213 | # Prerequisites of lib/regex.c and lib/regex_internal.c. | |
214 | AC_DEFUN([gl_PREREQ_REGEX], | |
215 | [ | |
216 | AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS]) | |
217 | AC_REQUIRE([AC_C_INLINE]) | |
218 | AC_REQUIRE([AC_C_RESTRICT]) | |
219 | AC_REQUIRE([AC_TYPE_MBSTATE_T]) | |
220 | AC_CHECK_HEADERS([libintl.h]) | |
221 | AC_CHECK_FUNCS_ONCE([isblank iswctype wcscoll]) | |
222 | AC_CHECK_DECLS([isblank], [], [], [[#include <ctype.h>]]) | |
223 | ]) |