← Back to branch summary

~ubuntu-branches/debian/experimental/parted/experimental

« back to all changes in this revision

Viewing changes to gnulib/m4/regex.m4

  • Committer: Bazaar Package Importer
  • Author(s): Otavio Salvador, Otavio Salvador, Colin Watson, Xavier Oswald, Xavier Oswald, Colin Watson
  • Date: 2010-02-06 16:39:19 UTC
  • mfrom: (1.1.4 upstream) (7.1.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100206163919-rt7jssmitulmp010
Tags: 2.1-1
http://bugs.debian.org/553824
http://bugs.debian.org/497626
http://bugs.debian.org/487833
http://bugs.debian.org/557044
* New upstream release

[ Otavio Salvador ]
* control.in: bump preferred soname for libreadline (closes: #553824).

[ Colin Watson ]
* control.in: Remove copy-and-paste error from libparted1.8-i18n
  description (closes: #497626).
* copyright: Document parted.info's licence, namely GFDL 1.1 with no
  invariant sections, front-cover texts, or back-cover texts (closes:
  #500201).
* rules: Cell partition tables are misdetected as pc98, so disable pc98
  support on powerpc (closes: #487833).
* control.in: Don't build-depend on libdevmapper-dev on hurd-i386.
* control.in: Build-depend on libdevmapper-dev (>= 1.02.33), for
  dm_task_set_major_minor.

[ Xavier Oswald ]
* debian/control.in: 
  - Change my mail address
  - Bump Standards-Version to 3.8.3
  - Update Build-Depends on debhelper 7
* debian/compat: update version to 7
* Parted not informing the kernel of changes to the partition table 
  (Closes: #557044), fixed upstream

[ Otavio Salvador ]
* debian/watch: fix URL to download
* Switch to quilt to manage patches
  - unpartitioned-disks.dpatch, drop (merged upstream)
  - unblacklist-md.dpatch, drop (merged upstream)
  - amiga-raid-lvm-fix.dpatch, drop (not used for ages)
  - devfs.dpatch, drop (devfs is not used)
  - reiserfs-libname.dpatch, drop (referenced library is unavailable)

[ Xavier Oswald, Colin Watson ]
* Refresh update-ext4-code.patch

[ Otavio Salvador ]
* Fix parted-doc info files installation
* Add lintian overrides for parted package
* Use soname in libparted udeb name

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib/m4/regex.m4
1
 
#serial 47
2
 
 
3
 
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
4
 
# 2006, 2007 Free Software Foundation, Inc.
5
 
#
6
 
# This file is free software; the Free Software Foundation
7
 
# gives unlimited permission to copy and/or distribute it,
8
 
# with or without modifications, as long as this notice is preserved.
9
 
 
10
 
dnl Initially derived from code in GNU grep.
11
 
dnl Mostly written by Jim Meyering.
12
 
 
13
 
AC_PREREQ([2.50])
14
 
 
15
 
AC_DEFUN([gl_REGEX],
16
 
[
17
 
  AC_CHECK_HEADERS_ONCE([locale.h])
18
 
 
19
 
  AC_ARG_WITH([included-regex],
20
 
    [AC_HELP_STRING([--without-included-regex],
21
 
                    [don't compile regex; this is the default on 32-bit
22
 
                     systems with recent-enough versions of the GNU C
23
 
                     Library (use with caution on other systems).
24
 
                     On systems with 64-bit ptrdiff_t and 32-bit int,
25
 
                     --with-included-regex is the default, in case
26
 
                     regex functions operate on very long strings (>2GB)])])
27
 
 
28
 
  case $with_included_regex in #(
29
 
  yes|no) ac_use_included_regex=$with_included_regex
30
 
        ;;
31
 
  '')
32
 
    # If the system regex support is good enough that it passes the
33
 
    # following run test, then default to *not* using the included regex.c.
34
 
    # If cross compiling, assume the test would fail and use the included
35
 
    # regex.c.
36
 
    AC_CACHE_CHECK([for working re_compile_pattern],
37
 
                   [gl_cv_func_re_compile_pattern_working],
38
 
      [AC_RUN_IFELSE(
39
 
        [AC_LANG_PROGRAM(
40
 
          [AC_INCLUDES_DEFAULT
41
 
           #if HAVE_LOCALE_H
42
 
            #include <locale.h>
43
 
           #endif
44
 
           #include <limits.h>
45
 
           #include <regex.h>
46
 
           ],
47
 
          [[static struct re_pattern_buffer regex;
48
 
            unsigned char folded_chars[UCHAR_MAX + 1];
49
 
            int i;
50
 
            const char *s;
51
 
            struct re_registers regs;
52
 
 
53
 
            #if HAVE_LOCALE_H
54
 
              /* http://sourceware.org/ml/libc-hacker/2006-09/msg00008.html
55
 
                 This test needs valgrind to catch the bug on Debian
56
 
                 GNU/Linux 3.1 x86, but it might catch the bug better
57
 
                 on other platforms and it shouldn't hurt to try the
58
 
                 test here.  */
59
 
              if (setlocale (LC_ALL, "en_US.UTF-8"))
60
 
                {
61
 
                  static char const pat[] = "insert into";
62
 
                  static char const data[] =
63
 
                    "\xFF\0\x12\xA2\xAA\xC4\xB1,K\x12\xC4\xB1*\xACK";
64
 
                  re_set_syntax (RE_SYNTAX_GREP | RE_HAT_LISTS_NOT_NEWLINE
65
 
                                 | RE_ICASE);
66
 
                  memset (&regex, 0, sizeof regex);
67
 
                  s = re_compile_pattern (pat, sizeof pat - 1, &regex);
68
 
                  if (s)
69
 
                    return 1;
70
 
                  if (re_search (&regex, data, sizeof data - 1,
71
 
                                 0, sizeof data - 1, &regs)
72
 
                      != -1)
73
 
                    return 1;
74
 
                  if (! setlocale (LC_ALL, "C"))
75
 
                    return 1;
76
 
                }
77
 
            #endif
78
 
 
79
 
            /* This test is from glibc bug 3957, reported by Andrew Mackey.  */
80
 
            re_set_syntax (RE_SYNTAX_EGREP | RE_HAT_LISTS_NOT_NEWLINE);
81
 
            memset (&regex, 0, sizeof regex);
82
 
            s = re_compile_pattern ("a[^x]b", 6, &regex);
83
 
            if (s)
84
 
              return 1;
85
 
 
86
 
            /* This should fail, but succeeds for glibc-2.5.  */
87
 
            if (re_search (&regex, "a\nb", 3, 0, 3, &regs) != -1)
88
 
              return 1;
89
 
 
90
 
            /* This regular expression is from Spencer ere test number 75
91
 
               in grep-2.3.  */
92
 
            re_set_syntax (RE_SYNTAX_POSIX_EGREP);
93
 
            memset (&regex, 0, sizeof regex);
94
 
            for (i = 0; i <= UCHAR_MAX; i++)
95
 
              folded_chars[i] = i;
96
 
            regex.translate = folded_chars;
97
 
            s = re_compile_pattern ("a[[:@:>@:]]b\n", 11, &regex);
98
 
            /* This should fail with _Invalid character class name_ error.  */
99
 
            if (!s)
100
 
              return 1;
101
 
 
102
 
            /* This should succeed, but does not for glibc-2.1.3.  */
103
 
            memset (&regex, 0, sizeof regex);
104
 
            s = re_compile_pattern ("{1", 2, &regex);
105
 
 
106
 
            if (s)
107
 
              return 1;
108
 
 
109
 
            /* The following example is derived from a problem report
110
 
               against gawk from Jorge Stolfi <stolfi@ic.unicamp.br>.  */
111
 
            memset (&regex, 0, sizeof regex);
112
 
            s = re_compile_pattern ("[an\371]*n", 7, &regex);
113
 
            if (s)
114
 
              return 1;
115
 
 
116
 
            /* This should match, but does not for glibc-2.2.1.  */
117
 
            if (re_match (&regex, "an", 2, 0, &regs) != 2)
118
 
              return 1;
119
 
 
120
 
            memset (&regex, 0, sizeof regex);
121
 
            s = re_compile_pattern ("x", 1, &regex);
122
 
            if (s)
123
 
              return 1;
124
 
 
125
 
            /* glibc-2.2.93 does not work with a negative RANGE argument.  */
126
 
            if (re_search (&regex, "wxy", 3, 2, -2, &regs) != 1)
127
 
              return 1;
128
 
 
129
 
            /* The version of regex.c in older versions of gnulib
130
 
               ignored RE_ICASE.  Detect that problem too.  */
131
 
            re_set_syntax (RE_SYNTAX_EMACS | RE_ICASE);
132
 
            memset (&regex, 0, sizeof regex);
133
 
            s = re_compile_pattern ("x", 1, &regex);
134
 
            if (s)
135
 
              return 1;
136
 
 
137
 
            if (re_search (&regex, "WXY", 3, 0, 3, &regs) < 0)
138
 
              return 1;
139
 
 
140
 
            /* Catch a bug reported by Vin Shelton in
141
 
               http://lists.gnu.org/archive/html/bug-coreutils/2007-06/msg00089.html
142
 
               */
143
 
            re_set_syntax (RE_SYNTAX_POSIX_BASIC
144
 
                           & ~RE_CONTEXT_INVALID_DUP
145
 
                           & ~RE_NO_EMPTY_RANGES);
146
 
            memset (&regex, 0, sizeof regex);
147
 
            s = re_compile_pattern ("[[:alnum:]_-]\\\\+$", 16, &regex);
148
 
            if (s)
149
 
              return 1;
150
 
 
151
 
            /* REG_STARTEND was added to glibc on 2004-01-15.
152
 
               Reject older versions.  */
153
 
            if (! REG_STARTEND)
154
 
              return 1;
155
 
 
156
 
            /* Reject hosts whose regoff_t values are too narrow.
157
 
               These include glibc 2.3.5 on hosts with 64-bit ptrdiff_t
158
 
               and 32-bit int.  */
159
 
            if (sizeof (regoff_t) < sizeof (ptrdiff_t)
160
 
                || sizeof (regoff_t) < sizeof (ssize_t))
161
 
              return 1;
162
 
 
163
 
            return 0;]])],
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
 
    AC_LIBOBJ([regex])
211
 
    gl_PREREQ_REGEX
212
 
  fi
213
 
])
214
 
 
215
 
# Prerequisites of lib/regex.c and lib/regex_internal.c.
216
 
AC_DEFUN([gl_PREREQ_REGEX],
217
 
[
218
 
  AC_REQUIRE([AC_GNU_SOURCE])
219
 
  AC_REQUIRE([AC_C_RESTRICT])
220
 
  AC_CHECK_FUNCS_ONCE([isblank iswctype mbrtowc wcrtomb wcscoll])
221
 
  AC_CHECK_DECLS([isblank], [], [], [#include <ctype.h>])
222
 
])