/[m4]/m4/lib/regex.c
ViewVC logotype

Diff of /m4/lib/regex.c

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

revision 1.1.1.1 by jbailey, Thu Feb 17 03:03:19 2000 UTC revision 1.1.1.1.2.1 by gary, Fri Feb 4 13:03:11 2005 UTC
# Line 1  Line 1 
1  /* Extended regular expression matching and search library,  /* Extended regular expression matching and search library,
2     version 0.12.     version 0.12.
3     (Implements POSIX draft P10003.2/D11.2, except for     (Implements POSIX draft P1003.2/D11.2, except for some of the
4     internationalization features.)     internationalization features.)
5    
6     Copyright (C) 1993, 1994 Free Software Foundation, Inc.     Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
7       2002, 2003, 2004 Free Software Foundation, Inc.
8    
9     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
10     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
# Line 15  Line 16 
16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17     GNU General Public License for more details.     GNU General Public License for more details.
18    
19     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License along
20     along with this program; if not, write to the Free Software     with this program; if not, write to the Free Software Foundation,
21     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */     Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
22    
23  /* AIX requires this to be the first thing in the file. */  /* AIX requires this to be the first thing in the file. */
24  #if defined (_AIX) && !defined (REGEX_MALLOC)  #if defined _AIX && !defined REGEX_MALLOC
25    #pragma alloca    #pragma alloca
26  #endif  #endif
27    
28    #undef  _GNU_SOURCE
29  #define _GNU_SOURCE  #define _GNU_SOURCE
30    
31  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
32  #include <config.h>  # include <config.h>
33  #endif  #endif
34    
35  /* We need this for `regex.h', and perhaps for the Emacs include files.  */  #ifndef INSIDE_RECURSION
 #include <sys/types.h>  
36    
37  /* The `emacs' switch turns on certain matching commands  # include <stddef.h>
    that make sense only in Emacs. */  
 #ifdef emacs  
38    
39  #include "lisp.h"  # define WIDE_CHAR_SUPPORT (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)
 #include "buffer.h"  
 #include "syntax.h"  
40    
41  /* Emacs uses `NULL' as a predicate.  */  /* For platform which support the ISO C amendement 1 functionality we
42  #undef NULL     support user defined character classes.  */
43    # if defined _LIBC || WIDE_CHAR_SUPPORT
44  #else  /* not emacs */  /* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
45    #  include <wchar.h>
46  #ifdef STDC_HEADERS  #  include <wctype.h>
47  #include <stdlib.h>  # endif
48  #else  
49  char *malloc ();  # ifdef _LIBC
50  char *realloc ();  /* We have to keep the namespace clean.  */
51  #endif  #  define regfree(preg) __regfree (preg)
52    #  define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
53    #  define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
54    #  define regerror(errcode, preg, errbuf, errbuf_size) \
55            __regerror(errcode, preg, errbuf, errbuf_size)
56    #  define re_set_registers(bu, re, nu, st, en) \
57            __re_set_registers (bu, re, nu, st, en)
58    #  define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
59            __re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
60    #  define re_match(bufp, string, size, pos, regs) \
61            __re_match (bufp, string, size, pos, regs)
62    #  define re_search(bufp, string, size, startpos, range, regs) \
63            __re_search (bufp, string, size, startpos, range, regs)
64    #  define re_compile_pattern(pattern, length, bufp) \
65            __re_compile_pattern (pattern, length, bufp)
66    #  define re_set_syntax(syntax) __re_set_syntax (syntax)
67    #  define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
68            __re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
69    #  define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)
70    
71    #  define btowc __btowc
72    #  define iswctype __iswctype
73    #  define mbrtowc __mbrtowc
74    #  define wcslen __wcslen
75    #  define wcscoll __wcscoll
76    #  define wcrtomb __wcrtomb
77    
78    /* We are also using some library internals.  */
79    #  include <locale/localeinfo.h>
80    #  include <locale/elem-hash.h>
81    #  include <langinfo.h>
82    #  include <locale/coll-lookup.h>
83    # endif
84    
85    # ifdef _LIBC
86    #  include <libintl.h>
87    #  undef gettext
88    #  define gettext(msgid) __dcgettext ("libc", msgid, LC_MESSAGES)
89       /* This define is so xgettext can find the internationalizable strings.  */
90    #  define gettext_noop(msgid) msgid
91    # else
92    #  define _(text) text
93    #  define gettext_noop(text) text
94    # endif
95    
96    /* Support for bounded pointers.  */
97    # if !defined _LIBC && !defined __BOUNDED_POINTERS__
98    #  define __bounded     /* nothing */
99    #  define __unbounded   /* nothing */
100    #  define __ptrvalue    /* nothing */
101    # endif
102    
103    /* The `emacs' switch turns on certain matching commands
104       that make sense only in Emacs. */
105    # ifdef emacs
106    
107  /* We used to test for `BSTRING' here, but only GCC and Emacs define  #  include "lisp.h"
108     `BSTRING', as far as I know, and neither of them use this code.  */  #  include "buffer.h"
109  #ifndef INHIBIT_STRING_HEADER  #  include "syntax.h"
110  #if HAVE_STRING_H || STDC_HEADERS  
111  #include <string.h>  # else  /* not emacs */
112  #ifndef bcmp  
113  #define bcmp(s1, s2, n) memcmp ((s1), (s2), (n))  /* If we are not linking with Emacs proper,
114  #endif     we can't use the relocating allocator
115  #ifndef bcopy     even if config.h says that we can.  */
116  #define bcopy(s, d, n)  memcpy ((d), (s), (n))  #  undef REL_ALLOC
117  #endif  
118  #ifndef bzero  #  include <stdlib.h>
119  #define bzero(s, n)     memset ((s), 0, (n))  
120  #endif  /* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
121  #else     If nothing else has been done, use the method below.  */
122  #include <strings.h>  #  ifdef INHIBIT_STRING_HEADER
123  #endif  #   if !(defined HAVE_BZERO && defined HAVE_BCOPY)
124  #endif  #    if !defined bzero && !defined bcopy
125    #     undef INHIBIT_STRING_HEADER
126    #    endif
127    #   endif
128    #  endif
129    
130    /* This is the normal way of making sure we have a bcopy and a bzero.
131       This is used in most programs--a few other programs avoid this
132       by defining INHIBIT_STRING_HEADER.  */
133    #  ifndef INHIBIT_STRING_HEADER
134    #   include <string.h>
135    #   ifndef bzero
136    #    ifndef _LIBC
137    #     define bzero(s, n)        (memset (s, '\0', n), (s))
138    #    else
139    #     define bzero(s, n)        __bzero (s, n)
140    #    endif
141    #   endif
142    #  endif
143    
144  /* Define the syntax stuff for \<, \>, etc.  */  /* Define the syntax stuff for \<, \>, etc.  */
145    
146  /* This must be nonzero for the wordchar and notwordchar pattern  /* This must be nonzero for the wordchar and notwordchar pattern
147     commands in re_match_2.  */     commands in re_match_2.  */
148  #ifndef Sword  #  ifndef Sword
149  #define Sword 1  #   define Sword 1
150  #endif  #  endif
151    
152    #  ifdef SWITCH_ENUM_BUG
153    #   define SWITCH_ENUM_CAST(x) ((int)(x))
154    #  else
155    #   define SWITCH_ENUM_CAST(x) (x)
156    #  endif
157    
158    # endif /* not emacs */
159    
160    # include <limits.h>
161    
162    # ifndef MB_LEN_MAX
163    #  define MB_LEN_MAX 1
164    # endif
165    
166    /* Get the interface, including the syntax bits.  */
167    # include <regex.h>
168    
169  #ifdef SYNTAX_TABLE  /* isalpha etc. are used for the character classes.  */
170    # include <ctype.h>
171    
172  extern char *re_syntax_table;  /* Jim Meyering writes:
173    
174  #else /* not SYNTAX_TABLE */     "... Some ctype macros are valid only for character codes that
175       isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when
176       using /bin/cc or gcc but without giving an ansi option).  So, all
177       ctype uses should be through macros like ISPRINT...  If
178       STDC_HEADERS is defined, then autoconf has verified that the ctype
179       macros don't need to be guarded with references to isascii. ...
180       Defining isascii to 1 should let any compiler worth its salt
181       eliminate the && through constant folding."
182       Solaris defines some of these symbols so we must undefine them first.  */
183    
184    # if defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
185    #  define IN_CTYPE_DOMAIN(c) 1
186    # else
187    #  define IN_CTYPE_DOMAIN(c) isascii(c)
188    # endif
189    
190    # ifdef isblank
191    #  define ISBLANK(c) (IN_CTYPE_DOMAIN (c) && isblank (c))
192    # else
193    #  define ISBLANK(c) ((c) == ' ' || (c) == '\t')
194    # endif
195    # ifdef isgraph
196    #  define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isgraph (c))
197    # else
198    #  define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isprint (c) && !isspace (c))
199    # endif
200    
201    # undef ISPRINT
202    # define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (c))
203    # define ISDIGIT(c) (IN_CTYPE_DOMAIN (c) && isdigit (c))
204    # define ISALNUM(c) (IN_CTYPE_DOMAIN (c) && isalnum (c))
205    # define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (c))
206    # define ISCNTRL(c) (IN_CTYPE_DOMAIN (c) && iscntrl (c))
207    # define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (c))
208    # define ISPUNCT(c) (IN_CTYPE_DOMAIN (c) && ispunct (c))
209    # define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (c))
210    # define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper (c))
211    # define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (c))
212    
213    # ifdef _tolower
214    #  define TOLOWER(c) _tolower(c)
215    # else
216    #  define TOLOWER(c) tolower(c)
217    # endif
218    
219    # ifndef emacs
220  /* How many characters in the character set.  */  /* How many characters in the character set.  */
221  #define CHAR_SET_SIZE 256  #  define CHAR_SET_SIZE 256
222    
223    #  ifdef SYNTAX_TABLE
224    
225    extern char *re_syntax_table;
226    
227    #  else /* not SYNTAX_TABLE */
228    
229  static char re_syntax_table[CHAR_SET_SIZE];  static char re_syntax_table[CHAR_SET_SIZE];
230    
231  static void  static void
232  init_syntax_once ()  init_syntax_once (void)
233  {  {
234     register int c;     register int c;
235     static int done = 0;     static int done = 0;
236    
237     if (done)     if (done)
238       return;       return;
   
239     bzero (re_syntax_table, sizeof re_syntax_table);     bzero (re_syntax_table, sizeof re_syntax_table);
240    
241     for (c = 'a'; c <= 'z'; c++)     for (c = 0; c < CHAR_SET_SIZE; ++c)
242       re_syntax_table[c] = Sword;       if (ISALNUM (c))
243            re_syntax_table[c] = Sword;
    for (c = 'A'; c <= 'Z'; c++)  
      re_syntax_table[c] = Sword;  
   
    for (c = '0'; c <= '9'; c++)  
      re_syntax_table[c] = Sword;  
244    
245     re_syntax_table['_'] = Sword;     re_syntax_table['_'] = Sword;
246    
247     done = 1;     done = 1;
248  }  }
249    
250  #endif /* not SYNTAX_TABLE */  #  endif /* not SYNTAX_TABLE */
251    
252  #define SYNTAX(c) re_syntax_table[c]  #  define SYNTAX(c) re_syntax_table[(unsigned char) (c)]
253    
254  #endif /* not emacs */  # endif /* emacs */
   
 /* Get the interface, including the syntax bits.  */  
 #include "regex.h"  
   
 /* isalpha etc. are used for the character classes.  */  
 #include <ctype.h>  
   
 /* Jim Meyering writes:  
   
    "... Some ctype macros are valid only for character codes that  
    isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when  
    using /bin/cc or gcc but without giving an ansi option).  So, all  
    ctype uses should be through macros like ISPRINT...  If  
    STDC_HEADERS is defined, then autoconf has verified that the ctype  
    macros don't need to be guarded with references to isascii. ...  
    Defining isascii to 1 should let any compiler worth its salt  
    eliminate the && through constant folding."  */  
   
 #if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))  
 #define ISASCII(c) 1  
 #else  
 #define ISASCII(c) isascii(c)  
 #endif  
   
 #ifdef isblank  
 #define ISBLANK(c) (ISASCII (c) && isblank (c))  
 #else  
 #define ISBLANK(c) ((c) == ' ' || (c) == '\t')  
 #endif  
 #ifdef isgraph  
 #define ISGRAPH(c) (ISASCII (c) && isgraph (c))  
 #else  
 #define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))  
 #endif  
   
 #define ISPRINT(c) (ISASCII (c) && isprint (c))  
 #define ISDIGIT(c) (ISASCII (c) && isdigit (c))  
 #define ISALNUM(c) (ISASCII (c) && isalnum (c))  
 #define ISALPHA(c) (ISASCII (c) && isalpha (c))  
 #define ISCNTRL(c) (ISASCII (c) && iscntrl (c))  
 #define ISLOWER(c) (ISASCII (c) && islower (c))  
 #define ISPUNCT(c) (ISASCII (c) && ispunct (c))  
 #define ISSPACE(c) (ISASCII (c) && isspace (c))  
 #define ISUPPER(c) (ISASCII (c) && isupper (c))  
 #define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))  
   
 #ifndef NULL  
 #define NULL 0  
 #endif  
   
 /* We remove any previous definition of `SIGN_EXTEND_CHAR',  
    since ours (we hope) works properly with all combinations of  
    machines, compilers, `char' and `unsigned char' argument types.  
    (Per Bothner suggested the basic approach.)  */  
 #undef SIGN_EXTEND_CHAR  
 #if __STDC__  
 #define SIGN_EXTEND_CHAR(c) ((signed char) (c))  
 #else  /* not __STDC__ */  
 /* As in Harbison and Steele.  */  
 #define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)  
 #endif  
255    
256  /* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we  /* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we
257     use `alloca' instead of `malloc'.  This is because using malloc in     use `alloca' instead of `malloc'.  This is because using malloc in
258     re_search* or re_match* could cause memory leaks when C-g is used in     re_search* or re_match* could cause memory leaks when C-g is used in
259     Emacs; also, malloc is slower and causes storage fragmentation.  On     Emacs; also, malloc is slower and causes storage fragmentation.  On
260     the other hand, malloc is more portable, and easier to debug.       the other hand, malloc is more portable, and easier to debug.
261      
262     Because we sometimes use alloca, some routines have to be macros,     Because we sometimes use alloca, some routines have to be macros,
263     not functions -- `alloca'-allocated space disappears at the end of the     not functions -- `alloca'-allocated space disappears at the end of the
264     function it is called in.  */     function it is called in.  */
265    
266  #ifdef REGEX_MALLOC  # ifdef REGEX_MALLOC
267    
268  #define REGEX_ALLOCATE malloc  #  define REGEX_ALLOCATE malloc
269  #define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)  #  define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)
270    #  define REGEX_FREE free
271    
272  #else /* not REGEX_MALLOC  */  # else /* not REGEX_MALLOC  */
273    
274  /* Emacs already defines alloca, sometimes.  */  /* Emacs already defines alloca, sometimes.  */
275  #ifndef alloca  #  ifndef alloca
276    
277  /* Make alloca work the best possible way.  */  /* Make alloca work the best possible way.  */
278  #ifdef __GNUC__  #   include <alloca.h>
 #define alloca __builtin_alloca  
 #else /* not __GNUC__ */  
 #if HAVE_ALLOCA_H  
 #include <alloca.h>  
 #else /* not __GNUC__ or HAVE_ALLOCA_H */  
 #ifndef _AIX /* Already did AIX, up at the top.  */  
 char *alloca ();  
 #endif /* not _AIX */  
 #endif /* not HAVE_ALLOCA_H */  
 #endif /* not __GNUC__ */  
279    
280  #endif /* not alloca */  #  endif /* not alloca */
281    
282  #define REGEX_ALLOCATE alloca  #  define REGEX_ALLOCATE alloca
283    
284  /* Assumes a `char *destination' variable.  */  /* Assumes a `char *destination' variable.  */
285  #define REGEX_REALLOCATE(source, osize, nsize)                          \  #  define REGEX_REALLOCATE(source, osize, nsize)                        \
286    (destination = (char *) alloca (nsize),                               \    (destination = (char *) alloca (nsize),                               \
287     bcopy (source, destination, osize),                                  \     memcpy (destination, source, osize))
288     destination)  
289    /* No need to do anything to free, after alloca.  */
290    #  define REGEX_FREE(arg) ((void)0) /* Do nothing!  But inhibit gcc warning.  */
291    
292    # endif /* not REGEX_MALLOC */
293    
294    /* Define how to allocate the failure stack.  */
295    
296    # if defined REL_ALLOC && defined REGEX_MALLOC
297    
298    #  define REGEX_ALLOCATE_STACK(size)                            \
299      r_alloc (&failure_stack_ptr, (size))
300    #  define REGEX_REALLOCATE_STACK(source, osize, nsize)          \
301      r_re_alloc (&failure_stack_ptr, (nsize))
302    #  define REGEX_FREE_STACK(ptr)                                 \
303      r_alloc_free (&failure_stack_ptr)
304    
305    # else /* not using relocating allocator */
306    
307    #  ifdef REGEX_MALLOC
308    
309    #   define REGEX_ALLOCATE_STACK malloc
310    #   define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize)
311    #   define REGEX_FREE_STACK free
312    
313    #  else /* not REGEX_MALLOC */
314    
315  #endif /* not REGEX_MALLOC */  #   define REGEX_ALLOCATE_STACK alloca
316    
317    #   define REGEX_REALLOCATE_STACK(source, osize, nsize)                 \
318       REGEX_REALLOCATE (source, osize, nsize)
319    /* No need to explicitly free anything.  */
320    #   define REGEX_FREE_STACK(arg)
321    
322    #  endif /* not REGEX_MALLOC */
323    # endif /* not using relocating allocator */
324    
325    
326  /* True if `size1' is non-NULL and PTR is pointing anywhere inside  /* True if `size1' is non-NULL and PTR is pointing anywhere inside
327     `string1' or just past its end.  This works if PTR is NULL, which is     `string1' or just past its end.  This works if PTR is NULL, which is
328     a good thing.  */     a good thing.  */
329  #define FIRST_STRING_P(ptr)                                     \  # define FIRST_STRING_P(ptr)                                    \
330    (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)    (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
331    
332  /* (Re)Allocate N items of type T using malloc, or fail.  */  /* (Re)Allocate N items of type T using malloc, or fail.  */
333  #define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))  # define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))
334  #define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))  # define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
335  #define RETALLOC_IF(addr, n, t) \  # define RETALLOC_IF(addr, n, t) \
336    if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)    if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
337  #define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))  # define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))
338    
339  #define BYTEWIDTH 8 /* In bits.  */  # define BYTEWIDTH 8 /* In bits.  */
340    
341  #define STREQ(s1, s2) ((strcmp (s1, s2) == 0))  # define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
342    
343  #undef MAX  # undef MAX
344  #undef MIN  # undef MIN
345  #define MAX(a, b) ((a) > (b) ? (a) : (b))  # define MAX(a, b) ((a) > (b) ? (a) : (b))
346  #define MIN(a, b) ((a) < (b) ? (a) : (b))  # define MIN(a, b) ((a) < (b) ? (a) : (b))
347    
348  typedef char boolean;  typedef char boolean;
349  #define false 0  # define false 0
350  #define true 1  # define true 1
351    
352  static int re_match_2_internal ();  static reg_errcode_t byte_regex_compile (const char *pattern, size_t size,
353                                             reg_syntax_t syntax,
354                                             struct re_pattern_buffer *bufp);
355    
356    static int byte_re_match_2_internal (struct re_pattern_buffer *bufp,
357                                         const char *string1, int size1,
358                                         const char *string2, int size2,
359                                         int pos,
360                                         struct re_registers *regs,
361                                         int stop);
362    static int byte_re_search_2 (struct re_pattern_buffer *bufp,
363                                 const char *string1, int size1,
364                                 const char *string2, int size2,
365                                 int startpos, int range,
366                                 struct re_registers *regs, int stop);
367    static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp);
368    
369    #ifdef MBS_SUPPORT
370    static reg_errcode_t wcs_regex_compile (const char *pattern, size_t size,
371                                            reg_syntax_t syntax,
372                                            struct re_pattern_buffer *bufp);
373    
374    
375    static int wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
376                                        const char *cstring1, int csize1,
377                                        const char *cstring2, int csize2,
378                                        int pos,
379                                        struct re_registers *regs,
380                                        int stop,
381                                        wchar_t *string1, int size1,
382                                        wchar_t *string2, int size2,
383                                        int *mbs_offset1, int *mbs_offset2);
384    static int wcs_re_search_2 (struct re_pattern_buffer *bufp,
385                                const char *string1, int size1,
386                                const char *string2, int size2,
387                                int startpos, int range,
388                                struct re_registers *regs, int stop);
389    static int wcs_re_compile_fastmap (struct re_pattern_buffer *bufp);
390    #endif
391    
392  /* These are the command codes that appear in compiled regular  /* These are the command codes that appear in compiled regular
393     expressions.  Some opcodes are followed by argument bytes.  A     expressions.  Some opcodes are followed by argument bytes.  A
# Line 267  typedef enum Line 398  typedef enum
398  {  {
399    no_op = 0,    no_op = 0,
400    
401      /* Succeed right away--no more backtracking.  */
402      succeed,
403    
404          /* Followed by one byte giving n, then by n literal bytes.  */          /* Followed by one byte giving n, then by n literal bytes.  */
405    exactn,    exactn,
406    
407    # ifdef MBS_SUPPORT
408            /* Same as exactn, but contains binary data.  */
409      exactn_bin,
410    # endif
411    
412          /* Matches any (more or less) character.  */          /* Matches any (more or less) character.  */
413    anychar,    anychar,
414    
# Line 279  typedef enum Line 418  typedef enum
418             are ordered low-bit-first.  A character is in the set if its             are ordered low-bit-first.  A character is in the set if its
419             bit is 1.  A character too large to have a bit in the map is             bit is 1.  A character too large to have a bit in the map is
420             automatically not in the set.  */             automatically not in the set.  */
421            /* ifdef MBS_SUPPORT, following element is length of character
422               classes, length of collating symbols, length of equivalence
423               classes, length of character ranges, and length of characters.
424               Next, character class element, collating symbols elements,
425               equivalence class elements, range elements, and character
426               elements follow.
427               See regex_compile function.  */
428    charset,    charset,
429    
430          /* Same parameters as charset, but match any character that is          /* Same parameters as charset, but match any character that is
# Line 319  typedef enum Line 465  typedef enum
465    
466          /* Analogously, for end of buffer/string.  */          /* Analogously, for end of buffer/string.  */
467    endbuf,    endbuf,
468    
469          /* Followed by two byte relative address to which to jump.  */          /* Followed by two byte relative address to which to jump.  */
470    jump,    jump,
471    
472          /* Same as jump, but marks the end of an alternative.  */          /* Same as jump, but marks the end of an alternative.  */
473    jump_past_alt,    jump_past_alt,
474    
475          /* Followed by two-byte relative address of place to resume at          /* Followed by two-byte relative address of place to resume at
476             in case of failure.  */             in case of failure.  */
477            /* ifdef MBS_SUPPORT, the size of address is 1.  */
478    on_failure_jump,    on_failure_jump,
479            
480          /* Like on_failure_jump, but pushes a placeholder instead of the          /* Like on_failure_jump, but pushes a placeholder instead of the
481             current string position when executed.  */             current string position when executed.  */
482    on_failure_keep_string_jump,    on_failure_keep_string_jump,
483      
484          /* Throw away latest failure point and then jump to following          /* Throw away latest failure point and then jump to following
485             two-byte relative address.  */             two-byte relative address.  */
486            /* ifdef MBS_SUPPORT, the size of address is 1.  */
487    pop_failure_jump,    pop_failure_jump,
488    
489          /* Change to pop_failure_jump if know won't have to backtrack to          /* Change to pop_failure_jump if know won't have to backtrack to
# Line 345  typedef enum Line 493  typedef enum
493             sure that there is no use backtracking out of repetitions             sure that there is no use backtracking out of repetitions
494             already matched, then we change it to a pop_failure_jump.             already matched, then we change it to a pop_failure_jump.
495             Followed by two-byte address.  */             Followed by two-byte address.  */
496            /* ifdef MBS_SUPPORT, the size of address is 1.  */
497    maybe_pop_jump,    maybe_pop_jump,
498    
499          /* Jump to following two-byte address, and push a dummy failure          /* Jump to following two-byte address, and push a dummy failure
# Line 352  typedef enum Line 501  typedef enum
501             is made to use it for a failure.  A `+' construct makes this             is made to use it for a failure.  A `+' construct makes this
502             before the first repeat.  Also used as an intermediary kind             before the first repeat.  Also used as an intermediary kind
503             of jump when compiling an alternative.  */             of jump when compiling an alternative.  */
504            /* ifdef MBS_SUPPORT, the size of address is 1.  */
505    dummy_failure_jump,    dummy_failure_jump,
506    
507          /* Push a dummy failure point and continue.  Used at the end of          /* Push a dummy failure point and continue.  Used at the end of
# Line 360  typedef enum Line 510  typedef enum
510    
511          /* Followed by two-byte relative address and two-byte number n.          /* Followed by two-byte relative address and two-byte number n.
512             After matching N times, jump to the address upon failure.  */             After matching N times, jump to the address upon failure.  */
513            /* ifdef MBS_SUPPORT, the size of address is 1.  */
514    succeed_n,    succeed_n,
515    
516          /* Followed by two-byte relative address, and two-byte number n.          /* Followed by two-byte relative address, and two-byte number n.
517             Jump to the address N times, then fail.  */             Jump to the address N times, then fail.  */
518            /* ifdef MBS_SUPPORT, the size of address is 1.  */
519    jump_n,    jump_n,
520    
521          /* Set the following two-byte relative address to the          /* Set the following two-byte relative address to the
522             subsequent two-byte number.  The address *includes* the two             subsequent two-byte number.  The address *includes* the two
523             bytes of number.  */             bytes of number.  */
524            /* ifdef MBS_SUPPORT, the size of address is 1.  */
525    set_number_at,    set_number_at,
526    
527    wordchar,     /* Matches any word-constituent character.  */    wordchar,     /* Matches any word-constituent character.  */
# Line 380  typedef enum Line 533  typedef enum
533    wordbound,    /* Succeeds if at a word boundary.  */    wordbound,    /* Succeeds if at a word boundary.  */
534    notwordbound  /* Succeeds if not at a word boundary.  */    notwordbound  /* Succeeds if not at a word boundary.  */
535    
536  #ifdef emacs  # ifdef emacs
537    ,before_dot,  /* Succeeds if before point.  */    ,before_dot,  /* Succeeds if before point.  */
538    at_dot,       /* Succeeds if at point.  */    at_dot,       /* Succeeds if at point.  */
539    after_dot,    /* Succeeds if after point.  */    after_dot,    /* Succeeds if after point.  */
# Line 391  typedef enum Line 544  typedef enum
544    
545          /* Matches any character whose syntax is not that specified.  */          /* Matches any character whose syntax is not that specified.  */
546    notsyntaxspec    notsyntaxspec
547  #endif /* emacs */  # endif /* emacs */
548  } re_opcode_t;  } re_opcode_t;
549    #endif /* not INSIDE_RECURSION */
550    
551    
552    #ifdef BYTE
553    # define CHAR_T char
554    # define UCHAR_T unsigned char
555    # define COMPILED_BUFFER_VAR bufp->buffer
556    # define OFFSET_ADDRESS_SIZE 2
557    # define PREFIX(name) byte_##name
558    # define ARG_PREFIX(name) name
559    # define PUT_CHAR(c) putchar (c)
560    #else
561    # ifdef WCHAR
562    #  define CHAR_T wchar_t
563    #  define UCHAR_T wchar_t
564    #  define COMPILED_BUFFER_VAR wc_buffer
565    #  define OFFSET_ADDRESS_SIZE 1 /* the size which STORE_NUMBER macro use */
566    #  define CHAR_CLASS_SIZE ((__alignof__(wctype_t)+sizeof(wctype_t))/sizeof(CHAR_T)+1)
567    #  define PREFIX(name) wcs_##name
568    #  define ARG_PREFIX(name) c##name
569    /* Should we use wide stream??  */
570    #  define PUT_CHAR(c) printf ("%C", c);
571    #  define TRUE 1
572    #  define FALSE 0
573    # else
574    #  ifdef MBS_SUPPORT
575    #   define WCHAR
576    #   define INSIDE_RECURSION
577    #   include "regex.c"
578    #   undef INSIDE_RECURSION
579    #  endif
580    #  define BYTE
581    #  define INSIDE_RECURSION
582    #  include "regex.c"
583    #  undef INSIDE_RECURSION
584    # endif
585    #endif
586    
587    #if USE_UNLOCKED_IO
588    # include "unlocked-io.h"
589    #endif
590    
591    #ifdef INSIDE_RECURSION
592  /* Common operations on the compiled pattern.  */  /* Common operations on the compiled pattern.  */
593    
594  /* Store NUMBER in two contiguous bytes starting at DESTINATION.  */  /* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
595    /* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
596    
597  #define STORE_NUMBER(destination, number)                               \  # ifdef WCHAR
598    #  define STORE_NUMBER(destination, number)                             \
599      do {                                                                  \
600        *(destination) = (UCHAR_T)(number);                         \
601      } while (0)
602    # else /* BYTE */
603    #  define STORE_NUMBER(destination, number)                             \
604    do {                                                                  \    do {                                                                  \
605      (destination)[0] = (number) & 0377;                                 \      (destination)[0] = (number) & 0377;                                 \
606      (destination)[1] = (number) >> 8;                                   \      (destination)[1] = (number) >> 8;                                   \
607    } while (0)    } while (0)
608    # endif /* WCHAR */
609    
610  /* Same as STORE_NUMBER, except increment DESTINATION to  /* Same as STORE_NUMBER, except increment DESTINATION to
611     the byte after where the number is stored.  Therefore, DESTINATION     the byte after where the number is stored.  Therefore, DESTINATION
612     must be an lvalue.  */     must be an lvalue.  */
613    /* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
614    
615  #define STORE_NUMBER_AND_INCR(destination, number)                      \  # define STORE_NUMBER_AND_INCR(destination, number)                     \
616    do {                                                                  \    do {                                                                  \
617      STORE_NUMBER (destination, number);                                 \      STORE_NUMBER (destination, number);                                 \
618      (destination) += 2;                                                 \      (destination) += OFFSET_ADDRESS_SIZE;                               \
619    } while (0)    } while (0)
620    
621  /* Put into DESTINATION a number stored in two contiguous bytes starting  /* Put into DESTINATION a number stored in two contiguous bytes starting
622     at SOURCE.  */     at SOURCE.  */
623    /* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
624    
625  #define EXTRACT_NUMBER(destination, source)                             \  # ifdef WCHAR
626    #  define EXTRACT_NUMBER(destination, source)                           \
627      do {                                                                  \
628        (destination) = *(source);                                          \
629      } while (0)
630    # else /* BYTE */
631    #  define EXTRACT_NUMBER(destination, source)                           \
632    do {                                                                  \    do {                                                                  \
633      (destination) = *(source) & 0377;                                   \      (destination) = *(source) & 0377;                                   \
634      (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8;           \      (destination) += (signed char) (*((source) + 1)) << 8;              \
635    } while (0)    } while (0)
636    # endif
637    
638  #ifdef DEBUG  # ifdef DEBUG
639  static void  static void
640  extract_number (dest, source)  PREFIX(extract_number) (int *dest, UCHAR_T *source)
     int *dest;  
     unsigned char *source;  
641  {  {
642    int temp = SIGN_EXTEND_CHAR (*(source + 1));  #  ifdef WCHAR
643      *dest = *source;
644    #  else /* BYTE */
645      signed char temp = source[1];
646    *dest = *source & 0377;    *dest = *source & 0377;
647    *dest += temp << 8;    *dest += temp << 8;
648    #  endif
649  }  }
650    
651  #ifndef EXTRACT_MACROS /* To debug the macros.  */  #  ifndef EXTRACT_MACROS /* To debug the macros.  */
652  #undef EXTRACT_NUMBER  #   undef EXTRACT_NUMBER
653  #define EXTRACT_NUMBER(dest, src) extract_number (&dest, src)  #   define EXTRACT_NUMBER(dest, src) PREFIX(extract_number) (&dest, src)
654  #endif /* not EXTRACT_MACROS */  #  endif /* not EXTRACT_MACROS */
655    
656  #endif /* DEBUG */  # endif /* DEBUG */
657    
658  /* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.  /* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
659     SOURCE must be an lvalue.  */     SOURCE must be an lvalue.  */
660    
661  #define EXTRACT_NUMBER_AND_INCR(destination, source)                    \  # define EXTRACT_NUMBER_AND_INCR(destination, source)                   \
662    do {                                                                  \    do {                                                                  \
663      EXTRACT_NUMBER (destination, source);                               \      EXTRACT_NUMBER (destination, source);                               \
664      (source) += 2;                                                      \      (source) += OFFSET_ADDRESS_SIZE;                                    \
665    } while (0)    } while (0)
666    
667  #ifdef DEBUG  # ifdef DEBUG
668  static void  static void
669  extract_number_and_incr (destination, source)  PREFIX(extract_number_and_incr) (int *destination, UCHAR_T **source)
670      int *destination;  {
671      unsigned char **source;    PREFIX(extract_number) (destination, *source);
672  {    *source += OFFSET_ADDRESS_SIZE;
   extract_number (destination, *source);  
   *source += 2;  
673  }  }
674    
675  #ifndef EXTRACT_MACROS  #  ifndef EXTRACT_MACROS
676  #undef EXTRACT_NUMBER_AND_INCR  #   undef EXTRACT_NUMBER_AND_INCR
677  #define EXTRACT_NUMBER_AND_INCR(dest, src) \  #   define EXTRACT_NUMBER_AND_INCR(dest, src) \
678    extract_number_and_incr (&dest, &src)    PREFIX(extract_number_and_incr) (&dest, &src)
679  #endif /* not EXTRACT_MACROS */  #  endif /* not EXTRACT_MACROS */
680    
681    # endif /* DEBUG */
682    
 #endif /* DEBUG */  
683    
684    
685  /* If DEBUG is defined, Regex prints many voluminous messages about what  /* If DEBUG is defined, Regex prints many voluminous messages about what
686     it is doing (if the variable `debug' is nonzero).  If linked with the     it is doing (if the variable `debug' is nonzero).  If linked with the
687     main program in `iregex.c', you can enter patterns and strings     main program in `iregex.c', you can enter patterns and strings
688     interactively.  And if linked with the main program in `main.c' and     interactively.  And if linked with the main program in `main.c' and
689     the other test files, you can run the already-written tests.  */     the other test files, you can run the already-written tests.  */
690    
691  #ifdef DEBUG  # ifdef DEBUG
692    
693    #  ifndef DEFINED_ONCE
694    
695  /* We use standard I/O for debugging.  */  /* We use standard I/O for debugging.  */
696  #include <stdio.h>  #   include <stdio.h>
697    
698  /* It is useful to test things that ``must'' be true when debugging.  */  /* It is useful to test things that ``must'' be true when debugging.  */
699  #include <assert.h>  #   include <assert.h>
   
 static int debug = 0;  
700    
701  #define DEBUG_STATEMENT(e) e  static int debug;
 #define DEBUG_PRINT1(x) if (debug) printf (x)  
 #define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)  
 #define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)  
 #define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)  
 #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)                           \  
   if (debug) print_partial_compiled_pattern (s, e)  
 #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)                  \  
   if (debug) print_double_string (w, s1, sz1, s2, sz2)  
702    
703    #   define DEBUG_STATEMENT(e) e
704    #   define DEBUG_PRINT1(x) if (debug) printf (x)
705    #   define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)
706    #   define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)
707    #   define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
708    #  endif /* not DEFINED_ONCE */
709    
710    #  define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)                         \
711      if (debug) PREFIX(print_partial_compiled_pattern) (s, e)
712    #  define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)                \
713      if (debug) PREFIX(print_double_string) (w, s1, sz1, s2, sz2)
714    
 extern void printchar ();  
715    
716  /* Print the fastmap in human-readable form.  */  /* Print the fastmap in human-readable form.  */
717    
718    #  ifndef DEFINED_ONCE
719  void  void
720  print_fastmap (fastmap)  print_fastmap (char *fastmap)
     char *fastmap;  
721  {  {
722    unsigned was_a_range = 0;    unsigned was_a_range = 0;
723    unsigned i = 0;      unsigned i = 0;
724      
725    while (i < (1 << BYTEWIDTH))    while (i < (1 << BYTEWIDTH))
726      {      {
727        if (fastmap[i++])        if (fastmap[i++])
728          {          {
729            was_a_range = 0;            was_a_range = 0;
730            printchar (i - 1);            putchar (i - 1);
731            while (i < (1 << BYTEWIDTH)  &&  fastmap[i])            while (i < (1 << BYTEWIDTH)  &&  fastmap[i])
732              {              {
733                was_a_range = 1;                was_a_range = 1;
# Line 520  print_fastmap (fastmap) Line 736  print_fastmap (fastmap)
736            if (was_a_range)            if (was_a_range)
737              {              {
738                printf ("-");                printf ("-");
739                printchar (i - 1);                putchar (i - 1);
740              }              }
741          }          }
742      }      }
743    putchar ('\n');    putchar ('\n');
744  }  }
745    #  endif /* not DEFINED_ONCE */
746    
747    
748  /* Print a compiled pattern string in human-readable form, starting at  /* Print a compiled pattern string in human-readable form, starting at
749     the START pointer into it and ending just before the pointer END.  */     the START pointer into it and ending just before the pointer END.  */
750    
751  void  void
752  print_partial_compiled_pattern (start, end)  PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end)
     unsigned char *start;  
     unsigned char *end;  
753  {  {
754    int mcnt, mcnt2;    int mcnt, mcnt2;
755    unsigned char *p = start;    UCHAR_T *p1;
756    unsigned char *pend = end;    UCHAR_T *p = start;
757      UCHAR_T *pend = end;
758    
759    if (start == NULL)    if (start == NULL)
760      {      {
761        printf ("(null)\n");        printf ("(null)\n");
762        return;        return;
763      }      }
764        
765    /* Loop over pattern commands.  */    /* Loop over pattern commands.  */
766    while (p < pend)    while (p < pend)
767      {      {
768        printf ("%d:\t", p - start);  #  ifdef _LIBC
769          printf ("%td:\t", p - start);
770    #  else
771          printf ("%ld:\t", (long int) (p - start));
772    #  endif
773    
774        switch ((re_opcode_t) *p++)        switch ((re_opcode_t) *p++)
775          {          {
# Line 563  print_partial_compiled_pattern (start, e Line 783  print_partial_compiled_pattern (start, e
783            do            do
784              {              {
785                putchar ('/');                putchar ('/');
786                printchar (*p++);                PUT_CHAR (*p++);
787              }              }
788            while (--mcnt);            while (--mcnt);
789            break;            break;
790    
791    #  ifdef MBS_SUPPORT
792            case exactn_bin:
793              mcnt = *p++;
794              printf ("/exactn_bin/%d", mcnt);
795              do
796                {
797                  printf("/%lx", (long int) *p++);
798                }
799              while (--mcnt);
800              break;
801    #  endif /* MBS_SUPPORT */
802    
803          case start_memory:          case start_memory:
804            mcnt = *p++;            mcnt = *p++;
805            printf ("/start_memory/%d/%d", mcnt, *p++);            printf ("/start_memory/%d/%ld", mcnt, (long int) *p++);
806            break;            break;
807    
808          case stop_memory:          case stop_memory:
809            mcnt = *p++;            mcnt = *p++;
810            printf ("/stop_memory/%d/%d", mcnt, *p++);            printf ("/stop_memory/%d/%ld", mcnt, (long int) *p++);
811            break;            break;
812    
813          case duplicate:          case duplicate:
814            printf ("/duplicate/%d", *p++);            printf ("/duplicate/%ld", (long int) *p++);
815            break;            break;
816    
817          case anychar:          case anychar:
# Line 589  print_partial_compiled_pattern (start, e Line 821  print_partial_compiled_pattern (start, e
821          case charset:          case charset:
822          case charset_not:          case charset_not:
823            {            {
824    #  ifdef WCHAR
825                int i, length;
826                wchar_t *workp = p;
827                printf ("/charset [%s",
828                        (re_opcode_t) *(workp - 1) == charset_not ? "^" : "");
829                p += 5;
830                length = *workp++; /* the length of char_classes */
831                for (i=0 ; i<length ; i++)
832                  printf("[:%lx:]", (long int) *p++);
833                length = *workp++; /* the length of collating_symbol */
834                for (i=0 ; i<length ;)
835                  {
836                    printf("[.");
837                    while(*p != 0)
838                      PUT_CHAR((i++,*p++));
839                    i++,p++;
840                    printf(".]");
841                  }
842                length = *workp++; /* the length of equivalence_class */
843                for (i=0 ; i<length ;)
844                  {
845                    printf("[=");
846                    while(*p != 0)
847                      PUT_CHAR((i++,*p++));
848                    i++,p++;
849                    printf("=]");
850                  }
851                length = *workp++; /* the length of char_range */
852                for (i=0 ; i<length ; i++)
853                  {
854                    wchar_t range_start = *p++;
855                    wchar_t range_end = *p++;
856                    printf("%C-%C", range_start, range_end);
857                  }
858                length = *workp++; /* the length of char */
859                for (i=0 ; i<length ; i++)
860                  printf("%C", *p++);
861                putchar (']');
862    #  else
863              register int c, last = -100;              register int c, last = -100;
864              register int in_range = 0;              register int in_range = 0;
865    
866              printf ("/charset [%s",              printf ("/charset [%s",
867                      (re_opcode_t) *(p - 1) == charset_not ? "^" : "");                      (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
868                
869              assert (p + *p < pend);              assert (p + *p < pend);
870    
871              for (c = 0; c < 256; c++)              for (c = 0; c < 256; c++)
# Line 610  print_partial_compiled_pattern (start, e Line 881  print_partial_compiled_pattern (start, e
881                    /* Have we broken a range?  */                    /* Have we broken a range?  */
882                    else if (last + 1 != c && in_range)                    else if (last + 1 != c && in_range)
883                {                {
884                        printchar (last);                        putchar (last);
885                        in_range = 0;                        in_range = 0;
886                      }                      }
887                    
888                    if (! in_range)                    if (! in_range)
889                      printchar (c);                      putchar (c);
890    
891                    last = c;                    last = c;
892                }                }
893    
894              if (in_range)              if (in_range)
895                printchar (last);                putchar (last);
896    
897              putchar (']');              putchar (']');
898    
899              p += 1 + *p;              p += 1 + *p;
900    #  endif /* WCHAR */
901            }            }
902            break;            break;
903    
# Line 638  print_partial_compiled_pattern (start, e Line 910  print_partial_compiled_pattern (start, e
910            break;            break;
911    
912          case on_failure_jump:          case on_failure_jump:
913            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
914            printf ("/on_failure_jump to %d", p + mcnt - start);  #  ifdef _LIBC
915              printf ("/on_failure_jump to %td", p + mcnt - start);
916    #  else
917              printf ("/on_failure_jump to %ld", (long int) (p + mcnt - start));
918    #  endif
919            break;            break;
920    
921          case on_failure_keep_string_jump:          case on_failure_keep_string_jump:
922            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
923            printf ("/on_failure_keep_string_jump to %d", p + mcnt - start);  #  ifdef _LIBC
924              printf ("/on_failure_keep_string_jump to %td", p + mcnt - start);
925    #  else
926              printf ("/on_failure_keep_string_jump to %ld",
927                      (long int) (p + mcnt - start));
928    #  endif
929            break;            break;
930    
931          case dummy_failure_jump:          case dummy_failure_jump:
932            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
933            printf ("/dummy_failure_jump to %d", p + mcnt - start);  #  ifdef _LIBC
934              printf ("/dummy_failure_jump to %td", p + mcnt - start);
935    #  else
936              printf ("/dummy_failure_jump to %ld", (long int) (p + mcnt - start));
937    #  endif
938            break;            break;
939    
940          case push_dummy_failure:          case push_dummy_failure:
941            printf ("/push_dummy_failure");            printf ("/push_dummy_failure");
942            break;            break;
943              
944          case maybe_pop_jump:          case maybe_pop_jump:
945            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
946            printf ("/maybe_pop_jump to %d", p + mcnt - start);  #  ifdef _LIBC
947              printf ("/maybe_pop_jump to %td", p + mcnt - start);
948    #  else
949              printf ("/maybe_pop_jump to %ld", (long int) (p + mcnt - start));
950    #  endif
951            break;            break;
952    
953          case pop_failure_jump:          case pop_failure_jump:
954            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
955            printf ("/pop_failure_jump to %d", p + mcnt - start);  #  ifdef _LIBC
956            break;                      printf ("/pop_failure_jump to %td", p + mcnt - start);
957              #  else
958              printf ("/pop_failure_jump to %ld", (long int) (p + mcnt - start));
959    #  endif
960              break;
961    
962          case jump_past_alt:          case jump_past_alt:
963            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
964            printf ("/jump_past_alt to %d", p + mcnt - start);  #  ifdef _LIBC
965            break;                      printf ("/jump_past_alt to %td", p + mcnt - start);
966              #  else
967              printf ("/jump_past_alt to %ld", (long int) (p + mcnt - start));
968    #  endif
969              break;
970    
971          case jump:          case jump:
972            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
973            printf ("/jump to %d", p + mcnt - start);  #  ifdef _LIBC
974              printf ("/jump to %td", p + mcnt - start);
975    #  else
976              printf ("/jump to %ld", (long int) (p + mcnt - start));
977    #  endif
978            break;            break;
979    
980          case succeed_n:          case succeed_n:
981            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
982            extract_number_and_incr (&mcnt2, &p);            p1 = p + mcnt;
983            printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2);            PREFIX(extract_number_and_incr) (&mcnt2, &p);
984    #  ifdef _LIBC
985              printf ("/succeed_n to %td, %d times", p1 - start, mcnt2);
986    #  else
987              printf ("/succeed_n to %ld, %d times",
988                      (long int) (p1 - start), mcnt2);
989    #  endif
990            break;            break;
991            
992          case jump_n:          case jump_n:
993            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
994            extract_number_and_incr (&mcnt2, &p);            p1 = p + mcnt;
995            printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2);            PREFIX(extract_number_and_incr) (&mcnt2, &p);
996              printf ("/jump_n to %d, %d times", p1 - start, mcnt2);
997            break;            break;
998            
999          case set_number_at:          case set_number_at:
1000            extract_number_and_incr (&mcnt, &p);            PREFIX(extract_number_and_incr) (&mcnt, &p);
1001            extract_number_and_incr (&mcnt2, &p);            p1 = p + mcnt;
1002            printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2);            PREFIX(extract_number_and_incr) (&mcnt2, &p);
1003    #  ifdef _LIBC
1004              printf ("/set_number_at location %td to %d", p1 - start, mcnt2);
1005    #  else
1006              printf ("/set_number_at location %ld to %d",
1007                      (long int) (p1 - start), mcnt2);
1008    #  endif
1009            break;            break;
1010            
1011          case wordbound:          case wordbound:
1012            printf ("/wordbound");            printf ("/wordbound");
1013            break;            break;
# Line 705  print_partial_compiled_pattern (start, e Line 1019  print_partial_compiled_pattern (start, e
1019          case wordbeg:          case wordbeg:
1020            printf ("/wordbeg");            printf ("/wordbeg");
1021            break;            break;
1022              
1023          case wordend:          case wordend:
1024            printf ("/wordend");            printf ("/wordend");
1025                        break;
1026  #ifdef emacs  
1027    #  ifdef emacs
1028          case before_dot:          case before_dot:
1029            printf ("/before_dot");            printf ("/before_dot");
1030            break;            break;
# Line 727  print_partial_compiled_pattern (start, e Line 1042  print_partial_compiled_pattern (start, e
1042            mcnt = *p++;            mcnt = *p++;
1043            printf ("/%d", mcnt);            printf ("/%d", mcnt);
1044            break;            break;
1045              
1046          case notsyntaxspec:          case notsyntaxspec:
1047            printf ("/notsyntaxspec");            printf ("/notsyntaxspec");
1048            mcnt = *p++;            mcnt = *p++;
1049            printf ("/%d", mcnt);            printf ("/%d", mcnt);
1050            break;            break;
1051  #endif /* emacs */  #  endif /* emacs */
1052    
1053          case wordchar:          case wordchar:
1054            printf ("/wordchar");            printf ("/wordchar");
1055            break;            break;
1056              
1057          case notwordchar:          case notwordchar:
1058            printf ("/notwordchar");            printf ("/notwordchar");
1059            break;            break;
# Line 752  print_partial_compiled_pattern (start, e Line 1067  print_partial_compiled_pattern (start, e
1067            break;            break;
1068    
1069          default:          default:
1070            printf ("?%d", *(p-1));            printf ("?%ld", (long int) *(p-1));
1071          }          }
1072    
1073        putchar ('\n');        putchar ('\n');
1074      }      }
1075    
1076    printf ("%d:\tend of pattern.\n", p - start);  #  ifdef _LIBC
1077      printf ("%td:\tend of pattern.\n", p - start);
1078    #  else
1079      printf ("%ld:\tend of pattern.\n", (long int) (p - start));
1080    #  endif
1081  }  }
1082    
1083    
1084  void  void
1085  print_compiled_pattern (bufp)  PREFIX(print_compiled_pattern) (struct re_pattern_buffer *bufp)
     struct re_pattern_buffer *bufp;  
1086  {  {
1087    unsigned char *buffer = bufp->buffer;    UCHAR_T *buffer = (UCHAR_T*) bufp->buffer;
1088    
1089    print_partial_compiled_pattern (buffer, buffer + bufp->used);    PREFIX(print_partial_compiled_pattern) (buffer, buffer
1090    printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated);                                    + bufp->used / sizeof(UCHAR_T));
1091      printf ("%ld bytes used/%ld bytes allocated.\n",
1092              bufp->used, bufp->allocated);
1093    
1094    if (bufp->fastmap_accurate && bufp->fastmap)    if (bufp->fastmap_accurate && bufp->fastmap)
1095      {      {
# Line 777  print_compiled_pattern (bufp) Line 1097  print_compiled_pattern (bufp)
1097        print_fastmap (bufp->fastmap);        print_fastmap (bufp->fastmap);
1098      }      }
1099    
1100    printf ("re_nsub: %d\t", bufp->re_nsub);  #  ifdef _LIBC
1101      printf ("re_nsub: %Zd\t", bufp->re_nsub);
1102    #  else
1103      printf ("re_nsub: %ld\t", (long int) bufp->re_nsub);
1104    #  endif
1105    printf ("regs_alloc: %d\t", bufp->regs_allocated);    printf ("regs_alloc: %d\t", bufp->regs_allocated);
1106    printf ("can_be_null: %d\t", bufp->can_be_null);    printf ("can_be_null: %d\t", bufp->can_be_null);
1107    printf ("newline_anchor: %d\n", bufp->newline_anchor);    printf ("newline_anchor: %d\n", bufp->newline_anchor);
1108    printf ("no_sub: %d\t", bufp->no_sub);    printf ("no_sub: %d\t", bufp->no_sub);
1109    printf ("not_bol: %d\t", bufp->not_bol);    printf ("not_bol: %d\t", bufp->not_bol);
1110    printf ("not_eol: %d\t", bufp->not_eol);    printf ("not_eol: %d\t", bufp->not_eol);
1111    printf ("syntax: %d\n", bufp->syntax);    printf ("syntax: %lx\n", bufp->syntax);
1112    /* Perhaps we should print the translate table?  */    /* Perhaps we should print the translate table?  */
1113  }  }
1114    
1115    
1116  void  void
1117  print_double_string (where, string1, size1, string2, size2)  PREFIX(print_double_string) (const CHAR_T *where,
1118      const char *where;                               const CHAR_T *string1,
1119      const char *string1;                               const CHAR_T *string2,
1120      const char *string2;                               int size1,
1121      int size1;                               int size2)
     int size2;  
1122  {  {
1123    unsigned this_char;    int this_char;
1124      
1125    if (where == NULL)    if (where == NULL)
1126      printf ("(null)");      printf ("(null)");
1127    else    else
1128      {      {
1129          int cnt;
1130    
1131        if (FIRST_STRING_P (where))        if (FIRST_STRING_P (where))
1132          {          {
1133            for (this_char = where - string1; this_char < size1; this_char++)            for (this_char = where - string1; this_char < size1; this_char++)
1134              printchar (string1[this_char]);              PUT_CHAR (string1[this_char]);
1135    
1136            where = string2;                where = string2;
1137          }          }
1138    
1139          cnt = 0;
1140        for (this_char = where - string2; this_char < size2; this_char++)        for (this_char = where - string2; this_char < size2; this_char++)
1141          printchar (string2[this_char]);          {
1142              PUT_CHAR (string2[this_char]);
1143              if (++cnt > 100)
1144                {
1145                  fputs ("...", stdout);
1146                  break;
1147                }
1148            }
1149      }      }
1150  }  }
1151    
1152  #else /* not DEBUG */  #  ifndef DEFINED_ONCE
1153    void
1154    printchar (c)
1155         int c;
1156    {
1157      putc (c, stderr);
1158    }
1159    #  endif
1160    
1161  #undef assert  # else /* not DEBUG */
 #define assert(e)  
1162    
1163  #define DEBUG_STATEMENT(e)  #  ifndef DEFINED_ONCE
1164  #define DEBUG_PRINT1(x)  #   undef assert
1165  #define DEBUG_PRINT2(x1, x2)  #   define assert(e)
1166  #define DEBUG_PRINT3(x1, x2, x3)  
1167  #define DEBUG_PRINT4(x1, x2, x3, x4)  #   define DEBUG_STATEMENT(e)
1168  #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)  #   define DEBUG_PRINT1(x)
1169  #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)  #   define DEBUG_PRINT2(x1, x2)
1170    #   define DEBUG_PRINT3(x1, x2, x3)
1171    #   define DEBUG_PRINT4(x1, x2, x3, x4)
1172    #  endif /* not DEFINED_ONCE */
1173    #  define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
1174    #  define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
1175    
1176    # endif /* not DEBUG */
1177    
 #endif /* not DEBUG */  
1178    
1179    
1180    # ifdef WCHAR
1181    /* This  convert a multibyte string to a wide character string.
1182       And write their correspondances to offset_buffer(see below)
1183       and write whether each wchar_t is binary data to is_binary.
1184       This assume invalid multibyte sequences as binary data.
1185       We assume offset_buffer and is_binary is already allocated
1186       enough space.  */
1187    
1188    static size_t
1189    convert_mbs_to_wcs (CHAR_T *dest,
1190                        const unsigned char* src,
1191    
1192                        /* The length of multibyte string.  */
1193                        size_t len,
1194    
1195                        /* Correspondences between src(char string) and
1196                           dest(wchar_t string) for optimization.  E.g.:
1197                           src  = "xxxyzz"
1198                           dest = {'X', 'Y', 'Z'}
1199                             (each "xxx", "y" and "zz" represent one
1200                              multibyte character corresponding to 'X',
1201                              'Y' and 'Z'.)
1202                           offset_buffer = {0, 0+3("xxx"), 0+3+1("y"),
1203                                            0+3+1+2("zz")}
1204                                         = {0, 3, 4, 6} */
1205                        int *offset_buffer,
1206    
1207                        char *is_binary)
1208    {
1209      wchar_t *pdest = dest;
1210      const unsigned char *psrc = src;
1211      size_t wc_count = 0;
1212    
1213      mbstate_t mbs;
1214      int i, consumed;
1215      size_t mb_remain = len;
1216      size_t mb_count = 0;
1217    
1218      /* Initialize the conversion state.  */
1219      memset (&mbs, 0, sizeof (mbstate_t));
1220    
1221      offset_buffer[0] = 0;
1222      for( ; mb_remain > 0 ; ++wc_count, ++pdest, mb_remain -= consumed,
1223             psrc += consumed)
1224        {
1225          consumed = mbrtowc (pdest, psrc, mb_remain, &mbs);
1226    
1227          if (consumed <= 0)
1228            /* failed to convert. maybe src contains binary data.
1229               So we consume 1 byte manualy.  */
1230            {
1231              *pdest = *psrc;
1232              consumed = 1;
1233              is_binary[wc_count] = TRUE;
1234            }
1235          else
1236            is_binary[wc_count] = FALSE;
1237          /* In sjis encoding, we use yen sign as escape character in
1238             place of reverse solidus. So we convert 0x5c(yen sign in
1239             sjis) to not 0xa5(yen sign in UCS2) but 0x5c(reverse
1240             solidus in UCS2).  */
1241          if (consumed == 1 && (int) *psrc == 0x5c && (int) *pdest == 0xa5)
1242            *pdest = (wchar_t) *psrc;
1243    
1244          offset_buffer[wc_count + 1] = mb_count += consumed;
1245        }
1246    
1247      /* Fill remain of the buffer with sentinel.  */
1248      for (i = wc_count + 1 ; i <= len ; i++)
1249        offset_buffer[i] = mb_count + 1;
1250    
1251      return wc_count;
1252    }
1253    
1254    # endif /* WCHAR */
1255    
1256    #else /* not INSIDE_RECURSION */
1257    
1258  /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can  /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
1259     also be assigned to arbitrarily: each pattern buffer stores its own     also be assigned to arbitrarily: each pattern buffer stores its own
1260     syntax, so it can be changed between regex compilations.  */     syntax, so it can be changed between regex compilations.  */
1261  reg_syntax_t re_syntax_options = RE_SYNTAX_EMACS;  /* This has no initializer because initialized variables in Emacs
1262       become read-only after dumping.  */
1263    reg_syntax_t re_syntax_options;
1264    
1265    
1266  /* Specify the precise syntax of regexps for compilation.  This provides  /* Specify the precise syntax of regexps for compilation.  This provides
# Line 845  reg_syntax_t re_syntax_options = RE_SYNT Line 1271  reg_syntax_t re_syntax_options = RE_SYNT
1271     defined in regex.h.  We return the old syntax.  */     defined in regex.h.  We return the old syntax.  */
1272    
1273  reg_syntax_t  reg_syntax_t
1274  re_set_syntax (syntax)  re_set_syntax (reg_syntax_t syntax)
     reg_syntax_t syntax;  
1275  {  {
1276    reg_syntax_t ret = re_syntax_options;    reg_syntax_t ret = re_syntax_options;
1277      
1278    re_syntax_options = syntax;    re_syntax_options = syntax;
1279    # ifdef DEBUG
1280      if (syntax & RE_DEBUG)
1281        debug = 1;
1282      else if (debug) /* was on but now is not */
1283        debug = 0;
1284    # endif /* DEBUG */
1285    return ret;    return ret;
1286  }  }
1287    # ifdef _LIBC
1288    weak_alias (__re_set_syntax, re_set_syntax)
1289    # endif
1290    
1291  /* This table gives an error message for each of the error codes listed  /* This table gives an error message for each of the error codes listed
1292     in regex.h.  Obviously the order here has to be same as there.  */     in regex.h.  Obviously the order here has to be same as there.
1293       POSIX doesn't require that we do anything for REG_NOERROR,
1294       but why not be nice?  */
1295    
1296  static const char *re_error_msg[] =  static const char re_error_msgid[] =
1297    { NULL,                                       /* REG_NOERROR */    {
1298      "No match",                                 /* REG_NOMATCH */  # define REG_NOERROR_IDX        0
1299      "Invalid regular expression",               /* REG_BADPAT */      gettext_noop ("Success")    /* REG_NOERROR */
1300      "Invalid collation character",              /* REG_ECOLLATE */      "\0"
1301      "Invalid character class name",             /* REG_ECTYPE */  # define REG_NOMATCH_IDX (REG_NOERROR_IDX + sizeof "Success")
1302      "Trailing backslash",                       /* REG_EESCAPE */      gettext_noop ("No match")   /* REG_NOMATCH */
1303      "Invalid back reference",                   /* REG_ESUBREG */      "\0"
1304      "Unmatched [ or [^",                        /* REG_EBRACK */  # define REG_BADPAT_IDX (REG_NOMATCH_IDX + sizeof "No match")
1305      "Unmatched ( or \\(",                       /* REG_EPAREN */      gettext_noop ("Invalid regular expression") /* REG_BADPAT */
1306      "Unmatched \\{",                            /* REG_EBRACE */      "\0"
1307      "Invalid content of \\{\\}",                /* REG_BADBR */  # define REG_ECOLLATE_IDX (REG_BADPAT_IDX + sizeof "Invalid regular expression")
1308      "Invalid range end",                        /* REG_ERANGE */      gettext_noop ("Invalid collation character") /* REG_ECOLLATE */
1309      "Memory exhausted",                         /* REG_ESPACE */      "\0"
1310      "Invalid preceding regular expression",     /* REG_BADRPT */  # define REG_ECTYPE_IDX (REG_ECOLLATE_IDX + sizeof "Invalid collation character")
1311      "Premature end of regular expression",      /* REG_EEND */      gettext_noop ("Invalid character class name") /* REG_ECTYPE */
1312      "Regular expression too big",               /* REG_ESIZE */      "\0"
1313      "Unmatched ) or \\)",                       /* REG_ERPAREN */  # define REG_EESCAPE_IDX        (REG_ECTYPE_IDX + sizeof "Invalid character class name")
1314        gettext_noop ("Trailing backslash") /* REG_EESCAPE */
1315        "\0"
1316    # define REG_ESUBREG_IDX        (REG_EESCAPE_IDX + sizeof "Trailing backslash")
1317        gettext_noop ("Invalid back reference") /* REG_ESUBREG */
1318        "\0"
1319    # define REG_EBRACK_IDX (REG_ESUBREG_IDX + sizeof "Invalid back reference")
1320        gettext_noop ("Unmatched [ or [^")  /* REG_EBRACK */
1321        "\0"
1322    # define REG_EPAREN_IDX (REG_EBRACK_IDX + sizeof "Unmatched [ or [^")
1323        gettext_noop ("Unmatched ( or \\(") /* REG_EPAREN */
1324        "\0"
1325    # define REG_EBRACE_IDX (REG_EPAREN_IDX + sizeof "Unmatched ( or \\(")
1326        gettext_noop ("Unmatched \\{") /* REG_EBRACE */
1327        "\0"
1328    # define REG_BADBR_IDX  (REG_EBRACE_IDX + sizeof "Unmatched \\{")
1329        gettext_noop ("Invalid content of \\{\\}") /* REG_BADBR */
1330        "\0"
1331    # define REG_ERANGE_IDX (REG_BADBR_IDX + sizeof "Invalid content of \\{\\}")
1332        gettext_noop ("Invalid range end")  /* REG_ERANGE */
1333        "\0"
1334    # define REG_ESPACE_IDX (REG_ERANGE_IDX + sizeof "Invalid range end")
1335        gettext_noop ("Memory exhausted") /* REG_ESPACE */
1336        "\0"
1337    # define REG_BADRPT_IDX (REG_ESPACE_IDX + sizeof "Memory exhausted")
1338        gettext_noop ("Invalid preceding regular expression") /* REG_BADRPT */
1339        "\0"
1340    # define REG_EEND_IDX   (REG_BADRPT_IDX + sizeof "Invalid preceding regular expression")
1341        gettext_noop ("Premature end of regular expression") /* REG_EEND */
1342        "\0"
1343    # define REG_ESIZE_IDX  (REG_EEND_IDX + sizeof "Premature end of regular expression")
1344        gettext_noop ("Regular expression too big") /* REG_ESIZE */
1345        "\0"
1346    # define REG_ERPAREN_IDX        (REG_ESIZE_IDX + sizeof "Regular expression too big")
1347        gettext_noop ("Unmatched ) or \\)") /* REG_ERPAREN */
1348      };
1349    
1350    static const size_t re_error_msgid_idx[] =
1351      {
1352        REG_NOERROR_IDX,
1353        REG_NOMATCH_IDX,
1354        REG_BADPAT_IDX,
1355        REG_ECOLLATE_IDX,
1356        REG_ECTYPE_IDX,
1357        REG_EESCAPE_IDX,
1358        REG_ESUBREG_IDX,
1359        REG_EBRACK_IDX,
1360        REG_EPAREN_IDX,
1361        REG_EBRACE_IDX,
1362        REG_BADBR_IDX,
1363        REG_ERANGE_IDX,
1364        REG_ESPACE_IDX,
1365        REG_BADRPT_IDX,
1366        REG_EEND_IDX,
1367        REG_ESIZE_IDX,
1368        REG_ERPAREN_IDX
1369    };    };
1370    
1371    #endif /* INSIDE_RECURSION */
1372    
1373    #ifndef DEFINED_ONCE
1374  /* Avoiding alloca during matching, to placate r_alloc.  */  /* Avoiding alloca during matching, to placate r_alloc.  */
1375    
1376  /* Define MATCH_MAY_ALLOCATE unless we need to make sure that the  /* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
# Line 887  static const char *re_error_msg[] = Line 1381  static const char *re_error_msg[] =
1381     ralloc heap) shift the data out from underneath the regexp     ralloc heap) shift the data out from underneath the regexp
1382     routines.     routines.
1383    
1384     Here's another reason to avoid allocation: Emacs     Here's another reason to avoid allocation: Emacs
1385     processes input from X in a signal handler; processing X input may     processes input from X in a signal handler; processing X input may
1386     call malloc; if input arrives while a matching routine is calling     call malloc; if input arrives while a matching routine is calling
1387     malloc, then we're scrod.  But Emacs can't just block input while     malloc, then we're scrod.  But Emacs can't just block input while
# Line 897  static const char *re_error_msg[] = Line 1391  static const char *re_error_msg[] =
1391     faith that they will not malloc.  */     faith that they will not malloc.  */
1392    
1393  /* Normally, this is fine.  */  /* Normally, this is fine.  */
1394  #define MATCH_MAY_ALLOCATE  # define MATCH_MAY_ALLOCATE
1395    
1396  /* The match routines may not allocate if (1) they would do it with malloc  /* When using GNU C, we are not REALLY using the C alloca, no matter
1397     and (2) it's not safe for them to use malloc.  */     what config.h may say.  So don't take precautions for it.  */
1398  #if (defined (C_ALLOCA) || defined (REGEX_MALLOC)) && (defined (emacs) || defined (REL_ALLOC))  # ifdef __GNUC__
1399  #undef MATCH_MAY_ALLOCATE  #  undef C_ALLOCA
1400  #endif  # endif
1401    
1402    /* The match routines may not allocate if (1) they would do it with malloc
1403       and (2) it's not safe for them to use malloc.
1404       Note that if REL_ALLOC is defined, matching would not use malloc for the
1405       failure stack, but we would still use it for the register vectors;
1406       so REL_ALLOC should not affect this.  */
1407    # if (defined C_ALLOCA || defined REGEX_MALLOC) && defined emacs
1408    #  undef MATCH_MAY_ALLOCATE
1409    # endif
1410    #endif /* not DEFINED_ONCE */
1411    
1412    #ifdef INSIDE_RECURSION
1413  /* Failure stack declarations and macros; both re_compile_fastmap and  /* Failure stack declarations and macros; both re_compile_fastmap and
1414     re_match_2 use a failure stack.  These have to be macros because of     re_match_2 use a failure stack.  These have to be macros because of
1415     REGEX_ALLOCATE.  */     REGEX_ALLOCATE_STACK.  */
1416      
1417    
1418  /* Number of failure points for which to initially allocate space  /* Number of failure points for which to initially allocate space
1419     when matching.  If this number is exceeded, we allocate more     when matching.  If this number is exceeded, we allocate more
1420     space, so it is not a hard limit.  */     space, so it is not a hard limit.  */
1421  #ifndef INIT_FAILURE_ALLOC  # ifndef INIT_FAILURE_ALLOC
1422  #define INIT_FAILURE_ALLOC 5  #  define INIT_FAILURE_ALLOC 5
1423  #endif  # endif
1424    
1425  /* Roughly the maximum number of failure points on the stack.  Would be  /* Roughly the maximum number of failure points on the stack.  Would be
1426     exactly that if always used MAX_FAILURE_SPACE each time we failed.     exactly that if always used MAX_FAILURE_ITEMS items each time we failed.
1427     This is a variable only so users of regex can assign to it; we never     This is a variable only so users of regex can assign to it; we never
1428     change it ourselves.  */     change it ourselves.  */
1429    
1430    # ifdef INT_IS_16BIT
1431    
1432    #  ifndef DEFINED_ONCE
1433    #   if defined MATCH_MAY_ALLOCATE
1434    /* 4400 was enough to cause a crash on Alpha OSF/1,
1435       whose default stack limit is 2mb.  */
1436    long int re_max_failures = 4000;
1437    #   else
1438    long int re_max_failures = 2000;
1439    #   endif
1440    #  endif
1441    
1442    union PREFIX(fail_stack_elt)
1443    {
1444      UCHAR_T *pointer;
1445      long int integer;
1446    };
1447    
1448    typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
1449    
1450    typedef struct
1451    {
1452      PREFIX(fail_stack_elt_t) *stack;
1453      unsigned long int size;
1454      unsigned long int avail;              /* Offset of next open position.  */
1455    } PREFIX(fail_stack_type);
1456    
1457    # else /* not INT_IS_16BIT */
1458    
1459    #  ifndef DEFINED_ONCE
1460    #   if defined MATCH_MAY_ALLOCATE
1461    /* 4400 was enough to cause a crash on Alpha OSF/1,
1462       whose default stack limit is 2mb.  */
1463    int re_max_failures = 4000;
1464    #   else
1465  int re_max_failures = 2000;  int re_max_failures = 2000;
1466    #   endif
1467    #  endif
1468    
1469  typedef unsigned char *fail_stack_elt_t;  union PREFIX(fail_stack_elt)
1470    {
1471      UCHAR_T *pointer;
1472      int integer;
1473    };
1474    
1475    typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
1476    
1477  typedef struct  typedef struct
1478  {  {
1479    fail_stack_elt_t *stack;    PREFIX(fail_stack_elt_t) *stack;
1480    unsigned size;    unsigned size;
1481    unsigned avail;                       /* Offset of next open position.  */    unsigned avail;                       /* Offset of next open position.  */
1482  } fail_stack_type;  } PREFIX(fail_stack_type);
1483    
1484  #define FAIL_STACK_EMPTY()     (fail_stack.avail == 0)  # endif /* INT_IS_16BIT */
 #define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)  
 #define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)  
 #define FAIL_STACK_TOP()       (fail_stack.stack[fail_stack.avail])  
1485    
1486    # ifndef DEFINED_ONCE
1487    #  define FAIL_STACK_EMPTY()     (fail_stack.avail == 0)
1488    #  define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)
1489    #  define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)
1490    # endif
1491    
 /* Initialize `fail_stack'.  Do `return -2' if the alloc fails.  */  
1492    
1493  #ifdef MATCH_MAY_ALLOCATE  /* Define macros to initialize and free the failure stack.
1494  #define INIT_FAIL_STACK()                                               \     Do `return -2' if the alloc fails.  */
1495    
1496    # ifdef MATCH_MAY_ALLOCATE
1497    #  define INIT_FAIL_STACK()                                             \
1498    do {                                                                  \    do {                                                                  \
1499      fail_stack.stack = (fail_stack_elt_t *)                             \      fail_stack.stack = (PREFIX(fail_stack_elt_t) *)             \
1500        REGEX_ALLOCATE (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t));  \        REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (PREFIX(fail_stack_elt_t))); \
1501                                                                          \                                                                          \
1502      if (fail_stack.stack == NULL)                                       \      if (fail_stack.stack == NULL)                               \
1503        return -2;                                                        \        return -2;                                                        \
1504                                                                          \                                                                          \
1505      fail_stack.size = INIT_FAILURE_ALLOC;                               \      fail_stack.size = INIT_FAILURE_ALLOC;                       \
1506      fail_stack.avail = 0;                                               \      fail_stack.avail = 0;                                       \
1507    } while (0)    } while (0)
1508  #else  
1509  #define INIT_FAIL_STACK()                                               \  #  define RESET_FAIL_STACK()  REGEX_FREE_STACK (fail_stack.stack)
1510    # else
1511    #  define INIT_FAIL_STACK()                                             \
1512    do {                                                                  \    do {                                                                  \
1513      fail_stack.avail = 0;                                               \      fail_stack.avail = 0;                                       \
1514    } while (0)    } while (0)
1515  #endif  
1516    #  define RESET_FAIL_STACK()
1517    # endif
1518    
1519    
1520  /* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.  /* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.
1521    
1522     Return 1 if succeeds, and 0 if either ran out of memory     Return 1 if succeeds, and 0 if either ran out of memory
1523     allocating space for it or it was already too large.       allocating space for it or it was already too large.
1524      
1525     REGEX_REALLOCATE requires `destination' be declared.   */     REGEX_REALLOCATE_STACK requires `destination' be declared.   */
1526    
1527  #define DOUBLE_FAIL_STACK(fail_stack)                                   \  # define DOUBLE_FAIL_STACK(fail_stack)                                  \
1528    ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS              \    ((fail_stack).size > (unsigned) (re_max_failures * MAX_FAILURE_ITEMS) \
1529     ? 0                                                                  \     ? 0                                                                  \
1530     : ((fail_stack).stack = (fail_stack_elt_t *)                         \     : ((fail_stack).stack = (PREFIX(fail_stack_elt_t) *)                 \
1531          REGEX_REALLOCATE ((fail_stack).stack,                           \          REGEX_REALLOCATE_STACK ((fail_stack).stack,                     \
1532            (fail_stack).size * sizeof (fail_stack_elt_t),                \            (fail_stack).size * sizeof (PREFIX(fail_stack_elt_t)),        \
1533            ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)),        \            ((fail_stack).size << 1) * sizeof (PREFIX(fail_stack_elt_t))),\
1534                                                                          \                                                                          \
1535        (fail_stack).stack == NULL                                        \        (fail_stack).stack == NULL                                        \
1536        ? 0                                                               \        ? 0                                                               \
# Line 982  typedef struct Line 1538  typedef struct
1538           1)))           1)))
1539    
1540    
1541  /* Push PATTERN_OP on FAIL_STACK.  /* Push pointer POINTER on FAIL_STACK.
   
1542     Return 1 if was able to do so and 0 if ran out of memory allocating     Return 1 if was able to do so and 0 if ran out of memory allocating
1543     space to do so.  */     space to do so.  */
1544  #define PUSH_PATTERN_OP(pattern_op, fail_stack)                         \  # define PUSH_PATTERN_OP(POINTER, FAIL_STACK)                           \
1545    ((FAIL_STACK_FULL ()                                                  \    ((FAIL_STACK_FULL ()                                                  \
1546      && !DOUBLE_FAIL_STACK (fail_stack))                                 \      && !DOUBLE_FAIL_STACK (FAIL_STACK))                                 \
1547      ? 0                                                                 \     ? 0                                                                  \
1548      : ((fail_stack).stack[(fail_stack).avail++] = pattern_op,           \     : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER,       \
1549         1))        1))
1550    
1551    /* Push a pointer value onto the failure stack.
1552       Assumes the variable `fail_stack'.  Probably should only
1553       be called from within `PUSH_FAILURE_POINT'.  */
1554    # define PUSH_FAILURE_POINTER(item)                                     \
1555      fail_stack.stack[fail_stack.avail++].pointer = (UCHAR_T *) (item)
1556    
1557  /* This pushes an item onto the failure stack.  Must be a four-byte  /* This pushes an integer-valued item onto the failure stack.
1558     value.  Assumes the variable `fail_stack'.  Probably should only     Assumes the variable `fail_stack'.  Probably should only
1559     be called from within `PUSH_FAILURE_POINT'.  */     be called from within `PUSH_FAILURE_POINT'.  */
1560  #define PUSH_FAILURE_ITEM(item)                                         \  # define PUSH_FAILURE_INT(item)                                 \
1561    fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) item    fail_stack.stack[fail_stack.avail++].integer = (item)
1562    
1563  /* The complement operation.  Assumes `fail_stack' is nonempty.  */  /* Push a fail_stack_elt_t value onto the failure stack.
1564  #define POP_FAILURE_ITEM() fail_stack.stack[--fail_stack.avail]     Assumes the variable `fail_stack'.  Probably should only
1565       be called from within `PUSH_FAILURE_POINT'.  */
1566    # define PUSH_FAILURE_ELT(item)                                 \
1567      fail_stack.stack[fail_stack.avail++] =  (item)
1568    
1569    /* These three POP... operations complement the three PUSH... operations.
1570       All assume that `fail_stack' is nonempty.  */
1571    # define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
1572    # define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
1573    # define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
1574    
1575  /* Used to omit pushing failure point id's when we're not debugging.  */  /* Used to omit pushing failure point id's when we're not debugging.  */
1576  #ifdef DEBUG  # ifdef DEBUG
1577  #define DEBUG_PUSH PUSH_FAILURE_ITEM  #  define DEBUG_PUSH PUSH_FAILURE_INT
1578  #define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_ITEM ()  #  define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT ()
1579  #else  # else
1580  #define DEBUG_PUSH(item)  #  define DEBUG_PUSH(item)
1581  #define DEBUG_POP(item_addr)  #  define DEBUG_POP(item_addr)
1582  #endif  # endif
1583    
1584    
1585  /* Push the information about the state we will need  /* Push the information about the state we will need
1586     if we ever fail back to it.       if we ever fail back to it.
1587      
1588     Requires variables fail_stack, regstart, regend, reg_info, and     Requires variables fail_stack, regstart, regend, reg_info, and
1589     num_regs be declared.  DOUBLE_FAIL_STACK requires `destination' be     num_regs_pushed be declared.  DOUBLE_FAIL_STACK requires `destination'
1590     declared.     be declared.
1591      
1592     Does `return FAILURE_CODE' if runs out of memory.  */     Does `return FAILURE_CODE' if runs out of memory.  */
1593    
1594  #define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code)   \  # define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code)  \
1595    do {                                                                  \    do {                                                                  \
1596      char *destination;                                                  \      char *destination;                                                  \
1597      /* Must be int, so when we don't save any registers, the arithmetic \      /* Must be int, so when we don't save any registers, the arithmetic \
1598         of 0 + -1 isn't done as unsigned.  */                            \         of 0 + -1 isn't done as unsigned.  */                            \
1599      int this_reg;                                                       \      /* Can't be int, since there is not a shred of a guarantee that int \
1600           is wide enough to hold a value of something to which pointer can \
1601           be assigned */                                                   \
1602        active_reg_t this_reg;                                              \
1603                                                                          \                                                                          \
1604      DEBUG_STATEMENT (failure_id++);                                     \      DEBUG_STATEMENT (failure_id++);                                     \
1605      DEBUG_STATEMENT (nfailure_points_pushed++);                         \      DEBUG_STATEMENT (nfailure_points_pushed++);                         \
# Line 1034  typedef struct Line 1607  typedef struct
1607      DEBUG_PRINT2 ("  Before push, next avail: %d\n", (fail_stack).avail);\      DEBUG_PRINT2 ("  Before push, next avail: %d\n", (fail_stack).avail);\
1608      DEBUG_PRINT2 ("                     size: %d\n", (fail_stack).size);\      DEBUG_PRINT2 ("                     size: %d\n", (fail_stack).size);\
1609                                                                          \                                                                          \
1610      DEBUG_PRINT2 ("  slots needed: %d\n", NUM_FAILURE_ITEMS);           \      DEBUG_PRINT2 ("  slots needed: %ld\n", NUM_FAILURE_ITEMS);          \
1611      DEBUG_PRINT2 ("     available: %d\n", REMAINING_AVAIL_SLOTS);       \      DEBUG_PRINT2 ("     available: %d\n", REMAINING_AVAIL_SLOTS);       \
1612                                                                          \                                                                          \
1613      /* Ensure we have enough space allocated for what we will push.  */ \      /* Ensure we have enough space allocated for what we will push.  */ \
1614      while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS)                   \      while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS)                   \
1615        {                                                                 \        {                                                                 \
1616          if (!DOUBLE_FAIL_STACK (fail_stack))                    \          if (!DOUBLE_FAIL_STACK (fail_stack))                            \
1617            return failure_code;                                          \            return failure_code;                                          \
1618                                                                          \                                                                          \
1619          DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n",              \          DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n",              \
# Line 1051  typedef struct Line 1624  typedef struct
1624      /* Push the info, starting with the registers.  */                  \      /* Push the info, starting with the registers.  */                  \
1625      DEBUG_PRINT1 ("\n");                                                \      DEBUG_PRINT1 ("\n");                                                \
1626                                                                          \                                                                          \
1627      for (this_reg = lowest_active_reg; this_reg <= highest_active_reg;  \      if (1)                                                              \
1628           this_reg++)                                                    \        for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \
1629        {                                                                 \             this_reg++)                                                  \
1630          DEBUG_PRINT2 ("  Pushing reg: %d\n", this_reg);                 \          {                                                               \
1631          DEBUG_STATEMENT (num_regs_pushed++);                            \            DEBUG_PRINT2 ("  Pushing reg: %lu\n", this_reg);              \
1632              DEBUG_STATEMENT (num_regs_pushed++);                          \
1633                                                                          \                                                                          \
1634          DEBUG_PRINT2 ("    start: 0x%x\n", regstart[this_reg]);         \            DEBUG_PRINT2 ("    start: %p\n", regstart[this_reg]);         \
1635          PUSH_FAILURE_ITEM (regstart[this_reg]);                         \            PUSH_FAILURE_POINTER (regstart[this_reg]);                    \
                                                                         \  
         DEBUG_PRINT2 ("    end: 0x%x\n", regend[this_reg]);             \  
         PUSH_FAILURE_ITEM (regend[this_reg]);                           \  
1636                                                                          \                                                                          \
1637          DEBUG_PRINT2 ("    info: 0x%x\n      ", reg_info[this_reg]);    \            DEBUG_PRINT2 ("    end: %p\n", regend[this_reg]);             \
1638          DEBUG_PRINT2 (" match_null=%d",                                 \            PUSH_FAILURE_POINTER (regend[this_reg]);                      \
                       REG_MATCH_NULL_STRING_P (reg_info[this_reg]));    \  
         DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg]));    \  
         DEBUG_PRINT2 (" matched_something=%d",                          \  
                       MATCHED_SOMETHING (reg_info[this_reg]));          \  
         DEBUG_PRINT2 (" ever_matched=%d",                               \  
                       EVER_MATCHED_SOMETHING (reg_info[this_reg]));     \  
         DEBUG_PRINT1 ("\n");                                            \  
         PUSH_FAILURE_ITEM (reg_info[this_reg].word);                    \  
       }                                                                 \  
1639                                                                          \                                                                          \
1640      DEBUG_PRINT2 ("  Pushing  low active reg: %d\n", lowest_active_reg);\            DEBUG_PRINT2 ("    info: %p\n      ",                         \
1641      PUSH_FAILURE_ITEM (lowest_active_reg);                              \                          reg_info[this_reg].word.pointer);               \
1642              DEBUG_PRINT2 (" match_null=%d",                               \
1643                            REG_MATCH_NULL_STRING_P (reg_info[this_reg]));  \
1644              DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg]));  \
1645              DEBUG_PRINT2 (" matched_something=%d",                        \
1646                            MATCHED_SOMETHING (reg_info[this_reg]));        \
1647              DEBUG_PRINT2 (" ever_matched=%d",                             \
1648                            EVER_MATCHED_SOMETHING (reg_info[this_reg]));   \
1649              DEBUG_PRINT1 ("\n");                                          \
1650              PUSH_FAILURE_ELT (reg_info[this_reg].word);                   \
1651            }                                                               \
1652                                                                          \                                                                          \
1653      DEBUG_PRINT2 ("  Pushing high active reg: %d\n", highest_active_reg);\      DEBUG_PRINT2 ("  Pushing  low active reg: %ld\n", lowest_active_reg);\
1654      PUSH_FAILURE_ITEM (highest_active_reg);                             \      PUSH_FAILURE_INT (lowest_active_reg);                               \
1655                                                                          \                                                                          \
1656      DEBUG_PRINT2 ("  Pushing pattern 0x%x: ", pattern_place);           \      DEBUG_PRINT2 ("  Pushing high active reg: %ld\n", highest_active_reg);\
1657        PUSH_FAILURE_INT (highest_active_reg);                              \
1658                                                                            \
1659        DEBUG_PRINT2 ("  Pushing pattern %p:\n", pattern_place);            \
1660      DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);           \      DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);           \
1661      PUSH_FAILURE_ITEM (pattern_place);                                  \      PUSH_FAILURE_POINTER (pattern_place);                               \
1662                                                                          \                                                                          \
1663      DEBUG_PRINT2 ("  Pushing string 0x%x: `", string_place);            \      DEBUG_PRINT2 ("  Pushing string %p: `", string_place);              \
1664      DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \      DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \
1665                                   size2);                                \                                   size2);                                \
1666      DEBUG_PRINT1 ("'\n");                                               \      DEBUG_PRINT1 ("'\n");                                               \
1667      PUSH_FAILURE_ITEM (string_place);                                   \      PUSH_FAILURE_POINTER (string_place);                                \
1668                                                                          \                                                                          \
1669      DEBUG_PRINT2 ("  Pushing failure id: %u\n", failure_id);            \      DEBUG_PRINT2 ("  Pushing failure id: %u\n", failure_id);            \
1670      DEBUG_PUSH (failure_id);                                            \      DEBUG_PUSH (failure_id);                                            \
1671    } while (0)    } while (0)
1672    
1673    # ifndef DEFINED_ONCE
1674  /* This is the number of items that are pushed and popped on the stack  /* This is the number of items that are pushed and popped on the stack
1675     for each register.  */     for each register.  */
1676  #define NUM_REG_ITEMS  3  #  define NUM_REG_ITEMS  3
1677    
1678  /* Individual items aside from the registers.  */  /* Individual items aside from the registers.  */
1679  #ifdef DEBUG  #  ifdef DEBUG
1680  #define NUM_NONREG_ITEMS 5 /* Includes failure point id.  */  #   define NUM_NONREG_ITEMS 5 /* Includes failure point id.  */
1681  #else  #  else
1682  #define NUM_NONREG_ITEMS 4  #   define NUM_NONREG_ITEMS 4
1683  #endif  #  endif
1684    
1685  /* We push at most this many items on the stack.  */  /* We push at most this many items on the stack.  */
1686  #define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS)  /* We used to use (num_regs - 1), which is the number of registers
1687       this regexp will save; but that was changed to 5
1688       to avoid stack overflow for a regexp with lots of parens.  */
1689    #  define MAX_FAILURE_ITEMS (5 * NUM_REG_ITEMS + NUM_NONREG_ITEMS)
1690    
1691  /* We actually push this many items.  */  /* We actually push this many items.  */
1692  #define NUM_FAILURE_ITEMS                                               \  #  define NUM_FAILURE_ITEMS                             \
1693    ((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS         \    (((0                                                  \
1694      + NUM_NONREG_ITEMS)       ? 0 : highest_active_reg - lowest_active_reg + 1)  \
1695        * NUM_REG_ITEMS)                                    \
1696       + NUM_NONREG_ITEMS)
1697    
1698  /* How many items can still be added to the stack without overflowing it.  */  /* How many items can still be added to the stack without overflowing it.  */
1699  #define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)  #  define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)
1700    # endif /* not DEFINED_ONCE */
1701    
1702    
1703  /* Pops what PUSH_FAIL_STACK pushes.  /* Pops what PUSH_FAIL_STACK pushes.
# Line 1126  typedef struct Line 1708  typedef struct
1708       LOW_REG, HIGH_REG -- the highest and lowest active registers.       LOW_REG, HIGH_REG -- the highest and lowest active registers.
1709       REGSTART, REGEND -- arrays of string positions.       REGSTART, REGEND -- arrays of string positions.
1710       REG_INFO -- array of information about each subexpression.       REG_INFO -- array of information about each subexpression.
1711      
1712     Also assumes the variables `fail_stack' and (if debugging), `bufp',     Also assumes the variables `fail_stack' and (if debugging), `bufp',
1713     `pend', `string1', `size1', `string2', and `size2'.  */     `pend', `string1', `size1', `string2', and `size2'.  */
1714    # define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\
 #define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\  
1715  {                                                                       \  {                                                                       \
1716    DEBUG_STATEMENT (fail_stack_elt_t failure_id;)                        \    DEBUG_STATEMENT (unsigned failure_id;)                                \
1717    int this_reg;                                                         \    active_reg_t this_reg;                                                \
1718    const unsigned char *string_temp;                                     \    const UCHAR_T *string_temp;                                           \
1719                                                                          \                                                                          \
1720    assert (!FAIL_STACK_EMPTY ());                                        \    assert (!FAIL_STACK_EMPTY ());                                        \
1721                                                                          \                                                                          \
# Line 1151  typedef struct Line 1732  typedef struct
1732    /* If the saved string location is NULL, it came from an              \    /* If the saved string location is NULL, it came from an              \
1733       on_failure_keep_string_jump opcode, and we want to throw away the  \       on_failure_keep_string_jump opcode, and we want to throw away the  \
1734       saved NULL, thus retaining our current position in the string.  */ \       saved NULL, thus retaining our current position in the string.  */ \
1735    string_temp = POP_FAILURE_ITEM ();                                    \    string_temp = POP_FAILURE_POINTER ();                                 \
1736    if (string_temp != NULL)                                              \    if (string_temp != NULL)                                              \
1737      str = (const char *) string_temp;                                   \      str = (const CHAR_T *) string_temp;                                 \
1738                                                                          \                                                                          \
1739    DEBUG_PRINT2 ("  Popping string 0x%x: `", str);                       \    DEBUG_PRINT2 ("  Popping string %p: `", str);                         \
1740    DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);      \    DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);      \
1741    DEBUG_PRINT1 ("'\n");                                                 \    DEBUG_PRINT1 ("'\n");                                                 \
1742                                                                          \                                                                          \
1743    pat = (unsigned char *) POP_FAILURE_ITEM ();                          \    pat = (UCHAR_T *) POP_FAILURE_POINTER ();                             \
1744    DEBUG_PRINT2 ("  Popping pattern 0x%x: ", pat);                       \    DEBUG_PRINT2 ("  Popping pattern %p:\n", pat);                        \
1745    DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);                       \    DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);                       \
1746                                                                          \                                                                          \
1747    /* Restore register info.  */                                         \    /* Restore register info.  */                                         \
1748    high_reg = (unsigned) POP_FAILURE_ITEM ();                            \    high_reg = (active_reg_t) POP_FAILURE_INT ();                         \
1749    DEBUG_PRINT2 ("  Popping high active reg: %d\n", high_reg);           \    DEBUG_PRINT2 ("  Popping high active reg: %ld\n", high_reg);          \
1750                                                                          \                                                                          \
1751    low_reg = (unsigned) POP_FAILURE_ITEM ();                             \    low_reg = (active_reg_t) POP_FAILURE_INT ();                          \
1752    DEBUG_PRINT2 ("  Popping  low active reg: %d\n", low_reg);            \    DEBUG_PRINT2 ("  Popping  low active reg: %ld\n", low_reg);           \
1753                                                                          \                                                                          \
1754    for (this_reg = high_reg; this_reg >= low_reg; this_reg--)            \    if (1)                                                                \
1755      {                                                                   \      for (this_reg = high_reg; this_reg >= low_reg; this_reg--)          \
1756        DEBUG_PRINT2 ("    Popping reg: %d\n", this_reg);                 \        {                                                                 \
1757            DEBUG_PRINT2 ("    Popping reg: %ld\n", this_reg);              \
1758                                                                          \                                                                          \
1759        reg_info[this_reg].word = POP_FAILURE_ITEM ();                    \          reg_info[this_reg].word = POP_FAILURE_ELT ();                   \
1760        DEBUG_PRINT2 ("      info: 0x%x\n", reg_info[this_reg]);          \          DEBUG_PRINT2 ("      info: %p\n",                               \
1761                          reg_info[this_reg].word.pointer);                 \
1762                                                                          \                                                                          \
1763        regend[this_reg] = (const char *) POP_FAILURE_ITEM ();            \          regend[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER ();     \
1764        DEBUG_PRINT2 ("      end: 0x%x\n", regend[this_reg]);             \          DEBUG_PRINT2 ("      end: %p\n", regend[this_reg]);             \
1765                                                                          \                                                                          \
1766        regstart[this_reg] = (const char *) POP_FAILURE_ITEM ();          \          regstart[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER ();   \
1767        DEBUG_PRINT2 ("      start: 0x%x\n", regstart[this_reg]);         \          DEBUG_PRINT2 ("      start: %p\n", regstart[this_reg]);         \
1768          }                                                                 \
1769      else                                                                  \
1770        {                                                                   \
1771          for (this_reg = highest_active_reg; this_reg > high_reg; this_reg--) \
1772            {                                                               \
1773              reg_info[this_reg].word.integer = 0;                          \
1774              regend[this_reg] = 0;                                         \
1775              regstart[this_reg] = 0;                                       \
1776            }                                                               \
1777          highest_active_reg = high_reg;                                    \
1778      }                                                                   \      }                                                                   \
1779                                                                          \                                                                          \
1780      set_regs_matched_done = 0;                                            \
1781    DEBUG_STATEMENT (nfailure_points_popped++);                           \    DEBUG_STATEMENT (nfailure_points_popped++);                           \
1782  } /* POP_FAILURE_POINT */  } /* POP_FAILURE_POINT */
   
   
1783    
1784  /* Structure for per-register (a.k.a. per-group) information.  /* Structure for per-register (a.k.a. per-group) information.
1785     This must not be longer than one word, because we push this value     Other register information, such as the
    onto the failure stack.  Other register information, such as the  
1786     starting and ending positions (which are addresses), and the list of     starting and ending positions (which are addresses), and the list of
1787     inner groups (which is a bits list) are maintained in separate     inner groups (which is a bits list) are maintained in separate
1788     variables.       variables.
1789      
1790     We are making a (strictly speaking) nonportable assumption here: that     We are making a (strictly speaking) nonportable assumption here: that
1791     the compiler will pack our bit fields into something that fits into     the compiler will pack our bit fields into something that fits into
1792     the type of `word', i.e., is something that fits into one item on the     the type of `word', i.e., is something that fits into one item on the
1793     failure stack.  */     failure stack.  */
1794    
1795    
1796    /* Declarations and macros for re_match_2.  */
1797    
1798  typedef union  typedef union
1799  {  {
1800    fail_stack_elt_t word;    PREFIX(fail_stack_elt_t) word;
1801    struct    struct
1802    {    {
1803        /* This field is one if this group can match the empty string,        /* This field is one if this group can match the empty string,
1804           zero if not.  If not yet determined,  `MATCH_NULL_UNSET_VALUE'.  */           zero if not.  If not yet determined,  `MATCH_NULL_UNSET_VALUE'.  */
1805  #define MATCH_NULL_UNSET_VALUE 3  # define MATCH_NULL_UNSET_VALUE 3
1806      unsigned match_null_string_p : 2;      unsigned match_null_string_p : 2;
1807      unsigned is_active : 1;      unsigned is_active : 1;
1808      unsigned matched_something : 1;      unsigned matched_something : 1;
1809      unsigned ever_matched_something : 1;      unsigned ever_matched_something : 1;
1810    } bits;    } bits;
1811  } register_info_type;  } PREFIX(register_info_type);
1812    
1813  #define REG_MATCH_NULL_STRING_P(R)  ((R).bits.match_null_string_p)  # ifndef DEFINED_ONCE
1814  #define IS_ACTIVE(R)  ((R).bits.is_active)  #  define REG_MATCH_NULL_STRING_P(R)  ((R).bits.match_null_string_p)
1815  #define MATCHED_SOMETHING(R)  ((R).bits.matched_something)  #  define IS_ACTIVE(R)  ((R).bits.is_active)
1816  #define EVER_MATCHED_SOMETHING(R)  ((R).bits.ever_matched_something)  #  define MATCHED_SOMETHING(R)  ((R).bits.matched_something)
1817    #  define EVER_MATCHED_SOMETHING(R)  ((R).bits.ever_matched_something)
1818    
1819    
1820  /* Call this when have matched a real character; it sets `matched' flags  /* Call this when have matched a real character; it sets `matched' flags
1821     for the subexpressions which we are currently inside.  Also records     for the subexpressions which we are currently inside.  Also records
1822     that those subexprs have matched.  */     that those subexprs have matched.  */
1823  #define SET_REGS_MATCHED()                                              \  #  define SET_REGS_MATCHED()                                            \
1824    do                                                                    \    do                                                                    \
1825      {                                                                   \      {                                                                   \
1826        unsigned r;                                                       \        if (!set_regs_matched_done)                                       \
1827        for (r = lowest_active_reg; r <= highest_active_reg; r++)         \          {                                                               \
1828          {                                                               \            active_reg_t r;                                               \
1829            MATCHED_SOMETHING (reg_info[r])                               \            set_regs_matched_done = 1;                                    \
1830              = EVER_MATCHED_SOMETHING (reg_info[r])                      \            for (r = lowest_active_reg; r <= highest_active_reg; r++)     \
1831              = 1;                                                        \              {                                                           \
1832          }                                                               \                MATCHED_SOMETHING (reg_info[r])                           \
1833                    = EVER_MATCHED_SOMETHING (reg_info[r])                  \
1834                    = 1;                                                    \
1835                }                                                           \
1836            }                                                               \
1837      }                                                                   \      }                                                                   \
1838    while (0)    while (0)
1839    # endif /* not DEFINED_ONCE */
1840    
1841  /* Registers are set to a sentinel when they haven't yet matched.  */  /* Registers are set to a sentinel when they haven't yet matched.  */
1842  #define REG_UNSET_VALUE ((char *) -1)  static CHAR_T PREFIX(reg_unset_dummy);
1843  #define REG_UNSET(e) ((e) == REG_UNSET_VALUE)  # define REG_UNSET_VALUE (&PREFIX(reg_unset_dummy))
1844    # define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
   
   
 /* How do we implement a missing MATCH_MAY_ALLOCATE?  
    We make the fail stack a global thing, and then grow it to  
    re_max_failures when we compile.  */  
 #ifndef MATCH_MAY_ALLOCATE  
 static fail_stack_type fail_stack;  
   
 static const char **     regstart, **     regend;  
 static const char ** old_regstart, ** old_regend;  
 static const char **best_regstart, **best_regend;  
 static register_info_type *reg_info;  
 static const char **reg_dummy;  
 static register_info_type *reg_info_dummy;  
 #endif  
1845    
   
1846  /* Subroutine declarations and macros for regex_compile.  */  /* Subroutine declarations and macros for regex_compile.  */
1847    static void PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg);
1848    static void PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc,
1849                                   int arg1, int arg2);
1850    static void PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc,
1851                                    int arg, UCHAR_T *end);
1852    static void PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc,
1853                                    int arg1, int arg2, UCHAR_T *end);
1854    static boolean PREFIX(at_begline_loc_p) (const CHAR_T *pattern,
1855                                             const CHAR_T *p,
1856                                             reg_syntax_t syntax);
1857    static boolean PREFIX(at_endline_loc_p) (const CHAR_T *p,
1858                                             const CHAR_T *pend,
1859                                             reg_syntax_t syntax);
1860    # ifdef WCHAR
1861    static reg_errcode_t wcs_compile_range (CHAR_T range_start,
1862                                            const CHAR_T **p_ptr,
1863                                            const CHAR_T *pend,
1864                                            char *translate,
1865                                            reg_syntax_t syntax,
1866                                            UCHAR_T *b,
1867                                            CHAR_T *char_set);
1868    static void insert_space (int num, CHAR_T *loc, CHAR_T *end);
1869    # else /* BYTE */
1870    static reg_errcode_t byte_compile_range (unsigned int range_start,
1871                                             const char **p_ptr,
1872                                             const char *pend,
1873                                             char *translate,
1874                                             reg_syntax_t syntax,
1875                                             unsigned char *b);
1876    # endif /* WCHAR */
1877    
1878  static void store_op1 (), store_op2 ();  /* Fetch the next character in the uncompiled pattern---translating it
 static void insert_op1 (), insert_op2 ();  
 static boolean at_begline_loc_p (), at_endline_loc_p ();  
 static boolean group_in_compile_stack ();  
 static reg_errcode_t compile_range ();  
   
 /* Fetch the next character in the uncompiled pattern---translating it  
1879     if necessary.  Also cast from a signed character in the constant     if necessary.  Also cast from a signed character in the constant
1880     string passed to us by the user to an unsigned char that we can use     string passed to us by the user to an unsigned char that we can use
1881     as an array index (in, e.g., `translate').  */     as an array index (in, e.g., `translate').  */
1882  #define PATFETCH(c)                                                     \  /* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
1883       because it is impossible to allocate 4GB array for some encodings
1884       which have 4 byte character_set like UCS4.  */
1885    # ifndef PATFETCH
1886    #  ifdef WCHAR
1887    #   define PATFETCH(c)                                                  \
1888      do {if (p == pend) return REG_EEND;                                   \
1889        c = (UCHAR_T) *p++;                                                 \
1890        if (translate && (c <= 0xff)) c = (UCHAR_T) translate[c];           \
1891      } while (0)
1892    #  else /* BYTE */
1893    #   define PATFETCH(c)                                                  \
1894    do {if (p == pend) return REG_EEND;                                   \    do {if (p == pend) return REG_EEND;                                   \
1895      c = (unsigned char) *p++;                                           \      c = (unsigned char) *p++;                                           \
1896      if (translate) c = translate[c];                                    \      if (translate) c = (unsigned char) translate[c];                    \
1897    } while (0)    } while (0)
1898    #  endif /* WCHAR */
1899    # endif
1900    
1901  /* Fetch the next character in the uncompiled pattern, with no  /* Fetch the next character in the uncompiled pattern, with no
1902     translation.  */     translation.  */
1903  #define PATFETCH_RAW(c)                                                 \  # define PATFETCH_RAW(c)                                                \
1904    do {if (p == pend) return REG_EEND;                                   \    do {if (p == pend) return REG_EEND;                                   \
1905      c = (unsigned char) *p++;                                           \      c = (UCHAR_T) *p++;                                                 \
1906    } while (0)    } while (0)
1907    
1908  /* Go backwards one character in the pattern.  */  /* Go backwards one character in the pattern.  */
1909  #define PATUNFETCH p--  # define PATUNFETCH p--
1910    
1911    
1912  /* If `translate' is non-null, return translate[D], else just D.  We  /* If `translate' is non-null, return translate[D], else just D.  We
1913     cast the subscript to translate because some data is declared as     cast the subscript to translate because some data is declared as
1914     `char *', to avoid warnings when a string constant is passed.  But     `char *', to avoid warnings when a string constant is passed.  But
1915     when we use a character as a subscript we must make it unsigned.  */     when we use a character as a subscript we must make it unsigned.  */
1916  #define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d))  /* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
1917       because it is impossible to allocate 4GB array for some encodings
1918       which have 4 byte character_set like UCS4.  */
1919    
1920    # ifndef TRANSLATE
1921    #  ifdef WCHAR
1922    #   define TRANSLATE(d) \
1923      ((translate && ((UCHAR_T) (d)) <= 0xff) \
1924       ? (char) translate[(unsigned char) (d)] : (d))
1925    # else /* BYTE */
1926    #   define TRANSLATE(d) \
1927      (translate ? (char) translate[(unsigned char) (d)] : (d))
1928    #  endif /* WCHAR */
1929    # endif
1930    
1931    
1932  /* Macros for outputting the compiled pattern into `buffer'.  */  /* Macros for outputting the compiled pattern into `buffer'.  */
1933    
1934  /* If the buffer isn't allocated when it comes in, use this.  */  /* If the buffer isn't allocated when it comes in, use this.  */
1935  #define INIT_BUF_SIZE  32  # define INIT_BUF_SIZE  (32 * sizeof(UCHAR_T))
1936    
1937  /* Make sure we have at least N more bytes of space in buffer.  */  /* Make sure we have at least N more bytes of space in buffer.  */
1938  #define GET_BUFFER_SPACE(n)                                             \  # ifdef WCHAR
1939      while (b - bufp->buffer + (n) > bufp->allocated)                    \  #  define GET_BUFFER_SPACE(n)                                           \
1940        while (((unsigned long)b - (unsigned long)COMPILED_BUFFER_VAR       \
1941                + (n)*sizeof(CHAR_T)) > bufp->allocated)                    \
1942        EXTEND_BUFFER ()        EXTEND_BUFFER ()
1943    # else /* BYTE */
1944    #  define GET_BUFFER_SPACE(n)                                           \
1945        while ((unsigned long) (b - bufp->buffer + (n)) > bufp->allocated)  \
1946          EXTEND_BUFFER ()
1947    # endif /* WCHAR */
1948    
1949  /* Make sure we have one more byte of buffer space and then add C to it.  */  /* Make sure we have one more byte of buffer space and then add C to it.  */
1950  #define BUF_PUSH(c)                                                     \  # define BUF_PUSH(c)                                                    \
1951    do {                                                                  \    do {                                                                  \
1952      GET_BUFFER_SPACE (1);                                               \      GET_BUFFER_SPACE (1);                                               \
1953      *b++ = (unsigned char) (c);                                         \      *b++ = (UCHAR_T) (c);                                               \
1954    } while (0)    } while (0)
1955    
1956    
1957  /* Ensure we have two more bytes of buffer space and then append C1 and C2.  */  /* Ensure we have two more bytes of buffer space and then append C1 and C2.  */
1958  #define BUF_PUSH_2(c1, c2)                                              \  # define BUF_PUSH_2(c1, c2)                                             \
1959    do {                                                                  \    do {                                                                  \
1960      GET_BUFFER_SPACE (2);                                               \      GET_BUFFER_SPACE (2);                                               \
1961      *b++ = (unsigned char) (c1);                                        \      *b++ = (UCHAR_T) (c1);                                              \
1962      *b++ = (unsigned char) (c2);                                        \      *b++ = (UCHAR_T) (c2);                                              \
1963    } while (0)    } while (0)
1964    
1965    
1966  /* As with BUF_PUSH_2, except for three bytes.  */  /* As with BUF_PUSH_2, except for three bytes.  */
1967  #define BUF_PUSH_3(c1, c2, c3)                                          \  # define BUF_PUSH_3(c1, c2, c3)                                         \
1968    do {                                                                  \    do {                                                                  \
1969      GET_BUFFER_SPACE (3);                                               \      GET_BUFFER_SPACE (3);                                               \
1970      *b++ = (unsigned char) (c1);                                        \      *b++ = (UCHAR_T) (c1);                                              \
1971      *b++ = (unsigned char) (c2);                                        \      *b++ = (UCHAR_T) (c2);                                              \
1972      *b++ = (unsigned char) (c3);                                        \      *b++ = (UCHAR_T) (c3);                                              \
1973    } while (0)    } while (0)
1974    
   
1975  /* Store a jump with opcode OP at LOC to location TO.  We store a  /* Store a jump with opcode OP at LOC to location TO.  We store a
1976     relative address offset by the three bytes the jump itself occupies.  */     relative address offset by the three bytes the jump itself occupies.  */
1977  #define STORE_JUMP(op, loc, to) \  # define STORE_JUMP(op, loc, to) \
1978    store_op1 (op, loc, (to) - (loc) - 3)   PREFIX(store_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)))
1979    
1980  /* Likewise, for a two-argument jump.  */  /* Likewise, for a two-argument jump.  */
1981  #define STORE_JUMP2(op, loc, to, arg) \  # define STORE_JUMP2(op, loc, to, arg) \
1982    store_op2 (op, loc, (to) - (loc) - 3, arg)    PREFIX(store_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), arg)
1983    
1984  /* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */  /* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
1985  #define INSERT_JUMP(op, loc, to) \  # define INSERT_JUMP(op, loc, to) \
1986    insert_op1 (op, loc, (to) - (loc) - 3, b)    PREFIX(insert_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), b)
1987    
1988  /* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */  /* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
1989  #define INSERT_JUMP2(op, loc, to, arg) \  # define INSERT_JUMP2(op, loc, to, arg) \
1990    insert_op2 (op, loc, (to) - (loc) - 3, arg, b)    PREFIX(insert_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)),\
1991                  arg, b)
1992    
1993  /* This is not an arbitrary limit: the arguments which represent offsets  /* This is not an arbitrary limit: the arguments which represent offsets
1994     into the pattern are two bytes long.  So if 2^16 bytes turns out to     into the pattern are two bytes long.  So if 2^16 bytes turns out to
1995     be too small, many things would have to change.  */     be too small, many things would have to change.  */
1996  #define MAX_BUF_SIZE (1L << 16)  /* Any other compiler which, like MSC, has allocation limit below 2^16
1997       bytes will have to use approach similar to what was done below for
1998       MSC and drop MAX_BUF_SIZE a bit.  Otherwise you may end up
1999       reallocating to 0 bytes.  Such thing is not going to work too well.
2000       You have been warned!!  */
2001    # ifndef DEFINED_ONCE
2002    #  if defined _MSC_VER  && !defined WIN32
2003    /* Microsoft C 16-bit versions limit malloc to approx 65512 bytes.
2004       The REALLOC define eliminates a flurry of conversion warnings,
2005       but is not required. */
2006    #   define MAX_BUF_SIZE  65500L
2007    #   define REALLOC(p,s) realloc ((p), (size_t) (s))
2008    #  else
2009    #   define MAX_BUF_SIZE (1L << 16)
2010    #   define REALLOC(p,s) realloc ((p), (s))
2011    #  endif
2012    
2013  /* Extend the buffer by twice its current size via realloc and  /* Extend the buffer by twice its current size via realloc and
2014     reset the pointers that pointed into the old block to point to the     reset the pointers that pointed into the old block to point to the
2015     correct places in the new one.  If extending the buffer results in it     correct places in the new one.  If extending the buffer results in it
2016     being larger than MAX_BUF_SIZE, then flag memory exhausted.  */     being larger than MAX_BUF_SIZE, then flag memory exhausted.  */
2017  #define EXTEND_BUFFER()                                                 \  #  if __BOUNDED_POINTERS__
2018    do {                                                                  \  #   define SET_HIGH_BOUND(P) (__ptrhigh (P) = __ptrlow (P) + bufp->allocated)
2019      unsigned char *old_buffer = bufp->buffer;                           \  #   define MOVE_BUFFER_POINTER(P) \
2020      if (bufp->allocated == MAX_BUF_SIZE)                                \    (__ptrlow (P) += incr, SET_HIGH_BOUND (P), __ptrvalue (P) += incr)
2021    #   define ELSE_EXTEND_BUFFER_HIGH_BOUND        \
2022      else                                          \
2023        {                                           \
2024          SET_HIGH_BOUND (b);                       \
2025          SET_HIGH_BOUND (begalt);                  \
2026          if (fixup_alt_jump)                       \
2027            SET_HIGH_BOUND (fixup_alt_jump);        \
2028          if (laststart)                            \
2029            SET_HIGH_BOUND (laststart);             \
2030          if (pending_exact)                        \
2031            SET_HIGH_BOUND (pending_exact);         \
2032        }
2033    #  else
2034    #   define MOVE_BUFFER_POINTER(P) (P) += incr
2035    #   define ELSE_EXTEND_BUFFER_HIGH_BOUND
2036    #  endif
2037    # endif /* not DEFINED_ONCE */
2038    
2039    # ifdef WCHAR
2040    #  define EXTEND_BUFFER()                                               \
2041      do {                                                                  \
2042        UCHAR_T *old_buffer = COMPILED_BUFFER_VAR;                          \
2043        int wchar_count;                                                    \
2044        if (bufp->allocated + sizeof(UCHAR_T) > MAX_BUF_SIZE)               \
2045        return REG_ESIZE;                                                 \        return REG_ESIZE;                                                 \
2046      bufp->allocated <<= 1;                                              \      bufp->allocated <<= 1;                                              \
2047      if (bufp->allocated > MAX_BUF_SIZE)                                 \      if (bufp->allocated > MAX_BUF_SIZE)                                 \
2048        bufp->allocated = MAX_BUF_SIZE;                                   \        bufp->allocated = MAX_BUF_SIZE;                                   \
2049      bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\      /* How many characters the new buffer can have?  */                 \
2050      if (bufp->buffer == NULL)                                           \      wchar_count = bufp->allocated / sizeof(UCHAR_T);                    \
2051        if (wchar_count == 0) wchar_count = 1;                              \
2052        /* Truncate the buffer to CHAR_T align.  */                 \
2053        bufp->allocated = wchar_count * sizeof(UCHAR_T);                    \
2054        RETALLOC (COMPILED_BUFFER_VAR, wchar_count, UCHAR_T);               \
2055        bufp->buffer = (char*)COMPILED_BUFFER_VAR;                          \
2056        if (COMPILED_BUFFER_VAR == NULL)                                    \
2057        return REG_ESPACE;                                                \        return REG_ESPACE;                                                \
2058      /* If the buffer moved, move all the pointers into it.  */          \      /* If the buffer moved, move all the pointers into it.  */          \
2059      if (old_buffer != bufp->buffer)                                     \      if (old_buffer != COMPILED_BUFFER_VAR)                              \
2060        {                                                                 \        {                                                                 \
2061          b = (b - old_buffer) + bufp->buffer;                            \          int incr = COMPILED_BUFFER_VAR - old_buffer;                    \
2062          begalt = (begalt - old_buffer) + bufp->buffer;                  \          MOVE_BUFFER_POINTER (b);                                        \
2063          if (fixup_alt_jump)                                             \          MOVE_BUFFER_POINTER (begalt);                                   \
2064            fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\          if (fixup_alt_jump)                                             \
2065          if (laststart)                                                  \            MOVE_BUFFER_POINTER (fixup_alt_jump);                         \
2066            laststart = (laststart - old_buffer) + bufp->buffer;          \          if (laststart)                                                  \
2067          if (pending_exact)                                              \            MOVE_BUFFER_POINTER (laststart);                              \
2068            pending_exact = (pending_exact - old_buffer) + bufp->buffer;  \          if (pending_exact)                                              \
2069              MOVE_BUFFER_POINTER (pending_exact);                          \
2070        }                                                                 \        }                                                                 \
2071        ELSE_EXTEND_BUFFER_HIGH_BOUND                                       \
2072    } while (0)    } while (0)
2073    # else /* BYTE */
2074    #  define EXTEND_BUFFER()                                               \
2075      do {                                                                  \
2076        UCHAR_T *old_buffer = COMPILED_BUFFER_VAR;                          \
2077        if (bufp->allocated == MAX_BUF_SIZE)                                \
2078          return REG_ESIZE;                                                 \
2079        bufp->allocated <<= 1;                                              \
2080        if (bufp->allocated > MAX_BUF_SIZE)                                 \
2081          bufp->allocated = MAX_BUF_SIZE;                                   \
2082        bufp->buffer = REALLOC (COMPILED_BUFFER_VAR, bufp->allocated);      \
2083        if (COMPILED_BUFFER_VAR == NULL)                                    \
2084          return REG_ESPACE;                                                \
2085        /* If the buffer moved, move all the pointers into it.  */          \
2086        if (old_buffer != COMPILED_BUFFER_VAR)                              \
2087          {                                                                 \
2088            int incr = COMPILED_BUFFER_VAR - old_buffer;                    \
2089            MOVE_BUFFER_POINTER (b);                                        \
2090            MOVE_BUFFER_POINTER (begalt);                                   \
2091            if (fixup_alt_jump)                                             \
2092              MOVE_BUFFER_POINTER (fixup_alt_jump);                         \
2093            if (laststart)                                                  \
2094              MOVE_BUFFER_POINTER (laststart);                              \
2095            if (pending_exact)                                              \
2096              MOVE_BUFFER_POINTER (pending_exact);                          \
2097          }                                                                 \
2098        ELSE_EXTEND_BUFFER_HIGH_BOUND                                       \
2099      } while (0)
2100    # endif /* WCHAR */
2101    
2102    # ifndef DEFINED_ONCE
2103  /* Since we have one byte reserved for the register number argument to  /* Since we have one byte reserved for the register number argument to
2104     {start,stop}_memory, the maximum number of groups we can report     {start,stop}_memory, the maximum number of groups we can report
2105     things about is what fits in that byte.  */     things about is what fits in that byte.  */
2106  #define MAX_REGNUM 255  #  define MAX_REGNUM 255
2107    
2108  /* But patterns can have more than `MAX_REGNUM' registers.  We just  /* But patterns can have more than `MAX_REGNUM' registers.  We just
2109     ignore the excess.  */     ignore the excess.  */
# Line 1400  typedef unsigned regnum_t; Line 2114  typedef unsigned regnum_t;
2114    
2115  /* Since offsets can go either forwards or backwards, this type needs to  /* Since offsets can go either forwards or backwards, this type needs to
2116     be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1.  */     be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1.  */
2117  typedef int pattern_offset_t;  /* int may be not enough when sizeof(int) == 2.  */
2118    typedef long pattern_offset_t;
2119    
2120  typedef struct  typedef struct
2121  {  {
2122    pattern_offset_t begalt_offset;    pattern_offset_t begalt_offset;
2123    pattern_offset_t fixup_alt_jump;    pattern_offset_t fixup_alt_jump;
2124    pattern_offset_t inner_group_offset;    pattern_offset_t inner_group_offset;
2125    pattern_offset_t laststart_offset;      pattern_offset_t laststart_offset;
2126    regnum_t regnum;    regnum_t regnum;
2127  } compile_stack_elt_t;  } compile_stack_elt_t;
2128    
# Line 1420  typedef struct Line 2135  typedef struct
2135  } compile_stack_type;  } compile_stack_type;
2136    
2137    
2138  #define INIT_COMPILE_STACK_SIZE 32  #  define INIT_COMPILE_STACK_SIZE 32
2139    
2140  #define COMPILE_STACK_EMPTY  (compile_stack.avail == 0)  #  define COMPILE_STACK_EMPTY  (compile_stack.avail == 0)
2141  #define COMPILE_STACK_FULL  (compile_stack.avail == compile_stack.size)  #  define COMPILE_STACK_FULL  (compile_stack.avail == compile_stack.size)
2142    
2143  /* The next available element.  */  /* The next available element.  */
2144  #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])  #  define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
2145    
2146    # endif /* not DEFINED_ONCE */
2147    
2148  /* Set the bit for character C in a list.  */  /* Set the bit for character C in a list.  */
2149  #define SET_LIST_BIT(c)                               \  # ifndef DEFINED_ONCE
2150    #  define SET_LIST_BIT(c)                               \
2151    (b[((unsigned char) (c)) / BYTEWIDTH]               \    (b[((unsigned char) (c)) / BYTEWIDTH]               \
2152     |= 1 << (((unsigned char) c) % BYTEWIDTH))     |= 1 << (((unsigned char) c) % BYTEWIDTH))
2153    # endif /* DEFINED_ONCE */
2154    
2155  /* Get the next unsigned number in the uncompiled pattern.  */  /* Get the next unsigned number in the uncompiled pattern.  */
2156  #define GET_UNSIGNED_NUMBER(num)                                        \  # define GET_UNSIGNED_NUMBER(num) \
2157    { if (p != pend)                                                      \    {                                                                     \
2158       {                                                                  \      while (p != pend)                                                   \
2159         PATFETCH (c);                                                    \        {                                                                 \
2160         while (ISDIGIT (c))                                              \          PATFETCH (c);                                                   \
2161           {                                                              \          if (c < '0' || c > '9')                                         \
2162             if (num < 0)                                                 \            break;                                                        \
2163                num = 0;                                                  \          if (num <= RE_DUP_MAX)                                          \
2164             num = num * 10 + c - '0';                                    \            {                                                             \
2165             if (p == pend)                                               \              if (num < 0)                                                \
2166                break;                                                    \                num = 0;                                                  \
2167             PATFETCH (c);                                                \              num = num * 10 + c - '0';                                   \
2168           }                                                              \            }                                                             \
2169         }                                                                \        }                                                                 \
2170      }              }
2171    
2172  #define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */  # ifndef DEFINED_ONCE
2173    #  if defined _LIBC || WIDE_CHAR_SUPPORT
2174    /* The GNU C library provides support for user-defined character classes
2175       and the functions from ISO C amendement 1.  */
2176    #   ifdef CHARCLASS_NAME_MAX
2177    #    define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
2178    #   else
2179    /* This shouldn't happen but some implementation might still have this
2180       problem.  Use a reasonable default value.  */
2181    #    define CHAR_CLASS_MAX_LENGTH 256
2182    #   endif
2183    
2184    #   ifdef _LIBC
2185    #    define IS_CHAR_CLASS(string) __wctype (string)
2186    #   else
2187    #    define IS_CHAR_CLASS(string) wctype (string)
2188    #   endif
2189    #  else
2190    #   define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */
2191    
2192  #define IS_CHAR_CLASS(string)                                           \  #   define IS_CHAR_CLASS(string)                                        \
2193     (STREQ (string, "alpha") || STREQ (string, "upper")                  \     (STREQ (string, "alpha") || STREQ (string, "upper")                  \
2194      || STREQ (string, "lower") || STREQ (string, "digit")               \      || STREQ (string, "lower") || STREQ (string, "digit")               \
2195      || STREQ (string, "alnum") || STREQ (string, "xdigit")              \      || STREQ (string, "alnum") || STREQ (string, "xdigit")              \
2196      || STREQ (string, "space") || STREQ (string, "print")               \      || STREQ (string, "space") || STREQ (string, "print")               \
2197      || STREQ (string, "punct") || STREQ (string, "graph")               \      || STREQ (string, "punct") || STREQ (string, "graph")               \
2198      || STREQ (string, "cntrl") || STREQ (string, "blank"))      || STREQ (string, "cntrl") || STREQ (string, "blank"))
2199    #  endif
2200    # endif /* DEFINED_ONCE */
2201    
2202    # ifndef MATCH_MAY_ALLOCATE
2203    
2204    /* If we cannot allocate large objects within re_match_2_internal,
2205       we make the fail stack and register vectors global.
2206       The fail stack, we grow to the maximum size when a regexp
2207       is compiled.
2208       The register vectors, we adjust in size each time we
2209       compile a regexp, according to the number of registers it needs.  */
2210    
2211    static PREFIX(fail_stack_type) fail_stack;
2212    
2213    /* Size with which the following vectors are currently allocated.
2214       That is so we can make them bigger as needed,
2215       but never make them smaller.  */
2216    #  ifdef DEFINED_ONCE
2217    static int regs_allocated_size;
2218    
2219    static const char **     regstart, **     regend;
2220    static const char ** old_regstart, ** old_regend;
2221    static const char **best_regstart, **best_regend;
2222    static const char **reg_dummy;
2223    #  endif /* DEFINED_ONCE */
2224    
2225    static PREFIX(register_info_type) *PREFIX(reg_info);
2226    static PREFIX(register_info_type) *PREFIX(reg_info_dummy);
2227    
2228    /* Make the register vectors big enough for NUM_REGS registers,
2229       but don't make them smaller.  */
2230    
2231    static void
2232    PREFIX(regex_grow_registers) (int num_regs)
2233    {
2234      if (num_regs > regs_allocated_size)
2235        {
2236          RETALLOC_IF (regstart,     num_regs, const char *);
2237          RETALLOC_IF (regend,       num_regs, const char *);
2238          RETALLOC_IF (old_regstart, num_regs, const char *);
2239          RETALLOC_IF (old_regend,   num_regs, const char *);
2240          RETALLOC_IF (best_regstart, num_regs, const char *);
2241          RETALLOC_IF (best_regend,  num_regs, const char *);
2242          RETALLOC_IF (PREFIX(reg_info), num_regs, PREFIX(register_info_type));
2243          RETALLOC_IF (reg_dummy,    num_regs, const char *);
2244          RETALLOC_IF (PREFIX(reg_info_dummy), num_regs, PREFIX(register_info_type));
2245    
2246          regs_allocated_size = num_regs;
2247        }
2248    }
2249    
2250    # endif /* not MATCH_MAY_ALLOCATE */
2251    
2252    # ifndef DEFINED_ONCE
2253    static boolean group_in_compile_stack (compile_stack_type
2254                                           compile_stack,
2255                                           regnum_t regnum);
2256    # endif /* not DEFINED_ONCE */
2257    
2258  /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.  /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.
2259     Returns one of error codes defined in `regex.h', or zero for success.     Returns one of error codes defined in `regex.h', or zero for success.
2260    
# Line 1476  typedef struct Line 2269  typedef struct
2269       `fastmap_accurate' is zero;       `fastmap_accurate' is zero;
2270       `re_nsub' is the number of subexpressions in PATTERN;       `re_nsub' is the number of subexpressions in PATTERN;
2271       `not_bol' and `not_eol' are zero;       `not_bol' and `not_eol' are zero;
2272      
2273     The `fastmap' and `newline_anchor' fields are neither     The `fastmap' and `newline_anchor' fields are neither
2274     examined nor set.  */     examined nor set.  */
2275    
2276  /* Return, freeing storage we allocated.  */  /* Return, freeing storage we allocated.  */
2277  #define FREE_STACK_RETURN(value)                \  # ifdef WCHAR
2278    #  define FREE_STACK_RETURN(value)              \
2279      return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value)
2280    # else
2281    #  define FREE_STACK_RETURN(value)              \
2282    return (free (compile_stack.stack), value)    return (free (compile_stack.stack), value)
2283    # endif /* WCHAR */
2284    
2285  static reg_errcode_t  static reg_errcode_t
2286  regex_compile (pattern, size, syntax, bufp)  PREFIX(regex_compile) (const char *ARG_PREFIX(pattern),
2287       const char *pattern;                         size_t ARG_PREFIX(size),
2288       int size;                         reg_syntax_t syntax,
2289       reg_syntax_t syntax;                         struct re_pattern_buffer *bufp)
      struct re_pattern_buffer *bufp;  
2290  {  {
2291    /* We fetch characters from PATTERN here.  Even though PATTERN is    /* We fetch characters from PATTERN here.  Even though PATTERN is
2292       `char *' (i.e., signed), we declare these variables as unsigned, so       `char *' (i.e., signed), we declare these variables as unsigned, so
2293       they can be reliably used as array indices.  */       they can be reliably used as array indices.  */
2294    register unsigned char c, c1;    register UCHAR_T c, c1;
2295      
2296    #ifdef WCHAR
2297      /* A temporary space to keep wchar_t pattern and compiled pattern.  */
2298      CHAR_T *pattern, *COMPILED_BUFFER_VAR;
2299      size_t size;
2300      /* offset buffer for optimization. See convert_mbs_to_wc.  */
2301      int *mbs_offset = NULL;
2302      /* It hold whether each wchar_t is binary data or not.  */
2303      char *is_binary = NULL;
2304      /* A flag whether exactn is handling binary data or not.  */
2305      char is_exactn_bin = FALSE;
2306    #endif /* WCHAR */
2307    
2308    /* A random temporary spot in PATTERN.  */    /* A random temporary spot in PATTERN.  */
2309    const char *p1;    const CHAR_T *p1;
2310    
2311    /* Points to the end of the buffer, where we should append.  */    /* Points to the end of the buffer, where we should append.  */
2312    register unsigned char *b;    register UCHAR_T *b;
2313      
2314    /* Keeps track of unclosed groups.  */    /* Keeps track of unclosed groups.  */
2315    compile_stack_type compile_stack;    compile_stack_type compile_stack;
2316    
2317    /* Points to the current (ending) position in the pattern.  */    /* Points to the current (ending) position in the pattern.  */
2318    const char *p = pattern;  #ifdef WCHAR
2319    const char *pend = pattern + size;    const CHAR_T *p;
2320        const CHAR_T *pend;
2321    #else /* BYTE */
2322      const CHAR_T *p = pattern;
2323      const CHAR_T *pend = pattern + size;
2324    #endif /* WCHAR */
2325    
2326    /* How to translate the characters in the pattern.  */    /* How to translate the characters in the pattern.  */
2327    char *translate = bufp->translate;    RE_TRANSLATE_TYPE translate = bufp->translate;
2328    
2329    /* Address of the count-byte of the most recently inserted `exactn'    /* Address of the count-byte of the most recently inserted `exactn'
2330       command.  This makes it possible to tell if a new exact-match       command.  This makes it possible to tell if a new exact-match
2331       character can be added to that command or if the character requires       character can be added to that command or if the character requires
2332       a new `exactn' command.  */       a new `exactn' command.  */
2333    unsigned char *pending_exact = 0;    UCHAR_T *pending_exact = 0;
2334    
2335    /* Address of start of the most recently finished expression.    /* Address of start of the most recently finished expression.
2336       This tells, e.g., postfix * where to find the start of its       This tells, e.g., postfix * where to find the start of its
2337       operand.  Reset at the beginning of groups and alternatives.  */       operand.  Reset at the beginning of groups and alternatives.  */
2338    unsigned char *laststart = 0;    UCHAR_T *laststart = 0;
2339    
2340    /* Address of beginning of regexp, or inside of last group.  */    /* Address of beginning of regexp, or inside of last group.  */
2341    unsigned char *begalt;    UCHAR_T *begalt;
2342    
   /* Place in the uncompiled pattern (i.e., the {) to  
      which to go back if the interval is invalid.  */  
   const char *beg_interval;  
                   
2343    /* Address of the place where a forward jump should go to the end of    /* Address of the place where a forward jump should go to the end of
2344       the containing expression.  Each alternative of an `or' -- except the       the containing expression.  Each alternative of an `or' -- except the
2345       last -- ends with a forward jump of this sort.  */       last -- ends with a forward jump of this sort.  */
2346    unsigned char *fixup_alt_jump = 0;    UCHAR_T *fixup_alt_jump = 0;
2347    
2348    /* Counts open-groups as they are encountered.  Remembered for the    /* Counts open-groups as they are encountered.  Remembered for the
2349       matching close-group on the compile stack, so the same register       matching close-group on the compile stack, so the same register
2350       number is put in the stop_memory as the start_memory.  */       number is put in the stop_memory as the start_memory.  */
2351    regnum_t regnum = 0;    regnum_t regnum = 0;
2352    
2353    #ifdef WCHAR
2354      /* Initialize the wchar_t PATTERN and offset_buffer.  */
2355      p = pend = pattern = TALLOC(csize + 1, CHAR_T);
2356      mbs_offset = TALLOC(csize + 1, int);
2357      is_binary = TALLOC(csize + 1, char);
2358      if (pattern == NULL || mbs_offset == NULL || is_binary == NULL)
2359        {
2360          free(pattern);
2361          free(mbs_offset);
2362          free(is_binary);
2363          return REG_ESPACE;
2364        }
2365      pattern[csize] = L'\0';       /* sentinel */
2366      size = convert_mbs_to_wcs(pattern, cpattern, csize, mbs_offset, is_binary);
2367      pend = p + size;
2368      if (size < 0)
2369        {
2370          free(pattern);
2371          free(mbs_offset);
2372          free(is_binary);
2373          return REG_BADPAT;
2374        }
2375    #endif
2376    
2377  #ifdef DEBUG  #ifdef DEBUG
2378    DEBUG_PRINT1 ("\nCompiling pattern: ");    DEBUG_PRINT1 ("\nCompiling pattern: ");
2379    if (debug)    if (debug)
2380      {      {
2381        unsigned debug_count;        unsigned debug_count;
2382          
2383        for (debug_count = 0; debug_count < size; debug_count++)        for (debug_count = 0; debug_count < size; debug_count++)
2384          printchar (pattern[debug_count]);          PUT_CHAR (pattern[debug_count]);
2385        putchar ('\n');        putchar ('\n');
2386      }      }
2387  #endif /* DEBUG */  #endif /* DEBUG */
# Line 1555  regex_compile (pattern, size, syntax, bu Line 2389  regex_compile (pattern, size, syntax, bu
2389    /* Initialize the compile stack.  */    /* Initialize the compile stack.  */
2390    compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);    compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
2391    if (compile_stack.stack == NULL)    if (compile_stack.stack == NULL)
2392      return REG_ESPACE;      {
2393    #ifdef WCHAR
2394          free(pattern);
2395          free(mbs_offset);
2396          free(is_binary);
2397    #endif
2398          return REG_ESPACE;
2399        }
2400    
2401    compile_stack.size = INIT_COMPILE_STACK_SIZE;    compile_stack.size = INIT_COMPILE_STACK_SIZE;
2402    compile_stack.avail = 0;    compile_stack.avail = 0;
# Line 1569  regex_compile (pattern, size, syntax, bu Line 2410  regex_compile (pattern, size, syntax, bu
2410       printer (for debugging) will think there's no pattern.  We reset it       printer (for debugging) will think there's no pattern.  We reset it
2411       at the end.  */       at the end.  */
2412    bufp->used = 0;    bufp->used = 0;
2413      
2414    /* Always count groups, whether or not bufp->no_sub is set.  */    /* Always count groups, whether or not bufp->no_sub is set.  */
2415    bufp->re_nsub = 0;                                bufp->re_nsub = 0;
2416    
2417  #if !defined (emacs) && !defined (SYNTAX_TABLE)  #if !defined emacs && !defined SYNTAX_TABLE
2418    /* Initialize the syntax table.  */    /* Initialize the syntax table.  */
2419     init_syntax_once ();     init_syntax_once ();
2420  #endif  #endif
# Line 1584  regex_compile (pattern, size, syntax, bu Line 2425  regex_compile (pattern, size, syntax, bu
2425          { /* If zero allocated, but buffer is non-null, try to realloc          { /* If zero allocated, but buffer is non-null, try to realloc
2426               enough space.  This loses if buffer's address is bogus, but               enough space.  This loses if buffer's address is bogus, but
2427               that is the user's responsibility.  */               that is the user's responsibility.  */
2428            RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char);  #ifdef WCHAR
2429              /* Free bufp->buffer and allocate an array for wchar_t pattern
2430                 buffer.  */
2431              free(bufp->buffer);
2432              COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE/sizeof(UCHAR_T),
2433                                            UCHAR_T);
2434    #else
2435              RETALLOC (COMPILED_BUFFER_VAR, INIT_BUF_SIZE, UCHAR_T);
2436    #endif /* WCHAR */
2437          }          }
2438        else        else
2439          { /* Caller did not allocate a buffer.  Do it for them.  */          { /* Caller did not allocate a buffer.  Do it for them.  */
2440            bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char);            COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE / sizeof(UCHAR_T),
2441                                            UCHAR_T);
2442          }          }
       if (!bufp->buffer) FREE_STACK_RETURN (REG_ESPACE);  
2443    
2444          if (!COMPILED_BUFFER_VAR) FREE_STACK_RETURN (REG_ESPACE);
2445    #ifdef WCHAR
2446          bufp->buffer = (char*)COMPILED_BUFFER_VAR;
2447    #endif /* WCHAR */
2448        bufp->allocated = INIT_BUF_SIZE;        bufp->allocated = INIT_BUF_SIZE;
2449      }      }
2450    #ifdef WCHAR
2451      else
2452        COMPILED_BUFFER_VAR = (UCHAR_T*) bufp->buffer;
2453    #endif
2454    
2455    begalt = b = bufp->buffer;    begalt = b = COMPILED_BUFFER_VAR;
2456    
2457    /* Loop through the uncompiled pattern until we're at the end.  */    /* Loop through the uncompiled pattern until we're at the end.  */
2458    while (p != pend)    while (p != pend)
# Line 1611  regex_compile (pattern, size, syntax, bu Line 2468  regex_compile (pattern, size, syntax, bu
2468                     /* If context independent, it's an operator.  */                     /* If context independent, it's an operator.  */
2469                  || syntax & RE_CONTEXT_INDEP_ANCHORS                  || syntax & RE_CONTEXT_INDEP_ANCHORS
2470                     /* Otherwise, depends on what's come before.  */                     /* Otherwise, depends on what's come before.  */
2471                  || at_begline_loc_p (pattern, p, syntax))                  || PREFIX(at_begline_loc_p) (pattern, p, syntax))
2472                BUF_PUSH (begline);                BUF_PUSH (begline);
2473              else              else
2474                goto normal_char;                goto normal_char;
# Line 1622  regex_compile (pattern, size, syntax, bu Line 2479  regex_compile (pattern, size, syntax, bu
2479          case '$':          case '$':
2480            {            {
2481              if (   /* If at end of pattern, it's an operator.  */              if (   /* If at end of pattern, it's an operator.  */
2482                     p == pend                     p == pend
2483                     /* If context independent, it's an operator.  */                     /* If context independent, it's an operator.  */
2484                  || syntax & RE_CONTEXT_INDEP_ANCHORS                  || syntax & RE_CONTEXT_INDEP_ANCHORS
2485                     /* Otherwise, depends on what's next.  */                     /* Otherwise, depends on what's next.  */
2486                  || at_endline_loc_p (p, pend, syntax))                  || PREFIX(at_endline_loc_p) (p, pend, syntax))
2487                 BUF_PUSH (endline);                 BUF_PUSH (endline);
2488               else               else
2489                 goto normal_char;                 goto normal_char;
# Line 1653  regex_compile (pattern, size, syntax, bu Line 2510  regex_compile (pattern, size, syntax, bu
2510            {            {
2511              /* Are we optimizing this jump?  */              /* Are we optimizing this jump?  */
2512              boolean keep_string_p = false;              boolean keep_string_p = false;
2513                
2514              /* 1 means zero (many) matches is allowed.  */              /* 1 means zero (many) matches is allowed.  */
2515              char zero_times_ok = 0, many_times_ok = 0;              char zero_times_ok = 0, many_times_ok = 0;
2516    
# Line 1701  regex_compile (pattern, size, syntax, bu Line 2558  regex_compile (pattern, size, syntax, bu
2558    
2559              /* Star, etc. applied to an empty pattern is equivalent              /* Star, etc. applied to an empty pattern is equivalent
2560                 to an empty pattern.  */                 to an empty pattern.  */
2561              if (!laststart)                if (!laststart)
2562                break;                break;
2563    
2564              /* Now we know whether or not zero matches is allowed              /* Now we know whether or not zero matches is allowed
# Line 1710  regex_compile (pattern, size, syntax, bu Line 2567  regex_compile (pattern, size, syntax, bu
2567                { /* More than one repetition is allowed, so put in at the                { /* More than one repetition is allowed, so put in at the
2568                     end a backward relative jump from `b' to before the next                     end a backward relative jump from `b' to before the next
2569                     jump we're going to put in below (which jumps from                     jump we're going to put in below (which jumps from
2570                     laststart to after this jump).                       laststart to after this jump).
2571    
2572                     But if we are at the `*' in the exact sequence `.*\n',                     But if we are at the `*' in the exact sequence `.*\n',
2573                     insert an unconditional jump backwards to the .,                     insert an unconditional jump backwards to the .,
# Line 1720  regex_compile (pattern, size, syntax, bu Line 2577  regex_compile (pattern, size, syntax, bu
2577                  assert (p - 1 > pattern);                  assert (p - 1 > pattern);
2578    
2579                  /* Allocate the space for the jump.  */                  /* Allocate the space for the jump.  */
2580                  GET_BUFFER_SPACE (3);                  GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
2581    
2582                  /* We know we are not at the first character of the pattern,                  /* We know we are not at the first character of the pattern,
2583                     because laststart was nonzero.  And we've already                     because laststart was nonzero.  And we've already
# Line 1737  regex_compile (pattern, size, syntax, bu Line 2594  regex_compile (pattern, size, syntax, bu
2594                    }                    }
2595                  else                  else
2596                    /* Anything else.  */                    /* Anything else.  */
2597                    STORE_JUMP (maybe_pop_jump, b, laststart - 3);                    STORE_JUMP (maybe_pop_jump, b, laststart -
2598                                  (1 + OFFSET_ADDRESS_SIZE));
2599    
2600                  /* We've added more stuff to the buffer.  */                  /* We've added more stuff to the buffer.  */
2601                  b += 3;                  b += 1 + OFFSET_ADDRESS_SIZE;
2602                }                }
2603    
2604              /* On failure, jump from laststart to b + 3, which will be the              /* On failure, jump from laststart to b + 3, which will be the
2605                 end of the buffer after this jump is inserted.  */                 end of the buffer after this jump is inserted.  */
2606              GET_BUFFER_SPACE (3);              /* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE' instead of
2607                   'b + 3'.  */
2608                GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
2609              INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump              INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump
2610                                         : on_failure_jump,                                         : on_failure_jump,
2611                           laststart, b + 3);                           laststart, b + 1 + OFFSET_ADDRESS_SIZE);
2612              pending_exact = 0;              pending_exact = 0;
2613              b += 3;              b += 1 + OFFSET_ADDRESS_SIZE;
2614    
2615              if (!zero_times_ok)              if (!zero_times_ok)
2616                {                {
# Line 1759  regex_compile (pattern, size, syntax, bu Line 2619  regex_compile (pattern, size, syntax, bu
2619                     `on_failure_jump' instruction of the loop. This                     `on_failure_jump' instruction of the loop. This
2620                     effects a skip over that instruction the first time                     effects a skip over that instruction the first time
2621                     we hit that loop.  */                     we hit that loop.  */
2622                  GET_BUFFER_SPACE (3);                  GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
2623                  INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6);                  INSERT_JUMP (dummy_failure_jump, laststart, laststart +
2624                  b += 3;                               2 + 2 * OFFSET_ADDRESS_SIZE);
2625                    b += 1 + OFFSET_ADDRESS_SIZE;
2626                }                }
2627              }              }
2628            break;            break;
# Line 1776  regex_compile (pattern, size, syntax, bu Line 2637  regex_compile (pattern, size, syntax, bu
2637          case '[':          case '[':
2638            {            {
2639              boolean had_char_class = false;              boolean had_char_class = false;
2640    #ifdef WCHAR
2641                CHAR_T range_start = 0xffffffff;
2642    #else
2643                unsigned int range_start = 0xffffffff;
2644    #endif
2645              if (p == pend) FREE_STACK_RETURN (REG_EBRACK);              if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
2646    
2647    #ifdef WCHAR
2648                /* We assume a charset(_not) structure as a wchar_t array.
2649                   charset[0] = (re_opcode_t) charset(_not)
2650                   charset[1] = l (= length of char_classes)
2651                   charset[2] = m (= length of collating_symbols)
2652                   charset[3] = n (= length of equivalence_classes)
2653                   charset[4] = o (= length of char_ranges)
2654                   charset[5] = p (= length of chars)
2655    
2656                   charset[6] = char_class (wctype_t)
2657                   charset[6+CHAR_CLASS_SIZE] = char_class (wctype_t)
2658                             ...
2659                   charset[l+5]  = char_class (wctype_t)
2660    
2661                   charset[l+6]  = collating_symbol (wchar_t)
2662                                ...
2663                   charset[l+m+5]  = collating_symbol (wchar_t)
2664                                            ifdef _LIBC we use the index if
2665                                            _NL_COLLATE_SYMB_EXTRAMB instead of
2666                                            wchar_t string.
2667    
2668                   charset[l+m+6]  = equivalence_classes (wchar_t)
2669                                  ...
2670                   charset[l+m+n+5]  = equivalence_classes (wchar_t)
2671                                            ifdef _LIBC we use the index in
2672                                            _NL_COLLATE_WEIGHT instead of
2673                                            wchar_t string.
2674    
2675                   charset[l+m+n+6] = range_start
2676                   charset[l+m+n+7] = range_end
2677                                   ...
2678                   charset[l+m+n+2o+4] = range_start
2679                   charset[l+m+n+2o+5] = range_end
2680                                            ifdef _LIBC we use the value looked up
2681                                            in _NL_COLLATE_COLLSEQ instead of
2682                                            wchar_t character.
2683    
2684                   charset[l+m+n+2o+6] = char
2685                                      ...
2686                   charset[l+m+n+2o+p+5] = char
2687    
2688                 */
2689    
2690                /* We need at least 6 spaces: the opcode, the length of
2691                   char_classes, the length of collating_symbols, the length of
2692                   equivalence_classes, the length of char_ranges, the length of
2693                   chars.  */
2694                GET_BUFFER_SPACE (6);
2695    
2696                /* Save b as laststart. And We use laststart as the pointer
2697                   to the first element of the charset here.
2698                   In other words, laststart[i] indicates charset[i].  */
2699                laststart = b;
2700    
2701                /* We test `*p == '^' twice, instead of using an if
2702                   statement, so we only need one BUF_PUSH.  */
2703                BUF_PUSH (*p == '^' ? charset_not : charset);
2704                if (*p == '^')
2705                  p++;
2706    
2707                /* Push the length of char_classes, the length of
2708                   collating_symbols, the length of equivalence_classes, the
2709                   length of char_ranges and the length of chars.  */
2710                BUF_PUSH_3 (0, 0, 0);
2711                BUF_PUSH_2 (0, 0);
2712    
2713                /* Remember the first position in the bracket expression.  */
2714                p1 = p;
2715    
2716                /* charset_not matches newline according to a syntax bit.  */
2717                if ((re_opcode_t) b[-6] == charset_not
2718                    && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
2719                  {
2720                    BUF_PUSH('\n');
2721                    laststart[5]++; /* Update the length of characters  */
2722                  }
2723    
2724                /* Read in characters and ranges, setting map bits.  */
2725                for (;;)
2726                  {
2727                    if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
2728    
2729                    PATFETCH (c);
2730    
2731                    /* \ might escape characters inside [...] and [^...].  */
2732                    if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
2733                      {
2734                        if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
2735    
2736                        PATFETCH (c1);
2737                        BUF_PUSH(c1);
2738                        laststart[5]++; /* Update the length of chars  */
2739                        range_start = c1;
2740                        continue;
2741                      }
2742    
2743                    /* Could be the end of the bracket expression.  If it's
2744                       not (i.e., when the bracket expression is `[]' so
2745                       far), the ']' character bit gets set way below.  */
2746                    if (c == ']' && p != p1 + 1)
2747                      break;
2748    
2749                    /* Look ahead to see if it's a range when the last thing
2750                       was a character class.  */
2751                    if (had_char_class && c == '-' && *p != ']')
2752                      FREE_STACK_RETURN (REG_ERANGE);
2753    
2754                    /* Look ahead to see if it's a range when the last thing
2755                       was a character: if this is a hyphen not at the
2756                       beginning or the end of a list, then it's the range
2757                       operator.  */
2758                    if (c == '-'
2759                        && !(p - 2 >= pattern && p[-2] == '[')
2760                        && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
2761                        && *p != ']')
2762                      {
2763                        reg_errcode_t ret;
2764                        /* Allocate the space for range_start and range_end.  */
2765                        GET_BUFFER_SPACE (2);
2766                        /* Update the pointer to indicate end of buffer.  */
2767                        b += 2;
2768                        ret = wcs_compile_range (range_start, &p, pend, translate,
2769                                             syntax, b, laststart);
2770                        if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
2771                        range_start = 0xffffffff;
2772                      }
2773                    else if (p[0] == '-' && p[1] != ']')
2774                      { /* This handles ranges made up of characters only.  */
2775                        reg_errcode_t ret;
2776    
2777                        /* Move past the `-'.  */
2778                        PATFETCH (c1);
2779                        /* Allocate the space for range_start and range_end.  */
2780                        GET_BUFFER_SPACE (2);
2781                        /* Update the pointer to indicate end of buffer.  */
2782                        b += 2;
2783                        ret = wcs_compile_range (c, &p, pend, translate, syntax, b,
2784                                             laststart);
2785                        if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
2786                        range_start = 0xffffffff;
2787                      }
2788    
2789                    /* See if we're at the beginning of a possible character
2790                       class.  */
2791                    else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
2792                      { /* Leave room for the null.  */
2793                        char str[CHAR_CLASS_MAX_LENGTH + 1];
2794    
2795                        PATFETCH (c);
2796                        c1 = 0;
2797    
2798                        /* If pattern is `[[:'.  */
2799                        if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
2800    
2801                        for (;;)
2802                          {
2803                            PATFETCH (c);
2804                            if ((c == ':' && *p == ']') || p == pend)
2805                              break;
2806                            if (c1 < CHAR_CLASS_MAX_LENGTH)
2807                              str[c1++] = c;
2808                            else
2809                              /* This is in any case an invalid class name.  */
2810                              str[0] = '\0';
2811                          }
2812                        str[c1] = '\0';
2813    
2814                        /* If isn't a word bracketed by `[:' and `:]':
2815                           undo the ending character, the letters, and leave
2816                           the leading `:' and `[' (but store them as character).  */
2817                        if (c == ':' && *p == ']')
2818                          {
2819                            wctype_t wt;
2820                            uintptr_t alignedp;
2821    
2822                            /* Query the character class as wctype_t.  */
2823                            wt = IS_CHAR_CLASS (str);
2824                            if (wt == 0)
2825                              FREE_STACK_RETURN (REG_ECTYPE);
2826    
2827                            /* Throw away the ] at the end of the character
2828                               class.  */
2829                            PATFETCH (c);
2830    
2831                            if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
2832    
2833                            /* Allocate the space for character class.  */
2834                            GET_BUFFER_SPACE(CHAR_CLASS_SIZE);
2835                            /* Update the pointer to indicate end of buffer.  */
2836                            b += CHAR_CLASS_SIZE;
2837                            /* Move data which follow character classes
2838                                not to violate the data.  */
2839                            insert_space(CHAR_CLASS_SIZE,
2840                                         laststart + 6 + laststart[1],
2841                                         b - 1);
2842                            alignedp = ((uintptr_t)(laststart + 6 + laststart[1])
2843                                        + __alignof__(wctype_t) - 1)
2844                                        & ~(uintptr_t)(__alignof__(wctype_t) - 1);
2845                            /* Store the character class.  */
2846                            *((wctype_t*)alignedp) = wt;
2847                            /* Update length of char_classes */
2848                            laststart[1] += CHAR_CLASS_SIZE;
2849    
2850                            had_char_class = true;
2851                          }
2852                        else
2853                          {
2854                            c1++;
2855                            while (c1--)
2856                              PATUNFETCH;
2857                            BUF_PUSH ('[');
2858                            BUF_PUSH (':');
2859                            laststart[5] += 2; /* Update the length of characters  */
2860                            range_start = ':';
2861                            had_char_class = false;
2862                          }
2863                      }
2864                    else if (syntax & RE_CHAR_CLASSES && c == '[' && (*p == '='
2865                                                              || *p == '.'))
2866                      {
2867                        CHAR_T str[128];    /* Should be large enough.  */
2868                        CHAR_T delim = *p; /* '=' or '.'  */
2869    # ifdef _LIBC
2870                        uint32_t nrules =
2871                          _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
2872    # endif
2873                        PATFETCH (c);
2874                        c1 = 0;
2875    
2876                        /* If pattern is `[[=' or '[[.'.  */
2877                        if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
2878    
2879                        for (;;)
2880                          {
2881                            PATFETCH (c);
2882                            if ((c == delim && *p == ']') || p == pend)
2883                              break;
2884                            if (c1 < sizeof (str) - 1)
2885                              str[c1++] = c;
2886                            else
2887                              /* This is in any case an invalid class name.  */
2888                              str[0] = '\0';
2889                          }
2890                        str[c1] = '\0';
2891    
2892                        if (c == delim && *p == ']' && str[0] != '\0')
2893                          {
2894                            unsigned int i, offset;
2895                            /* If we have no collation data we use the default
2896                               collation in which each character is in a class
2897                               by itself.  It also means that ASCII is the
2898                               character set and therefore we cannot have character
2899                               with more than one byte in the multibyte
2900                               representation.  */
2901    
2902                            /* If not defined _LIBC, we push the name and
2903                               `\0' for the sake of matching performance.  */
2904                            int datasize = c1 + 1;
2905    
2906    # ifdef _LIBC
2907                            int32_t idx = 0;
2908                            if (nrules == 0)
2909    # endif
2910                              {
2911                                if (c1 != 1)
2912                                  FREE_STACK_RETURN (REG_ECOLLATE);
2913                              }
2914    # ifdef _LIBC
2915                            else
2916                              {
2917                                const int32_t *table;
2918                                const int32_t *weights;
2919                                const int32_t *extra;
2920                                const int32_t *indirect;
2921                                wint_t *cp;
2922    
2923                                /* This #include defines a local function!  */
2924    #  include <locale/weightwc.h>
2925    
2926                                if(delim == '=')
2927                                  {
2928                                    /* We push the index for equivalence class.  */
2929                                    cp = (wint_t*)str;
2930    
2931                                    table = (const int32_t *)
2932                                      _NL_CURRENT (LC_COLLATE,
2933                                                   _NL_COLLATE_TABLEWC);
2934                                    weights = (const int32_t *)
2935                                      _NL_CURRENT (LC_COLLATE,
2936                                                   _NL_COLLATE_WEIGHTWC);
2937                                    extra = (const int32_t *)
2938                                      _NL_CURRENT (LC_COLLATE,
2939                                                   _NL_COLLATE_EXTRAWC);
2940                                    indirect = (const int32_t *)
2941                                      _NL_CURRENT (LC_COLLATE,
2942                                                   _NL_COLLATE_INDIRECTWC);
2943    
2944                                    idx = findidx ((const wint_t**)&cp);
2945                                    if (idx == 0 || cp < (wint_t*) str + c1)
2946                                      /* This is no valid character.  */
2947                                      FREE_STACK_RETURN (REG_ECOLLATE);
2948    
2949                                    str[0] = (wchar_t)idx;
2950                                  }
2951                                else /* delim == '.' */
2952                                  {
2953                                    /* We push collation sequence value
2954                                       for collating symbol.  */
2955                                    int32_t table_size;
2956                                    const int32_t *symb_table;
2957                                    const unsigned char *extra;
2958                                    int32_t idx;
2959                                    int32_t elem;
2960                                    int32_t second;
2961                                    int32_t hash;
2962                                    char char_str[c1];
2963    
2964                                    /* We have to convert the name to a single-byte
2965                                       string.  This is possible since the names
2966                                       consist of ASCII characters and the internal
2967                                       representation is UCS4.  */
2968                                    for (i = 0; i < c1; ++i)
2969                                      char_str[i] = str[i];
2970    
2971                                    table_size =
2972                                      _NL_CURRENT_WORD (LC_COLLATE,
2973                                                        _NL_COLLATE_SYMB_HASH_SIZEMB);
2974                                    symb_table = (const int32_t *)
2975                                      _NL_CURRENT (LC_COLLATE,
2976                                                   _NL_COLLATE_SYMB_TABLEMB);
2977                                    extra = (const unsigned char *)
2978                                      _NL_CURRENT (LC_COLLATE,
2979                                                   _NL_COLLATE_SYMB_EXTRAMB);
2980    
2981                                    /* Locate the character in the hashing table.  */
2982                                    hash = elem_hash (char_str, c1);
2983    
2984                                    idx = 0;
2985                                    elem = hash % table_size;
2986                                    second = hash % (table_size - 2);
2987                                    while (symb_table[2 * elem] != 0)
2988                                      {
2989                                        /* First compare the hashing value.  */
2990                                        if (symb_table[2 * elem] == hash
2991                                            && c1 == extra[symb_table[2 * elem + 1]]
2992                                            && memcmp (char_str,
2993                                                       &extra[symb_table[2 * elem + 1]
2994                                                             + 1], c1) == 0)
2995                                          {
2996                                            /* Yep, this is the entry.  */
2997                                            idx = symb_table[2 * elem + 1];
2998                                            idx += 1 + extra[idx];
2999                                            break;
3000                                          }
3001    
3002                                        /* Next entry.  */
3003                                        elem += second;
3004                                      }
3005    
3006                                    if (symb_table[2 * elem] != 0)
3007                                      {
3008                                        /* Compute the index of the byte sequence
3009                                           in the table.  */
3010                                        idx += 1 + extra[idx];
3011                                        /* Adjust for the alignment.  */
3012                                        idx = (idx + 3) & ~3;
3013    
3014                                        str[0] = (wchar_t) idx + 4;
3015                                      }
3016                                    else if (symb_table[2 * elem] == 0 && c1 == 1)
3017                                      {
3018                                        /* No valid character.  Match it as a
3019                                           single byte character.  */
3020                                        had_char_class = false;
3021                                        BUF_PUSH(str[0]);
3022                                        /* Update the length of characters  */
3023                                        laststart[5]++;
3024                                        range_start = str[0];
3025    
3026                                        /* Throw away the ] at the end of the
3027                                           collating symbol.  */
3028                                        PATFETCH (c);
3029                                        /* exit from the switch block.  */
3030                                        continue;
3031                                      }
3032                                    else
3033                                      FREE_STACK_RETURN (REG_ECOLLATE);
3034                                  }
3035                                datasize = 1;
3036                              }
3037    # endif
3038                            /* Throw away the ] at the end of the equivalence
3039                               class (or collating symbol).  */
3040                            PATFETCH (c);
3041    
3042                            /* Allocate the space for the equivalence class
3043                               (or collating symbol) (and '\0' if needed).  */
3044                            GET_BUFFER_SPACE(datasize);
3045                            /* Update the pointer to indicate end of buffer.  */
3046                            b += datasize;
3047    
3048                            if (delim == '=')
3049                              { /* equivalence class  */
3050                                /* Calculate the offset of char_ranges,
3051                                   which is next to equivalence_classes.  */
3052                                offset = laststart[1] + laststart[2]
3053                                  + laststart[3] +6;
3054                                /* Insert space.  */
3055                                insert_space(datasize, laststart + offset, b - 1);
3056    
3057                                /* Write the equivalence_class and \0.  */
3058                                for (i = 0 ; i < datasize ; i++)
3059                                  laststart[offset + i] = str[i];
3060    
3061                                /* Update the length of equivalence_classes.  */
3062                                laststart[3] += datasize;
3063                                had_char_class = true;
3064                              }
3065                            else /* delim == '.' */
3066                              { /* collating symbol  */
3067                                /* Calculate the offset of the equivalence_classes,
3068                                   which is next to collating_symbols.  */
3069                                offset = laststart[1] + laststart[2] + 6;
3070                                /* Insert space and write the collationg_symbol
3071                                   and \0.  */
3072                                insert_space(datasize, laststart + offset, b-1);
3073                                for (i = 0 ; i < datasize ; i++)
3074                                  laststart[offset + i] = str[i];
3075    
3076                                /* In re_match_2_internal if range_start < -1, we
3077                                   assume -range_start is the offset of the
3078                                   collating symbol which is specified as
3079                                   the character of the range start.  So we assign
3080                                   -(laststart[1] + laststart[2] + 6) to
3081                                   range_start.  */
3082                                range_start = -(laststart[1] + laststart[2] + 6);
3083                                /* Update the length of collating_symbol.  */
3084                                laststart[2] += datasize;
3085                                had_char_class = false;
3086                              }
3087                          }
3088                        else
3089                          {
3090                            c1++;
3091                            while (c1--)
3092                              PATUNFETCH;
3093                            BUF_PUSH ('[');
3094                            BUF_PUSH (delim);
3095                            laststart[5] += 2; /* Update the length of characters  */
3096                            range_start = delim;
3097                            had_char_class = false;
3098                          }
3099                      }
3100                    else
3101                      {
3102                        had_char_class = false;
3103                        BUF_PUSH(c);
3104                        laststart[5]++;  /* Update the length of characters  */
3105                        range_start = c;
3106                      }
3107                  }
3108    
3109    #else /* BYTE */
3110              /* Ensure that we have enough space to push a charset: the              /* Ensure that we have enough space to push a charset: the
3111                 opcode, the length count, and the bitset; 34 bytes in all.  */                 opcode, the length count, and the bitset; 34 bytes in all.  */
3112              GET_BUFFER_SPACE (34);              GET_BUFFER_SPACE (34);
# Line 1787  regex_compile (pattern, size, syntax, bu Line 3115  regex_compile (pattern, size, syntax, bu
3115    
3116              /* We test `*p == '^' twice, instead of using an if              /* We test `*p == '^' twice, instead of using an if
3117                 statement, so we only need one BUF_PUSH.  */                 statement, so we only need one BUF_PUSH.  */
3118              BUF_PUSH (*p == '^' ? charset_not : charset);              BUF_PUSH (*p == '^' ? charset_not : charset);
3119              if (*p == '^')              if (*p == '^')
3120                p++;                p++;
3121    
# Line 1819  regex_compile (pattern, size, syntax, bu Line 3147  regex_compile (pattern, size, syntax, bu
3147    
3148                      PATFETCH (c1);                      PATFETCH (c1);
3149                      SET_LIST_BIT (c1);                      SET_LIST_BIT (c1);
3150                        range_start = c1;
3151                      continue;                      continue;
3152                    }                    }
3153    
# Line 1837  regex_compile (pattern, size, syntax, bu Line 3166  regex_compile (pattern, size, syntax, bu
3166                     was a character: if this is a hyphen not at the                     was a character: if this is a hyphen not at the
3167                     beginning or the end of a list, then it's the range                     beginning or the end of a list, then it's the range
3168                     operator.  */                     operator.  */
3169                  if (c == '-'                  if (c == '-'
3170                      && !(p - 2 >= pattern && p[-2] == '[')                      && !(p - 2 >= pattern && p[-2] == '[')
3171                      && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')                      && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
3172                      && *p != ']')                      && *p != ']')
3173                    {                    {
3174                      reg_errcode_t ret                      reg_errcode_t ret
3175                        = compile_range (&p, pend, translate, syntax, b);                        = byte_compile_range (range_start, &p, pend, translate,
3176                                                syntax, b);
3177                      if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);                      if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
3178                        range_start = 0xffffffff;
3179                    }                    }
3180    
3181                  else if (p[0] == '-' && p[1] != ']')                  else if (p[0] == '-' && p[1] != ']')
# Line 1853  regex_compile (pattern, size, syntax, bu Line 3184  regex_compile (pattern, size, syntax, bu
3184    
3185                      /* Move past the `-'.  */                      /* Move past the `-'.  */
3186                      PATFETCH (c1);                      PATFETCH (c1);
3187                        
3188                      ret = compile_range (&p, pend, translate, syntax, b);                      ret = byte_compile_range (c, &p, pend, translate, syntax, b);
3189                      if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);                      if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
3190                        range_start = 0xffffffff;
3191                    }                    }
3192    
3193                  /* See if we're at the beginning of a possible character                  /* See if we're at the beginning of a possible character
# Line 1874  regex_compile (pattern, size, syntax, bu Line 3206  regex_compile (pattern, size, syntax, bu
3206                      for (;;)                      for (;;)
3207                        {                        {
3208                          PATFETCH (c);                          PATFETCH (c);
3209                          if (c == ':' || c == ']' || p == pend                          if ((c == ':' && *p == ']') || p == pend)
                             || c1 == CHAR_CLASS_MAX_LENGTH)  
3210                            break;                            break;
3211                          str[c1++] = c;                          if (c1 < CHAR_CLASS_MAX_LENGTH)
3212                              str[c1++] = c;
3213                            else
3214                              /* This is in any case an invalid class name.  */
3215                              str[0] = '\0';
3216                        }                        }
3217                      str[c1] = '\0';                      str[c1] = '\0';
3218    
3219                      /* If isn't a word bracketed by `[:' and:`]':                      /* If isn't a word bracketed by `[:' and `:]':
3220                         undo the ending character, the letters, and leave                         undo the ending character, the letters, and leave
3221                         the leading `:' and `[' (but set bits for them).  */                         the leading `:' and `[' (but set bits for them).  */
3222                      if (c == ':' && *p == ']')                      if (c == ':' && *p == ']')
3223                        {                        {
3224    # if defined _LIBC || WIDE_CHAR_SUPPORT
3225                            boolean is_lower = STREQ (str, "lower");
3226                            boolean is_upper = STREQ (str, "upper");
3227                            wctype_t wt;
3228                            int ch;
3229    
3230                            wt = IS_CHAR_CLASS (str);
3231                            if (wt == 0)
3232                              FREE_STACK_RETURN (REG_ECTYPE);
3233    
3234                            /* Throw away the ] at the end of the character
3235                               class.  */
3236                            PATFETCH (c);
3237    
3238                            if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
3239    
3240                            for (ch = 0; ch < 1 << BYTEWIDTH; ++ch)
3241                              {
3242                                if (iswctype (btowc (ch), wt))
3243                                  SET_LIST_BIT (ch);
3244    
3245                                if (translate && (is_upper || is_lower)
3246                                    && (ISUPPER (ch) || ISLOWER (ch)))
3247                                  SET_LIST_BIT (ch);
3248                              }
3249    
3250                            had_char_class = true;
3251    # else
3252                          int ch;                          int ch;
3253                          boolean is_alnum = STREQ (str, "alnum");                          boolean is_alnum = STREQ (str, "alnum");
3254                          boolean is_alpha = STREQ (str, "alpha");                          boolean is_alpha = STREQ (str, "alpha");
# Line 1899  regex_compile (pattern, size, syntax, bu Line 3262  regex_compile (pattern, size, syntax, bu
3262                          boolean is_space = STREQ (str, "space");                          boolean is_space = STREQ (str, "space");
3263                          boolean is_upper = STREQ (str, "upper");                          boolean is_upper = STREQ (str, "upper");
3264                          boolean is_xdigit = STREQ (str, "xdigit");                          boolean is_xdigit = STREQ (str, "xdigit");
3265                            
3266                          if (!IS_CHAR_CLASS (str))                          if (!IS_CHAR_CLASS (str))
3267                            FREE_STACK_RETURN (REG_ECTYPE);                            FREE_STACK_RETURN (REG_ECTYPE);
3268    
3269                          /* Throw away the ] at the end of the character                          /* Throw away the ] at the end of the character
3270                             class.  */                             class.  */
3271                          PATFETCH (c);                                                            PATFETCH (c);
3272    
3273                          if (p == pend) FREE_STACK_RETURN (REG_EBRACK);                          if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
3274    
# Line 1928  regex_compile (pattern, size, syntax, bu Line 3291  regex_compile (pattern, size, syntax, bu
3291                                  || (is_upper  && ISUPPER (ch))                                  || (is_upper  && ISUPPER (ch))
3292                                  || (is_xdigit && ISXDIGIT (ch)))                                  || (is_xdigit && ISXDIGIT (ch)))
3293                                SET_LIST_BIT (ch);                                SET_LIST_BIT (ch);
3294                                if (   translate && (is_upper || is_lower)
3295                                    && (ISUPPER (ch) || ISLOWER (ch)))
3296                                  SET_LIST_BIT (ch);
3297                            }                            }
3298                          had_char_class = true;                          had_char_class = true;
3299    # endif /* libc || wctype.h */
3300                        }                        }
3301                      else                      else
3302                        {                        {
3303                          c1++;                          c1++;
3304                          while (c1--)                              while (c1--)
3305                            PATUNFETCH;                            PATUNFETCH;
3306                          SET_LIST_BIT ('[');                          SET_LIST_BIT ('[');
3307                          SET_LIST_BIT (':');                          SET_LIST_BIT (':');
3308                            range_start = ':';
3309                          had_char_class = false;                          had_char_class = false;
3310                        }                        }
3311                    }                    }
3312                    else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '=')
3313                      {
3314                        unsigned char str[MB_LEN_MAX + 1];
3315    # ifdef _LIBC
3316                        uint32_t nrules =
3317                          _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
3318    # endif
3319    
3320                        PATFETCH (c);
3321                        c1 = 0;
3322    
3323                        /* If pattern is `[[='.  */
3324                        if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
3325    
3326                        for (;;)
3327                          {
3328                            PATFETCH (c);
3329                            if ((c == '=' && *p == ']') || p == pend)
3330                              break;
3331                            if (c1 < MB_LEN_MAX)
3332                              str[c1++] = c;
3333                            else
3334                              /* This is in any case an invalid class name.  */
3335                              str[0] = '\0';
3336                          }
3337                        str[c1] = '\0';
3338    
3339                        if (c == '=' && *p == ']' && str[0] != '\0')
3340                          {
3341                            /* If we have no collation data we use the default
3342                               collation in which each character is in a class
3343                               by itself.  It also means that ASCII is the
3344                               character set and therefore we cannot have character
3345                               with more than one byte in the multibyte
3346                               representation.  */
3347    # ifdef _LIBC
3348                            if (nrules == 0)
3349    # endif
3350                              {
3351                                if (c1 != 1)
3352                                  FREE_STACK_RETURN (REG_ECOLLATE);
3353    
3354                                /* Throw away the ] at the end of the equivalence
3355                                   class.  */
3356                                PATFETCH (c);
3357    
3358                                /* Set the bit for the character.  */
3359                                SET_LIST_BIT (str[0]);
3360                              }
3361    # ifdef _LIBC
3362                            else
3363                              {
3364                                /* Try to match the byte sequence in `str' against
3365                                   those known to the collate implementation.
3366                                   First find out whether the bytes in `str' are
3367                                   actually from exactly one character.  */
3368                                const int32_t *table;
3369                                const unsigned char *weights;
3370                                const unsigned char *extra;
3371                                const int32_t *indirect;
3372                                int32_t idx;
3373                                const unsigned char *cp = str;
3374                                int ch;
3375    
3376                                /* This #include defines a local function!  */
3377    #  include <locale/weight.h>
3378    
3379                                table = (const int32_t *)
3380                                  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
3381                                weights = (const unsigned char *)
3382                                  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
3383                                extra = (const unsigned char *)
3384                                  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
3385                                indirect = (const int32_t *)
3386                                  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
3387    
3388                                idx = findidx (&cp);
3389                                if (idx == 0 || cp < str + c1)
3390                                  /* This is no valid character.  */
3391                                  FREE_STACK_RETURN (REG_ECOLLATE);
3392    
3393                                /* Throw away the ] at the end of the equivalence
3394                                   class.  */
3395                                PATFETCH (c);
3396    
3397                                /* Now we have to go throught the whole table
3398                                   and find all characters which have the same
3399                                   first level weight.
3400    
3401                                   XXX Note that this is not entirely correct.
3402                                   we would have to match multibyte sequences
3403                                   but this is not possible with the current
3404                                   implementation.  */
3405                                for (ch = 1; ch < 256; ++ch)
3406                                  /* XXX This test would have to be changed if we
3407                                     would allow matching multibyte sequences.  */
3408                                  if (table[ch] > 0)
3409                                    {
3410                                      int32_t idx2 = table[ch];
3411                                      size_t len = weights[idx2];
3412    
3413                                      /* Test whether the lenghts match.  */
3414                                      if (weights[idx] == len)
3415                                        {
3416                                          /* They do.  New compare the bytes of
3417                                             the weight.  */
3418                                          size_t cnt = 0;
3419    
3420                                          while (cnt < len
3421                                                 && (weights[idx + 1 + cnt]
3422                                                     == weights[idx2 + 1 + cnt]))
3423                                            ++cnt;
3424    
3425                                          if (cnt == len)
3426                                            /* They match.  Mark the character as
3427                                               acceptable.  */
3428                                            SET_LIST_BIT (ch);
3429                                        }
3430                                    }
3431                              }
3432    # endif
3433                            had_char_class = true;
3434                          }
3435                        else
3436                          {
3437                            c1++;
3438                            while (c1--)
3439                              PATUNFETCH;
3440                            SET_LIST_BIT ('[');
3441                            SET_LIST_BIT ('=');
3442                            range_start = '=';
3443                            had_char_class = false;
3444                          }
3445                      }
3446                    else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.')
3447                      {
3448                        unsigned char str[128];     /* Should be large enough.  */
3449    # ifdef _LIBC
3450                        uint32_t nrules =
3451                          _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
3452    # endif
3453    
3454                        PATFETCH (c);
3455                        c1 = 0;
3456    
3457                        /* If pattern is `[[.'.  */
3458                        if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
3459    
3460                        for (;;)
3461                          {
3462                            PATFETCH (c);
3463                            if ((c == '.' && *p == ']') || p == pend)
3464                              break;
3465                            if (c1 < sizeof (str))
3466                              str[c1++] = c;
3467                            else
3468                              /* This is in any case an invalid class name.  */
3469                              str[0] = '\0';
3470                          }
3471                        str[c1] = '\0';
3472    
3473                        if (c == '.' && *p == ']' && str[0] != '\0')
3474                          {
3475                            /* If we have no collation data we use the default
3476                               collation in which each character is the name
3477                               for its own class which contains only the one
3478                               character.  It also means that ASCII is the
3479                               character set and therefore we cannot have character
3480                               with more than one byte in the multibyte
3481                               representation.  */
3482    # ifdef _LIBC
3483                            if (nrules == 0)
3484    # endif
3485                              {
3486                                if (c1 != 1)
3487                                  FREE_STACK_RETURN (REG_ECOLLATE);
3488    
3489                                /* Throw away the ] at the end of the equivalence
3490                                   class.  */
3491                                PATFETCH (c);
3492    
3493                                /* Set the bit for the character.  */
3494                                SET_LIST_BIT (str[0]);
3495                                range_start = ((const unsigned char *) str)[0];
3496                              }
3497    # ifdef _LIBC
3498                            else
3499                              {
3500                                /* Try to match the byte sequence in `str' against
3501                                   those known to the collate implementation.
3502                                   First find out whether the bytes in `str' are
3503                                   actually from exactly one character.  */
3504                                int32_t table_size;
3505                                const int32_t *symb_table;
3506                                const unsigned char *extra;
3507                                int32_t idx;
3508                                int32_t elem;
3509                                int32_t second;
3510                                int32_t hash;
3511    
3512                                table_size =
3513                                  _NL_CURRENT_WORD (LC_COLLATE,
3514                                                    _NL_COLLATE_SYMB_HASH_SIZEMB);
3515                                symb_table = (const int32_t *)
3516                                  _NL_CURRENT (LC_COLLATE,
3517                                               _NL_COLLATE_SYMB_TABLEMB);
3518                                extra = (const unsigned char *)
3519                                  _NL_CURRENT (LC_COLLATE,
3520                                               _NL_COLLATE_SYMB_EXTRAMB);
3521    
3522                                /* Locate the character in the hashing table.  */
3523                                hash = elem_hash (str, c1);
3524    
3525                                idx = 0;
3526                                elem = hash % table_size;
3527                                second = hash % (table_size - 2);
3528                                while (symb_table[2 * elem] != 0)
3529                                  {
3530                                    /* First compare the hashing value.  */
3531                                    if (symb_table[2 * elem] == hash
3532                                        && c1 == extra[symb_table[2 * elem + 1]]
3533                                        && memcmp (str,
3534                                                   &extra[symb_table[2 * elem + 1]
3535                                                         + 1],
3536                                                   c1) == 0)
3537                                      {
3538                                        /* Yep, this is the entry.  */
3539                                        idx = symb_table[2 * elem + 1];
3540                                        idx += 1 + extra[idx];
3541                                        break;
3542                                      }
3543    
3544                                    /* Next entry.  */
3545                                    elem += second;
3546                                  }
3547    
3548                                if (symb_table[2 * elem] == 0)
3549                                  /* This is no valid character.  */
3550                                  FREE_STACK_RETURN (REG_ECOLLATE);
3551    
3552                                /* Throw away the ] at the end of the equivalence
3553                                   class.  */
3554                                PATFETCH (c);
3555    
3556                                /* Now add the multibyte character(s) we found
3557                                   to the accept list.
3558    
3559                                   XXX Note that this is not entirely correct.
3560                                   we would have to match multibyte sequences
3561                                   but this is not possible with the current
3562                                   implementation.  Also, we have to match
3563                                   collating symbols, which expand to more than
3564                                   one file, as a whole and not allow the
3565                                   individual bytes.  */
3566                                c1 = extra[idx++];
3567                                if (c1 == 1)
3568                                  range_start = extra[idx];
3569                                while (c1-- > 0)
3570                                  {
3571                                    SET_LIST_BIT (extra[idx]);
3572                                    ++idx;
3573                                  }
3574                              }
3575    # endif
3576                            had_char_class = false;
3577                          }
3578                        else
3579                          {
3580                            c1++;
3581                            while (c1--)
3582                              PATUNFETCH;
3583                            SET_LIST_BIT ('[');
3584                            SET_LIST_BIT ('.');
3585                            range_start = '.';
3586                            had_char_class = false;
3587                          }
3588                      }
3589                  else                  else
3590                    {                    {
3591                      had_char_class = false;                      had_char_class = false;
3592                      SET_LIST_BIT (c);                      SET_LIST_BIT (c);
3593                        range_start = c;
3594                    }                    }
3595                }                }
3596    
3597              /* Discard any (non)matching list bytes that are all 0 at the              /* Discard any (non)matching list bytes that are all 0 at the
3598                 end of the map.  Decrease the map-length byte too.  */                 end of the map.  Decrease the map-length byte too.  */
3599              while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)              while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
3600                b[-1]--;                b[-1]--;
3601              b += b[-1];              b += b[-1];
3602    #endif /* WCHAR */
3603            }            }
3604            break;            break;
3605    
# Line 2011  regex_compile (pattern, size, syntax, bu Line 3658  regex_compile (pattern, size, syntax, bu
3658                regnum++;                regnum++;
3659    
3660                if (COMPILE_STACK_FULL)                if (COMPILE_STACK_FULL)
3661                  {                  {
3662                    RETALLOC (compile_stack.stack, compile_stack.size << 1,                    RETALLOC (compile_stack.stack, compile_stack.size << 1,
3663                              compile_stack_elt_t);                              compile_stack_elt_t);
3664                    if (compile_stack.stack == NULL) return REG_ESPACE;                    if (compile_stack.stack == NULL) return REG_ESPACE;
# Line 2023  regex_compile (pattern, size, syntax, bu Line 3670  regex_compile (pattern, size, syntax, bu
3670                   group.  They are all relative offsets, so that if the                   group.  They are all relative offsets, so that if the
3671                   whole pattern moves because of realloc, they will still                   whole pattern moves because of realloc, they will still
3672                   be valid.  */                   be valid.  */
3673                COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer;                COMPILE_STACK_TOP.begalt_offset = begalt - COMPILED_BUFFER_VAR;
3674                COMPILE_STACK_TOP.fixup_alt_jump                COMPILE_STACK_TOP.fixup_alt_jump
3675                  = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;                  = fixup_alt_jump ? fixup_alt_jump - COMPILED_BUFFER_VAR + 1 : 0;
3676                COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;                COMPILE_STACK_TOP.laststart_offset = b - COMPILED_BUFFER_VAR;
3677                COMPILE_STACK_TOP.regnum = regnum;                COMPILE_STACK_TOP.regnum = regnum;
3678    
3679                /* We will eventually replace the 0 with the number of                /* We will eventually replace the 0 with the number of
# Line 2035  regex_compile (pattern, size, syntax, bu Line 3682  regex_compile (pattern, size, syntax, bu
3682                   represent in the compiled pattern.  */                   represent in the compiled pattern.  */
3683                if (regnum <= MAX_REGNUM)                if (regnum <= MAX_REGNUM)
3684                  {                  {
3685                    COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2;                    COMPILE_STACK_TOP.inner_group_offset = b
3686                        - COMPILED_BUFFER_VAR + 2;
3687                    BUF_PUSH_3 (start_memory, regnum, 0);                    BUF_PUSH_3 (start_memory, regnum, 0);
3688                  }                  }
3689                    
3690                compile_stack.avail++;                compile_stack.avail++;
3691    
3692                fixup_alt_jump = 0;                fixup_alt_jump = 0;
# Line 2055  regex_compile (pattern, size, syntax, bu Line 3703  regex_compile (pattern, size, syntax, bu
3703                if (syntax & RE_NO_BK_PARENS) goto normal_backslash;                if (syntax & RE_NO_BK_PARENS) goto normal_backslash;
3704    
3705                if (COMPILE_STACK_EMPTY)                if (COMPILE_STACK_EMPTY)
3706                  if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)                  {
3707                    goto normal_backslash;                    if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
3708                  else                      goto normal_backslash;
3709                    FREE_STACK_RETURN (REG_ERPAREN);                    else
3710                        FREE_STACK_RETURN (REG_ERPAREN);
3711                    }
3712    
3713              handle_close:              handle_close:
3714                if (fixup_alt_jump)                if (fixup_alt_jump)
# Line 2067  regex_compile (pattern, size, syntax, bu Line 3717  regex_compile (pattern, size, syntax, bu
3717                       `pop_failure_jump' to pop.  See comments at                       `pop_failure_jump' to pop.  See comments at
3718                       `push_dummy_failure' in `re_match_2'.  */                       `push_dummy_failure' in `re_match_2'.  */
3719                    BUF_PUSH (push_dummy_failure);                    BUF_PUSH (push_dummy_failure);
3720                      
3721                    /* We allocated space for this jump when we assigned                    /* We allocated space for this jump when we assigned
3722                       to `fixup_alt_jump', in the `handle_alt' case below.  */                       to `fixup_alt_jump', in the `handle_alt' case below.  */
3723                    STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);                    STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);
# Line 2075  regex_compile (pattern, size, syntax, bu Line 3725  regex_compile (pattern, size, syntax, bu
3725    
3726                /* See similar code for backslashed left paren above.  */                /* See similar code for backslashed left paren above.  */
3727                if (COMPILE_STACK_EMPTY)                if (COMPILE_STACK_EMPTY)
3728                  if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)                  {
3729                    goto normal_char;                    if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
3730                  else                      goto normal_char;
3731                    FREE_STACK_RETURN (REG_ERPAREN);                    else
3732                        FREE_STACK_RETURN (REG_ERPAREN);
3733                    }
3734    
3735                /* Since we just checked for an empty stack above, this                /* Since we just checked for an empty stack above, this
3736                   ``can't happen''.  */                   ``can't happen''.  */
# Line 2089  regex_compile (pattern, size, syntax, bu Line 3741  regex_compile (pattern, size, syntax, bu
3741                     as in `(ab)c(de)' -- the second group is #2.  */                     as in `(ab)c(de)' -- the second group is #2.  */
3742                  regnum_t this_group_regnum;                  regnum_t this_group_regnum;
3743    
3744                  compile_stack.avail--;                            compile_stack.avail--;
3745                  begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset;                  begalt = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.begalt_offset;
3746                  fixup_alt_jump                  fixup_alt_jump
3747                    = COMPILE_STACK_TOP.fixup_alt_jump                    = COMPILE_STACK_TOP.fixup_alt_jump
3748                      ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1                      ? COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.fixup_alt_jump - 1
3749                      : 0;                      : 0;
3750                  laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset;                  laststart = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.laststart_offset;
3751                  this_group_regnum = COMPILE_STACK_TOP.regnum;                  this_group_regnum = COMPILE_STACK_TOP.regnum;
3752                  /* If we've reached MAX_REGNUM groups, then this open                  /* If we've reached MAX_REGNUM groups, then this open
3753                     won't actually generate any code, so we'll have to                     won't actually generate any code, so we'll have to
# Line 2106  regex_compile (pattern, size, syntax, bu Line 3758  regex_compile (pattern, size, syntax, bu
3758                     groups were inside this one.  */                     groups were inside this one.  */
3759                  if (this_group_regnum <= MAX_REGNUM)                  if (this_group_regnum <= MAX_REGNUM)
3760                    {                    {
3761                      unsigned char *inner_group_loc                      UCHAR_T *inner_group_loc
3762                        = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset;                        = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.inner_group_offset;
3763                        
3764                      *inner_group_loc = regnum - this_group_regnum;                      *inner_group_loc = regnum - this_group_regnum;
3765                      BUF_PUSH_3 (stop_memory, this_group_regnum,                      BUF_PUSH_3 (stop_memory, this_group_regnum,
3766                                  regnum - this_group_regnum);                                  regnum - this_group_regnum);
# Line 2126  regex_compile (pattern, size, syntax, bu Line 3778  regex_compile (pattern, size, syntax, bu
3778    
3779                /* Insert before the previous alternative a jump which                /* Insert before the previous alternative a jump which
3780                   jumps to this alternative if the former fails.  */                   jumps to this alternative if the former fails.  */
3781                GET_BUFFER_SPACE (3);                GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
3782                INSERT_JUMP (on_failure_jump, begalt, b + 6);                INSERT_JUMP (on_failure_jump, begalt,
3783                               b + 2 + 2 * OFFSET_ADDRESS_SIZE);
3784                pending_exact = 0;                pending_exact = 0;
3785                b += 3;                b += 1 + OFFSET_ADDRESS_SIZE;
3786    
3787                /* The alternative before this one has a jump after it                /* The alternative before this one has a jump after it
3788                   which gets executed if it gets matched.  Adjust that                   which gets executed if it gets matched.  Adjust that
# Line 2137  regex_compile (pattern, size, syntax, bu Line 3790  regex_compile (pattern, size, syntax, bu
3790                   jump (put in below, which in turn will jump to the next                   jump (put in below, which in turn will jump to the next
3791                   (if any) alternative's such jump, etc.).  The last such                   (if any) alternative's such jump, etc.).  The last such
3792                   jump jumps to the correct final destination.  A picture:                   jump jumps to the correct final destination.  A picture:
3793                            _____ _____                            _____ _____
3794                            |   | |   |                              |   | |   |
3795                            |   v |   v                            |   v |   v
3796                           a | b   | c                             a | b   | c
3797    
3798                   If we are at `b', then fixup_alt_jump right now points to a                   If we are at `b', then fixup_alt_jump right now points to a
3799                   three-byte space after `a'.  We'll put in the jump, set                   three-byte space after `a'.  We'll put in the jump, set
# Line 2154  regex_compile (pattern, size, syntax, bu Line 3807  regex_compile (pattern, size, syntax, bu
3807                   to be filled in later either by next alternative or                   to be filled in later either by next alternative or
3808                   when know we're at the end of a series of alternatives.  */                   when know we're at the end of a series of alternatives.  */
3809                fixup_alt_jump = b;                fixup_alt_jump = b;
3810                GET_BUFFER_SPACE (3);                GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
3811                b += 3;                b += 1 + OFFSET_ADDRESS_SIZE;
3812    
3813                laststart = 0;                laststart = 0;
3814                begalt = b;                begalt = b;
3815                break;                break;
3816    
3817    
3818              case '{':              case '{':
3819                /* If \{ is a literal.  */                /* If \{ is a literal.  */
3820                if (!(syntax & RE_INTERVALS)                if (!(syntax & RE_INTERVALS)
3821                       /* If we're at `\{' and it's not the open-interval                       /* If we're at `\{' and it's not the open-interval
3822                          operator.  */                          operator.  */
3823                    || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))                    || (syntax & RE_NO_BK_BRACES))
                   || (p - 2 == pattern  &&  p == pend))  
3824                  goto normal_backslash;                  goto normal_backslash;
3825    
3826              handle_interval:              handle_interval:
# Line 2178  regex_compile (pattern, size, syntax, bu Line 3830  regex_compile (pattern, size, syntax, bu
3830                  /* At least (most) this many matches must be made.  */                  /* At least (most) this many matches must be made.  */
3831                  int lower_bound = -1, upper_bound = -1;                  int lower_bound = -1, upper_bound = -1;
3832    
3833                  beg_interval = p - 1;                  /* Place in the uncompiled pattern (i.e., just after
3834                       the '{') to go back to if the interval is invalid.  */
3835                    const CHAR_T *beg_interval = p;
3836    
3837                  if (p == pend)                  if (p == pend)
3838                    {                    goto invalid_interval;
                     if (syntax & RE_NO_BK_BRACES)  
                       goto unfetch_interval;  
                     else  
                       FREE_STACK_RETURN (REG_EBRACE);  
                   }  
3839    
3840                  GET_UNSIGNED_NUMBER (lower_bound);                  GET_UNSIGNED_NUMBER (lower_bound);
3841    
3842                  if (c == ',')                  if (c == ',')
3843                    {                    {
3844                      GET_UNSIGNED_NUMBER (upper_bound);                      GET_UNSIGNED_NUMBER (upper_bound);
3845                      if (upper_bound < 0) upper_bound = RE_DUP_MAX;                      if (upper_bound < 0)
3846                          upper_bound = RE_DUP_MAX;
3847                    }                    }
3848                  else                  else
3849                    /* Interval such as `{1}' => match exactly once. */                    /* Interval such as `{1}' => match exactly once. */
3850                    upper_bound = lower_bound;                    upper_bound = lower_bound;
3851    
3852                  if (lower_bound < 0 || upper_bound > RE_DUP_MAX                  if (! (0 <= lower_bound && lower_bound <= upper_bound))
3853                      || lower_bound > upper_bound)                    goto invalid_interval;
                   {  
                     if (syntax & RE_NO_BK_BRACES)  
                       goto unfetch_interval;  
                     else  
                       FREE_STACK_RETURN (REG_BADBR);  
                   }  
3854    
3855                  if (!(syntax & RE_NO_BK_BRACES))                  if (!(syntax & RE_NO_BK_BRACES))
3856                    {                    {
3857                      if (c != '\\') FREE_STACK_RETURN (REG_EBRACE);                      if (c != '\\' || p == pend)
3858                          goto invalid_interval;
3859                      PATFETCH (c);                      PATFETCH (c);
3860                    }                    }
3861    
3862                  if (c != '}')                  if (c != '}')
3863                    {                    goto invalid_interval;
                     if (syntax & RE_NO_BK_BRACES)  
                       goto unfetch_interval;  
                     else  
                       FREE_STACK_RETURN (REG_BADBR);  
                   }  
   
                 /* We just parsed a valid interval.  */  
3864    
3865                  /* If it's invalid to have no preceding re.  */                  /* If it's invalid to have no preceding re.  */
3866                  if (!laststart)                  if (!laststart)
3867                    {                    {
3868                      if (syntax & RE_CONTEXT_INVALID_OPS)                      if (syntax & RE_CONTEXT_INVALID_OPS
3869                            && !(syntax & RE_INVALID_INTERVAL_ORD))
3870                        FREE_STACK_RETURN (REG_BADRPT);                        FREE_STACK_RETURN (REG_BADRPT);
3871                      else if (syntax & RE_CONTEXT_INDEP_OPS)                      else if (syntax & RE_CONTEXT_INDEP_OPS)
3872                        laststart = b;                        laststart = b;
# Line 2236  regex_compile (pattern, size, syntax, bu Line 3874  regex_compile (pattern, size, syntax, bu
3874                        goto unfetch_interval;                        goto unfetch_interval;
3875                    }                    }
3876    
3877                    /* We just parsed a valid interval.  */
3878    
3879                    if (RE_DUP_MAX < upper_bound)
3880                      FREE_STACK_RETURN (REG_BADBR);
3881    
3882                  /* If the upper bound is zero, don't want to succeed at                  /* If the upper bound is zero, don't want to succeed at
3883                     all; jump from `laststart' to `b + 3', which will be                     all; jump from `laststart' to `b + 3', which will be
3884                     the end of the buffer after we insert the jump.  */                     the end of the buffer after we insert the jump.  */
3885                    /* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE'
3886                       instead of 'b + 3'.  */
3887                   if (upper_bound == 0)                   if (upper_bound == 0)
3888                     {                     {
3889                       GET_BUFFER_SPACE (3);                       GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
3890                       INSERT_JUMP (jump, laststart, b + 3);                       INSERT_JUMP (jump, laststart, b + 1
3891                       b += 3;                                    + OFFSET_ADDRESS_SIZE);
3892                         b += 1 + OFFSET_ADDRESS_SIZE;
3893                     }                     }
3894    
3895                   /* Otherwise, we have a nontrivial interval.  When                   /* Otherwise, we have a nontrivial interval.  When
# Line 2255  regex_compile (pattern, size, syntax, bu Line 3901  regex_compile (pattern, size, syntax, bu
3901                        jump_n <succeed_n addr> <jump count>                        jump_n <succeed_n addr> <jump count>
3902                      (The upper bound and `jump_n' are omitted if                      (The upper bound and `jump_n' are omitted if
3903                      `upper_bound' is 1, though.)  */                      `upper_bound' is 1, though.)  */
3904                   else                   else
3905                     { /* If the upper bound is > 1, we need to insert                     { /* If the upper bound is > 1, we need to insert
3906                          more at the end of the loop.  */                          more at the end of the loop.  */
3907                       unsigned nbytes = 10 + (upper_bound > 1) * 10;                       unsigned nbytes = 2 + 4 * OFFSET_ADDRESS_SIZE +
3908                           (upper_bound > 1) * (2 + 4 * OFFSET_ADDRESS_SIZE);
3909    
3910                       GET_BUFFER_SPACE (nbytes);                       GET_BUFFER_SPACE (nbytes);
3911    
# Line 2268  regex_compile (pattern, size, syntax, bu Line 3915  regex_compile (pattern, size, syntax, bu
3915                          because `re_compile_fastmap' needs to know.                          because `re_compile_fastmap' needs to know.
3916                          Jump to the `jump_n' we might insert below.  */                          Jump to the `jump_n' we might insert below.  */
3917                       INSERT_JUMP2 (succeed_n, laststart,                       INSERT_JUMP2 (succeed_n, laststart,
3918                                     b + 5 + (upper_bound > 1) * 5,                                     b + 1 + 2 * OFFSET_ADDRESS_SIZE
3919                                     lower_bound);                                     + (upper_bound > 1) * (1 + 2 * OFFSET_ADDRESS_SIZE)
3920                       b += 5;                                     , lower_bound);
3921                         b += 1 + 2 * OFFSET_ADDRESS_SIZE;
3922    
3923                       /* Code to initialize the lower bound.  Insert                       /* Code to initialize the lower bound.  Insert
3924                          before the `succeed_n'.  The `5' is the last two                          before the `succeed_n'.  The `5' is the last two
3925                          bytes of this `set_number_at', plus 3 bytes of                          bytes of this `set_number_at', plus 3 bytes of
3926                          the following `succeed_n'.  */                          the following `succeed_n'.  */
3927                       insert_op2 (set_number_at, laststart, 5, lower_bound, b);                       /* ifdef WCHAR, The '1+2*OFFSET_ADDRESS_SIZE'
3928                       b += 5;                          is the 'set_number_at', plus '1+OFFSET_ADDRESS_SIZE'
3929                            of the following `succeed_n'.  */
3930                         PREFIX(insert_op2) (set_number_at, laststart, 1
3931                                     + 2 * OFFSET_ADDRESS_SIZE, lower_bound, b);
3932                         b += 1 + 2 * OFFSET_ADDRESS_SIZE;
3933    
3934                       if (upper_bound > 1)                       if (upper_bound > 1)
3935                         { /* More than one repetition is allowed, so                         { /* More than one repetition is allowed, so
3936                              append a backward jump to the `succeed_n'                              append a backward jump to the `succeed_n'
3937                              that starts this interval.                              that starts this interval.
3938                                
3939                              When we've reached this during matching,                              When we've reached this during matching,
3940                              we'll have matched the interval once, so                              we'll have matched the interval once, so
3941                              jump back only `upper_bound - 1' times.  */                              jump back only `upper_bound - 1' times.  */
3942                           STORE_JUMP2 (jump_n, b, laststart + 5,                           STORE_JUMP2 (jump_n, b, laststart
3943                                          + 2 * OFFSET_ADDRESS_SIZE + 1,
3944                                        upper_bound - 1);                                        upper_bound - 1);
3945                           b += 5;                           b += 1 + 2 * OFFSET_ADDRESS_SIZE;
3946    
3947                           /* The location we want to set is the second                           /* The location we want to set is the second
3948                              parameter of the `jump_n'; that is `b-2' as                              parameter of the `jump_n'; that is `b-2' as
# Line 2301  regex_compile (pattern, size, syntax, bu Line 3954  regex_compile (pattern, size, syntax, bu
3954                              so everything is getting moved up by 5.                              so everything is getting moved up by 5.
3955                              Conclusion: (b - 2) - (laststart + 3) + 5,                              Conclusion: (b - 2) - (laststart + 3) + 5,
3956                              i.e., b - laststart.                              i.e., b - laststart.
3957                                
3958                              We insert this at the beginning of the loop                              We insert this at the beginning of the loop
3959                              so that if we fail during matching, we'll                              so that if we fail during matching, we'll
3960                              reinitialize the bounds.  */                              reinitialize the bounds.  */
3961                           insert_op2 (set_number_at, laststart, b - laststart,                           PREFIX(insert_op2) (set_number_at, laststart,
3962                                       upper_bound - 1, b);                                               b - laststart,
3963                           b += 5;                                               upper_bound - 1, b);
3964                             b += 1 + 2 * OFFSET_ADDRESS_SIZE;
3965                         }                         }
3966                     }                     }
3967                  pending_exact = 0;                  pending_exact = 0;
3968                  beg_interval = NULL;                  break;
               }  
               break;  
3969    
3970              unfetch_interval:                invalid_interval:
3971                /* If an invalid interval, match the characters as literals.  */                  if (!(syntax & RE_INVALID_INTERVAL_ORD))
3972                 assert (beg_interval);                    FREE_STACK_RETURN (p == pend ? REG_EBRACE : REG_BADBR);
3973                 p = beg_interval;                unfetch_interval:
3974                 beg_interval = NULL;                  /* Match the characters as literals.  */
3975                    p = beg_interval;
3976                 /* normal_char and normal_backslash need `c'.  */                  c = '{';
3977                 PATFETCH (c);                      if (syntax & RE_NO_BK_BRACES)
3978                      goto normal_char;
3979                 if (!(syntax & RE_NO_BK_BRACES))                  else
3980                   {                    goto normal_backslash;
3981                     if (p > pattern  &&  p[-1] == '\\')                }
                      goto normal_backslash;  
                  }  
                goto normal_char;  
3982    
3983  #ifdef emacs  #ifdef emacs
3984              /* There is no way to specify the before_dot and after_dot              /* There is no way to specify the before_dot and after_dot
# Line 2338  regex_compile (pattern, size, syntax, bu Line 3987  regex_compile (pattern, size, syntax, bu
3987                BUF_PUSH (at_dot);                BUF_PUSH (at_dot);
3988                break;                break;
3989    
3990              case 's':                case 's':
3991                laststart = b;                laststart = b;
3992                PATFETCH (c);                PATFETCH (c);
3993                BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);                BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
# Line 2353  regex_compile (pattern, size, syntax, bu Line 4002  regex_compile (pattern, size, syntax, bu
4002    
4003    
4004              case 'w':              case 'w':
4005                  if (syntax & RE_NO_GNU_OPS)
4006                    goto normal_char;
4007                laststart = b;                laststart = b;
4008                BUF_PUSH (wordchar);                BUF_PUSH (wordchar);
4009                break;                break;
4010    
4011    
4012              case 'W':              case 'W':
4013                  if (syntax & RE_NO_GNU_OPS)
4014                    goto normal_char;
4015                laststart = b;                laststart = b;
4016                BUF_PUSH (notwordchar);                BUF_PUSH (notwordchar);
4017                break;                break;
4018    
4019    
4020              case '<':              case '<':
4021                  if (syntax & RE_NO_GNU_OPS)
4022                    goto normal_char;
4023                BUF_PUSH (wordbeg);                BUF_PUSH (wordbeg);
4024                break;                break;
4025    
4026              case '>':              case '>':
4027                  if (syntax & RE_NO_GNU_OPS)
4028                    goto normal_char;
4029                BUF_PUSH (wordend);                BUF_PUSH (wordend);
4030                break;                break;
4031    
4032              case 'b':              case 'b':
4033                  if (syntax & RE_NO_GNU_OPS)
4034                    goto normal_char;
4035                BUF_PUSH (wordbound);                BUF_PUSH (wordbound);
4036                break;                break;
4037    
4038              case 'B':              case 'B':
4039                  if (syntax & RE_NO_GNU_OPS)
4040                    goto normal_char;
4041                BUF_PUSH (notwordbound);                BUF_PUSH (notwordbound);
4042                break;                break;
4043    
4044              case '`':              case '`':
4045                  if (syntax & RE_NO_GNU_OPS)
4046                    goto normal_char;
4047                BUF_PUSH (begbuf);                BUF_PUSH (begbuf);
4048                break;                break;
4049    
4050              case '\'':              case '\'':
4051                  if (syntax & RE_NO_GNU_OPS)
4052                    goto normal_char;
4053                BUF_PUSH (endbuf);                BUF_PUSH (endbuf);
4054                break;                break;
4055    
# Line 2399  regex_compile (pattern, size, syntax, bu Line 4064  regex_compile (pattern, size, syntax, bu
4064                  FREE_STACK_RETURN (REG_ESUBREG);                  FREE_STACK_RETURN (REG_ESUBREG);
4065    
4066                /* Can't back reference to a subexpression if inside of it.  */                /* Can't back reference to a subexpression if inside of it.  */
4067                if (group_in_compile_stack (compile_stack, c1))                if (group_in_compile_stack (compile_stack, (regnum_t) c1))
4068                  goto normal_char;                  goto normal_char;
4069    
4070                laststart = b;                laststart = b;
# Line 2429  regex_compile (pattern, size, syntax, bu Line 4094  regex_compile (pattern, size, syntax, bu
4094          /* Expects the character in `c'.  */          /* Expects the character in `c'.  */
4095          normal_char:          normal_char:
4096                /* If no exactn currently being built.  */                /* If no exactn currently being built.  */
4097            if (!pending_exact            if (!pending_exact
4098    #ifdef WCHAR
4099                  /* If last exactn handle binary(or character) and
4100                     new exactn handle character(or binary).  */
4101                  || is_exactn_bin != is_binary[p - 1 - pattern]
4102    #endif /* WCHAR */
4103    
4104                /* If last exactn not at current position.  */                /* If last exactn not at current position.  */
4105                || pending_exact + *pending_exact + 1 != b                || pending_exact + *pending_exact + 1 != b
4106                  
4107                /* We have only one byte following the exactn for the count.  */                /* We have only one byte following the exactn for the count.  */
4108                || *pending_exact == (1 << BYTEWIDTH) - 1                || *pending_exact == (1 << BYTEWIDTH) - 1
4109    
# Line 2448  regex_compile (pattern, size, syntax, bu Line 4118  regex_compile (pattern, size, syntax, bu
4118                        : (p[0] == '\\' && p[1] == '{'))))                        : (p[0] == '\\' && p[1] == '{'))))
4119              {              {
4120                /* Start building a new exactn.  */                /* Start building a new exactn.  */
4121                  
4122                laststart = b;                laststart = b;
4123    
4124    #ifdef WCHAR
4125                  /* Is this exactn binary data or character? */
4126                  is_exactn_bin = is_binary[p - 1 - pattern];
4127                  if (is_exactn_bin)
4128                      BUF_PUSH_2 (exactn_bin, 0);
4129                  else
4130                      BUF_PUSH_2 (exactn, 0);
4131    #else
4132                BUF_PUSH_2 (exactn, 0);                BUF_PUSH_2 (exactn, 0);
4133    #endif /* WCHAR */
4134                pending_exact = b - 1;                pending_exact = b - 1;
4135              }              }
4136                
4137            BUF_PUSH (c);            BUF_PUSH (c);
4138            (*pending_exact)++;            (*pending_exact)++;
4139            break;            break;
4140          } /* switch (c) */          } /* switch (c) */
4141      } /* while p != pend */      } /* while p != pend */
4142    
4143      
4144    /* Through the pattern now.  */    /* Through the pattern now.  */
4145      
4146    if (fixup_alt_jump)    if (fixup_alt_jump)
4147      STORE_JUMP (jump_past_alt, fixup_alt_jump, b);      STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
4148    
4149    if (!COMPILE_STACK_EMPTY)    if (!COMPILE_STACK_EMPTY)
4150      FREE_STACK_RETURN (REG_EPAREN);      FREE_STACK_RETURN (REG_EPAREN);
4151    
4152      /* If we don't want backtracking, force success
4153         the first time we reach the end of the compiled pattern.  */
4154      if (syntax & RE_NO_POSIX_BACKTRACKING)
4155        BUF_PUSH (succeed);
4156    
4157    #ifdef WCHAR
4158      free (pattern);
4159      free (mbs_offset);
4160      free (is_binary);
4161    #endif
4162    free (compile_stack.stack);    free (compile_stack.stack);
4163    
4164    /* We have succeeded; set the length of the buffer.  */    /* We have succeeded; set the length of the buffer.  */
4165    #ifdef WCHAR
4166      bufp->used = (uintptr_t) b - (uintptr_t) COMPILED_BUFFER_VAR;
4167    #else
4168    bufp->used = b - bufp->buffer;    bufp->used = b - bufp->buffer;
4169    #endif
4170    
4171  #ifdef DEBUG  #ifdef DEBUG
4172    if (debug)    if (debug)
4173      {      {
4174        DEBUG_PRINT1 ("\nCompiled pattern: \n");        DEBUG_PRINT1 ("\nCompiled pattern: \n");
4175        print_compiled_pattern (bufp);        PREFIX(print_compiled_pattern) (bufp);
4176      }      }
4177  #endif /* DEBUG */  #endif /* DEBUG */
4178    
# Line 2497  regex_compile (pattern, size, syntax, bu Line 4190  regex_compile (pattern, size, syntax, bu
4190        {        {
4191          fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS);          fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS);
4192    
4193  #ifdef emacs  # ifdef emacs
4194          if (! fail_stack.stack)          if (! fail_stack.stack)
4195            fail_stack.stack            fail_stack.stack
4196              = (fail_stack_elt_t *) xmalloc (fail_stack.size              = (PREFIX(fail_stack_elt_t) *) xmalloc (fail_stack.size
4197                                              * sizeof (fail_stack_elt_t));                                      * sizeof (PREFIX(fail_stack_elt_t)));
4198          else          else
4199            fail_stack.stack            fail_stack.stack
4200              = (fail_stack_elt_t *) xrealloc (fail_stack.stack,              = (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack,
4201                                               (fail_stack.size                                       (fail_stack.size
4202                                                * sizeof (fail_stack_elt_t)));                                        * sizeof (PREFIX(fail_stack_elt_t))));
4203  #else /* not emacs */  # else /* not emacs */
4204          if (! fail_stack.stack)          if (! fail_stack.stack)
4205            fail_stack.stack            fail_stack.stack
4206              = (fail_stack_elt_t *) malloc (fail_stack.size              = malloc (fail_stack.size * sizeof (PREFIX(fail_stack_elt_t)));
                                            * sizeof (fail_stack_elt_t));  
4207          else          else
4208            fail_stack.stack            fail_stack.stack
4209              = (fail_stack_elt_t *) realloc (fail_stack.stack,              = realloc (fail_stack.stack,
4210                                              (fail_stack.size                         fail_stack.size * sizeof (PREFIX(fail_stack_elt_t)));
4211                                               * sizeof (fail_stack_elt_t)));  # endif /* not emacs */
 #endif /* not emacs */  
4212        }        }
4213    
4214      /* Initialize some other variables the matcher uses.  */     PREFIX(regex_grow_registers) (num_regs);
     RETALLOC_IF (regstart,       num_regs, const char *);  
     RETALLOC_IF (regend,         num_regs, const char *);  
     RETALLOC_IF (old_regstart,   num_regs, const char *);  
     RETALLOC_IF (old_regend,     num_regs, const char *);  
     RETALLOC_IF (best_regstart,  num_regs, const char *);  
     RETALLOC_IF (best_regend,    num_regs, const char *);  
     RETALLOC_IF (reg_info,       num_regs, register_info_type);  
     RETALLOC_IF (reg_dummy,      num_regs, const char *);  
     RETALLOC_IF (reg_info_dummy, num_regs, register_info_type);  
4215    }    }
4216  #endif  #endif /* not MATCH_MAY_ALLOCATE */
4217    
4218    return REG_NOERROR;    return REG_NOERROR;
4219  } /* regex_compile */  } /* regex_compile */
4220    
4221  /* Subroutines for `regex_compile'.  */  /* Subroutines for `regex_compile'.  */
4222    
4223  /* Store OP at LOC followed by two-byte integer parameter ARG.  */  /* Store OP at LOC followed by two-byte integer parameter ARG.  */
4224    /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
4225    
4226  static void  static void
4227  store_op1 (op, loc, arg)  PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg)
     re_opcode_t op;  
     unsigned char *loc;  
     int arg;  
4228  {  {
4229    *loc = (unsigned char) op;    *loc = (UCHAR_T) op;
4230    STORE_NUMBER (loc + 1, arg);    STORE_NUMBER (loc + 1, arg);
4231  }  }
4232    
4233    
4234  /* Like `store_op1', but for two two-byte parameters ARG1 and ARG2.  */  /* Like `store_op1', but for two two-byte parameters ARG1 and ARG2.  */
4235    /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
4236    
4237  static void  static void
4238  store_op2 (op, loc, arg1, arg2)  PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2)
     re_opcode_t op;  
     unsigned char *loc;  
     int arg1, arg2;  
4239  {  {
4240    *loc = (unsigned char) op;    *loc = (UCHAR_T) op;
4241    STORE_NUMBER (loc + 1, arg1);    STORE_NUMBER (loc + 1, arg1);
4242    STORE_NUMBER (loc + 3, arg2);    STORE_NUMBER (loc + 1 + OFFSET_ADDRESS_SIZE, arg2);
4243  }  }
4244    
4245    
4246  /* Copy the bytes from LOC to END to open up three bytes of space at LOC  /* Copy the bytes from LOC to END to open up three bytes of space at LOC
4247     for OP followed by two-byte integer parameter ARG.  */     for OP followed by two-byte integer parameter ARG.  */
4248    /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
4249    
4250  static void  static void
4251  insert_op1 (op, loc, arg, end)  PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc, int arg, UCHAR_T *end)
     re_opcode_t op;  
     unsigned char *loc;  
     int arg;  
     unsigned char *end;      
4252  {  {
4253    register unsigned char *pfrom = end;    register UCHAR_T *pfrom = end;
4254    register unsigned char *pto = end + 3;    register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE;
4255    
4256    while (pfrom != loc)    while (pfrom != loc)
4257      *--pto = *--pfrom;      *--pto = *--pfrom;
4258        
4259    store_op1 (op, loc, arg);    PREFIX(store_op1) (op, loc, arg);
4260  }  }
4261    
4262    
4263  /* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2.  */  /* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2.  */
4264    /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
4265    
4266  static void  static void
4267  insert_op2 (op, loc, arg1, arg2, end)  PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2,
4268      re_opcode_t op;                      UCHAR_T *end)
     unsigned char *loc;  
     int arg1, arg2;  
     unsigned char *end;      
4269  {  {
4270    register unsigned char *pfrom = end;    register UCHAR_T *pfrom = end;
4271    register unsigned char *pto = end + 5;    register UCHAR_T *pto = end + 1 + 2 * OFFSET_ADDRESS_SIZE;
4272    
4273    while (pfrom != loc)    while (pfrom != loc)
4274      *--pto = *--pfrom;      *--pto = *--pfrom;
4275        
4276    store_op2 (op, loc, arg1, arg2);    PREFIX(store_op2) (op, loc, arg1, arg2);
4277  }  }
4278    
4279    
# Line 2609  insert_op2 (op, loc, arg1, arg2, end) Line 4282  insert_op2 (op, loc, arg1, arg2, end)
4282     least one character before the ^.  */     least one character before the ^.  */
4283    
4284  static boolean  static boolean
4285  at_begline_loc_p (pattern, p, syntax)  PREFIX(at_begline_loc_p) (const CHAR_T *pattern, const CHAR_T *p,
4286      const char *pattern, *p;                            reg_syntax_t syntax)
     reg_syntax_t syntax;  
4287  {  {
4288    const char *prev = p - 2;    const CHAR_T *prev = p - 2;
4289    boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';    boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
4290      
4291    return    return
4292         /* After a subexpression?  */         /* After a subexpression?  */
4293         (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))         (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
# Line 2628  at_begline_loc_p (pattern, p, syntax) Line 4300  at_begline_loc_p (pattern, p, syntax)
4300     at least one character after the $, i.e., `P < PEND'.  */     at least one character after the $, i.e., `P < PEND'.  */
4301    
4302  static boolean  static boolean
4303  at_endline_loc_p (p, pend, syntax)  PREFIX(at_endline_loc_p) (const CHAR_T *p, const CHAR_T *pend,
4304      const char *p, *pend;                            reg_syntax_t syntax)
     int syntax;  
4305  {  {
4306    const char *next = p;    const CHAR_T *next = p;
4307    boolean next_backslash = *next == '\\';    boolean next_backslash = *next == '\\';
4308    const char *next_next = p + 1 < pend ? p + 1 : NULL;    const CHAR_T *next_next = p + 1 < pend ? p + 1 : 0;
4309      
4310    return    return
4311         /* Before a subexpression?  */         /* Before a subexpression?  */
4312         (syntax & RE_NO_BK_PARENS ? *next == ')'         (syntax & RE_NO_BK_PARENS ? *next == ')'
# Line 2645  at_endline_loc_p (p, pend, syntax) Line 4316  at_endline_loc_p (p, pend, syntax)
4316          : next_backslash && next_next && *next_next == '|');          : next_backslash && next_next && *next_next == '|');
4317  }  }
4318    
4319    #else /* not INSIDE_RECURSION */
4320    
4321  /* Returns true if REGNUM is in one of COMPILE_STACK's elements and  /* Returns true if REGNUM is in one of COMPILE_STACK's elements and
4322     false if it's not.  */     false if it's not.  */
4323    
4324  static boolean  static boolean
4325  group_in_compile_stack (compile_stack, regnum)  group_in_compile_stack (compile_stack_type compile_stack,
4326      compile_stack_type compile_stack;                          regnum_t regnum)
     regnum_t regnum;  
4327  {  {
4328    int this_element;    int this_element;
4329    
4330    for (this_element = compile_stack.avail - 1;      for (this_element = compile_stack.avail - 1;
4331         this_element >= 0;         this_element >= 0;
4332         this_element--)         this_element--)
4333      if (compile_stack.stack[this_element].regnum == regnum)      if (compile_stack.stack[this_element].regnum == regnum)
4334        return true;        return true;
4335    
4336    return false;    return false;
4337  }  }
4338    #endif /* not INSIDE_RECURSION */
4339    
4340    #ifdef INSIDE_RECURSION
4341    
4342    #ifdef WCHAR
4343    /* This insert space, which size is "num", into the pattern at "loc".
4344       "end" must point the end of the allocated buffer.  */
4345    static void
4346    insert_space (int num, CHAR_T *loc, CHAR_T *end)
4347    {
4348      register CHAR_T *pto = end;
4349      register CHAR_T *pfrom = end - num;
4350    
4351      while (pfrom >= loc)
4352        *pto-- = *pfrom--;
4353    }
4354    #endif /* WCHAR */
4355    
4356    #ifdef WCHAR
4357    static reg_errcode_t
4358    wcs_compile_range (CHAR_T range_start_char,
4359                       const CHAR_T **p_ptr, const CHAR_T *pend,
4360                       RE_TRANSLATE_TYPE translate, reg_syntax_t syntax,
4361                       CHAR_T *b, CHAR_T *char_set)
4362    {
4363      const CHAR_T *p = *p_ptr;
4364      CHAR_T range_start, range_end;
4365      reg_errcode_t ret;
4366    # ifdef _LIBC
4367      uint32_t nrules;
4368      uint32_t start_val, end_val;
4369    # endif
4370      if (p == pend)
4371        return REG_ERANGE;
4372    
4373    # ifdef _LIBC
4374      nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
4375      if (nrules != 0)
4376        {
4377          const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE,
4378                                                           _NL_COLLATE_COLLSEQWC);
4379          const unsigned char *extra = (const unsigned char *)
4380            _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
4381    
4382          if (range_start_char < -1)
4383            {
4384              /* range_start is a collating symbol.  */
4385              int32_t *wextra;
4386              /* Retreive the index and get collation sequence value.  */
4387              wextra = (int32_t*)(extra + char_set[-range_start_char]);
4388              start_val = wextra[1 + *wextra];
4389            }
4390          else
4391            start_val = collseq_table_lookup(collseq, TRANSLATE(range_start_char));
4392    
4393          end_val = collseq_table_lookup (collseq, TRANSLATE (p[0]));
4394    
4395          /* Report an error if the range is empty and the syntax prohibits
4396             this.  */
4397          ret = ((syntax & RE_NO_EMPTY_RANGES)
4398                 && (start_val > end_val))? REG_ERANGE : REG_NOERROR;
4399    
4400          /* Insert space to the end of the char_ranges.  */
4401          insert_space(2, b - char_set[5] - 2, b - 1);
4402          *(b - char_set[5] - 2) = (wchar_t)start_val;
4403          *(b - char_set[5] - 1) = (wchar_t)end_val;
4404          char_set[4]++; /* ranges_index */
4405        }
4406      else
4407    # endif
4408        {
4409          range_start = (range_start_char >= 0)? TRANSLATE (range_start_char):
4410            range_start_char;
4411          range_end = TRANSLATE (p[0]);
4412          /* Report an error if the range is empty and the syntax prohibits
4413             this.  */
4414          ret = ((syntax & RE_NO_EMPTY_RANGES)
4415                 && (range_start > range_end))? REG_ERANGE : REG_NOERROR;
4416    
4417          /* Insert space to the end of the char_ranges.  */
4418          insert_space(2, b - char_set[5] - 2, b - 1);
4419          *(b - char_set[5] - 2) = range_start;
4420          *(b - char_set[5] - 1) = range_end;
4421          char_set[4]++; /* ranges_index */
4422        }
4423      /* Have to increment the pointer into the pattern string, so the
4424         caller isn't still at the ending character.  */
4425      (*p_ptr)++;
4426    
4427      return ret;
4428    }
4429    #else /* BYTE */
4430  /* Read the ending character of a range (in a bracket expression) from the  /* Read the ending character of a range (in a bracket expression) from the
4431     uncompiled pattern *P_PTR (which ends at PEND).  We assume the     uncompiled pattern *P_PTR (which ends at PEND).  We assume the
4432     starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)     starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)
4433     Then we set the translation of all bits between the starting and     Then we set the translation of all bits between the starting and
4434     ending characters (inclusive) in the compiled pattern B.     ending characters (inclusive) in the compiled pattern B.
4435      
4436     Return an error code.     Return an error code.
4437      
4438     We use these short variable names so we can use the same macros as     We use these short variable names so we can use the same macros as
4439     `regex_compile' itself.  */     `regex_compile' itself.  */
4440    
4441  static reg_errcode_t  static reg_errcode_t
4442  compile_range (p_ptr, pend, translate, syntax, b)  byte_compile_range (unsigned int range_start_char,
4443      const char **p_ptr, *pend;                      const char **p_ptr, const char *pend,
4444      char *translate;                      RE_TRANSLATE_TYPE translate, reg_syntax_t syntax,
4445      reg_syntax_t syntax;                      unsigned char *b)
     unsigned char *b;  
4446  {  {
4447    unsigned this_char;    unsigned this_char;
   
4448    const char *p = *p_ptr;    const char *p = *p_ptr;
4449    int range_start, range_end;    reg_errcode_t ret;
4450      # if _LIBC
4451      const unsigned char *collseq;
4452      unsigned int start_colseq;
4453      unsigned int end_colseq;
4454    # else
4455      unsigned end_char;
4456    # endif
4457    
4458    if (p == pend)    if (p == pend)
4459      return REG_ERANGE;      return REG_ERANGE;
4460    
   /* Even though the pattern is a signed `char *', we need to fetch  
      with unsigned char *'s; if the high bit of the pattern character  
      is set, the range endpoints will be negative if we fetch using a  
      signed char *.  
   
      We also want to fetch the endpoints without translating them; the  
      appropriate translation is done in the bit-setting loop below.  */  
   /* The SVR4 compiler on the 3B2 had trouble with unsigned const char *.  */  
   range_start = ((const unsigned char *) p)[-2];  
   range_end   = ((const unsigned char *) p)[0];  
   
4461    /* Have to increment the pointer into the pattern string, so the    /* Have to increment the pointer into the pattern string, so the
4462       caller isn't still at the ending character.  */       caller isn't still at the ending character.  */
4463    (*p_ptr)++;    (*p_ptr)++;
4464    
4465    /* If the start is after the end, the range is empty.  */    /* Report an error if the range is empty and the syntax prohibits this.  */
4466    if (range_start > range_end)    ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
4467      return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;  
4468    # if _LIBC
4469      collseq = (const unsigned char *) _NL_CURRENT (LC_COLLATE,
4470                                                     _NL_COLLATE_COLLSEQMB);
4471    
4472      start_colseq = collseq[(unsigned char) TRANSLATE (range_start_char)];
4473      end_colseq = collseq[(unsigned char) TRANSLATE (p[0])];
4474      for (this_char = 0; this_char <= (unsigned char) -1; ++this_char)
4475        {
4476          unsigned int this_colseq = collseq[(unsigned char) TRANSLATE (this_char)];
4477    
4478          if (start_colseq <= this_colseq && this_colseq <= end_colseq)
4479            {
4480              SET_LIST_BIT (TRANSLATE (this_char));
4481              ret = REG_NOERROR;
4482            }
4483        }
4484    # else
4485    /* Here we see why `this_char' has to be larger than an `unsigned    /* Here we see why `this_char' has to be larger than an `unsigned
4486       char' -- the range is inclusive, so if `range_end' == 0xff       char' -- we would otherwise go into an infinite loop, since all
4487       (assuming 8-bit characters), we would otherwise go into an infinite       characters <= 0xff.  */
4488       loop, since all characters <= 0xff.  */    range_start_char = TRANSLATE (range_start_char);
4489    for (this_char = range_start; this_char <= range_end; this_char++)    /* TRANSLATE(p[0]) is casted to char (not unsigned char) in TRANSLATE,
4490         and some compilers cast it to int implicitly, so following for_loop
4491         may fall to (almost) infinite loop.
4492         e.g. If translate[p[0]] = 0xff, end_char may equals to 0xffffffff.
4493         To avoid this, we cast p[0] to unsigned int and truncate it.  */
4494      end_char = ((unsigned)TRANSLATE(p[0]) & ((1 << BYTEWIDTH) - 1));
4495    
4496      for (this_char = range_start_char; this_char <= end_char; ++this_char)
4497      {      {
4498        SET_LIST_BIT (TRANSLATE (this_char));        SET_LIST_BIT (TRANSLATE (this_char));
4499          ret = REG_NOERROR;
4500      }      }
4501      # endif
4502    return REG_NOERROR;  
4503      return ret;
4504  }  }
4505    #endif /* WCHAR */
4506    
4507  /* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in  /* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
4508     BUFP.  A fastmap records which of the (1 << BYTEWIDTH) possible     BUFP.  A fastmap records which of the (1 << BYTEWIDTH) possible
# Line 2730  compile_range (p_ptr, pend, translate, s Line 4511  compile_range (p_ptr, pend, translate, s
4511    
4512     The caller must supply the address of a (1 << BYTEWIDTH)-byte data     The caller must supply the address of a (1 << BYTEWIDTH)-byte data
4513     area as BUFP->fastmap.     area as BUFP->fastmap.
4514      
4515     We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in     We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
4516     the pattern buffer.     the pattern buffer.
4517    
4518     Returns 0 if we succeed, -2 if an internal error.   */     Returns 0 if we succeed, -2 if an internal error.   */
4519    
4520  int  #ifdef WCHAR
4521  re_compile_fastmap (bufp)  /* local function for re_compile_fastmap.
4522       struct re_pattern_buffer *bufp;     truncate wchar_t character to char.  */
4523    
4524    static unsigned char
4525    truncate_wchar (CHAR_T c)
4526    {
4527      unsigned char buf[MB_CUR_MAX];
4528      mbstate_t state;
4529      int retval;
4530      memset (&state, '\0', sizeof (state));
4531      retval = wcrtomb (buf, c, &state);
4532      return retval > 0 ? buf[0] : (unsigned char) c;
4533    }
4534    #endif /* WCHAR */
4535    
4536    static int
4537    PREFIX(re_compile_fastmap) (struct re_pattern_buffer *bufp)
4538  {  {
4539    int j, k;    int j, k;
4540  #ifdef MATCH_MAY_ALLOCATE  #ifdef MATCH_MAY_ALLOCATE
4541    fail_stack_type fail_stack;    PREFIX(fail_stack_type) fail_stack;
4542  #endif  #endif
4543  #ifndef REGEX_MALLOC  #ifndef REGEX_MALLOC
4544    char *destination;    char *destination;
4545  #endif  #endif
4546    /* We don't push any register information onto the failure stack.  */  
   unsigned num_regs = 0;  
     
4547    register char *fastmap = bufp->fastmap;    register char *fastmap = bufp->fastmap;
4548    unsigned char *pattern = bufp->buffer;  
4549    unsigned long size = bufp->used;  #ifdef WCHAR
4550    unsigned char *p = pattern;    /* We need to cast pattern to (wchar_t*), because we casted this compiled
4551    register unsigned char *pend = pattern + size;       pattern to (char*) in regex_compile.  */
4552      UCHAR_T *pattern = (UCHAR_T*)bufp->buffer;
4553      register UCHAR_T *pend = (UCHAR_T*) (bufp->buffer + bufp->used);
4554    #else /* BYTE */
4555      UCHAR_T *pattern = bufp->buffer;
4556      register UCHAR_T *pend = pattern + bufp->used;
4557    #endif /* WCHAR */
4558      UCHAR_T *p = pattern;
4559    
4560    #ifdef REL_ALLOC
4561      /* This holds the pointer to the failure stack, when
4562         it is allocated relocatably.  */
4563      fail_stack_elt_t *failure_stack_ptr;
4564    #endif
4565    
4566    /* Assume that each path through the pattern can be null until    /* Assume that each path through the pattern can be null until
4567       proven otherwise.  We set this false at the bottom of switch       proven otherwise.  We set this false at the bottom of switch
# Line 2766  re_compile_fastmap (bufp) Line 4573  re_compile_fastmap (bufp)
4573    boolean succeed_n_p = false;    boolean succeed_n_p = false;
4574    
4575    assert (fastmap != NULL && p != NULL);    assert (fastmap != NULL && p != NULL);
4576      
4577    INIT_FAIL_STACK ();    INIT_FAIL_STACK ();
4578    bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */    bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
4579    bufp->fastmap_accurate = 1;       /* It will be when we're done.  */    bufp->fastmap_accurate = 1;       /* It will be when we're done.  */
4580    bufp->can_be_null = 0;    bufp->can_be_null = 0;
4581          
4582    while (p != pend || !FAIL_STACK_EMPTY ())    while (1)
4583      {      {
4584        if (p == pend)        if (p == pend || *p == succeed)
4585          {          {
4586            bufp->can_be_null |= path_can_be_null;            /* We have reached the (effective) end of pattern.  */
4587                        if (!FAIL_STACK_EMPTY ())
4588            /* Reset for next path.  */              {
4589            path_can_be_null = true;                bufp->can_be_null |= path_can_be_null;
4590              
4591            p = fail_stack.stack[--fail_stack.avail];                /* Reset for next path.  */
4592                  path_can_be_null = true;
4593    
4594                  p = fail_stack.stack[--fail_stack.avail].pointer;
4595    
4596                  continue;
4597                }
4598              else
4599                break;
4600          }          }
4601    
4602        /* We should never be about to go beyond the end of the pattern.  */        /* We should never be about to go beyond the end of the pattern.  */
4603        assert (p < pend);        assert (p < pend);
4604          
4605  #ifdef SWITCH_ENUM_BUG        switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
       switch ((int) ((re_opcode_t) *p++))  
 #else  
       switch ((re_opcode_t) *p++)  
 #endif  
4606          {          {
4607    
4608          /* I guess the idea here is to simply not bother with a fastmap          /* I guess the idea here is to simply not bother with a fastmap
# Line 2801  re_compile_fastmap (bufp) Line 4612  re_compile_fastmap (bufp)
4612             that is all we do.  */             that is all we do.  */
4613          case duplicate:          case duplicate:
4614            bufp->can_be_null = 1;            bufp->can_be_null = 1;
4615            return 0;            goto done;
4616    
4617    
4618        /* Following are the cases which match a character.  These end        /* Following are the cases which match a character.  These end
4619           with `break'.  */           with `break'.  */
4620    
4621    #ifdef WCHAR
4622            case exactn:
4623              fastmap[truncate_wchar(p[1])] = 1;
4624              break;
4625    #else /* BYTE */
4626          case exactn:          case exactn:
4627            fastmap[p[1]] = 1;            fastmap[p[1]] = 1;
4628            break;            break;
4629    #endif /* WCHAR */
4630    #ifdef MBS_SUPPORT
4631            case exactn_bin:
4632              fastmap[p[1]] = 1;
4633              break;
4634    #endif
4635    
4636    #ifdef WCHAR
4637            /* It is hard to distinguish fastmap from (multi byte) characters
4638               which depends on current locale.  */
4639            case charset:
4640            case charset_not:
4641            case wordchar:
4642            case notwordchar:
4643              bufp->can_be_null = 1;
4644              goto done;
4645    #else /* BYTE */
4646          case charset:          case charset:
4647            for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)            for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
4648              if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))              if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
# Line 2842  re_compile_fastmap (bufp) Line 4673  re_compile_fastmap (bufp)
4673              if (SYNTAX (j) != Sword)              if (SYNTAX (j) != Sword)
4674                fastmap[j] = 1;                fastmap[j] = 1;
4675            break;            break;
4676    #endif /* WCHAR */
4677    
4678          case anychar:          case anychar:
4679            {            {
# Line 2859  re_compile_fastmap (bufp) Line 4690  re_compile_fastmap (bufp)
4690              /* Return if we have already set `can_be_null'; if we have,              /* Return if we have already set `can_be_null'; if we have,
4691                 then the fastmap is irrelevant.  Something's wrong here.  */                 then the fastmap is irrelevant.  Something's wrong here.  */
4692              else if (bufp->can_be_null)              else if (bufp->can_be_null)
4693                return 0;                goto done;
4694    
4695              /* Otherwise, have to check alternative paths.  */              /* Otherwise, have to check alternative paths.  */
4696              break;              break;
# Line 2890  re_compile_fastmap (bufp) Line 4721  re_compile_fastmap (bufp)
4721          case at_dot:          case at_dot:
4722          case after_dot:          case after_dot:
4723            continue;            continue;
4724  #endif /* not emacs */  #endif /* emacs */
4725    
4726    
4727          case no_op:          case no_op:
# Line 2913  re_compile_fastmap (bufp) Line 4744  re_compile_fastmap (bufp)
4744          case jump_past_alt:          case jump_past_alt:
4745          case dummy_failure_jump:          case dummy_failure_jump:
4746            EXTRACT_NUMBER_AND_INCR (j, p);            EXTRACT_NUMBER_AND_INCR (j, p);
4747            p += j;                  p += j;
4748            if (j > 0)            if (j > 0)
4749              continue;              continue;
4750                
4751            /* Jump backward implies we just went through the body of a            /* Jump backward implies we just went through the body of a
4752               loop and matched nothing.  Opcode jumped to should be               loop and matched nothing.  Opcode jumped to should be
4753               `on_failure_jump' or `succeed_n'.  Just treat it like an               `on_failure_jump' or `succeed_n'.  Just treat it like an
# Line 2928  re_compile_fastmap (bufp) Line 4759  re_compile_fastmap (bufp)
4759    
4760            p++;            p++;
4761            EXTRACT_NUMBER_AND_INCR (j, p);            EXTRACT_NUMBER_AND_INCR (j, p);
4762            p += j;                          p += j;
4763              
4764            /* If what's on the stack is where we are now, pop it.  */            /* If what's on the stack is where we are now, pop it.  */
4765            if (!FAIL_STACK_EMPTY ()            if (!FAIL_STACK_EMPTY ()
4766                && fail_stack.stack[fail_stack.avail - 1] == p)                && fail_stack.stack[fail_stack.avail - 1].pointer == p)
4767              fail_stack.avail--;              fail_stack.avail--;
4768    
4769            continue;            continue;
# Line 2953  re_compile_fastmap (bufp) Line 4784  re_compile_fastmap (bufp)
4784            if (p + j < pend)            if (p + j < pend)
4785              {              {
4786                if (!PUSH_PATTERN_OP (p + j, fail_stack))                if (!PUSH_PATTERN_OP (p + j, fail_stack))
4787                  return -2;                  {
4788                      RESET_FAIL_STACK ();
4789                      return -2;
4790                    }
4791              }              }
4792            else            else
4793              bufp->can_be_null = 1;              bufp->can_be_null = 1;
# Line 2969  re_compile_fastmap (bufp) Line 4803  re_compile_fastmap (bufp)
4803    
4804          case succeed_n:          case succeed_n:
4805            /* Get to the number of times to succeed.  */            /* Get to the number of times to succeed.  */
4806            p += 2;                          p += OFFSET_ADDRESS_SIZE;
4807    
4808            /* Increment p past the n for when k != 0.  */            /* Increment p past the n for when k != 0.  */
4809            EXTRACT_NUMBER_AND_INCR (k, p);            EXTRACT_NUMBER_AND_INCR (k, p);
4810            if (k == 0)            if (k == 0)
4811              {              {
4812                p -= 4;                p -= 2 * OFFSET_ADDRESS_SIZE;
4813                succeed_n_p = true;  /* Spaghetti code alert.  */                succeed_n_p = true;  /* Spaghetti code alert.  */
4814                goto handle_on_failure_jump;                goto handle_on_failure_jump;
4815              }              }
# Line 2983  re_compile_fastmap (bufp) Line 4817  re_compile_fastmap (bufp)
4817    
4818    
4819          case set_number_at:          case set_number_at:
4820            p += 4;            p += 2 * OFFSET_ADDRESS_SIZE;
4821            continue;            continue;
4822    
4823    
# Line 3010  re_compile_fastmap (bufp) Line 4844  re_compile_fastmap (bufp)
4844    /* Set `can_be_null' for the last path (also the first path, if the    /* Set `can_be_null' for the last path (also the first path, if the
4845       pattern is empty).  */       pattern is empty).  */
4846    bufp->can_be_null |= path_can_be_null;    bufp->can_be_null |= path_can_be_null;
4847    
4848     done:
4849      RESET_FAIL_STACK ();
4850    return 0;    return 0;
4851    }
4852    
4853    #else /* not INSIDE_RECURSION */
4854    
4855    int
4856    re_compile_fastmap (struct re_pattern_buffer *bufp)
4857    {
4858    # ifdef MBS_SUPPORT
4859      if (MB_CUR_MAX != 1)
4860        return wcs_re_compile_fastmap(bufp);
4861      else
4862    # endif
4863        return byte_re_compile_fastmap(bufp);
4864  } /* re_compile_fastmap */  } /* re_compile_fastmap */
4865    #ifdef _LIBC
4866    weak_alias (__re_compile_fastmap, re_compile_fastmap)
4867    #endif
4868    
4869    
4870  /* Set REGS to hold NUM_REGS registers, storing them in STARTS and  /* Set REGS to hold NUM_REGS registers, storing them in STARTS and
4871     ENDS.  Subsequent matches using PATTERN_BUFFER and REGS will use     ENDS.  Subsequent matches using PATTERN_BUFFER and REGS will use
4872     this memory for recording register information.  STARTS and ENDS     this memory for recording register information.  STARTS and ENDS
# Line 3027  re_compile_fastmap (bufp) Line 4881  re_compile_fastmap (bufp)
4881     freeing the old data.  */     freeing the old data.  */
4882    
4883  void  void
4884  re_set_registers (bufp, regs, num_regs, starts, ends)  re_set_registers (struct re_pattern_buffer *bufp,
4885      struct re_pattern_buffer *bufp;                    struct re_registers *regs,
4886      struct re_registers *regs;                    unsigned int num_regs,
4887      unsigned num_regs;                    regoff_t *starts, regoff_t *ends)
     regoff_t *starts, *ends;  
4888  {  {
4889    if (num_regs)    if (num_regs)
4890      {      {
# Line 3047  re_set_registers (bufp, regs, num_regs, Line 4900  re_set_registers (bufp, regs, num_regs,
4900        regs->start = regs->end = (regoff_t *) 0;        regs->start = regs->end = (regoff_t *) 0;
4901      }      }
4902  }  }
4903    #ifdef _LIBC
4904    weak_alias (__re_set_registers, re_set_registers)
4905    #endif
4906    
4907  /* Searching routines.  */  /* Searching routines.  */
4908    
4909  /* Like re_search_2, below, but only one string is specified, and  /* Like re_search_2, below, but only one string is specified, and
4910     doesn't let you say where to stop matching. */     doesn't let you say where to stop matching.  */
4911    
4912  int  int
4913  re_search (bufp, string, size, startpos, range, regs)  re_search (struct re_pattern_buffer *bufp,
4914       struct re_pattern_buffer *bufp;             const char *string,
4915       const char *string;             int size, int startpos, int range,
4916       int size, startpos, range;             struct re_registers *regs)
      struct re_registers *regs;  
4917  {  {
4918    return re_search_2 (bufp, NULL, 0, string, size, startpos, range,    return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
4919                        regs, size);                        regs, size);
4920  }  }
4921    #ifdef _LIBC
4922    weak_alias (__re_search, re_search)
4923    #endif
4924    
4925    
4926  /* Using the compiled pattern in BUFP->buffer, first tries to match the  /* Using the compiled pattern in BUFP->buffer, first tries to match the
4927     virtual concatenation of STRING1 and STRING2, starting first at index     virtual concatenation of STRING1 and STRING2, starting first at index
4928     STARTPOS, then at STARTPOS + 1, and so on.     STARTPOS, then at STARTPOS + 1, and so on.
4929      
4930     STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.     STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
4931      
4932     RANGE is how far to scan while trying to match.  RANGE = 0 means try     RANGE is how far to scan while trying to match.  RANGE = 0 means try
4933     only at STARTPOS; in general, the last start tried is STARTPOS +     only at STARTPOS; in general, the last start tried is STARTPOS +
4934     RANGE.     RANGE.
4935      
4936     In REGS, return the indices of the virtual concatenation of STRING1     In REGS, return the indices of the virtual concatenation of STRING1
4937     and STRING2 that matched the entire BUFP->buffer and its contained     and STRING2 that matched the entire BUFP->buffer and its contained
4938     subexpressions.     subexpressions.
4939      
4940     Do not consider matching one past the index STOP in the virtual     Do not consider matching one past the index STOP in the virtual
4941     concatenation of STRING1 and STRING2.     concatenation of STRING1 and STRING2.
4942    
# Line 3087  re_search (bufp, string, size, startpos, Line 4945  re_search (bufp, string, size, startpos,
4945     stack overflow).  */     stack overflow).  */
4946    
4947  int  int
4948  re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)  re_search_2 (struct re_pattern_buffer *bufp,
4949       struct re_pattern_buffer *bufp;               const char *string1, int size1,
4950       const char *string1, *string2;               const char *string2, int size2,
4951       int size1, size2;               int startpos, int range,
4952       int startpos;               struct re_registers *regs,
4953       int range;               int stop)
4954       struct re_registers *regs;  {
4955       int stop;  # ifdef MBS_SUPPORT
4956      if (MB_CUR_MAX != 1)
4957        return wcs_re_search_2 (bufp, string1, size1, string2, size2, startpos,
4958                                range, regs, stop);
4959      else
4960    # endif
4961        return byte_re_search_2 (bufp, string1, size1, string2, size2, startpos,
4962                                 range, regs, stop);
4963    } /* re_search_2 */
4964    #ifdef _LIBC
4965    weak_alias (__re_search_2, re_search_2)
4966    #endif
4967    
4968    #endif /* not INSIDE_RECURSION */
4969    
4970    #ifdef INSIDE_RECURSION
4971    
4972    #ifdef MATCH_MAY_ALLOCATE
4973    # define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL
4974    #else
4975    # define FREE_VAR(var) if (var) free (var); var = NULL
4976    #endif
4977    
4978    #ifdef WCHAR
4979    # define MAX_ALLOCA_SIZE        2000
4980    
4981    # define FREE_WCS_BUFFERS() \
4982      do {                                                                        \
4983        if (size1 > MAX_ALLOCA_SIZE)                                              \
4984          {                                                                       \
4985            free (wcs_string1);                                                   \
4986            free (mbs_offset1);                                                   \
4987          }                                                                       \
4988        else                                                                      \
4989          {                                                                       \
4990            FREE_VAR (wcs_string1);                                               \
4991            FREE_VAR (mbs_offset1);                                               \
4992          }                                                                       \
4993        if (size2 > MAX_ALLOCA_SIZE)                                              \
4994          {                                                                       \
4995            free (wcs_string2);                                                   \
4996            free (mbs_offset2);                                                   \
4997          }                                                                       \
4998        else                                                                      \
4999          {                                                                       \
5000            FREE_VAR (wcs_string2);                                               \
5001            FREE_VAR (mbs_offset2);                                               \
5002          }                                                                       \
5003      } while (0)
5004    
5005    #endif
5006    
5007    
5008    static int
5009    PREFIX(re_search_2) (struct re_pattern_buffer *bufp,
5010                         const char *string1, int size1,
5011                         const char *string2, int size2,
5012                         int startpos, int range,
5013                         struct re_registers *regs,
5014                         int stop)
5015  {  {
5016    int val;    int val;
5017    register char *fastmap = bufp->fastmap;    register char *fastmap = bufp->fastmap;
5018    register char *translate = bufp->translate;    register RE_TRANSLATE_TYPE translate = bufp->translate;
5019    int total_size = size1 + size2;    int total_size = size1 + size2;
5020    int endpos = startpos + range;    int endpos = startpos + range;
5021    #ifdef WCHAR
5022      /* We need wchar_t* buffers correspond to cstring1, cstring2.  */
5023      wchar_t *wcs_string1 = NULL, *wcs_string2 = NULL;
5024      /* We need the size of wchar_t buffers correspond to csize1, csize2.  */
5025      int wcs_size1 = 0, wcs_size2 = 0;
5026      /* offset buffer for optimizatoin. See convert_mbs_to_wc.  */
5027      int *mbs_offset1 = NULL, *mbs_offset2 = NULL;
5028      /* They hold whether each wchar_t is binary data or not.  */
5029      char *is_binary = NULL;
5030    #endif /* WCHAR */
5031    
5032    /* Check for out-of-range STARTPOS.  */    /* Check for out-of-range STARTPOS.  */
5033    if (startpos < 0 || startpos > total_size)    if (startpos < 0 || startpos > total_size)
5034      return -1;      return -1;
5035        
5036    /* Fix up RANGE if it might eventually take us outside    /* Fix up RANGE if it might eventually take us outside
5037       the virtual concatenation of STRING1 and STRING2.  */       the virtual concatenation of STRING1 and STRING2.
5038    if (endpos < -1)       Make sure we won't move STARTPOS below 0 or above TOTAL_SIZE.  */
5039      range = -1 - startpos;    if (endpos < 0)
5040        range = 0 - startpos;
5041    else if (endpos > total_size)    else if (endpos > total_size)
5042      range = total_size - startpos;      range = total_size - startpos;
5043    
5044    /* If the search isn't to be a backwards one, don't waste time in a    /* If the search isn't to be a backwards one, don't waste time in a
5045       search for a pattern that must be anchored.  */       search for a pattern that must be anchored.  */
5046    if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == begbuf && range > 0)    if (bufp->used > 0 && range > 0
5047          && ((re_opcode_t) bufp->buffer[0] == begbuf
5048              /* `begline' is like `begbuf' if it cannot match at newlines.  */
5049              || ((re_opcode_t) bufp->buffer[0] == begline
5050                  && !bufp->newline_anchor)))
5051      {      {
5052        if (startpos > 0)        if (startpos > 0)
5053          return -1;          return -1;
# Line 3123  re_search_2 (bufp, string1, size1, strin Line 5055  re_search_2 (bufp, string1, size1, strin
5055          range = 1;          range = 1;
5056      }      }
5057    
5058    #ifdef emacs
5059      /* In a forward search for something that starts with \=.
5060         don't keep searching past point.  */
5061      if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == at_dot && range > 0)
5062        {
5063          range = PT - startpos;
5064          if (range <= 0)
5065            return -1;
5066        }
5067    #endif /* emacs */
5068    
5069    /* Update the fastmap now if not correct already.  */    /* Update the fastmap now if not correct already.  */
5070    if (fastmap && !bufp->fastmap_accurate)    if (fastmap && !bufp->fastmap_accurate)
5071      if (re_compile_fastmap (bufp) == -2)      if (re_compile_fastmap (bufp) == -2)
5072        return -2;        return -2;
5073      
5074    #ifdef WCHAR
5075      /* Allocate wchar_t array for wcs_string1 and wcs_string2 and
5076         fill them with converted string.  */
5077      if (size1 != 0)
5078        {
5079          if (size1 > MAX_ALLOCA_SIZE)
5080            {
5081              wcs_string1 = TALLOC (size1 + 1, CHAR_T);
5082              mbs_offset1 = TALLOC (size1 + 1, int);
5083              is_binary = TALLOC (size1 + 1, char);
5084            }
5085          else
5086            {
5087              wcs_string1 = REGEX_TALLOC (size1 + 1, CHAR_T);
5088              mbs_offset1 = REGEX_TALLOC (size1 + 1, int);
5089              is_binary = REGEX_TALLOC (size1 + 1, char);
5090            }
5091          if (!wcs_string1 || !mbs_offset1 || !is_binary)
5092            {
5093              if (size1 > MAX_ALLOCA_SIZE)
5094                {
5095                  free (wcs_string1);
5096                  free (mbs_offset1);
5097                  free (is_binary);
5098                }
5099              else
5100                {
5101                  FREE_VAR (wcs_string1);
5102                  FREE_VAR (mbs_offset1);
5103                  FREE_VAR (is_binary);
5104                }
5105              return -2;
5106            }
5107          wcs_size1 = convert_mbs_to_wcs(wcs_string1, string1, size1,
5108                                         mbs_offset1, is_binary);
5109          wcs_string1[wcs_size1] = L'\0'; /* for a sentinel  */
5110          if (size1 > MAX_ALLOCA_SIZE)
5111            free (is_binary);
5112          else
5113            FREE_VAR (is_binary);
5114        }
5115      if (size2 != 0)
5116        {
5117          if (size2 > MAX_ALLOCA_SIZE)
5118            {
5119              wcs_string2 = TALLOC (size2 + 1, CHAR_T);
5120              mbs_offset2 = TALLOC (size2 + 1, int);
5121              is_binary = TALLOC (size2 + 1, char);
5122            }
5123          else
5124            {
5125              wcs_string2 = REGEX_TALLOC (size2 + 1, CHAR_T);
5126              mbs_offset2 = REGEX_TALLOC (size2 + 1, int);
5127              is_binary = REGEX_TALLOC (size2 + 1, char);
5128            }
5129          if (!wcs_string2 || !mbs_offset2 || !is_binary)
5130            {
5131              FREE_WCS_BUFFERS ();
5132              if (size2 > MAX_ALLOCA_SIZE)
5133                free (is_binary);
5134              else
5135                FREE_VAR (is_binary);
5136              return -2;
5137            }
5138          wcs_size2 = convert_mbs_to_wcs(wcs_string2, string2, size2,
5139                                         mbs_offset2, is_binary);
5140          wcs_string2[wcs_size2] = L'\0'; /* for a sentinel  */
5141          if (size2 > MAX_ALLOCA_SIZE)
5142            free (is_binary);
5143          else
5144            FREE_VAR (is_binary);
5145        }
5146    #endif /* WCHAR */
5147    
5148    
5149    /* Loop through the string, looking for a place to start matching.  */    /* Loop through the string, looking for a place to start matching.  */
5150    for (;;)    for (;;)
5151      {      {
5152        /* If a fastmap is supplied, skip quickly over characters that        /* If a fastmap is supplied, skip quickly over characters that
5153           cannot be the start of a match.  If the pattern can match the           cannot be the start of a match.  If the pattern can match the
5154           null string, however, we don't need to skip characters; we want           null string, however, we don't need to skip characters; we want
# Line 3147  re_search_2 (bufp, string1, size1, strin Line 5165  re_search_2 (bufp, string1, size1, strin
5165                  lim = range - (size1 - startpos);                  lim = range - (size1 - startpos);
5166    
5167                d = (startpos >= size1 ? string2 - size1 : string1) + startpos;                d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
5168      
5169                /* Written out as an if-else to avoid testing `translate'                /* Written out as an if-else to avoid testing `translate'
5170                   inside the loop.  */                   inside the loop.  */
5171                if (translate)                if (translate)
# Line 3163  re_search_2 (bufp, string1, size1, strin Line 5181  re_search_2 (bufp, string1, size1, strin
5181              }              }
5182            else                          /* Searching backwards.  */            else                          /* Searching backwards.  */
5183              {              {
5184                register char c = (size1 == 0 || startpos >= size1                register CHAR_T c = (size1 == 0 || startpos >= size1
5185                                   ? string2[startpos - size1]                                        ? string2[startpos - size1]
5186                                   : string1[startpos]);                                        : string1[startpos]);
5187    
5188                if (!fastmap[(unsigned char) TRANSLATE (c)])                if (!fastmap[(unsigned char) TRANSLATE (c)])
5189                  goto advance;                  goto advance;
# Line 3175  re_search_2 (bufp, string1, size1, strin Line 5193  re_search_2 (bufp, string1, size1, strin
5193        /* If can't match the null string, and that's all we have left, fail.  */        /* If can't match the null string, and that's all we have left, fail.  */
5194        if (range >= 0 && startpos == total_size && fastmap        if (range >= 0 && startpos == total_size && fastmap
5195            && !bufp->can_be_null)            && !bufp->can_be_null)
5196          return -1;         {
5197    #ifdef WCHAR
5198             FREE_WCS_BUFFERS ();
5199    #endif
5200             return -1;
5201           }
5202    
5203    #ifdef WCHAR
5204          val = wcs_re_match_2_internal (bufp, string1, size1, string2,
5205                                         size2, startpos, regs, stop,
5206                                         wcs_string1, wcs_size1,
5207                                         wcs_string2, wcs_size2,
5208                                         mbs_offset1, mbs_offset2);
5209    #else /* BYTE */
5210          val = byte_re_match_2_internal (bufp, string1, size1, string2,
5211                                          size2, startpos, regs, stop);
5212    #endif /* BYTE */
5213    
       val = re_match_2_internal (bufp, string1, size1, string2, size2,  
                                  startpos, regs, stop);  
5214  #ifndef REGEX_MALLOC  #ifndef REGEX_MALLOC
5215  #ifdef C_ALLOCA  # ifdef C_ALLOCA
5216        alloca (0);        alloca (0);
5217  #endif  # endif
5218  #endif  #endif
5219    
5220        if (val >= 0)        if (val >= 0)
5221          return startpos;          {
5222            #ifdef WCHAR
5223              FREE_WCS_BUFFERS ();
5224    #endif
5225              return startpos;
5226            }
5227    
5228        if (val == -2)        if (val == -2)
5229          return -2;          {
5230    #ifdef WCHAR
5231              FREE_WCS_BUFFERS ();
5232    #endif
5233              return -2;
5234            }
5235    
5236      advance:      advance:
5237        if (!range)        if (!range)
5238          break;          break;
5239        else if (range > 0)        else if (range > 0)
5240          {          {
5241            range--;            range--;
5242            startpos++;            startpos++;
5243          }          }
5244        else        else
5245          {          {
5246            range++;            range++;
5247            startpos--;            startpos--;
5248          }          }
5249      }      }
5250    #ifdef WCHAR
5251      FREE_WCS_BUFFERS ();
5252    #endif
5253    return -1;    return -1;
5254  } /* re_search_2 */  }
   
 /* Declarations and macros for re_match_2.  */  
   
 static int bcmp_translate ();  
 static boolean alt_match_null_string_p (),  
                common_op_match_null_string_p (),  
                group_match_null_string_p ();  
5255    
5256    #ifdef WCHAR
5257    /* This converts PTR, a pointer into one of the search wchar_t strings
5258       `string1' and `string2' into an multibyte string offset from the
5259       beginning of that string. We use mbs_offset to optimize.
5260       See convert_mbs_to_wcs.  */
5261    # define POINTER_TO_OFFSET(ptr)                                         \
5262      (FIRST_STRING_P (ptr)                                                 \
5263       ? ((regoff_t)(mbs_offset1 != NULL? mbs_offset1[(ptr)-string1] : 0))  \
5264       : ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0)  \
5265                     + csize1)))
5266    #else /* BYTE */
5267  /* This converts PTR, a pointer into one of the search strings `string1'  /* This converts PTR, a pointer into one of the search strings `string1'
5268     and `string2' into an offset from the beginning of that string.  */     and `string2' into an offset from the beginning of that string.  */
5269  #define POINTER_TO_OFFSET(ptr)                  \  # define POINTER_TO_OFFSET(ptr)                 \
5270    (FIRST_STRING_P (ptr)                         \    (FIRST_STRING_P (ptr)                         \
5271     ? ((regoff_t) ((ptr) - string1))             \     ? ((regoff_t) ((ptr) - string1))             \
5272     : ((regoff_t) ((ptr) - string2 + size1)))     : ((regoff_t) ((ptr) - string2 + size1)))
5273    #endif /* WCHAR */
5274    
5275  /* Macros for dealing with the split strings in re_match_2.  */  /* Macros for dealing with the split strings in re_match_2.  */
5276    
# Line 3239  static boolean alt_match_null_string_p ( Line 5289  static boolean alt_match_null_string_p (
5289        dend = end_match_2;                                               \        dend = end_match_2;                                               \
5290      }      }
5291    
   
5292  /* Test if at very beginning or at very end of the virtual concatenation  /* Test if at very beginning or at very end of the virtual concatenation
5293     of `string1' and `string2'.  If only one string, it's `string2'.  */     of `string1' and `string2'.  If only one string, it's `string2'.  */
5294  #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)  #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
5295  #define AT_STRINGS_END(d) ((d) == end2)  #define AT_STRINGS_END(d) ((d) == end2)
5296    
5297    
5298  /* Test if D points to a character which is word-constituent.  We have  /* Test if D points to a character which is word-constituent.  We have
5299     two special cases to check for: if past the end of string1, look at     two special cases to check for: if past the end of string1, look at
5300     the first character in string2; and if before the beginning of     the first character in string2; and if before the beginning of
5301     string2, look at the last character in string1.  */     string2, look at the last character in string1.  */
5302  #define WORDCHAR_P(d)                                                   \  #ifdef WCHAR
5303    /* Use internationalized API instead of SYNTAX.  */
5304    # define WORDCHAR_P(d)                                                  \
5305      (iswalnum ((wint_t)((d) == end1 ? *string2                            \
5306               : (d) == string2 - 1 ? *(end1 - 1) : *(d))) != 0             \
5307       || ((d) == end1 ? *string2                                           \
5308           : (d) == string2 - 1 ? *(end1 - 1) : *(d)) == L'_')
5309    #else /* BYTE */
5310    # define WORDCHAR_P(d)                                                  \
5311    (SYNTAX ((d) == end1 ? *string2                                       \    (SYNTAX ((d) == end1 ? *string2                                       \
5312             : (d) == string2 - 1 ? *(end1 - 1) : *(d))                   \             : (d) == string2 - 1 ? *(end1 - 1) : *(d))                   \
5313     == Sword)     == Sword)
5314    #endif /* WCHAR */
5315    
5316    /* Disabled due to a compiler bug -- see comment at case wordbound */
5317    #if 0
5318  /* Test if the character before D and the one at D differ with respect  /* Test if the character before D and the one at D differ with respect
5319     to being word-constituent.  */     to being word-constituent.  */
5320  #define AT_WORD_BOUNDARY(d)                                             \  #define AT_WORD_BOUNDARY(d)                                             \
5321    (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)                             \    (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)                             \
5322     || WORDCHAR_P (d - 1) != WORDCHAR_P (d))     || WORDCHAR_P (d - 1) != WORDCHAR_P (d))
5323    #endif
5324    
5325  /* Free everything we malloc.  */  /* Free everything we malloc.  */
5326  #ifdef MATCH_MAY_ALLOCATE  #ifdef MATCH_MAY_ALLOCATE
5327  #ifdef REGEX_MALLOC  # ifdef WCHAR
5328  #define FREE_VAR(var) if (var) free (var); var = NULL  #  define FREE_VARIABLES()                                              \
 #define FREE_VARIABLES()                                                \  
5329    do {                                                                  \    do {                                                                  \
5330      FREE_VAR (fail_stack.stack);                                        \      REGEX_FREE_STACK (fail_stack.stack);                                \
5331      FREE_VAR (regstart);                                                \      FREE_VAR (regstart);                                                \
5332      FREE_VAR (regend);                                                  \      FREE_VAR (regend);                                                  \
5333      FREE_VAR (old_regstart);                                            \      FREE_VAR (old_regstart);                                            \
# Line 3278  static boolean alt_match_null_string_p ( Line 5337  static boolean alt_match_null_string_p (
5337      FREE_VAR (reg_info);                                                \      FREE_VAR (reg_info);                                                \
5338      FREE_VAR (reg_dummy);                                               \      FREE_VAR (reg_dummy);                                               \
5339      FREE_VAR (reg_info_dummy);                                          \      FREE_VAR (reg_info_dummy);                                          \
5340        if (!cant_free_wcs_buf)                                             \
5341          {                                                                 \
5342            FREE_VAR (string1);                                             \
5343            FREE_VAR (string2);                                             \
5344            FREE_VAR (mbs_offset1);                                         \
5345            FREE_VAR (mbs_offset2);                                         \
5346          }                                                                 \
5347    } while (0)    } while (0)
5348  #else /* not REGEX_MALLOC */  # else /* BYTE */
5349  /* This used to do alloca (0), but now we do that in the caller.  */  #  define FREE_VARIABLES()                                              \
5350  #define FREE_VARIABLES() /* Nothing */    do {                                                                  \
5351  #endif /* not REGEX_MALLOC */      REGEX_FREE_STACK (fail_stack.stack);                                \
5352        FREE_VAR (regstart);                                                \
5353        FREE_VAR (regend);                                                  \
5354        FREE_VAR (old_regstart);                                            \
5355        FREE_VAR (old_regend);                                              \
5356        FREE_VAR (best_regstart);                                           \
5357        FREE_VAR (best_regend);                                             \
5358        FREE_VAR (reg_info);                                                \
5359        FREE_VAR (reg_dummy);                                               \
5360        FREE_VAR (reg_info_dummy);                                          \
5361      } while (0)
5362    # endif /* WCHAR */
5363  #else  #else
5364  #define FREE_VARIABLES() /* Do nothing!  */  # ifdef WCHAR
5365    #  define FREE_VARIABLES()                                              \
5366      do {                                                                  \
5367        if (!cant_free_wcs_buf)                                             \
5368          {                                                                 \
5369            FREE_VAR (string1);                                             \
5370            FREE_VAR (string2);                                             \
5371            FREE_VAR (mbs_offset1);                                         \
5372            FREE_VAR (mbs_offset2);                                         \
5373          }                                                                 \
5374      } while (0)
5375    # else /* BYTE */
5376    #  define FREE_VARIABLES() ((void)0) /* Do nothing!  But inhibit gcc warning. */
5377    # endif /* WCHAR */
5378  #endif /* not MATCH_MAY_ALLOCATE */  #endif /* not MATCH_MAY_ALLOCATE */
5379    
5380  /* These values must meet several constraints.  They must not be valid  /* These values must meet several constraints.  They must not be valid
# Line 3297  static boolean alt_match_null_string_p ( Line 5387  static boolean alt_match_null_string_p (
5387  #define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)  #define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)
5388  #define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)  #define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)
5389    
5390    #else /* not INSIDE_RECURSION */
5391  /* Matching routines.  */  /* Matching routines.  */
5392    
5393  #ifndef emacs   /* Emacs never uses this.  */  #ifndef emacs   /* Emacs never uses this.  */
5394  /* re_match is like re_match_2 except it takes only a single string.  */  /* re_match is like re_match_2 except it takes only a single string.  */
5395    
5396  int  int
5397  re_match (bufp, string, size, pos, regs)  re_match (struct re_pattern_buffer *bufp,
5398       struct re_pattern_buffer *bufp;            const char *string,
5399       const char *string;            int size, int pos,
5400       int size, pos;            struct re_registers *regs)
      struct re_registers *regs;  
5401  {  {
5402    int result = re_match_2_internal (bufp, NULL, 0, string, size,    int result;
5403                                      pos, regs, size);  # ifdef MBS_SUPPORT
5404      if (MB_CUR_MAX != 1)
5405        result = wcs_re_match_2_internal (bufp, NULL, 0, string, size,
5406                                          pos, regs, size,
5407                                          NULL, 0, NULL, 0, NULL, NULL);
5408      else
5409    # endif
5410        result = byte_re_match_2_internal (bufp, NULL, 0, string, size,
5411                                      pos, regs, size);
5412    # ifndef REGEX_MALLOC
5413    #  ifdef C_ALLOCA
5414    alloca (0);    alloca (0);
5415    #  endif
5416    # endif
5417    return result;    return result;
5418  }  }
5419    # ifdef _LIBC
5420    weak_alias (__re_match, re_match)
5421    # endif
5422  #endif /* not emacs */  #endif /* not emacs */
5423    
5424    #endif /* not INSIDE_RECURSION */
5425    
5426    #ifdef INSIDE_RECURSION
5427    static boolean PREFIX(group_match_null_string_p) (UCHAR_T **p,
5428                                                      UCHAR_T *end,
5429                                            PREFIX(register_info_type) *reg_info);
5430    static boolean PREFIX(alt_match_null_string_p) (UCHAR_T *p,
5431                                                    UCHAR_T *end,
5432                                            PREFIX(register_info_type) *reg_info);
5433    static boolean PREFIX(common_op_match_null_string_p) (UCHAR_T **p,
5434                                                          UCHAR_T *end,
5435                                            PREFIX(register_info_type) *reg_info);
5436    static int PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2,
5437                                       int len, char *translate);
5438    #else /* not INSIDE_RECURSION */
5439    
5440  /* re_match_2 matches the compiled pattern in BUFP against the  /* re_match_2 matches the compiled pattern in BUFP against the
5441     the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1     the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
5442     and SIZE2, respectively).  We start matching at POS, and stop     and SIZE2, respectively).  We start matching at POS, and stop
5443     matching at STOP.     matching at STOP.
5444      
5445     If REGS is non-null and the `no_sub' field of BUFP is nonzero, we     If REGS is non-null and the `no_sub' field of BUFP is nonzero, we
5446     store offsets for the substring each group matched in REGS.  See the     store offsets for the substring each group matched in REGS.  See the
5447     documentation for exactly how many groups we fill.     documentation for exactly how many groups we fill.
# Line 3331  re_match (bufp, string, size, pos, regs) Line 5451  re_match (bufp, string, size, pos, regs)
5451     matched substring.  */     matched substring.  */
5452    
5453  int  int
5454  re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)  re_match_2 (struct re_pattern_buffer *bufp,
5455       struct re_pattern_buffer *bufp;              const char *string1, int size1,
5456       const char *string1, *string2;              const char *string2, int size2,
5457       int size1, size2;              int pos, struct re_registers *regs,
5458       int pos;              int stop)
      struct re_registers *regs;  
      int stop;  
5459  {  {
5460    int result = re_match_2_internal (bufp, string1, size1, string2, size2,    int result;
5461                                      pos, regs, stop);  # ifdef MBS_SUPPORT
5462      if (MB_CUR_MAX != 1)
5463        result = wcs_re_match_2_internal (bufp, string1, size1, string2, size2,
5464                                          pos, regs, stop,
5465                                          NULL, 0, NULL, 0, NULL, NULL);
5466      else
5467    # endif
5468        result = byte_re_match_2_internal (bufp, string1, size1, string2, size2,
5469                                      pos, regs, stop);
5470    
5471    #ifndef REGEX_MALLOC
5472    # ifdef C_ALLOCA
5473    alloca (0);    alloca (0);
5474    # endif
5475    #endif
5476    return result;    return result;
5477  }  }
5478    #ifdef _LIBC
5479    weak_alias (__re_match_2, re_match_2)
5480    #endif
5481    
5482    #endif /* not INSIDE_RECURSION */
5483    
5484    #ifdef INSIDE_RECURSION
5485    
5486    #ifdef WCHAR
5487    
5488    /* This check the substring (from 0, to length) of the multibyte string,
5489       to which offset_buffer correspond. And count how many wchar_t_characters
5490       the substring occupy. We use offset_buffer to optimization.
5491       See convert_mbs_to_wcs.  */
5492    
5493    static int
5494    count_mbs_length (int *offset_buffer, int length)
5495    {
5496      int upper, lower;
5497    
5498      /* Check whether the size is valid.  */
5499      if (length < 0)
5500        return -1;
5501    
5502      if (offset_buffer == NULL)
5503        return 0;
5504    
5505      /* If there are no multibyte character, offset_buffer[i] == i.
5506       Optmize for this case.  */
5507      if (offset_buffer[length] == length)
5508        return length;
5509    
5510      /* Set up upper with length. (because for all i, offset_buffer[i] >= i)  */
5511      upper = length;
5512      lower = 0;
5513    
5514      while (true)
5515        {
5516          int middle = (lower + upper) / 2;
5517          if (middle == lower || middle == upper)
5518            break;
5519          if (offset_buffer[middle] > length)
5520            upper = middle;
5521          else if (offset_buffer[middle] < length)
5522            lower = middle;
5523          else
5524            return middle;
5525        }
5526    
5527      return -1;
5528    }
5529    #endif /* WCHAR */
5530    
5531  /* This is a separate function so that we can force an alloca cleanup  /* This is a separate function so that we can force an alloca cleanup
5532     afterwards.  */     afterwards.  */
5533    #ifdef WCHAR
5534    static int
5535    wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
5536                             const char *cstring1, int csize1,
5537                             const char *cstring2, int csize2,
5538                             int pos,
5539                             struct re_registers *regs,
5540                             int stop,
5541                             /* string1 == string2 == NULL means
5542                                string1/2, size1/2 and mbs_offset1/2 need
5543                                setting up in this function.  */
5544                             /* We need wchar_t * buffers corresponding to
5545                                cstring1, cstring2.  */
5546                             wchar_t *string1, int size1,
5547                             wchar_t *string2, int size2,
5548                             /* Offset buffer for optimization.  See
5549                                convert_mbs_to_wc.  */
5550                             int *mbs_offset1,
5551                             int *mbs_offset2)
5552    #else /* BYTE */
5553  static int  static int
5554  re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop)  byte_re_match_2_internal (struct re_pattern_buffer *bufp,
5555       struct re_pattern_buffer *bufp;                            const char *string1, int size1,
5556       const char *string1, *string2;                            const char *string2, int size2,
5557       int size1, size2;                            int pos,
5558       int pos;                            struct re_registers *regs,
5559       struct re_registers *regs;                            int stop)
5560       int stop;  #endif /* BYTE */
5561  {  {
5562    /* General temporaries.  */    /* General temporaries.  */
5563    int mcnt;    int mcnt;
5564    unsigned char *p1;    UCHAR_T *p1;
5565    #ifdef WCHAR
5566      /* They hold whether each wchar_t is binary data or not.  */
5567      char *is_binary = NULL;
5568      /* If true, we can't free string1/2, mbs_offset1/2.  */
5569      int cant_free_wcs_buf = 1;
5570    #endif /* WCHAR */
5571    
5572    /* Just past the end of the corresponding string.  */    /* Just past the end of the corresponding string.  */
5573    const char *end1, *end2;    const CHAR_T *end1, *end2;
5574    
5575    /* Pointers into string1 and string2, just past the last characters in    /* Pointers into string1 and string2, just past the last characters in
5576       each to consider matching.  */       each to consider matching.  */
5577    const char *end_match_1, *end_match_2;    const CHAR_T *end_match_1, *end_match_2;
5578    
5579    /* Where we are in the data, and the end of the current string.  */    /* Where we are in the data, and the end of the current string.  */
5580    const char *d, *dend;    const CHAR_T *d, *dend;
5581      
5582    /* Where we are in the pattern, and the end of the pattern.  */    /* Where we are in the pattern, and the end of the pattern.  */
5583    unsigned char *p = bufp->buffer;  #ifdef WCHAR
5584    register unsigned char *pend = p + bufp->used;    UCHAR_T *pattern, *p;
5585      register UCHAR_T *pend;
5586    #else /* BYTE */
5587      UCHAR_T *p = bufp->buffer;
5588      register UCHAR_T *pend = p + bufp->used;
5589    #endif /* WCHAR */
5590    
5591    /* Mark the opcode just after a start_memory, so we can test for an    /* Mark the opcode just after a start_memory, so we can test for an
5592       empty subpattern when we get to the stop_memory.  */       empty subpattern when we get to the stop_memory.  */
5593    unsigned char *just_past_start_mem = 0;    UCHAR_T *just_past_start_mem = 0;
5594    
5595    /* We use this to map every character in the string.  */    /* We use this to map every character in the string.  */
5596    char *translate = bufp->translate;    RE_TRANSLATE_TYPE translate = bufp->translate;
5597    
5598    /* Failure point stack.  Each place that can handle a failure further    /* Failure point stack.  Each place that can handle a failure further
5599       down the line pushes a failure point on this stack.  It consists of       down the line pushes a failure point on this stack.  It consists of
# Line 3391  re_match_2_internal (bufp, string1, size Line 5605  re_match_2_internal (bufp, string1, size
5605       a ``dummy''; if a failure happens and the failure point is a dummy,       a ``dummy''; if a failure happens and the failure point is a dummy,
5606       it gets discarded and the next next one is tried.  */       it gets discarded and the next next one is tried.  */
5607  #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */  #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
5608    fail_stack_type fail_stack;    PREFIX(fail_stack_type) fail_stack;
5609  #endif  #endif
5610  #ifdef DEBUG  #ifdef DEBUG
5611    static unsigned failure_id = 0;    static unsigned failure_id;
5612    unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;    unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
5613  #endif  #endif
5614    
5615    #ifdef REL_ALLOC
5616      /* This holds the pointer to the failure stack, when
5617         it is allocated relocatably.  */
5618      fail_stack_elt_t *failure_stack_ptr;
5619    #endif
5620    
5621    /* We fill all the registers internally, independent of what we    /* We fill all the registers internally, independent of what we
5622       return, for use in backreferences.  The number here includes       return, for use in backreferences.  The number here includes
5623       an element for register zero.  */       an element for register zero.  */
5624    unsigned num_regs = bufp->re_nsub + 1;    size_t num_regs = bufp->re_nsub + 1;
5625      
5626    /* The currently active registers.  */    /* The currently active registers.  */
5627    unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG;    active_reg_t lowest_active_reg = NO_LOWEST_ACTIVE_REG;
5628    unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG;    active_reg_t highest_active_reg = NO_HIGHEST_ACTIVE_REG;
5629    
5630    /* Information on the contents of registers. These are pointers into    /* Information on the contents of registers. These are pointers into
5631       the input strings; they record just what was matched (on this       the input strings; they record just what was matched (on this
# Line 3415  re_match_2_internal (bufp, string1, size Line 5635  re_match_2_internal (bufp, string1, size
5635       stopped matching the regnum-th subexpression.  (The zeroth register       stopped matching the regnum-th subexpression.  (The zeroth register
5636       keeps track of what the whole pattern matches.)  */       keeps track of what the whole pattern matches.)  */
5637  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
5638    const char **regstart, **regend;    const CHAR_T **regstart, **regend;
5639  #endif  #endif
5640    
5641    /* If a group that's operated upon by a repetition operator fails to    /* If a group that's operated upon by a repetition operator fails to
# Line 3424  re_match_2_internal (bufp, string1, size Line 5644  re_match_2_internal (bufp, string1, size
5644       are when we last see its open-group operator.  Similarly for a       are when we last see its open-group operator.  Similarly for a
5645       register's end.  */       register's end.  */
5646  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
5647    const char **old_regstart, **old_regend;    const CHAR_T **old_regstart, **old_regend;
5648  #endif  #endif
5649    
5650    /* The is_active field of reg_info helps us keep track of which (possibly    /* The is_active field of reg_info helps us keep track of which (possibly
# Line 3434  re_match_2_internal (bufp, string1, size Line 5654  re_match_2_internal (bufp, string1, size
5654       subexpression.  These two fields get reset each time through any       subexpression.  These two fields get reset each time through any
5655       loop their register is in.  */       loop their register is in.  */
5656  #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */  #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
5657    register_info_type *reg_info;    PREFIX(register_info_type) *reg_info;
5658  #endif  #endif
5659    
5660    /* The following record the register info as found in the above    /* The following record the register info as found in the above
5661       variables when we find a match better than any we've seen before.       variables when we find a match better than any we've seen before.
5662       This happens as we backtrack through the failure points, which in       This happens as we backtrack through the failure points, which in
5663       turn happens only if we have not yet matched the entire string. */       turn happens only if we have not yet matched the entire string. */
5664    unsigned best_regs_set = false;    unsigned best_regs_set = false;
5665  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
5666    const char **best_regstart, **best_regend;    const CHAR_T **best_regstart, **best_regend;
5667  #endif  #endif
5668      
5669    /* Logically, this is `best_regend[0]'.  But we don't want to have to    /* Logically, this is `best_regend[0]'.  But we don't want to have to
5670       allocate space for that if we're not allocating space for anything       allocate space for that if we're not allocating space for anything
5671       else (see below).  Also, we never need info about register 0 for       else (see below).  Also, we never need info about register 0 for
# Line 3454  re_match_2_internal (bufp, string1, size Line 5674  re_match_2_internal (bufp, string1, size
5674       the end of the best match so far in a separate variable.  We       the end of the best match so far in a separate variable.  We
5675       initialize this to NULL so that when we backtrack the first time       initialize this to NULL so that when we backtrack the first time
5676       and need to test it, it's not garbage.  */       and need to test it, it's not garbage.  */
5677    const char *match_end = NULL;    const CHAR_T *match_end = NULL;
5678    
5679      /* This helps SET_REGS_MATCHED avoid doing redundant work.  */
5680      int set_regs_matched_done = 0;
5681    
5682    /* Used when we pop values we don't care about.  */    /* Used when we pop values we don't care about.  */
5683  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */  #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
5684    const char **reg_dummy;    const CHAR_T **reg_dummy;
5685    register_info_type *reg_info_dummy;    PREFIX(register_info_type) *reg_info_dummy;
5686  #endif  #endif
5687    
5688  #ifdef DEBUG  #ifdef DEBUG
5689    /* Counts the total number of registers pushed.  */    /* Counts the total number of registers pushed.  */
5690    unsigned num_regs_pushed = 0;            unsigned num_regs_pushed = 0;
5691    #endif
5692    
5693      /* Definitions for state transitions.  More efficiently for gcc.  */
5694    #ifdef __GNUC__
5695    # if defined HAVE_SUBTRACT_LOCAL_LABELS && defined SHARED
5696    #  define NEXT \
5697          do                                                                      \
5698            {                                                                     \
5699              int offset;                                                         \
5700              const void *__unbounded ptr;                                        \
5701              offset = (p == pend                                                 \
5702                        ? 0 : jmptable[SWITCH_ENUM_CAST ((re_opcode_t) *p++)]);   \
5703              ptr = &&end_of_pattern + offset;                                    \
5704              goto *ptr;                                                          \
5705            }                                                                     \
5706          while (0)
5707    #  define REF(x) \
5708      &&label_##x - &&end_of_pattern
5709    #  define JUMP_TABLE_TYPE const int
5710    # else
5711    #  define NEXT \
5712          do                                                                      \
5713            {                                                                     \
5714              const void *__unbounded ptr;                                        \
5715              ptr = (p == pend ? &&end_of_pattern                                 \
5716                     : jmptable[SWITCH_ENUM_CAST ((re_opcode_t) *p++)]);          \
5717              goto *ptr;                                                          \
5718            }                                                                     \
5719          while (0)
5720    #  define REF(x) \
5721      &&label_##x
5722    #  define JUMP_TABLE_TYPE const void *const
5723    # endif
5724    # define CASE(x) label_##x
5725      static JUMP_TABLE_TYPE jmptable[] =
5726        {
5727        REF (no_op),
5728        REF (succeed),
5729        REF (exactn),
5730    # ifdef MBS_SUPPORT
5731        REF (exactn_bin),
5732    # endif
5733        REF (anychar),
5734        REF (charset),
5735        REF (charset_not),
5736        REF (start_memory),
5737        REF (stop_memory),
5738        REF (duplicate),
5739        REF (begline),
5740        REF (endline),
5741        REF (begbuf),
5742        REF (endbuf),
5743        REF (jump),
5744        REF (jump_past_alt),
5745        REF (on_failure_jump),
5746        REF (on_failure_keep_string_jump),
5747        REF (pop_failure_jump),
5748        REF (maybe_pop_jump),
5749        REF (dummy_failure_jump),
5750        REF (push_dummy_failure),
5751        REF (succeed_n),
5752        REF (jump_n),
5753        REF (set_number_at),
5754        REF (wordchar),
5755        REF (notwordchar),
5756        REF (wordbeg),
5757        REF (wordend),
5758        REF (wordbound),
5759        REF (notwordbound)
5760    # ifdef emacs
5761        ,REF (before_dot),
5762        REF (at_dot),
5763        REF (after_dot),
5764        REF (syntaxspec),
5765        REF (notsyntaxspec)
5766    # endif
5767        };
5768    #else
5769    # define NEXT \
5770      break
5771    # define CASE(x) \
5772      case x
5773  #endif  #endif
5774    
5775    DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");    DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");
5776      
5777    INIT_FAIL_STACK ();    INIT_FAIL_STACK ();
5778      
5779  #ifdef MATCH_MAY_ALLOCATE  #ifdef MATCH_MAY_ALLOCATE
5780    /* Do not bother to initialize all the register variables if there are    /* Do not bother to initialize all the register variables if there are
5781       no groups in the pattern, as it takes a fair amount of time.  If       no groups in the pattern, as it takes a fair amount of time.  If
# Line 3479  re_match_2_internal (bufp, string1, size Line 5784  re_match_2_internal (bufp, string1, size
5784       array indexing.  We should fix this.  */       array indexing.  We should fix this.  */
5785    if (bufp->re_nsub)    if (bufp->re_nsub)
5786      {      {
5787        regstart = REGEX_TALLOC (num_regs, const char *);        regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
5788        regend = REGEX_TALLOC (num_regs, const char *);        regend = REGEX_TALLOC (num_regs, const CHAR_T *);
5789        old_regstart = REGEX_TALLOC (num_regs, const char *);        old_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
5790        old_regend = REGEX_TALLOC (num_regs, const char *);        old_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
5791        best_regstart = REGEX_TALLOC (num_regs, const char *);        best_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
5792        best_regend = REGEX_TALLOC (num_regs, const char *);        best_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
5793        reg_info = REGEX_TALLOC (num_regs, register_info_type);        reg_info = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
5794        reg_dummy = REGEX_TALLOC (num_regs, const char *);        reg_dummy = REGEX_TALLOC (num_regs, const CHAR_T *);
5795        reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type);        reg_info_dummy = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
5796    
5797        if (!(regstart && regend && old_regstart && old_regend && reg_info        if (!(regstart && regend && old_regstart && old_regend && reg_info
5798              && best_regstart && best_regend && reg_dummy && reg_info_dummy))              && best_regstart && best_regend && reg_dummy && reg_info_dummy))
5799          {          {
5800            FREE_VARIABLES ();            FREE_VARIABLES ();
5801            return -2;            return -2;
5802          }          }
5803      }      }
 #if defined (REGEX_MALLOC)  
5804    else    else
5805      {      {
5806        /* We must initialize all our variables to NULL, so that        /* We must initialize all our variables to NULL, so that
5807           `FREE_VARIABLES' doesn't try to free them.  */           `FREE_VARIABLES' doesn't try to free them.  */
5808        regstart = regend = old_regstart = old_regend = best_regstart        regstart = regend = old_regstart = old_regend = best_regstart
5809          = best_regend = reg_dummy = NULL;          = best_regend = reg_dummy = NULL;
5810        reg_info = reg_info_dummy = (register_info_type *) NULL;        reg_info = reg_info_dummy = (PREFIX(register_info_type) *) NULL;
5811      }      }
 #endif /* REGEX_MALLOC */  
5812  #endif /* MATCH_MAY_ALLOCATE */  #endif /* MATCH_MAY_ALLOCATE */
5813    
5814    /* The starting position is bogus.  */    /* The starting position is bogus.  */
5815    #ifdef WCHAR
5816      if (pos < 0 || pos > csize1 + csize2)
5817    #else /* BYTE */
5818    if (pos < 0 || pos > size1 + size2)    if (pos < 0 || pos > size1 + size2)
5819    #endif
5820      {      {
5821        FREE_VARIABLES ();        FREE_VARIABLES ();
5822        return -1;        return -1;
5823      }      }
5824        
5825    #ifdef WCHAR
5826      /* Allocate wchar_t array for string1 and string2 and
5827         fill them with converted string.  */
5828      if (string1 == NULL && string2 == NULL)
5829        {
5830          /* We need seting up buffers here.  */
5831    
5832          /* We must free wcs buffers in this function.  */
5833          cant_free_wcs_buf = 0;
5834    
5835          if (csize1 != 0)
5836            {
5837              string1 = REGEX_TALLOC (csize1 + 1, CHAR_T);
5838              mbs_offset1 = REGEX_TALLOC (csize1 + 1, int);
5839              is_binary = REGEX_TALLOC (csize1 + 1, char);
5840              if (!string1 || !mbs_offset1 || !is_binary)
5841                {
5842                  FREE_VAR (string1);
5843                  FREE_VAR (mbs_offset1);
5844                  FREE_VAR (is_binary);
5845                  return -2;
5846                }
5847            }
5848          if (csize2 != 0)
5849            {
5850              string2 = REGEX_TALLOC (csize2 + 1, CHAR_T);
5851              mbs_offset2 = REGEX_TALLOC (csize2 + 1, int);
5852              is_binary = REGEX_TALLOC (csize2 + 1, char);
5853              if (!string2 || !mbs_offset2 || !is_binary)
5854                {
5855                  FREE_VAR (string1);
5856                  FREE_VAR (mbs_offset1);
5857                  FREE_VAR (string2);
5858                  FREE_VAR (mbs_offset2);
5859                  FREE_VAR (is_binary);
5860                  return -2;
5861                }
5862              size2 = convert_mbs_to_wcs(string2, cstring2, csize2,
5863                                         mbs_offset2, is_binary);
5864              string2[size2] = L'\0'; /* for a sentinel  */
5865              FREE_VAR (is_binary);
5866            }
5867        }
5868    
5869      /* We need to cast pattern to (wchar_t*), because we casted this compiled
5870         pattern to (char*) in regex_compile.  */
5871      p = pattern = (CHAR_T*)bufp->buffer;
5872      pend = (CHAR_T*)(bufp->buffer + bufp->used);
5873    
5874    #endif /* WCHAR */
5875    
5876    /* Initialize subexpression text positions to -1 to mark ones that no    /* Initialize subexpression text positions to -1 to mark ones that no
5877       start_memory/stop_memory has been seen for. Also initialize the       start_memory/stop_memory has been seen for. Also initialize the
5878       register information struct.  */       register information struct.  */
5879    for (mcnt = 1; mcnt < num_regs; mcnt++)    for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
5880      {      {
5881        regstart[mcnt] = regend[mcnt]        regstart[mcnt] = regend[mcnt]
5882          = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;          = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;
5883            
5884        REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;        REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
5885        IS_ACTIVE (reg_info[mcnt]) = 0;        IS_ACTIVE (reg_info[mcnt]) = 0;
5886        MATCHED_SOMETHING (reg_info[mcnt]) = 0;        MATCHED_SOMETHING (reg_info[mcnt]) = 0;
5887        EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;        EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;
5888      }      }
5889      
5890    /* We move `string1' into `string2' if the latter's empty -- but not if    /* We move `string1' into `string2' if the latter's empty -- but not if
5891       `string1' is null.  */       `string1' is null.  */
5892    if (size2 == 0 && string1 != NULL)    if (size2 == 0 && string1 != NULL)
# Line 3537  re_match_2_internal (bufp, string1, size Line 5895  re_match_2_internal (bufp, string1, size
5895        size2 = size1;        size2 = size1;
5896        string1 = 0;        string1 = 0;
5897        size1 = 0;        size1 = 0;
5898    #ifdef WCHAR
5899          mbs_offset2 = mbs_offset1;
5900          csize2 = csize1;
5901          mbs_offset1 = NULL;
5902          csize1 = 0;
5903    #endif
5904      }      }
5905    end1 = string1 + size1;    end1 = string1 + size1;
5906    end2 = string2 + size2;    end2 = string2 + size2;
5907    
5908    /* Compute where to stop matching, within the two strings.  */    /* Compute where to stop matching, within the two strings.  */
5909    #ifdef WCHAR
5910      if (stop <= csize1)
5911        {
5912          mcnt = count_mbs_length(mbs_offset1, stop);
5913          end_match_1 = string1 + mcnt;
5914          end_match_2 = string2;
5915        }
5916      else
5917        {
5918          if (stop > csize1 + csize2)
5919            stop = csize1 + csize2;
5920          end_match_1 = end1;
5921          mcnt = count_mbs_length(mbs_offset2, stop-csize1);
5922          end_match_2 = string2 + mcnt;
5923        }
5924      if (mcnt < 0)
5925        { /* count_mbs_length return error.  */
5926          FREE_VARIABLES ();
5927          return -1;
5928        }
5929    #else
5930    if (stop <= size1)    if (stop <= size1)
5931      {      {
5932        end_match_1 = string1 + stop;        end_match_1 = string1 + stop;
# Line 3552  re_match_2_internal (bufp, string1, size Line 5937  re_match_2_internal (bufp, string1, size
5937        end_match_1 = end1;        end_match_1 = end1;
5938        end_match_2 = string2 + stop - size1;        end_match_2 = string2 + stop - size1;
5939      }      }
5940    #endif /* WCHAR */
5941    
5942    /* `p' scans through the pattern as `d' scans through the data.    /* `p' scans through the pattern as `d' scans through the data.
5943       `dend' is the end of the input string that `d' points within.  `d'       `dend' is the end of the input string that `d' points within.  `d'
5944       is advanced into the following input string whenever necessary, but       is advanced into the following input string whenever necessary, but
5945       this happens before fetching; therefore, at the beginning of the       this happens before fetching; therefore, at the beginning of the
5946       loop, `d' can be pointing at the end of a string, but it cannot       loop, `d' can be pointing at the end of a string, but it cannot
5947       equal `string2'.  */       equal `string2'.  */
5948    #ifdef WCHAR
5949      if (size1 > 0 && pos <= csize1)
5950        {
5951          mcnt = count_mbs_length(mbs_offset1, pos);
5952          d = string1 + mcnt;
5953          dend = end_match_1;
5954        }
5955      else
5956        {
5957          mcnt = count_mbs_length(mbs_offset2, pos-csize1);
5958          d = string2 + mcnt;
5959          dend = end_match_2;
5960        }
5961    
5962      if (mcnt < 0)
5963        { /* count_mbs_length return error.  */
5964          FREE_VARIABLES ();
5965          return -1;
5966        }
5967    #else
5968    if (size1 > 0 && pos <= size1)    if (size1 > 0 && pos <= size1)
5969      {      {
5970        d = string1 + pos;        d = string1 + pos;
# Line 3569  re_match_2_internal (bufp, string1, size Line 5975  re_match_2_internal (bufp, string1, size
5975        d = string2 + pos - size1;        d = string2 + pos - size1;
5976        dend = end_match_2;        dend = end_match_2;
5977      }      }
5978    #endif /* WCHAR */
5979    
5980    DEBUG_PRINT1 ("The compiled pattern is: ");    DEBUG_PRINT1 ("The compiled pattern is:\n");
5981    DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);    DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
5982    DEBUG_PRINT1 ("The string to match is: `");    DEBUG_PRINT1 ("The string to match is: `");
5983    DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);    DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
5984    DEBUG_PRINT1 ("'\n");    DEBUG_PRINT1 ("'\n");
5985      
5986    /* This loops over pattern commands.  It exits by returning from the    /* This loops over pattern commands.  It exits by returning from the
5987       function if the match is complete, or it drops through if the match       function if the match is complete, or it drops through if the match
5988       fails at this starting point in the input data.  */       fails at this starting point in the input data.  */
5989    for (;;)    for (;;)
5990      {      {
5991    #ifdef _LIBC
5992          DEBUG_PRINT2 ("\n%p: ", p);
5993    #else
5994        DEBUG_PRINT2 ("\n0x%x: ", p);        DEBUG_PRINT2 ("\n0x%x: ", p);
5995    #endif
5996    
5997    #ifdef __GNUC__
5998          NEXT;
5999    #else
6000        if (p == pend)        if (p == pend)
6001          { /* End of pattern means we might have succeeded.  */  #endif
6002            DEBUG_PRINT1 ("end of pattern ... ");          {
6003              #ifdef __GNUC__
6004            end_of_pattern:
6005    #endif
6006              /* End of pattern means we might have succeeded.  */
6007              DEBUG_PRINT1 ("end of pattern ... ");
6008    
6009            /* If we haven't matched the entire string, and we want the            /* If we haven't matched the entire string, and we want the
6010               longest match, try backtracking.  */               longest match, try backtracking.  */
6011            if (d != end_match_2)            if (d != end_match_2)
6012              {              {
6013                /* 1 if this match ends in the same string (string1 or string2)                /* 1 if this match ends in the same string (string1 or string2)
6014                   as the best previous match.  */                   as the best previous match.  */
6015                boolean same_str_p = (FIRST_STRING_P (match_end)                boolean same_str_p = (FIRST_STRING_P (match_end)
6016                                      == MATCHING_IN_FIRST_STRING);                                      == MATCHING_IN_FIRST_STRING);
6017                /* 1 if this match is the best seen so far.  */                /* 1 if this match is the best seen so far.  */
6018                boolean best_match_p;                boolean best_match_p;
# Line 3605  re_match_2_internal (bufp, string1, size Line 6024  re_match_2_internal (bufp, string1, size
6024                else                else
6025                  best_match_p = !MATCHING_IN_FIRST_STRING;                  best_match_p = !MATCHING_IN_FIRST_STRING;
6026    
6027                DEBUG_PRINT1 ("backtracking.\n");                DEBUG_PRINT1 ("backtracking.\n");
                 
               if (!FAIL_STACK_EMPTY ())  
                 { /* More failure points to try.  */  
6028    
6029                    /* If exceeds best match so far, save it.  */                if (!FAIL_STACK_EMPTY ())
6030                    if (!best_regs_set || best_match_p)                  { /* More failure points to try.  */
                     {  
                       best_regs_set = true;  
                       match_end = d;  
                         
                       DEBUG_PRINT1 ("\nSAVING match as best so far.\n");  
                         
                       for (mcnt = 1; mcnt < num_regs; mcnt++)  
                         {  
                           best_regstart[mcnt] = regstart[mcnt];  
                           best_regend[mcnt] = regend[mcnt];  
                         }  
                     }  
                   goto fail;            
                 }  
6031    
6032                /* If no failure points, don't restore garbage.  And if                    /* If exceeds best match so far, save it.  */
6033                   last match is real best match, don't restore second                    if (!best_regs_set || best_match_p)
6034                   best one. */                      {
6035                else if (best_regs_set && !best_match_p)                        best_regs_set = true;
6036                  {                        match_end = d;
6037                  restore_best_regs:  
6038                    /* Restore best match.  It may happen that `dend ==                        DEBUG_PRINT1 ("\nSAVING match as best so far.\n");
6039                       end_match_1' while the restored d is in string2.  
6040                       For example, the pattern `x.*y.*z' against the                        for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
6041                       strings `x-' and `y-z-', if the two strings are                          {
6042                       not consecutive in memory.  */                            best_regstart[mcnt] = regstart[mcnt];
6043                    DEBUG_PRINT1 ("Restoring best registers.\n");                            best_regend[mcnt] = regend[mcnt];
6044                                              }
6045                    d = match_end;                      }
6046                    dend = ((d >= string1 && d <= end1)                    goto fail;
6047                             ? end_match_1 : end_match_2);                  }
6048    
6049                  /* If no failure points, don't restore garbage.  And if
6050                     last match is real best match, don't restore second
6051                     best one. */
6052                  else if (best_regs_set && !best_match_p)
6053                    {
6054                    restore_best_regs:
6055                      /* Restore best match.  It may happen that `dend ==
6056                         end_match_1' while the restored d is in string2.
6057                         For example, the pattern `x.*y.*z' against the
6058                         strings `x-' and `y-z-', if the two strings are
6059                         not consecutive in memory.  */
6060                      DEBUG_PRINT1 ("Restoring best registers.\n");
6061    
6062                      d = match_end;
6063                      dend = ((d >= string1 && d <= end1)
6064                              ? end_match_1 : end_match_2);
6065    
6066                    for (mcnt = 1; mcnt < num_regs; mcnt++)                    for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
6067                      {                      {
6068                        regstart[mcnt] = best_regstart[mcnt];                        regstart[mcnt] = best_regstart[mcnt];
6069                        regend[mcnt] = best_regend[mcnt];                        regend[mcnt] = best_regend[mcnt];
6070                      }                      }
6071                  }                  }
6072              } /* d != end_match_2 */              } /* d != end_match_2 */
   
           DEBUG_PRINT1 ("Accepting match.\n");  
6073    
6074            /* If caller wants register contents data back, do it.  */          succeed_label:
6075            if (regs && !bufp->no_sub)            DEBUG_PRINT1 ("Accepting match.\n");
6076              /* If caller wants register contents data back, do it.  */
6077              if (regs && !bufp->no_sub)
6078              {              {
6079                /* Have the register data arrays been allocated?  */                /* Have the register data arrays been allocated?  */
6080                if (bufp->regs_allocated == REGS_UNALLOCATED)                if (bufp->regs_allocated == REGS_UNALLOCATED)
6081                  { /* No.  So allocate them with malloc.  We need one                  { /* No.  So allocate them with malloc.  We need one
6082                       extra element beyond `num_regs' for the `-1' marker                       extra element beyond `num_regs' for the `-1' marker
6083                       GNU code uses.  */                       GNU code uses.  */
6084                    regs->num_regs = MAX (RE_NREGS, num_regs + 1);                    regs->num_regs = MAX (RE_NREGS, num_regs + 1);
6085                    regs->start = TALLOC (regs->num_regs, regoff_t);                    regs->start = TALLOC (regs->num_regs, regoff_t);
6086                    regs->end = TALLOC (regs->num_regs, regoff_t);                    regs->end = TALLOC (regs->num_regs, regoff_t);
6087                    if (regs->start == NULL || regs->end == NULL)                    if (regs->start == NULL || regs->end == NULL)
6088                      return -2;                      {
6089                    bufp->regs_allocated = REGS_REALLOCATE;                        FREE_VARIABLES ();
6090                  }                        return -2;
6091                else if (bufp->regs_allocated == REGS_REALLOCATE)                      }
6092                  { /* Yes.  If we need more elements than were already                    bufp->regs_allocated = REGS_REALLOCATE;
6093                       allocated, reallocate them.  If we need fewer, just                  }
6094                       leave it alone.  */                else if (bufp->regs_allocated == REGS_REALLOCATE)
6095                    if (regs->num_regs < num_regs + 1)                  { /* Yes.  If we need more elements than were already
6096                      {                       allocated, reallocate them.  If we need fewer, just
6097                        regs->num_regs = num_regs + 1;                       leave it alone.  */
6098                        RETALLOC (regs->start, regs->num_regs, regoff_t);                    if (regs->num_regs < num_regs + 1)
6099                        RETALLOC (regs->end, regs->num_regs, regoff_t);                      {
6100                        if (regs->start == NULL || regs->end == NULL)                        regs->num_regs = num_regs + 1;
6101                          return -2;                        RETALLOC (regs->start, regs->num_regs, regoff_t);
6102                      }                        RETALLOC (regs->end, regs->num_regs, regoff_t);
6103                  }                        if (regs->start == NULL || regs->end == NULL)
6104                else                          {
6105                              FREE_VARIABLES ();
6106                              return -2;
6107                            }
6108                        }
6109                    }
6110                  else
6111                  {                  {
6112                    /* These braces fend off a "empty body in an else-statement"                    /* These braces fend off a "empty body in an else-statement"
6113                       warning under GCC when assert expands to nothing.  */                       warning under GCC when assert expands to nothing.  */
6114                    assert (bufp->regs_allocated == REGS_FIXED);                    assert (bufp->regs_allocated == REGS_FIXED);
6115                  }                  }
6116    
6117                /* Convert the pointer data in `regstart' and `regend' to                /* Convert the pointer data in `regstart' and `regend' to
6118                   indices.  Register zero has to be set differently,                   indices.  Register zero has to be set differently,
6119                   since we haven't kept track of any info for it.  */                   since we haven't kept track of any info for it.  */
6120                if (regs->num_regs > 0)                if (regs->num_regs > 0)
6121                  {                  {
6122                    regs->start[0] = pos;                    regs->start[0] = pos;
6123                    regs->end[0] = (MATCHING_IN_FIRST_STRING  #ifdef WCHAR
6124                      if (MATCHING_IN_FIRST_STRING)
6125                        regs->end[0] = (mbs_offset1 != NULL ?
6126                                        mbs_offset1[d-string1] : 0);
6127                      else
6128                        regs->end[0] = csize1 + (mbs_offset2 != NULL
6129                                                 ? mbs_offset2[d-string2] : 0);
6130    #else
6131                      regs->end[0] = (MATCHING_IN_FIRST_STRING
6132                                    ? ((regoff_t) (d - string1))                                    ? ((regoff_t) (d - string1))
6133                                    : ((regoff_t) (d - string2 + size1)));                                    : ((regoff_t) (d - string2 + size1)));
6134                  }  #endif /* WCHAR */
6135                                  }
6136                /* Go through the first `min (num_regs, regs->num_regs)'  
6137                   registers, since that is all we initialized.  */                /* Go through the first `min (num_regs, regs->num_regs)'
6138                for (mcnt = 1; mcnt < MIN (num_regs, regs->num_regs); mcnt++)                   registers, since that is all we initialized.  */
6139                  for (mcnt = 1; (unsigned) mcnt < MIN (num_regs, regs->num_regs);
6140                       mcnt++)
6141                  {                  {
6142                    if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt]))                    if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt]))
6143                      regs->start[mcnt] = regs->end[mcnt] = -1;                      regs->start[mcnt] = regs->end[mcnt] = -1;
6144                    else                    else
6145                      {                      {
6146                        regs->start[mcnt]                        regs->start[mcnt]
6147                          = (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]);                          = (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]);
6148                        regs->end[mcnt]                        regs->end[mcnt]
6149                          = (regoff_t) POINTER_TO_OFFSET (regend[mcnt]);                          = (regoff_t) POINTER_TO_OFFSET (regend[mcnt]);
6150                      }                      }
6151                  }                  }
6152                  
6153                /* If the regs structure we return has more elements than                /* If the regs structure we return has more elements than
6154                   were in the pattern, set the extra elements to -1.  If                   were in the pattern, set the extra elements to -1.  If
6155                   we (re)allocated the registers, this is the case,                   we (re)allocated the registers, this is the case,
6156                   because we always allocate enough to have at least one                   because we always allocate enough to have at least one
6157                   -1 at the end.  */                   -1 at the end.  */
6158                for (mcnt = num_regs; mcnt < regs->num_regs; mcnt++)                for (mcnt = num_regs; (unsigned) mcnt < regs->num_regs; mcnt++)
6159                  regs->start[mcnt] = regs->end[mcnt] = -1;                  regs->start[mcnt] = regs->end[mcnt] = -1;
6160              } /* regs && !bufp->no_sub */              } /* regs && !bufp->no_sub */
6161    
6162            FREE_VARIABLES ();            DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",
6163            DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",                          nfailure_points_pushed, nfailure_points_popped,
6164                          nfailure_points_pushed, nfailure_points_popped,                          nfailure_points_pushed - nfailure_points_popped);
6165                          nfailure_points_pushed - nfailure_points_popped);            DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);
6166            DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);  
6167    #ifdef WCHAR
6168            mcnt = d - pos - (MATCHING_IN_FIRST_STRING            if (MATCHING_IN_FIRST_STRING)
6169                              ? string1              mcnt = mbs_offset1 != NULL ? mbs_offset1[d-string1] : 0;
6170                              : string2 - size1);            else
6171                mcnt = (mbs_offset2 != NULL ? mbs_offset2[d-string2] : 0) +
6172                  csize1;
6173              mcnt -= pos;
6174    #else
6175              mcnt = d - pos - (MATCHING_IN_FIRST_STRING
6176                                ? string1 : string2 - size1);
6177    #endif /* WCHAR */
6178    
6179            DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);            DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);
6180    
6181            return mcnt;            FREE_VARIABLES ();
6182          }            return mcnt;
6183            }
6184    
6185    #ifndef __GNUC__
6186        /* Otherwise match next pattern command.  */        /* Otherwise match next pattern command.  */
6187  #ifdef SWITCH_ENUM_BUG        switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
       switch ((int) ((re_opcode_t) *p++))  
 #else  
       switch ((re_opcode_t) *p++)  
 #endif  
6188          {          {
6189    #endif
6190          /* Ignore these.  Used to ignore the n of succeed_n's which          /* Ignore these.  Used to ignore the n of succeed_n's which
6191             currently have n == 0.  */             currently have n == 0.  */
6192          case no_op:          CASE (no_op):
6193            DEBUG_PRINT1 ("EXECUTING no_op.\n");            DEBUG_PRINT1 ("EXECUTING no_op.\n");
6194            break;            NEXT;
6195    
6196            CASE (succeed):
6197              DEBUG_PRINT1 ("EXECUTING succeed.\n");
6198              goto succeed_label;
6199    
6200          /* Match the next n pattern characters exactly.  The following          /* Match the next n pattern characters exactly.  The following
6201             byte in the pattern defines n, and the n bytes after that             byte in the pattern defines n, and the n bytes after that
6202             are the characters to match.  */             are the characters to match.  */
6203          case exactn:          CASE (exactn):
6204    #ifdef MBS_SUPPORT
6205            CASE (exactn_bin):
6206    #endif
6207            mcnt = *p++;            mcnt = *p++;
6208            DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);            DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);
6209    
# Line 3767  re_match_2_internal (bufp, string1, size Line 6214  re_match_2_internal (bufp, string1, size
6214                do                do
6215                  {                  {
6216                    PREFETCH ();                    PREFETCH ();
6217                    if (translate[(unsigned char) *d++] != (char) *p++)  #ifdef WCHAR
6218                      if (*d <= 0xff)
6219                        {
6220                          if ((UCHAR_T) translate[(unsigned char) *d++]
6221                              != (UCHAR_T) *p++)
6222                            goto fail;
6223                        }
6224                      else
6225                        {
6226                          if (*d++ != (CHAR_T) *p++)
6227                            goto fail;
6228                        }
6229    #else
6230                      if ((UCHAR_T) translate[(unsigned char) *d++]
6231                          != (UCHAR_T) *p++)
6232                      goto fail;                      goto fail;
6233    #endif /* WCHAR */
6234                  }                  }
6235                while (--mcnt);                while (--mcnt);
6236              }              }
# Line 3777  re_match_2_internal (bufp, string1, size Line 6239  re_match_2_internal (bufp, string1, size
6239                do                do
6240                  {                  {
6241                    PREFETCH ();                    PREFETCH ();
6242                    if (*d++ != (char) *p++) goto fail;                    if (*d++ != (CHAR_T) *p++) goto fail;
6243                  }                  }
6244                while (--mcnt);                while (--mcnt);
6245              }              }
6246            SET_REGS_MATCHED ();            SET_REGS_MATCHED ();
6247            break;            NEXT;
6248    
6249    
6250          /* Match any character except possibly a newline or a null.  */          /* Match any character except possibly a newline or a null.  */
6251          case anychar:          CASE (anychar):
6252            DEBUG_PRINT1 ("EXECUTING anychar.\n");            DEBUG_PRINT1 ("EXECUTING anychar.\n");
6253    
6254            PREFETCH ();            PREFETCH ();
# Line 3796  re_match_2_internal (bufp, string1, size Line 6258  re_match_2_internal (bufp, string1, size
6258              goto fail;              goto fail;
6259    
6260            SET_REGS_MATCHED ();            SET_REGS_MATCHED ();
6261            DEBUG_PRINT2 ("  Matched `%d'.\n", *d);            DEBUG_PRINT2 ("  Matched `%ld'.\n", (long int) *d);
6262            d++;            d++;
6263            break;            NEXT;
6264    
6265    
6266          case charset:          CASE (charset):
6267          case charset_not:          CASE (charset_not):
6268            {            {
6269              register unsigned char c;              register UCHAR_T c;
6270    #ifdef WCHAR
6271                unsigned int i, char_class_length, coll_symbol_length,
6272                  equiv_class_length, ranges_length, chars_length, length;
6273                CHAR_T *workp, *workp2, *charset_top;
6274    #define WORK_BUFFER_SIZE 128
6275                CHAR_T str_buf[WORK_BUFFER_SIZE];
6276    # ifdef _LIBC
6277                uint32_t nrules;
6278    # endif /* _LIBC */
6279    #endif /* WCHAR */
6280              boolean not = (re_opcode_t) *(p - 1) == charset_not;              boolean not = (re_opcode_t) *(p - 1) == charset_not;
6281    
6282              DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : "");              DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : "");
   
6283              PREFETCH ();              PREFETCH ();
6284              c = TRANSLATE (*d); /* The character to match.  */              c = TRANSLATE (*d); /* The character to match.  */
6285    #ifdef WCHAR
6286    # ifdef _LIBC
6287                nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
6288    # endif /* _LIBC */
6289                charset_top = p - 1;
6290                char_class_length = *p++;
6291                coll_symbol_length = *p++;
6292                equiv_class_length = *p++;
6293                ranges_length = *p++;
6294                chars_length = *p++;
6295                /* p points charset[6], so the address of the next instruction
6296                   (charset[l+m+n+2o+k+p']) equals p[l+m+n+2*o+p'],
6297                   where l=length of char_classes, m=length of collating_symbol,
6298                   n=equivalence_class, o=length of char_range,
6299                   p'=length of character.  */
6300                workp = p;
6301                /* Update p to indicate the next instruction.  */
6302                p += char_class_length + coll_symbol_length+ equiv_class_length +
6303                  2*ranges_length + chars_length;
6304    
6305                /* match with char_class?  */
6306                for (i = 0; i < char_class_length ; i += CHAR_CLASS_SIZE)
6307                  {
6308                    wctype_t wctype;
6309                    uintptr_t alignedp = ((uintptr_t)workp
6310                                          + __alignof__(wctype_t) - 1)
6311                                          & ~(uintptr_t)(__alignof__(wctype_t) - 1);
6312                    wctype = *((wctype_t*)alignedp);
6313                    workp += CHAR_CLASS_SIZE;
6314                    if (iswctype((wint_t)c, wctype))
6315                      goto char_set_matched;
6316                  }
6317    
6318                /* match with collating_symbol?  */
6319    # ifdef _LIBC
6320                if (nrules != 0)
6321                  {
6322                    const unsigned char *extra = (const unsigned char *)
6323                      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
6324    
6325                    for (workp2 = workp + coll_symbol_length ; workp < workp2 ;
6326                         workp++)
6327                      {
6328                        int32_t *wextra;
6329                        wextra = (int32_t*)(extra + *workp++);
6330                        for (i = 0; i < *wextra; ++i)
6331                          if (TRANSLATE(d[i]) != wextra[1 + i])
6332                            break;
6333    
6334                        if (i == *wextra)
6335                          {
6336                            /* Update d, however d will be incremented at
6337                               char_set_matched:, we decrement d here.  */
6338                            d += i - 1;
6339                            goto char_set_matched;
6340                          }
6341                      }
6342                  }
6343                else /* (nrules == 0) */
6344    # endif
6345                  /* If we can't look up collation data, we use wcscoll
6346                     instead.  */
6347                  {
6348                    for (workp2 = workp + coll_symbol_length ; workp < workp2 ;)
6349                      {
6350                        const CHAR_T *backup_d = d, *backup_dend = dend;
6351                        length = wcslen (workp);
6352    
6353                        /* If wcscoll(the collating symbol, whole string) > 0,
6354                           any substring of the string never match with the
6355                           collating symbol.  */
6356                        if (wcscoll (workp, d) > 0)
6357                          {
6358                            workp += length + 1;
6359                            continue;
6360                          }
6361    
6362                        /* First, we compare the collating symbol with
6363                           the first character of the string.
6364                           If it don't match, we add the next character to
6365                           the compare buffer in turn.  */
6366                        for (i = 0 ; i < WORK_BUFFER_SIZE-1 ; i++, d++)
6367                          {
6368                            int match;
6369                            if (d == dend)
6370                              {
6371                                if (dend == end_match_2)
6372                                  break;
6373                                d = string2;
6374                                dend = end_match_2;
6375                              }
6376    
6377                            /* add next character to the compare buffer.  */
6378                            str_buf[i] = TRANSLATE(*d);
6379                            str_buf[i+1] = '\0';
6380    
6381                            match = wcscoll (workp, str_buf);
6382                            if (match == 0)
6383                              goto char_set_matched;
6384    
6385                            if (match < 0)
6386                              /* (str_buf > workp) indicate (str_buf + X > workp),
6387                                 because for all X (str_buf + X > str_buf).
6388                                 So we don't need continue this loop.  */
6389                              break;
6390    
6391                            /* Otherwise(str_buf < workp),
6392                               (str_buf+next_character) may equals (workp).
6393                               So we continue this loop.  */
6394                          }
6395                        /* not matched */
6396                        d = backup_d;
6397                        dend = backup_dend;
6398                        workp += length + 1;
6399                      }
6400                  }
6401                /* match with equivalence_class?  */
6402    # ifdef _LIBC
6403                if (nrules != 0)
6404                  {
6405                    const CHAR_T *backup_d = d, *backup_dend = dend;
6406                    /* Try to match the equivalence class against
6407                       those known to the collate implementation.  */
6408                    const int32_t *table;
6409                    const int32_t *weights;
6410                    const int32_t *extra;
6411                    const int32_t *indirect;
6412                    int32_t idx, idx2;
6413                    wint_t *cp;
6414                    size_t len;
6415    
6416                    /* This #include defines a local function!  */
6417    #  include <locale/weightwc.h>
6418    
6419                    table = (const int32_t *)
6420                      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
6421                    weights = (const wint_t *)
6422                      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
6423                    extra = (const wint_t *)
6424                      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
6425                    indirect = (const int32_t *)
6426                      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
6427    
6428                    /* Write 1 collating element to str_buf, and
6429                       get its index.  */
6430                    idx2 = 0;
6431    
6432                    for (i = 0 ; idx2 == 0 && i < WORK_BUFFER_SIZE - 1; i++)
6433                      {
6434                        cp = (wint_t*)str_buf;
6435                        if (d == dend)
6436                          {
6437                            if (dend == end_match_2)
6438                              break;
6439                            d = string2;
6440                            dend = end_match_2;
6441                          }
6442                        str_buf[i] = TRANSLATE(*(d+i));
6443                        str_buf[i+1] = '\0'; /* sentinel */
6444                        idx2 = findidx ((const wint_t**)&cp);
6445                      }
6446    
6447                    /* Update d, however d will be incremented at
6448                       char_set_matched:, we decrement d here.  */
6449                    d = backup_d + ((wchar_t*)cp - (wchar_t*)str_buf - 1);
6450                    if (d >= dend)
6451                      {
6452                        if (dend == end_match_2)
6453                            d = dend;
6454                        else
6455                          {
6456                            d = string2;
6457                            dend = end_match_2;
6458                          }
6459                      }
6460    
6461                    len = weights[idx2];
6462    
6463                    for (workp2 = workp + equiv_class_length ; workp < workp2 ;
6464                         workp++)
6465                      {
6466                        idx = (int32_t)*workp;
6467                        /* We already checked idx != 0 in regex_compile. */
6468    
6469                        if (idx2 != 0 && len == weights[idx])
6470                          {
6471                            int cnt = 0;
6472                            while (cnt < len && (weights[idx + 1 + cnt]
6473                                                 == weights[idx2 + 1 + cnt]))
6474                              ++cnt;
6475    
6476                            if (cnt == len)
6477                              goto char_set_matched;
6478                          }
6479                      }
6480                    /* not matched */
6481                    d = backup_d;
6482                    dend = backup_dend;
6483                  }
6484                else /* (nrules == 0) */
6485    # endif
6486                  /* If we can't look up collation data, we use wcscoll
6487                     instead.  */
6488                  {
6489                    for (workp2 = workp + equiv_class_length ; workp < workp2 ;)
6490                      {
6491                        const CHAR_T *backup_d = d, *backup_dend = dend;
6492                        length = wcslen (workp);
6493    
6494                        /* If wcscoll(the collating symbol, whole string) > 0,
6495                           any substring of the string never match with the
6496                           collating symbol.  */
6497                        if (wcscoll (workp, d) > 0)
6498                          {
6499                            workp += length + 1;
6500                            break;
6501                          }
6502    
6503                        /* First, we compare the equivalence class with
6504                           the first character of the string.
6505                           If it don't match, we add the next character to
6506                           the compare buffer in turn.  */
6507                        for (i = 0 ; i < WORK_BUFFER_SIZE - 1 ; i++, d++)
6508                          {
6509                            int match;
6510                            if (d == dend)
6511                              {
6512                                if (dend == end_match_2)
6513                                  break;
6514                                d = string2;
6515                                dend = end_match_2;
6516                              }
6517    
6518                            /* add next character to the compare buffer.  */
6519                            str_buf[i] = TRANSLATE(*d);
6520                            str_buf[i+1] = '\0';
6521    
6522                            match = wcscoll (workp, str_buf);
6523    
6524                            if (match == 0)
6525                              goto char_set_matched;
6526    
6527                            if (match < 0)
6528                            /* (str_buf > workp) indicate (str_buf + X > workp),
6529                               because for all X (str_buf + X > str_buf).
6530                               So we don't need continue this loop.  */
6531                              break;
6532    
6533                            /* Otherwise(str_buf < workp),
6534                               (str_buf+next_character) may equals (workp).
6535                               So we continue this loop.  */
6536                          }
6537                        /* not matched */
6538                        d = backup_d;
6539                        dend = backup_dend;
6540                        workp += length + 1;
6541                      }
6542                  }
6543    
6544                /* match with char_range?  */
6545    # ifdef _LIBC
6546                if (nrules != 0)
6547                  {
6548                    uint32_t collseqval;
6549                    const char *collseq = (const char *)
6550                      _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
6551    
6552                    collseqval = collseq_table_lookup (collseq, c);
6553    
6554                    for (; workp < p - chars_length ;)
6555                      {
6556                        uint32_t start_val, end_val;
6557    
6558                        /* We already compute the collation sequence value
6559                           of the characters (or collating symbols).  */
6560                        start_val = (uint32_t) *workp++; /* range_start */
6561                        end_val = (uint32_t) *workp++; /* range_end */
6562    
6563                        if (start_val <= collseqval && collseqval <= end_val)
6564                          goto char_set_matched;
6565                      }
6566                  }
6567                else
6568    # endif
6569                  {
6570                    /* We set range_start_char at str_buf[0], range_end_char
6571                       at str_buf[4], and compared char at str_buf[2].  */
6572                    str_buf[1] = 0;
6573                    str_buf[2] = c;
6574                    str_buf[3] = 0;
6575                    str_buf[5] = 0;
6576                    for (; workp < p - chars_length ;)
6577                      {
6578                        wchar_t *range_start_char, *range_end_char;
6579    
6580                        /* match if (range_start_char <= c <= range_end_char).  */
6581    
6582                        /* If range_start(or end) < 0, we assume -range_start(end)
6583                           is the offset of the collating symbol which is specified
6584                           as the character of the range start(end).  */
6585    
6586                        /* range_start */
6587                        if (*workp < 0)
6588                          range_start_char = charset_top - (*workp++);
6589                        else
6590                          {
6591                            str_buf[0] = *workp++;
6592                            range_start_char = str_buf;
6593                          }
6594    
6595                        /* range_end */
6596                        if (*workp < 0)
6597                          range_end_char = charset_top - (*workp++);
6598                        else
6599                          {
6600                            str_buf[4] = *workp++;
6601                            range_end_char = str_buf + 4;
6602                          }
6603    
6604                        if (wcscoll (range_start_char, str_buf+2) <= 0
6605                            && wcscoll (str_buf+2, range_end_char) <= 0)
6606                          goto char_set_matched;
6607                      }
6608                  }
6609    
6610                /* match with char?  */
6611                for (; workp < p ; workp++)
6612                  if (c == *workp)
6613                    goto char_set_matched;
6614    
6615                not = !not;
6616    
6617              char_set_matched:
6618                if (not) goto fail;
6619    #else
6620              /* Cast to `unsigned' instead of `unsigned char' in case the              /* Cast to `unsigned' instead of `unsigned char' in case the
6621                 bit list is a full 32 bytes long.  */                 bit list is a full 32 bytes long.  */
6622              if (c < (unsigned) (*p * BYTEWIDTH)              if (c < (unsigned) (*p * BYTEWIDTH)
# Line 3821  re_match_2_internal (bufp, string1, size Line 6626  re_match_2_internal (bufp, string1, size
6626              p += 1 + *p;              p += 1 + *p;
6627    
6628              if (!not) goto fail;              if (!not) goto fail;
6629                #undef WORK_BUFFER_SIZE
6630    #endif /* WCHAR */
6631              SET_REGS_MATCHED ();              SET_REGS_MATCHED ();
6632              d++;              d++;
6633              break;              NEXT;
6634            }            }
6635    
6636    
# Line 3833  re_match_2_internal (bufp, string1, size Line 6639  re_match_2_internal (bufp, string1, size
6639             number of groups inner to this one in the next.  The text             number of groups inner to this one in the next.  The text
6640             matched within the group is recorded (in the internal             matched within the group is recorded (in the internal
6641             registers data structure) under the register number.  */             registers data structure) under the register number.  */
6642          case start_memory:          CASE (start_memory):
6643            DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]);            DEBUG_PRINT3 ("EXECUTING start_memory %ld (%ld):\n",
6644                            (long int) *p, (long int) p[1]);
6645    
6646            /* Find out if this group can match the empty string.  */            /* Find out if this group can match the empty string.  */
6647            p1 = p;               /* To send to group_match_null_string_p.  */            p1 = p;               /* To send to group_match_null_string_p.  */
6648              
6649            if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)            if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)
6650              REG_MATCH_NULL_STRING_P (reg_info[*p])              REG_MATCH_NULL_STRING_P (reg_info[*p])
6651                = group_match_null_string_p (&p1, pend, reg_info);                = PREFIX(group_match_null_string_p) (&p1, pend, reg_info);
6652    
6653            /* Save the position in the string where we were the last time            /* Save the position in the string where we were the last time
6654               we were at this open-group operator in case the group is               we were at this open-group operator in case the group is
# Line 3851  re_match_2_internal (bufp, string1, size Line 6658  re_match_2_internal (bufp, string1, size
6658            old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])            old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
6659                               ? REG_UNSET (regstart[*p]) ? d : regstart[*p]                               ? REG_UNSET (regstart[*p]) ? d : regstart[*p]
6660                               : regstart[*p];                               : regstart[*p];
6661            DEBUG_PRINT2 ("  old_regstart: %d\n",            DEBUG_PRINT2 ("  old_regstart: %d\n",
6662                           POINTER_TO_OFFSET (old_regstart[*p]));                           POINTER_TO_OFFSET (old_regstart[*p]));
6663    
6664            regstart[*p] = d;            regstart[*p] = d;
# Line 3859  re_match_2_internal (bufp, string1, size Line 6666  re_match_2_internal (bufp, string1, size
6666    
6667            IS_ACTIVE (reg_info[*p]) = 1;            IS_ACTIVE (reg_info[*p]) = 1;
6668            MATCHED_SOMETHING (reg_info[*p]) = 0;            MATCHED_SOMETHING (reg_info[*p]) = 0;
6669              
6670              /* Clear this whenever we change the register activity status.  */
6671              set_regs_matched_done = 0;
6672    
6673            /* This is the new highest active register.  */            /* This is the new highest active register.  */
6674            highest_active_reg = *p;            highest_active_reg = *p;
6675              
6676            /* If nothing was active before, this is the new lowest active            /* If nothing was active before, this is the new lowest active
6677               register.  */               register.  */
6678            if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)            if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
# Line 3871  re_match_2_internal (bufp, string1, size Line 6681  re_match_2_internal (bufp, string1, size
6681            /* Move past the register number and inner group count.  */            /* Move past the register number and inner group count.  */
6682            p += 2;            p += 2;
6683            just_past_start_mem = p;            just_past_start_mem = p;
6684            break;  
6685              NEXT;
6686    
6687    
6688          /* The stop_memory opcode represents the end of a group.  Its          /* The stop_memory opcode represents the end of a group.  Its
6689             arguments are the same as start_memory's: the register             arguments are the same as start_memory's: the register
6690             number, and the number of inner groups.  */             number, and the number of inner groups.  */
6691          case stop_memory:          CASE (stop_memory):
6692            DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]);            DEBUG_PRINT3 ("EXECUTING stop_memory %ld (%ld):\n",
6693                                        (long int) *p, (long int) p[1]);
6694    
6695            /* We need to save the string position the last time we were at            /* We need to save the string position the last time we were at
6696               this close-group operator in case the group is operated               this close-group operator in case the group is operated
6697               upon by a repetition operator, e.g., with `((a*)*(b*)*)*'               upon by a repetition operator, e.g., with `((a*)*(b*)*)*'
# Line 3888  re_match_2_internal (bufp, string1, size Line 6700  re_match_2_internal (bufp, string1, size
6700            old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])            old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
6701                             ? REG_UNSET (regend[*p]) ? d : regend[*p]                             ? REG_UNSET (regend[*p]) ? d : regend[*p]
6702                             : regend[*p];                             : regend[*p];
6703            DEBUG_PRINT2 ("      old_regend: %d\n",            DEBUG_PRINT2 ("      old_regend: %d\n",
6704                           POINTER_TO_OFFSET (old_regend[*p]));                           POINTER_TO_OFFSET (old_regend[*p]));
6705    
6706            regend[*p] = d;            regend[*p] = d;
# Line 3896  re_match_2_internal (bufp, string1, size Line 6708  re_match_2_internal (bufp, string1, size
6708    
6709            /* This register isn't active anymore.  */            /* This register isn't active anymore.  */
6710            IS_ACTIVE (reg_info[*p]) = 0;            IS_ACTIVE (reg_info[*p]) = 0;
6711              
6712              /* Clear this whenever we change the register activity status.  */
6713              set_regs_matched_done = 0;
6714    
6715            /* If this was the only register active, nothing is active            /* If this was the only register active, nothing is active
6716               anymore.  */               anymore.  */
6717            if (lowest_active_reg == highest_active_reg)            if (lowest_active_reg == highest_active_reg)
# Line 3909  re_match_2_internal (bufp, string1, size Line 6724  re_match_2_internal (bufp, string1, size
6724                   it isn't necessarily one less than now: consider                   it isn't necessarily one less than now: consider
6725                   (a(b)c(d(e)f)g).  When group 3 ends, after the f), the                   (a(b)c(d(e)f)g).  When group 3 ends, after the f), the
6726                   new highest active register is 1.  */                   new highest active register is 1.  */
6727                unsigned char r = *p - 1;                UCHAR_T r = *p - 1;
6728                while (r > 0 && !IS_ACTIVE (reg_info[r]))                while (r > 0 && !IS_ACTIVE (reg_info[r]))
6729                  r--;                  r--;
6730                  
6731                /* If we end up at register zero, that means that we saved                /* If we end up at register zero, that means that we saved
6732                   the registers as the result of an `on_failure_jump', not                   the registers as the result of an `on_failure_jump', not
6733                   a `start_memory', and we jumped to past the innermost                   a `start_memory', and we jumped to past the innermost
# Line 3928  re_match_2_internal (bufp, string1, size Line 6743  re_match_2_internal (bufp, string1, size
6743                else                else
6744                  highest_active_reg = r;                  highest_active_reg = r;
6745              }              }
6746              
6747            /* If just failed to match something this time around with a            /* If just failed to match something this time around with a
6748               group that's operated on by a repetition operator, try to               group that's operated on by a repetition operator, try to
6749               force exit from the ``loop'', and restore the register               force exit from the ``loop'', and restore the register
# Line 3936  re_match_2_internal (bufp, string1, size Line 6751  re_match_2_internal (bufp, string1, size
6751               last match.  */               last match.  */
6752            if ((!MATCHED_SOMETHING (reg_info[*p])            if ((!MATCHED_SOMETHING (reg_info[*p])
6753                 || just_past_start_mem == p - 1)                 || just_past_start_mem == p - 1)
6754                && (p + 2) < pend)                              && (p + 2) < pend)
6755              {              {
6756                boolean is_a_jump_n = false;                boolean is_a_jump_n = false;
6757                  
6758                p1 = p + 2;                p1 = p + 2;
6759                mcnt = 0;                mcnt = 0;
6760                switch ((re_opcode_t) *p1++)                switch ((re_opcode_t) *p1++)
# Line 3952  re_match_2_internal (bufp, string1, size Line 6767  re_match_2_internal (bufp, string1, size
6767                    case dummy_failure_jump:                    case dummy_failure_jump:
6768                      EXTRACT_NUMBER_AND_INCR (mcnt, p1);                      EXTRACT_NUMBER_AND_INCR (mcnt, p1);
6769                      if (is_a_jump_n)                      if (is_a_jump_n)
6770                        p1 += 2;                        p1 += OFFSET_ADDRESS_SIZE;
6771                      break;                      break;
6772                      
6773                    default:                    default:
6774                      /* do nothing */ ;                      /* do nothing */ ;
6775                  }                  }
6776                p1 += mcnt;                p1 += mcnt;
6777            
6778                /* If the next operation is a jump backwards in the pattern                /* If the next operation is a jump backwards in the pattern
6779                   to an on_failure_jump right before the start_memory                   to an on_failure_jump right before the start_memory
6780                   corresponding to this stop_memory, exit from the loop                   corresponding to this stop_memory, exit from the loop
6781                   by forcing a failure after pushing on the stack the                   by forcing a failure after pushing on the stack the
6782                   on_failure_jump's jump in the pattern, and d.  */                   on_failure_jump's jump in the pattern, and d.  */
6783                if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump                if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump
6784                    && (re_opcode_t) p1[3] == start_memory && p1[4] == *p)                    && (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == start_memory
6785                      && p1[2+OFFSET_ADDRESS_SIZE] == *p)
6786                  {                  {
6787                    /* If this group ever matched anything, then restore                    /* If this group ever matched anything, then restore
6788                       what its registers were before trying this last                       what its registers were before trying this last
6789                       failed match, e.g., with `(a*)*b' against `ab' for                       failed match, e.g., with `(a*)*b' against `ab' for
6790                       regstart[1], and, e.g., with `((a*)*(b*)*)*'                       regstart[1], and, e.g., with `((a*)*(b*)*)*'
6791                       against `aba' for regend[3].                       against `aba' for regend[3].
6792                        
6793                       Also restore the registers for inner groups for,                       Also restore the registers for inner groups for,
6794                       e.g., `((a*)(b*))*' against `aba' (register 3 would                       e.g., `((a*)(b*))*' against `aba' (register 3 would
6795                       otherwise get trashed).  */                       otherwise get trashed).  */
6796                        
6797                    if (EVER_MATCHED_SOMETHING (reg_info[*p]))                    if (EVER_MATCHED_SOMETHING (reg_info[*p]))
6798                      {                      {
6799                        unsigned r;                        unsigned r;
6800            
6801                        EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;                        EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;
6802                          
6803                        /* Restore this and inner groups' (if any) registers.  */                        /* Restore this and inner groups' (if any) registers.  */
6804                        for (r = *p; r < *p + *(p + 1); r++)                        for (r = *p; r < (unsigned) *p + (unsigned) *(p + 1);
6805                               r++)
6806                          {                          {
6807                            regstart[r] = old_regstart[r];                            regstart[r] = old_regstart[r];
6808    
6809                            /* xx why this test?  */                            /* xx why this test?  */
6810                            if ((int) old_regend[r] >= (int) regstart[r])                            if (old_regend[r] >= regstart[r])
6811                              regend[r] = old_regend[r];                              regend[r] = old_regend[r];
6812                          }                              }
6813                      }                      }
6814                    p1++;                    p1++;
6815                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);
# Line 4001  re_match_2_internal (bufp, string1, size Line 6818  re_match_2_internal (bufp, string1, size
6818                    goto fail;                    goto fail;
6819                  }                  }
6820              }              }
6821              
6822            /* Move past the register number and the inner group count.  */            /* Move past the register number and the inner group count.  */
6823            p += 2;            p += 2;
6824            break;            NEXT;
6825    
6826    
6827          /* \<digit> has been turned into a `duplicate' command which is          /* \<digit> has been turned into a `duplicate' command which is
6828             followed by the numeric value of <digit> as the register number.  */             followed by the numeric value of <digit> as the register number.  */
6829          case duplicate:          CASE (duplicate):
6830            {            {
6831              register const char *d2, *dend2;              register const CHAR_T *d2, *dend2;
6832              int regno = *p++;   /* Get which register to match against.  */              int regno = *p++;   /* Get which register to match against.  */
6833              DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);              DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);
6834    
6835              /* Can't back reference a group which we've never matched.  */              /* Can't back reference a group which we've never matched.  */
6836              if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))              if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
6837                goto fail;                goto fail;
6838                  
6839              /* Where in input to try to start matching.  */              /* Where in input to try to start matching.  */
6840              d2 = regstart[regno];              d2 = regstart[regno];
6841                
6842              /* Where to stop matching; if both the place to start and              /* Where to stop matching; if both the place to start and
6843                 the place to stop matching are in the same string, then                 the place to stop matching are in the same string, then
6844                 set to the place to stop, otherwise, for now have to use                 set to the place to stop, otherwise, for now have to use
6845                 the end of the first string.  */                 the end of the first string.  */
6846    
6847              dend2 = ((FIRST_STRING_P (regstart[regno])              dend2 = ((FIRST_STRING_P (regstart[regno])
6848                        == FIRST_STRING_P (regend[regno]))                        == FIRST_STRING_P (regend[regno]))
6849                       ? regend[regno] : end_match_1);                       ? regend[regno] : end_match_1);
6850              for (;;)              for (;;)
# Line 4051  re_match_2_internal (bufp, string1, size Line 6868  re_match_2_internal (bufp, string1, size
6868    
6869                  /* How many characters left in this segment to match.  */                  /* How many characters left in this segment to match.  */
6870                  mcnt = dend - d;                  mcnt = dend - d;
6871                    
6872                  /* Want how many consecutive characters we can match in                  /* Want how many consecutive characters we can match in
6873                     one shot, so, if necessary, adjust the count.  */                     one shot, so, if necessary, adjust the count.  */
6874                  if (mcnt > dend2 - d2)                  if (mcnt > dend2 - d2)
6875                    mcnt = dend2 - d2;                    mcnt = dend2 - d2;
6876                      
6877                  /* Compare that many; failure if mismatch, else move                  /* Compare that many; failure if mismatch, else move
6878                     past them.  */                     past them.  */
6879                  if (translate                  if (translate
6880                      ? bcmp_translate (d, d2, mcnt, translate)                      ? PREFIX(bcmp_translate) (d, d2, mcnt, translate)
6881                      : bcmp (d, d2, mcnt))                      : memcmp (d, d2, mcnt*sizeof(UCHAR_T)))
6882                    goto fail;                    goto fail;
6883                  d += mcnt, d2 += mcnt;                  d += mcnt, d2 += mcnt;
6884    
6885                    /* Do this because we've match some characters.  */
6886                    SET_REGS_MATCHED ();
6887                }                }
6888            }            }
6889            break;            NEXT;
6890    
6891    
6892          /* begline matches the empty string at the beginning of the string          /* begline matches the empty string at the beginning of the string
6893             (unless `not_bol' is set in `bufp'), and, if             (unless `not_bol' is set in `bufp'), and, if
6894             `newline_anchor' is set, after newlines.  */             `newline_anchor' is set, after newlines.  */
6895          case begline:          CASE (begline):
6896            DEBUG_PRINT1 ("EXECUTING begline.\n");            DEBUG_PRINT1 ("EXECUTING begline.\n");
6897              
6898            if (AT_STRINGS_BEG (d))            if (AT_STRINGS_BEG (d))
6899              {              {
6900                if (!bufp->not_bol) break;                if (!bufp->not_bol)
6901                    {
6902                      NEXT;
6903                    }
6904              }              }
6905            else if (d[-1] == '\n' && bufp->newline_anchor)            else if (d[-1] == '\n' && bufp->newline_anchor)
6906              {              {
6907                break;                NEXT;
6908              }              }
6909            /* In all other cases, we fail.  */            /* In all other cases, we fail.  */
6910            goto fail;            goto fail;
6911    
6912    
6913          /* endline is the dual of begline.  */          /* endline is the dual of begline.  */
6914          case endline:          CASE (endline):
6915            DEBUG_PRINT1 ("EXECUTING endline.\n");            DEBUG_PRINT1 ("EXECUTING endline.\n");
6916    
6917            if (AT_STRINGS_END (d))            if (AT_STRINGS_END (d))
6918              {              {
6919                if (!bufp->not_eol) break;                if (!bufp->not_eol)
6920                    {
6921                      NEXT;
6922                    }
6923              }              }
6924              
6925            /* We have to ``prefetch'' the next character.  */            /* We have to ``prefetch'' the next character.  */
6926            else if ((d == end1 ? *string2 : *d) == '\n'            else if ((d == end1 ? *string2 : *d) == '\n'
6927                     && bufp->newline_anchor)                     && bufp->newline_anchor)
6928              {              {
6929                break;                NEXT;
6930              }              }
6931            goto fail;            goto fail;
6932    
6933    
6934          /* Match at the very beginning of the data.  */          /* Match at the very beginning of the data.  */
6935          case begbuf:          CASE (begbuf):
6936            DEBUG_PRINT1 ("EXECUTING begbuf.\n");            DEBUG_PRINT1 ("EXECUTING begbuf.\n");
6937            if (AT_STRINGS_BEG (d))            if (AT_STRINGS_BEG (d))
6938              break;              {
6939                  NEXT;
6940                }
6941            goto fail;            goto fail;
6942    
6943    
6944          /* Match at the very end of the data.  */          /* Match at the very end of the data.  */
6945          case endbuf:          CASE (endbuf):
6946            DEBUG_PRINT1 ("EXECUTING endbuf.\n");            DEBUG_PRINT1 ("EXECUTING endbuf.\n");
6947            if (AT_STRINGS_END (d))            if (AT_STRINGS_END (d))
6948              break;              {
6949                  NEXT;
6950                }
6951            goto fail;            goto fail;
6952    
6953    
# Line 4129  re_match_2_internal (bufp, string1, size Line 6959  re_match_2_internal (bufp, string1, size
6959             then the . fails against the \n.  But the next thing we want             then the . fails against the \n.  But the next thing we want
6960             to do is match the \n against the \n; if we restored the             to do is match the \n against the \n; if we restored the
6961             string value, we would be back at the foo.             string value, we would be back at the foo.
6962              
6963             Because this is used only in specific cases, we don't need to             Because this is used only in specific cases, we don't need to
6964             check all the things that `on_failure_jump' does, to make             check all the things that `on_failure_jump' does, to make
6965             sure the right things get saved on the stack.  Hence we don't             sure the right things get saved on the stack.  Hence we don't
# Line 4137  re_match_2_internal (bufp, string1, size Line 6967  re_match_2_internal (bufp, string1, size
6967             stack at all is that otherwise we would have to change             stack at all is that otherwise we would have to change
6968             `anychar's code to do something besides goto fail in this             `anychar's code to do something besides goto fail in this
6969             case; that seems worse than this.  */             case; that seems worse than this.  */
6970          case on_failure_keep_string_jump:          CASE (on_failure_keep_string_jump):
6971            DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");            DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");
6972              
6973            EXTRACT_NUMBER_AND_INCR (mcnt, p);            EXTRACT_NUMBER_AND_INCR (mcnt, p);
6974    #ifdef _LIBC
6975              DEBUG_PRINT3 (" %d (to %p):\n", mcnt, p + mcnt);
6976    #else
6977            DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);            DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);
6978    #endif
6979    
6980            PUSH_FAILURE_POINT (p + mcnt, NULL, -2);            PUSH_FAILURE_POINT (p + mcnt, NULL, -2);
6981            break;            NEXT;
6982    
6983    
6984          /* Uses of on_failure_jump:          /* Uses of on_failure_jump:
6985            
6986             Each alternative starts with an on_failure_jump that points             Each alternative starts with an on_failure_jump that points
6987             to the beginning of the next alternative.  Each alternative             to the beginning of the next alternative.  Each alternative
6988             except the last ends with a jump that in effect jumps past             except the last ends with a jump that in effect jumps past
# Line 4159  re_match_2_internal (bufp, string1, size Line 6993  re_match_2_internal (bufp, string1, size
6993             Repeats start with an on_failure_jump that points past both             Repeats start with an on_failure_jump that points past both
6994             the repetition text and either the following jump or             the repetition text and either the following jump or
6995             pop_failure_jump back to this on_failure_jump.  */             pop_failure_jump back to this on_failure_jump.  */
6996          case on_failure_jump:          CASE (on_failure_jump):
6997          on_failure:          on_failure:
6998            DEBUG_PRINT1 ("EXECUTING on_failure_jump");            DEBUG_PRINT1 ("EXECUTING on_failure_jump");
6999    
7000            EXTRACT_NUMBER_AND_INCR (mcnt, p);            EXTRACT_NUMBER_AND_INCR (mcnt, p);
7001    #ifdef _LIBC
7002              DEBUG_PRINT3 (" %d (to %p)", mcnt, p + mcnt);
7003    #else
7004            DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt);            DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt);
7005    #endif
7006    
7007            /* If this on_failure_jump comes right before a group (i.e.,            /* If this on_failure_jump comes right before a group (i.e.,
7008               the original * applied to a group), save the information               the original * applied to a group), save the information
7009               for that group and all inner ones, so that if we fail back               for that group and all inner ones, so that if we fail back
7010               to this point, the group's information will be correct.               to this point, the group's information will be correct.
7011               For example, in \(a*\)*\1, we need the preceding group,               For example, in \(a*\)*\1, we need the preceding group,
7012               and in \(\(a*\)b*\)\2, we need the inner group.  */               and in \(zz\(a*\)b*\)\2, we need the inner group.  */
7013    
7014            /* We can't use `p' to check ahead because we push            /* We can't use `p' to check ahead because we push
7015               a failure point to `p + mcnt' after we do this.  */               a failure point to `p + mcnt' after we do this.  */
# Line 4197  re_match_2_internal (bufp, string1, size Line 7035  re_match_2_internal (bufp, string1, size
7035    
7036            DEBUG_PRINT1 (":\n");            DEBUG_PRINT1 (":\n");
7037            PUSH_FAILURE_POINT (p + mcnt, d, -2);            PUSH_FAILURE_POINT (p + mcnt, d, -2);
7038            break;            NEXT;
7039    
7040    
7041          /* A smart repeat ends with `maybe_pop_jump'.          /* A smart repeat ends with `maybe_pop_jump'.
7042             We change it to either `pop_failure_jump' or `jump'.  */             We change it to either `pop_failure_jump' or `jump'.  */
7043          case maybe_pop_jump:          CASE (maybe_pop_jump):
7044            EXTRACT_NUMBER_AND_INCR (mcnt, p);            EXTRACT_NUMBER_AND_INCR (mcnt, p);
7045            DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt);            DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt);
7046            {            {
7047              register unsigned char *p2 = p;              register UCHAR_T *p2 = p;
7048    
7049              /* Compare the beginning of the repeat with what in the              /* Compare the beginning of the repeat with what in the
7050                 pattern follows its end. If we can establish that there                 pattern follows its end. If we can establish that there
# Line 4214  re_match_2_internal (bufp, string1, size Line 7052  re_match_2_internal (bufp, string1, size
7052                 would have to backtrack because of (as in, e.g., `a*a')                 would have to backtrack because of (as in, e.g., `a*a')
7053                 then we can change to pop_failure_jump, because we'll                 then we can change to pop_failure_jump, because we'll
7054                 never have to backtrack.                 never have to backtrack.
7055                  
7056                 This is not true in the case of alternatives: in                 This is not true in the case of alternatives: in
7057                 `(a|ab)*' we do need to backtrack to the `ab' alternative                 `(a|ab)*' we do need to backtrack to the `ab' alternative
7058                 (e.g., if the string was `ab').  But instead of trying to                 (e.g., if the string was `ab').  But instead of trying to
# Line 4231  re_match_2_internal (bufp, string1, size Line 7069  re_match_2_internal (bufp, string1, size
7069                      && ((re_opcode_t) *p2 == stop_memory                      && ((re_opcode_t) *p2 == stop_memory
7070                          || (re_opcode_t) *p2 == start_memory))                          || (re_opcode_t) *p2 == start_memory))
7071                    p2 += 3;                    p2 += 3;
7072                  else if (p2 + 6 < pend                  else if (p2 + 2 + 2 * OFFSET_ADDRESS_SIZE < pend
7073                           && (re_opcode_t) *p2 == dummy_failure_jump)                           && (re_opcode_t) *p2 == dummy_failure_jump)
7074                    p2 += 6;                    p2 += 2 + 2 * OFFSET_ADDRESS_SIZE;
7075                  else                  else
7076                    break;                    break;
7077                }                }
7078    
7079              p1 = p + mcnt;              p1 = p + mcnt;
7080              /* p1[0] ... p1[2] are the `on_failure_jump' corresponding              /* p1[0] ... p1[2] are the `on_failure_jump' corresponding
7081                 to the `maybe_finalize_jump' of this case.  Examine what                 to the `maybe_finalize_jump' of this case.  Examine what
7082                 follows.  */                 follows.  */
7083    
7084              /* If we're at the end of the pattern, we can change.  */              /* If we're at the end of the pattern, we can change.  */
# Line 4249  re_match_2_internal (bufp, string1, size Line 7087  re_match_2_internal (bufp, string1, size
7087                  /* Consider what happens when matching ":\(.*\)"                  /* Consider what happens when matching ":\(.*\)"
7088                     against ":/".  I don't really understand this code                     against ":/".  I don't really understand this code
7089                     yet.  */                     yet.  */
7090                  p[-3] = (unsigned char) pop_failure_jump;                  p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
7091                      pop_failure_jump;
7092                  DEBUG_PRINT1                  DEBUG_PRINT1
7093                    ("  End of pattern: change to `pop_failure_jump'.\n");                    ("  End of pattern: change to `pop_failure_jump'.\n");
7094                }                }
7095    
7096              else if ((re_opcode_t) *p2 == exactn              else if ((re_opcode_t) *p2 == exactn
7097    #ifdef MBS_SUPPORT
7098                         || (re_opcode_t) *p2 == exactn_bin
7099    #endif
7100                       || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))                       || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
7101                {                {
7102                  register unsigned char c                  register UCHAR_T c
7103                    = *p2 == (unsigned char) endline ? '\n' : p2[2];                    = *p2 == (UCHAR_T) endline ? '\n' : p2[2];
7104    
7105                  if ((re_opcode_t) p1[3] == exactn && p1[5] != c)                  if (((re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn
7106    #ifdef MBS_SUPPORT
7107                         || (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn_bin
7108    #endif
7109                        ) && p1[3+OFFSET_ADDRESS_SIZE] != c)
7110                    {                    {
7111                      p[-3] = (unsigned char) pop_failure_jump;                      p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
7112                      DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",                        pop_failure_jump;
7113                                    c, p1[5]);  #ifdef WCHAR
7114                          DEBUG_PRINT3 ("  %C != %C => pop_failure_jump.\n",
7115                                        (wint_t) c,
7116                                        (wint_t) p1[3+OFFSET_ADDRESS_SIZE]);
7117    #else
7118                          DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
7119                                        (char) c,
7120                                        (char) p1[3+OFFSET_ADDRESS_SIZE]);
7121    #endif
7122                    }                    }
7123                      
7124    #ifndef WCHAR
7125                  else if ((re_opcode_t) p1[3] == charset                  else if ((re_opcode_t) p1[3] == charset
7126                           || (re_opcode_t) p1[3] == charset_not)                           || (re_opcode_t) p1[3] == charset_not)
7127                    {                    {
7128                      int not = (re_opcode_t) p1[3] == charset_not;                      int not = (re_opcode_t) p1[3] == charset_not;
7129                        
7130                      if (c < (unsigned char) (p1[4] * BYTEWIDTH)                      if (c < (unsigned) (p1[4] * BYTEWIDTH)
7131                          && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))                          && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
7132                        not = !not;                        not = !not;
7133    
# Line 4284  re_match_2_internal (bufp, string1, size Line 7139  re_match_2_internal (bufp, string1, size
7139                          DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");                          DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
7140                        }                        }
7141                    }                    }
7142    #endif /* not WCHAR */
7143                }                }
7144    #ifndef WCHAR
7145              else if ((re_opcode_t) *p2 == charset)              else if ((re_opcode_t) *p2 == charset)
7146                {                {
7147  #ifdef DEBUG                  /* We win if the first character of the loop is not part
7148                  register unsigned char c                     of the charset.  */
                   = *p2 == (unsigned char) endline ? '\n' : p2[2];  
 #endif  
   
7149                  if ((re_opcode_t) p1[3] == exactn                  if ((re_opcode_t) p1[3] == exactn
7150                      && ! ((int) p2[1] * BYTEWIDTH > (int) p1[4]                      && ! ((int) p2[1] * BYTEWIDTH > (int) p1[5]
7151                            && (p2[1 + p1[4] / BYTEWIDTH]                            && (p2[2 + p1[5] / BYTEWIDTH]
7152                                & (1 << (p1[4] % BYTEWIDTH)))))                                & (1 << (p1[5] % BYTEWIDTH)))))
7153                    {                    {
7154                      p[-3] = (unsigned char) pop_failure_jump;                      p[-3] = (unsigned char) pop_failure_jump;
7155                      DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",                      DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
                                   c, p1[5]);  
7156                    }                    }
7157                      
7158                  else if ((re_opcode_t) p1[3] == charset_not)                  else if ((re_opcode_t) p1[3] == charset_not)
7159                    {                    {
7160                      int idx;                      int idx;
# Line 4337  re_match_2_internal (bufp, string1, size Line 7190  re_match_2_internal (bufp, string1, size
7190                        }                        }
7191                    }                    }
7192                }                }
7193    #endif /* not WCHAR */
7194            }            }
7195            p -= 2;               /* Point at relative address again.  */            p -= OFFSET_ADDRESS_SIZE;     /* Point at relative address again.  */
7196            if ((re_opcode_t) p[-1] != pop_failure_jump)            if ((re_opcode_t) p[-1] != pop_failure_jump)
7197              {              {
7198                p[-1] = (unsigned char) jump;                p[-1] = (UCHAR_T) jump;
7199                DEBUG_PRINT1 ("  Match => jump.\n");                DEBUG_PRINT1 ("  Match => jump.\n");
7200                goto unconditional_jump;                goto unconditional_jump;
7201              }              }
# Line 4354  re_match_2_internal (bufp, string1, size Line 7208  re_match_2_internal (bufp, string1, size
7208             points put on by this pop_failure_jump's matching             points put on by this pop_failure_jump's matching
7209             on_failure_jump; we got through the pattern to here from the             on_failure_jump; we got through the pattern to here from the
7210             matching on_failure_jump, so didn't fail.  */             matching on_failure_jump, so didn't fail.  */
7211          case pop_failure_jump:          CASE (pop_failure_jump):
7212            {            {
7213              /* We need to pass separate storage for the lowest and              /* We need to pass separate storage for the lowest and
7214                 highest registers, even though we don't care about the                 highest registers, even though we don't care about the
7215                 actual values.  Otherwise, we will restore only one                 actual values.  Otherwise, we will restore only one
7216                 register from the stack, since lowest will == highest in                 register from the stack, since lowest will == highest in
7217                 `pop_failure_point'.  */                 `pop_failure_point'.  */
7218              unsigned dummy_low_reg, dummy_high_reg;              active_reg_t dummy_low_reg, dummy_high_reg;
7219              unsigned char *pdummy;              UCHAR_T *pdummy = NULL;
7220              const char *sdummy;              const CHAR_T *sdummy = NULL;
7221    
7222              DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");              DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");
7223              POP_FAILURE_POINT (sdummy, pdummy,              POP_FAILURE_POINT (sdummy, pdummy,
7224                                 dummy_low_reg, dummy_high_reg,                                 dummy_low_reg, dummy_high_reg,
7225                                 reg_dummy, reg_dummy, reg_info_dummy);                                 reg_dummy, reg_dummy, reg_info_dummy);
7226            }            }
7227              /* Note fall through.  */
7228    
7229            unconditional_jump:
7230    #ifdef _LIBC
7231              DEBUG_PRINT2 ("\n%p: ", p);
7232    #else
7233              DEBUG_PRINT2 ("\n0x%x: ", p);
7234    #endif
7235            /* Note fall through.  */            /* Note fall through.  */
7236    
             
7237          /* Unconditionally jump (without popping any failure points).  */          /* Unconditionally jump (without popping any failure points).  */
7238          case jump:          CASE (jump):
         unconditional_jump:  
7239            EXTRACT_NUMBER_AND_INCR (mcnt, p);    /* Get the amount to jump.  */            EXTRACT_NUMBER_AND_INCR (mcnt, p);    /* Get the amount to jump.  */
7240            DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);            DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
7241            p += mcnt;                            /* Do the jump.  */            p += mcnt;                            /* Do the jump.  */
7242    #ifdef _LIBC
7243              DEBUG_PRINT2 ("(to %p).\n", p);
7244    #else
7245            DEBUG_PRINT2 ("(to 0x%x).\n", p);            DEBUG_PRINT2 ("(to 0x%x).\n", p);
7246            break;  #endif
7247              NEXT;
7248    
7249    
           
7250          /* We need this opcode so we can detect where alternatives end          /* We need this opcode so we can detect where alternatives end
7251             in `group_match_null_string_p' et al.  */             in `group_match_null_string_p' et al.  */
7252          case jump_past_alt:          CASE (jump_past_alt):
7253            DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n");            DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n");
7254            goto unconditional_jump;            goto unconditional_jump;
7255    
# Line 4395  re_match_2_internal (bufp, string1, size Line 7259  re_match_2_internal (bufp, string1, size
7259             pop_failure_jump, also, and with a pattern of, say, `a+', we             pop_failure_jump, also, and with a pattern of, say, `a+', we
7260             are skipping over the on_failure_jump, so we have to push             are skipping over the on_failure_jump, so we have to push
7261             something meaningless for pop_failure_jump to pop.  */             something meaningless for pop_failure_jump to pop.  */
7262          case dummy_failure_jump:          CASE (dummy_failure_jump):
7263            DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");            DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");
7264            /* It doesn't matter what we push for the string here.  What            /* It doesn't matter what we push for the string here.  What
7265               the code at `fail' tests is the value for the pattern.  */               the code at `fail' tests is the value for the pattern.  */
7266            PUSH_FAILURE_POINT (0, 0, -2);            PUSH_FAILURE_POINT (NULL, NULL, -2);
7267            goto unconditional_jump;            goto unconditional_jump;
7268    
7269    
# Line 4408  re_match_2_internal (bufp, string1, size Line 7272  re_match_2_internal (bufp, string1, size
7272             we don't want the failure point for the alternative to be             we don't want the failure point for the alternative to be
7273             popped.  For example, matching `(a|ab)*' against `aab'             popped.  For example, matching `(a|ab)*' against `aab'
7274             requires that we match the `ab' alternative.  */             requires that we match the `ab' alternative.  */
7275          case push_dummy_failure:          CASE (push_dummy_failure):
7276            DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");            DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");
7277            /* See comments just above at `dummy_failure_jump' about the            /* See comments just above at `dummy_failure_jump' about the
7278               two zeroes.  */               two zeroes.  */
7279            PUSH_FAILURE_POINT (0, 0, -2);            PUSH_FAILURE_POINT (NULL, NULL, -2);
7280            break;            NEXT;
7281    
7282          /* Have to succeed matching what follows at least n times.          /* Have to succeed matching what follows at least n times.
7283             After that, handle like `on_failure_jump'.  */             After that, handle like `on_failure_jump'.  */
7284          case succeed_n:          CASE (succeed_n):
7285            EXTRACT_NUMBER (mcnt, p + 2);            EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
7286            DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);            DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);
7287    
7288            assert (mcnt >= 0);            assert (mcnt >= 0);
# Line 4426  re_match_2_internal (bufp, string1, size Line 7290  re_match_2_internal (bufp, string1, size
7290            if (mcnt > 0)            if (mcnt > 0)
7291              {              {
7292                 mcnt--;                 mcnt--;
7293                 p += 2;                 p += OFFSET_ADDRESS_SIZE;
7294                 STORE_NUMBER_AND_INCR (p, mcnt);                 STORE_NUMBER_AND_INCR (p, mcnt);
7295                 DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p, mcnt);  #ifdef _LIBC
7296                   DEBUG_PRINT3 ("  Setting %p to %d.\n", p - OFFSET_ADDRESS_SIZE
7297                                 , mcnt);
7298    #else
7299                   DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p - OFFSET_ADDRESS_SIZE
7300                                 , mcnt);
7301    #endif
7302              }              }
7303            else if (mcnt == 0)            else if (mcnt == 0)
7304              {              {
7305                DEBUG_PRINT2 ("  Setting two bytes from 0x%x to no_op.\n", p+2);  #ifdef _LIBC
7306                p[2] = (unsigned char) no_op;                DEBUG_PRINT2 ("  Setting two bytes from %p to no_op.\n",
7307                p[3] = (unsigned char) no_op;                              p + OFFSET_ADDRESS_SIZE);
7308    #else
7309                  DEBUG_PRINT2 ("  Setting two bytes from 0x%x to no_op.\n",
7310                                p + OFFSET_ADDRESS_SIZE);
7311    #endif /* _LIBC */
7312    
7313    #ifdef WCHAR
7314                  p[1] = (UCHAR_T) no_op;
7315    #else
7316                  p[2] = (UCHAR_T) no_op;
7317                  p[3] = (UCHAR_T) no_op;
7318    #endif /* WCHAR */
7319                goto on_failure;                goto on_failure;
7320              }              }
7321            break;            NEXT;
7322            
7323          case jump_n:          CASE (jump_n):
7324            EXTRACT_NUMBER (mcnt, p + 2);            EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
7325            DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);            DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);
7326    
7327            /* Originally, this is how many times we CAN jump.  */            /* Originally, this is how many times we CAN jump.  */
7328            if (mcnt)            if (mcnt)
7329              {              {
7330                 mcnt--;                 mcnt--;
7331                 STORE_NUMBER (p + 2, mcnt);                 STORE_NUMBER (p + OFFSET_ADDRESS_SIZE, mcnt);
7332                 goto unconditional_jump;        
7333    #ifdef _LIBC
7334                   DEBUG_PRINT3 ("  Setting %p to %d.\n", p + OFFSET_ADDRESS_SIZE,
7335                                 mcnt);
7336    #else
7337                   DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p + OFFSET_ADDRESS_SIZE,
7338                                 mcnt);
7339    #endif /* _LIBC */
7340                   goto unconditional_jump;
7341              }              }
7342            /* If don't have to jump any more, skip over the rest of command.  */            /* If don't have to jump any more, skip over the rest of command.  */
7343            else                  else
7344              p += 4;                                p += 2 * OFFSET_ADDRESS_SIZE;
7345            break;            NEXT;
7346            
7347          case set_number_at:          CASE (set_number_at):
7348            {            {
7349              DEBUG_PRINT1 ("EXECUTING set_number_at.\n");              DEBUG_PRINT1 ("EXECUTING set_number_at.\n");
7350    
7351              EXTRACT_NUMBER_AND_INCR (mcnt, p);              EXTRACT_NUMBER_AND_INCR (mcnt, p);
7352              p1 = p + mcnt;              p1 = p + mcnt;
7353              EXTRACT_NUMBER_AND_INCR (mcnt, p);              EXTRACT_NUMBER_AND_INCR (mcnt, p);
7354    #ifdef _LIBC
7355                DEBUG_PRINT3 ("  Setting %p to %d.\n", p1, mcnt);
7356    #else
7357              DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p1, mcnt);              DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p1, mcnt);
7358    #endif
7359              STORE_NUMBER (p1, mcnt);              STORE_NUMBER (p1, mcnt);
7360              break;              NEXT;
7361            }            }
7362    
7363          case wordbound:  #if 0
7364            DEBUG_PRINT1 ("EXECUTING wordbound.\n");          /* The DEC Alpha C compiler 3.x generates incorrect code for the
7365            if (AT_WORD_BOUNDARY (d))             test  WORDCHAR_P (d - 1) != WORDCHAR_P (d)  in the expansion of
7366              break;             AT_WORD_BOUNDARY, so this code is disabled.  Expanding the
7367            goto fail;             macro and introducing temporary variables works around the bug.  */
7368    
7369          case notwordbound:          CASE (wordbound):
7370            DEBUG_PRINT1 ("EXECUTING notwordbound.\n");            DEBUG_PRINT1 ("EXECUTING wordbound.\n");
7371              if (AT_WORD_BOUNDARY (d))
7372                {
7373                  NEXT;
7374                }
7375              goto fail;
7376    
7377            CASE (notwordbound):
7378              DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
7379            if (AT_WORD_BOUNDARY (d))            if (AT_WORD_BOUNDARY (d))
7380              goto fail;              goto fail;
7381            break;            NEXT;
7382    #else
7383            CASE (wordbound):
7384            {
7385              boolean prevchar, thischar;
7386    
7387          case wordbeg:            DEBUG_PRINT1 ("EXECUTING wordbound.\n");
7388              if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
7389                {
7390                  NEXT;
7391                }
7392    
7393              prevchar = WORDCHAR_P (d - 1);
7394              thischar = WORDCHAR_P (d);
7395              if (prevchar != thischar)
7396                {
7397                  NEXT;
7398                }
7399              goto fail;
7400            }
7401    
7402          CASE (notwordbound):
7403            {
7404              boolean prevchar, thischar;
7405    
7406              DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
7407              if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
7408                goto fail;
7409    
7410              prevchar = WORDCHAR_P (d - 1);
7411              thischar = WORDCHAR_P (d);
7412              if (prevchar != thischar)
7413                goto fail;
7414              NEXT;
7415            }
7416    #endif
7417    
7418            CASE (wordbeg):
7419            DEBUG_PRINT1 ("EXECUTING wordbeg.\n");            DEBUG_PRINT1 ("EXECUTING wordbeg.\n");
7420            if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1)))            if (!AT_STRINGS_END (d) && WORDCHAR_P (d)
7421              break;                && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1)))
7422                {
7423                  NEXT;
7424                }
7425            goto fail;            goto fail;
7426    
7427          case wordend:          CASE (wordend):
7428            DEBUG_PRINT1 ("EXECUTING wordend.\n");            DEBUG_PRINT1 ("EXECUTING wordend.\n");
7429            if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1)            if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1)
7430                && (!WORDCHAR_P (d) || AT_STRINGS_END (d)))                && (AT_STRINGS_END (d) || !WORDCHAR_P (d)))
7431              break;              {
7432                  NEXT;
7433                }
7434            goto fail;            goto fail;
7435    
7436  #ifdef emacs  #ifdef emacs
7437          case before_dot:          CASE (before_dot):
7438            DEBUG_PRINT1 ("EXECUTING before_dot.\n");            DEBUG_PRINT1 ("EXECUTING before_dot.\n");
7439            if (PTR_CHAR_POS ((unsigned char *) d) >= point)            if (PTR_CHAR_POS ((unsigned char *) d) >= point)
7440              goto fail;              goto fail;
7441            break;            NEXT;
7442      
7443          case at_dot:          CASE (at_dot):
7444            DEBUG_PRINT1 ("EXECUTING at_dot.\n");            DEBUG_PRINT1 ("EXECUTING at_dot.\n");
7445            if (PTR_CHAR_POS ((unsigned char *) d) != point)            if (PTR_CHAR_POS ((unsigned char *) d) != point)
7446              goto fail;              goto fail;
7447            break;            NEXT;
7448      
7449          case after_dot:          CASE (after_dot):
7450            DEBUG_PRINT1 ("EXECUTING after_dot.\n");            DEBUG_PRINT1 ("EXECUTING after_dot.\n");
7451            if (PTR_CHAR_POS ((unsigned char *) d) <= point)            if (PTR_CHAR_POS ((unsigned char *) d) <= point)
7452              goto fail;              goto fail;
7453            break;            NEXT;
 #if 0 /* not emacs19 */  
         case at_dot:  
           DEBUG_PRINT1 ("EXECUTING at_dot.\n");  
           if (PTR_CHAR_POS ((unsigned char *) d) + 1 != point)  
             goto fail;  
           break;  
 #endif /* not emacs19 */  
7454    
7455          case syntaxspec:          CASE (syntaxspec):
7456            DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt);            DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt);
7457            mcnt = *p++;            mcnt = *p++;
7458            goto matchsyntax;            goto matchsyntax;
7459    
7460          case wordchar:          CASE (wordchar):
7461            DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n");            DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n");
7462            mcnt = (int) Sword;            mcnt = (int) Sword;
7463          matchsyntax:          matchsyntax:
# Line 4533  re_match_2_internal (bufp, string1, size Line 7467  re_match_2_internal (bufp, string1, size
7467            if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt)            if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt)
7468              goto fail;              goto fail;
7469            SET_REGS_MATCHED ();            SET_REGS_MATCHED ();
7470            break;            NEXT;
7471    
7472          case notsyntaxspec:          CASE (notsyntaxspec):
7473            DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt);            DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt);
7474            mcnt = *p++;            mcnt = *p++;
7475            goto matchnotsyntax;            goto matchnotsyntax;
7476    
7477          case notwordchar:          CASE (notwordchar):
7478            DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n");            DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n");
7479            mcnt = (int) Sword;            mcnt = (int) Sword;
7480          matchnotsyntax:          matchnotsyntax:
# Line 4550  re_match_2_internal (bufp, string1, size Line 7484  re_match_2_internal (bufp, string1, size
7484            if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt)            if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt)
7485              goto fail;              goto fail;
7486            SET_REGS_MATCHED ();            SET_REGS_MATCHED ();
7487            break;            NEXT;
7488    
7489  #else /* not emacs */  #else /* not emacs */
7490          case wordchar:          CASE (wordchar):
7491            DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n");            DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n");
7492            PREFETCH ();            PREFETCH ();
7493            if (!WORDCHAR_P (d))            if (!WORDCHAR_P (d))
7494              goto fail;              goto fail;
7495            SET_REGS_MATCHED ();            SET_REGS_MATCHED ();
7496            d++;            d++;
7497            break;            NEXT;
7498              
7499          case notwordchar:          CASE (notwordchar):
7500            DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");            DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");
7501            PREFETCH ();            PREFETCH ();
7502            if (WORDCHAR_P (d))            if (WORDCHAR_P (d))
7503              goto fail;              goto fail;
7504            SET_REGS_MATCHED ();            SET_REGS_MATCHED ();
7505            d++;            d++;
7506            break;            NEXT;
7507  #endif /* not emacs */  #endif /* not emacs */
7508              
7509    #ifndef __GNUC__
7510          default:          default:
7511            abort ();            abort ();
7512          }          }
7513        continue;  /* Successfully executed one pattern command; keep going.  */        continue;  /* Successfully executed one pattern command; keep going.  */
7514    #endif
7515    
7516    
7517      /* We goto here if a matching operation fails. */      /* We goto here if a matching operation fails. */
# Line 4596  re_match_2_internal (bufp, string1, size Line 7532  re_match_2_internal (bufp, string1, size
7532            if (p < pend)            if (p < pend)
7533              {              {
7534                boolean is_a_jump_n = false;                boolean is_a_jump_n = false;
7535                  
7536                /* If failed to a backwards jump that's part of a repetition                /* If failed to a backwards jump that's part of a repetition
7537                   loop, need to pop this failure point and use the next one.  */                   loop, need to pop this failure point and use the next one.  */
7538                switch ((re_opcode_t) *p)                switch ((re_opcode_t) *p)
# Line 4608  re_match_2_internal (bufp, string1, size Line 7544  re_match_2_internal (bufp, string1, size
7544                  case jump:                  case jump:
7545                    p1 = p + 1;                    p1 = p + 1;
7546                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);
7547                    p1 += mcnt;                      p1 += mcnt;
7548    
7549                    if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)                    if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)
7550                        || (!is_a_jump_n                        || (!is_a_jump_n
# Line 4639  re_match_2_internal (bufp, string1, size Line 7575  re_match_2_internal (bufp, string1, size
7575    
7576    
7577  /* We are passed P pointing to a register number after a start_memory.  /* We are passed P pointing to a register number after a start_memory.
7578      
7579     Return true if the pattern up to the corresponding stop_memory can     Return true if the pattern up to the corresponding stop_memory can
7580     match the empty string, and false otherwise.     match the empty string, and false otherwise.
7581      
7582     If we find the matching stop_memory, sets P to point to one past its number.     If we find the matching stop_memory, sets P to point to one past its number.
7583     Otherwise, sets P to an undefined byte less than or equal to END.     Otherwise, sets P to an undefined byte less than or equal to END.
7584    
7585     We don't handle duplicates properly (yet).  */     We don't handle duplicates properly (yet).  */
7586    
7587  static boolean  static boolean
7588  group_match_null_string_p (p, end, reg_info)  PREFIX(group_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
7589      unsigned char **p, *end;                                     PREFIX(register_info_type) *reg_info)
     register_info_type *reg_info;  
7590  {  {
7591    int mcnt;    int mcnt;
7592    /* Point to after the args to the start_memory.  */    /* Point to after the args to the start_memory.  */
7593    unsigned char *p1 = *p + 2;    UCHAR_T *p1 = *p + 2;
7594      
7595    while (p1 < end)    while (p1 < end)
7596      {      {
7597        /* Skip over opcodes that can match nothing, and return true or        /* Skip over opcodes that can match nothing, and return true or
7598           false, as appropriate, when we get to one that can't, or to the           false, as appropriate, when we get to one that can't, or to the
7599           matching stop_memory.  */           matching stop_memory.  */
7600          
7601        switch ((re_opcode_t) *p1)        switch ((re_opcode_t) *p1)
7602          {          {
7603          /* Could be either a loop or a series of alternatives.  */          /* Could be either a loop or a series of alternatives.  */
7604          case on_failure_jump:          case on_failure_jump:
7605            p1++;            p1++;
7606            EXTRACT_NUMBER_AND_INCR (mcnt, p1);            EXTRACT_NUMBER_AND_INCR (mcnt, p1);
7607              
7608            /* If the next operation is not a jump backwards in the            /* If the next operation is not a jump backwards in the
7609               pattern.  */               pattern.  */
7610    
# Line 4683  group_match_null_string_p (p, end, reg_i Line 7618  group_match_null_string_p (p, end, reg_i
7618    
7619                   /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6                   /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6
7620                   /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3                   /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3
7621                   /exactn/1/c                                                               /exactn/1/c
7622    
7623                   So, we have to first go through the first (n-1)                   So, we have to first go through the first (n-1)
7624                   alternatives and then deal with the last one separately.  */                   alternatives and then deal with the last one separately.  */
# Line 4693  group_match_null_string_p (p, end, reg_i Line 7628  group_match_null_string_p (p, end, reg_i
7628                   with an on_failure_jump (see above) that jumps to right                   with an on_failure_jump (see above) that jumps to right
7629                   past a jump_past_alt.  */                   past a jump_past_alt.  */
7630    
7631                while ((re_opcode_t) p1[mcnt-3] == jump_past_alt)                while ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] ==
7632                         jump_past_alt)
7633                  {                  {
7634                    /* `mcnt' holds how many bytes long the alternative                    /* `mcnt' holds how many bytes long the alternative
7635                       is, including the ending `jump_past_alt' and                       is, including the ending `jump_past_alt' and
7636                       its number.  */                       its number.  */
7637    
7638                    if (!alt_match_null_string_p (p1, p1 + mcnt - 3,                    if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt -
7639                                                        reg_info))                                                  (1 + OFFSET_ADDRESS_SIZE),
7640                                                    reg_info))
7641                      return false;                      return false;
7642    
7643                    /* Move to right after this alternative, including the                    /* Move to right after this alternative, including the
7644                       jump_past_alt.  */                       jump_past_alt.  */
7645                    p1 += mcnt;                      p1 += mcnt;
7646    
7647                    /* Break if it's the beginning of an n-th alternative                    /* Break if it's the beginning of an n-th alternative
7648                       that doesn't begin with an on_failure_jump.  */                       that doesn't begin with an on_failure_jump.  */
7649                    if ((re_opcode_t) *p1 != on_failure_jump)                    if ((re_opcode_t) *p1 != on_failure_jump)
7650                      break;                      break;
7651                    
7652                    /* Still have to check that it's not an n-th                    /* Still have to check that it's not an n-th
7653                       alternative that starts with an on_failure_jump.  */                       alternative that starts with an on_failure_jump.  */
7654                    p1++;                    p1++;
7655                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);
7656                    if ((re_opcode_t) p1[mcnt-3] != jump_past_alt)                    if ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] !=
7657                          jump_past_alt)
7658                      {                      {
7659                        /* Get to the beginning of the n-th alternative.  */                        /* Get to the beginning of the n-th alternative.  */
7660                        p1 -= 3;                        p1 -= 1 + OFFSET_ADDRESS_SIZE;
7661                        break;                        break;
7662                      }                      }
7663                  }                  }
# Line 4727  group_match_null_string_p (p, end, reg_i Line 7665  group_match_null_string_p (p, end, reg_i
7665                /* Deal with the last alternative: go back and get number                /* Deal with the last alternative: go back and get number
7666                   of the `jump_past_alt' just before it.  `mcnt' contains                   of the `jump_past_alt' just before it.  `mcnt' contains
7667                   the length of the alternative.  */                   the length of the alternative.  */
7668                EXTRACT_NUMBER (mcnt, p1 - 2);                EXTRACT_NUMBER (mcnt, p1 - OFFSET_ADDRESS_SIZE);
7669    
7670                if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info))                if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt, reg_info))
7671                  return false;                  return false;
7672    
7673                p1 += mcnt;       /* Get past the n-th alternative.  */                p1 += mcnt;       /* Get past the n-th alternative.  */
7674              } /* if mcnt > 0 */              } /* if mcnt > 0 */
7675            break;            break;
7676    
7677              
7678          case stop_memory:          case stop_memory:
7679            assert (p1[1] == **p);            assert (p1[1] == **p);
7680            *p = p1 + 2;            *p = p1 + 2;
7681            return true;            return true;
7682    
7683            
7684          default:          default:
7685            if (!common_op_match_null_string_p (&p1, end, reg_info))            if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
7686              return false;              return false;
7687          }          }
7688      } /* while p1 < end */      } /* while p1 < end */
# Line 4756  group_match_null_string_p (p, end, reg_i Line 7694  group_match_null_string_p (p, end, reg_i
7694  /* Similar to group_match_null_string_p, but doesn't deal with alternatives:  /* Similar to group_match_null_string_p, but doesn't deal with alternatives:
7695     It expects P to be the first byte of a single alternative and END one     It expects P to be the first byte of a single alternative and END one
7696     byte past the last. The alternative can contain groups.  */     byte past the last. The alternative can contain groups.  */
7697      
7698  static boolean  static boolean
7699  alt_match_null_string_p (p, end, reg_info)  PREFIX(alt_match_null_string_p) (UCHAR_T *p, UCHAR_T *end,
7700      unsigned char *p, *end;                                   PREFIX(register_info_type) *reg_info)
     register_info_type *reg_info;  
7701  {  {
7702    int mcnt;    int mcnt;
7703    unsigned char *p1 = p;    UCHAR_T *p1 = p;
7704      
7705    while (p1 < end)    while (p1 < end)
7706      {      {
7707        /* Skip over opcodes that can match nothing, and break when we get        /* Skip over opcodes that can match nothing, and break when we get
7708           to one that can't.  */           to one that can't.  */
7709          
7710        switch ((re_opcode_t) *p1)        switch ((re_opcode_t) *p1)
7711          {          {
7712          /* It's a loop.  */          /* It's a loop.  */
# Line 4778  alt_match_null_string_p (p, end, reg_inf Line 7715  alt_match_null_string_p (p, end, reg_inf
7715            EXTRACT_NUMBER_AND_INCR (mcnt, p1);            EXTRACT_NUMBER_AND_INCR (mcnt, p1);
7716            p1 += mcnt;            p1 += mcnt;
7717            break;            break;
7718              
7719          default:          default:
7720            if (!common_op_match_null_string_p (&p1, end, reg_info))            if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
7721              return false;              return false;
7722          }          }
7723      }  /* while p1 < end */      }  /* while p1 < end */
# Line 4790  alt_match_null_string_p (p, end, reg_inf Line 7727  alt_match_null_string_p (p, end, reg_inf
7727    
7728    
7729  /* Deals with the ops common to group_match_null_string_p and  /* Deals with the ops common to group_match_null_string_p and
7730     alt_match_null_string_p.       alt_match_null_string_p.
7731      
7732     Sets P to one after the op and its arguments, if any.  */     Sets P to one after the op and its arguments, if any.  */
7733    
7734  static boolean  static boolean
7735  common_op_match_null_string_p (p, end, reg_info)  PREFIX(common_op_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
7736      unsigned char **p, *end;                                         PREFIX(register_info_type) *reg_info)
     register_info_type *reg_info;  
7737  {  {
7738    int mcnt;    int mcnt;
7739    boolean ret;    boolean ret;
7740    int reg_no;    int reg_no;
7741    unsigned char *p1 = *p;    UCHAR_T *p1 = *p;
7742    
7743    switch ((re_opcode_t) *p1++)    switch ((re_opcode_t) *p1++)
7744      {      {
# Line 4825  common_op_match_null_string_p (p, end, r Line 7761  common_op_match_null_string_p (p, end, r
7761      case start_memory:      case start_memory:
7762        reg_no = *p1;        reg_no = *p1;
7763        assert (reg_no > 0 && reg_no <= MAX_REGNUM);        assert (reg_no > 0 && reg_no <= MAX_REGNUM);
7764        ret = group_match_null_string_p (&p1, end, reg_info);        ret = PREFIX(group_match_null_string_p) (&p1, end, reg_info);
7765          
7766        /* Have to set this here in case we're checking a group which        /* Have to set this here in case we're checking a group which
7767           contains a group and a back reference to it.  */           contains a group and a back reference to it.  */
7768    
# Line 4836  common_op_match_null_string_p (p, end, r Line 7772  common_op_match_null_string_p (p, end, r
7772        if (!ret)        if (!ret)
7773          return false;          return false;
7774        break;        break;
7775              
7776      /* If this is an optimized succeed_n for zero times, make the jump.  */      /* If this is an optimized succeed_n for zero times, make the jump.  */
7777      case jump:      case jump:
7778        EXTRACT_NUMBER_AND_INCR (mcnt, p1);        EXTRACT_NUMBER_AND_INCR (mcnt, p1);
# Line 4848  common_op_match_null_string_p (p, end, r Line 7784  common_op_match_null_string_p (p, end, r
7784    
7785      case succeed_n:      case succeed_n:
7786        /* Get to the number of times to succeed.  */        /* Get to the number of times to succeed.  */
7787        p1 += 2;                  p1 += OFFSET_ADDRESS_SIZE;
7788        EXTRACT_NUMBER_AND_INCR (mcnt, p1);        EXTRACT_NUMBER_AND_INCR (mcnt, p1);
7789    
7790        if (mcnt == 0)        if (mcnt == 0)
7791          {          {
7792            p1 -= 4;            p1 -= 2 * OFFSET_ADDRESS_SIZE;
7793            EXTRACT_NUMBER_AND_INCR (mcnt, p1);            EXTRACT_NUMBER_AND_INCR (mcnt, p1);
7794            p1 += mcnt;            p1 += mcnt;
7795          }          }
# Line 4861  common_op_match_null_string_p (p, end, r Line 7797  common_op_match_null_string_p (p, end, r
7797          return false;          return false;
7798        break;        break;
7799    
7800      case duplicate:      case duplicate:
7801        if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))        if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))
7802          return false;          return false;
7803        break;        break;
7804    
7805      case set_number_at:      case set_number_at:
7806        p1 += 4;        p1 += 2 * OFFSET_ADDRESS_SIZE;
7807    
7808      default:      default:
7809        /* All other opcodes mean we cannot match the empty string.  */        /* All other opcodes mean we cannot match the empty string.  */
# Line 4881  common_op_match_null_string_p (p, end, r Line 7817  common_op_match_null_string_p (p, end, r
7817    
7818  /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN  /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
7819     bytes; nonzero otherwise.  */     bytes; nonzero otherwise.  */
7820      
7821  static int  static int
7822  bcmp_translate (s1, s2, len, translate)  PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2,
7823       unsigned char *s1, *s2;                          register int len,
7824       register int len;                          RE_TRANSLATE_TYPE translate)
      char *translate;  
7825  {  {
7826    register unsigned char *p1 = s1, *p2 = s2;    register const UCHAR_T *p1 = (const UCHAR_T *) s1;
7827      register const UCHAR_T *p2 = (const UCHAR_T *) s2;
7828    while (len)    while (len)
7829      {      {
7830    #ifdef WCHAR
7831          if (((*p1<=0xff)?translate[*p1++]:*p1++)
7832              != ((*p2<=0xff)?translate[*p2++]:*p2++))
7833            return 1;
7834    #else /* BYTE */
7835        if (translate[*p1++] != translate[*p2++]) return 1;        if (translate[*p1++] != translate[*p2++]) return 1;
7836    #endif /* WCHAR */
7837        len--;        len--;
7838      }      }
7839    return 0;    return 0;
7840  }  }
7841    
7842    
7843    #else /* not INSIDE_RECURSION */
7844    
7845  /* Entry points for GNU code.  */  /* Entry points for GNU code.  */
7846    
7847  /* re_compile_pattern is the GNU regular expression compiler: it  /* re_compile_pattern is the GNU regular expression compiler: it
7848     compiles PATTERN (of length SIZE) and puts the result in BUFP.     compiles PATTERN (of length SIZE) and puts the result in BUFP.
7849     Returns 0 if the pattern was valid, otherwise an error string.     Returns 0 if the pattern was valid, otherwise an error string.
7850      
7851     Assumes the `allocated' (and perhaps `buffer') and `translate' fields     Assumes the `allocated' (and perhaps `buffer') and `translate' fields
7852     are set in BUFP on entry.     are set in BUFP on entry.
7853      
7854     We call regex_compile to do the actual compilation.  */     We call regex_compile to do the actual compilation.  */
7855    
7856  const char *  const char *
7857  re_compile_pattern (pattern, length, bufp)  re_compile_pattern (const char *pattern,
7858       const char *pattern;                      size_t length,
7859       int length;                      struct re_pattern_buffer *bufp)
      struct re_pattern_buffer *bufp;  
7860  {  {
7861    reg_errcode_t ret;    reg_errcode_t ret;
7862      
7863    /* GNU code is written to assume at least RE_NREGS registers will be set    /* GNU code is written to assume at least RE_NREGS registers will be set
7864       (and at least one extra will be -1).  */       (and at least one extra will be -1).  */
7865    bufp->regs_allocated = REGS_UNALLOCATED;    bufp->regs_allocated = REGS_UNALLOCATED;
7866      
7867    /* And GNU code determines whether or not to get register information    /* And GNU code determines whether or not to get register information
7868       by passing null for the REGS argument to re_match, etc., not by       by passing null for the REGS argument to re_match, etc., not by
7869       setting no_sub.  */       setting no_sub.  */
7870    bufp->no_sub = 0;    bufp->no_sub = 0;
7871      
7872    /* Match anchors at newline.  */    /* Match anchors at newline.  */
7873    bufp->newline_anchor = 1;    bufp->newline_anchor = 1;
     
   ret = regex_compile (pattern, length, re_syntax_options, bufp);  
7874    
7875    return re_error_msg[(int) ret];  # ifdef MBS_SUPPORT
7876  }        if (MB_CUR_MAX != 1)
7877        ret = wcs_regex_compile (pattern, length, re_syntax_options, bufp);
7878      else
7879    # endif
7880        ret = byte_regex_compile (pattern, length, re_syntax_options, bufp);
7881    
7882      if (!ret)
7883        return NULL;
7884      return gettext (re_error_msgid + re_error_msgid_idx[(int) ret]);
7885    }
7886    #ifdef _LIBC
7887    weak_alias (__re_compile_pattern, re_compile_pattern)
7888    #endif
7889    
7890  /* Entry points compatible with 4.2 BSD regex library.  We don't define  /* Entry points compatible with 4.2 BSD regex library.  We don't define
7891     them unless specifically requested.  */     them unless specifically requested.  */
7892    
7893  #ifdef _REGEX_RE_COMP  #if defined _REGEX_RE_COMP || defined _LIBC
7894    
7895  /* BSD has one and only one pattern buffer.  */  /* BSD has one and only one pattern buffer.  */
7896  static struct re_pattern_buffer re_comp_buf;  static struct re_pattern_buffer re_comp_buf;
7897    
7898  char *  char *
7899  re_comp (s)  #ifdef _LIBC
7900      const char *s;  /* Make these definitions weak in libc, so POSIX programs can redefine
7901       these names if they don't use our functions, and still use
7902       regcomp/regexec below without link errors.  */
7903    weak_function
7904    #endif
7905    re_comp (const char *s)
7906  {  {
7907    reg_errcode_t ret;    reg_errcode_t ret;
7908      
7909    if (!s)    if (!s)
7910      {      {
7911        if (!re_comp_buf.buffer)        if (!re_comp_buf.buffer)
7912          return "No previous regular expression";          return (char *) gettext ("No previous regular expression");
7913        return 0;        return 0;
7914      }      }
7915    
7916    if (!re_comp_buf.buffer)    if (!re_comp_buf.buffer)
7917      {      {
7918        re_comp_buf.buffer = (unsigned char *) malloc (200);        re_comp_buf.buffer = malloc (200);
7919        if (re_comp_buf.buffer == NULL)        if (re_comp_buf.buffer == NULL)
7920          return "Memory exhausted";          return (char *) gettext (re_error_msgid
7921                                     + re_error_msgid_idx[(int) REG_ESPACE]);
7922        re_comp_buf.allocated = 200;        re_comp_buf.allocated = 200;
7923    
7924        re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);        re_comp_buf.fastmap = malloc (1 << BYTEWIDTH);
7925        if (re_comp_buf.fastmap == NULL)        if (re_comp_buf.fastmap == NULL)
7926          return "Memory exhausted";          return (char *) gettext (re_error_msgid
7927                                     + re_error_msgid_idx[(int) REG_ESPACE]);
7928      }      }
7929    
7930    /* Since `re_exec' always passes NULL for the `regs' argument, we    /* Since `re_exec' always passes NULL for the `regs' argument, we
# Line 4972  re_comp (s) Line 7933  re_comp (s)
7933    /* Match anchors at newlines.  */    /* Match anchors at newlines.  */
7934    re_comp_buf.newline_anchor = 1;    re_comp_buf.newline_anchor = 1;
7935    
7936    ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);  # ifdef MBS_SUPPORT
7937        if (MB_CUR_MAX != 1)
7938    /* Yes, we're discarding `const' here.  */      ret = wcs_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
7939    return (char *) re_error_msg[(int) ret];    else
7940    # endif
7941        ret = byte_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
7942    
7943      if (!ret)
7944        return NULL;
7945    
7946      /* Yes, we're discarding `const' here if !HAVE_LIBINTL.  */
7947      return (char *) gettext (re_error_msgid + re_error_msgid_idx[(int) ret]);
7948  }  }
7949    
7950    
7951  int  int
7952  re_exec (s)  #ifdef _LIBC
7953      const char *s;  weak_function
7954    #endif
7955    re_exec (const char *s)
7956  {  {
7957    const int len = strlen (s);    const int len = strlen (s);
7958    return    return
7959      0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);      0 <= re_search (&re_comp_buf, s, len, 0, len, 0);
7960  }  }
7961    
7962  #endif /* _REGEX_RE_COMP */  #endif /* _REGEX_RE_COMP */
7963    
7964  /* POSIX.2 functions.  Don't define these for Emacs.  */  /* POSIX.2 functions.  Don't define these for Emacs.  */
# Line 5004  re_exec (s) Line 7976  re_exec (s)
7976         REG_EXTENDED bit in CFLAGS is set; otherwise, to         REG_EXTENDED bit in CFLAGS is set; otherwise, to
7977         RE_SYNTAX_POSIX_BASIC;         RE_SYNTAX_POSIX_BASIC;
7978       `newline_anchor' to REG_NEWLINE being set in CFLAGS;       `newline_anchor' to REG_NEWLINE being set in CFLAGS;
7979       `fastmap' and `fastmap_accurate' to zero;       `fastmap' to an allocated space for the fastmap;
7980         `fastmap_accurate' to zero;
7981       `re_nsub' to the number of subexpressions in PATTERN.       `re_nsub' to the number of subexpressions in PATTERN.
7982    
7983     PATTERN is the address of the pattern string.     PATTERN is the address of the pattern string.
# Line 5028  re_exec (s) Line 8001  re_exec (s)
8001     the return codes and their meanings.)  */     the return codes and their meanings.)  */
8002    
8003  int  int
8004  regcomp (preg, pattern, cflags)  regcomp (regex_t *preg, const char *pattern, int cflags)
     regex_t *preg;  
     const char *pattern;  
     int cflags;  
8005  {  {
8006    reg_errcode_t ret;    reg_errcode_t ret;
8007    unsigned syntax    reg_syntax_t syntax
8008      = (cflags & REG_EXTENDED) ?      = (cflags & REG_EXTENDED) ?
8009        RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;        RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;
8010    
# Line 5042  regcomp (preg, pattern, cflags) Line 8012  regcomp (preg, pattern, cflags)
8012    preg->buffer = 0;    preg->buffer = 0;
8013    preg->allocated = 0;    preg->allocated = 0;
8014    preg->used = 0;    preg->used = 0;
8015      
8016    /* Don't bother to use a fastmap when searching.  This simplifies the    /* Try to allocate space for the fastmap.  */
8017       REG_NEWLINE case: if we used a fastmap, we'd have to put all the    preg->fastmap = malloc (1 << BYTEWIDTH);
8018       characters after newlines into the fastmap.  This way, we just try  
      every character.  */  
   preg->fastmap = 0;  
     
8019    if (cflags & REG_ICASE)    if (cflags & REG_ICASE)
8020      {      {
8021        unsigned i;        unsigned i;
8022          
8023        preg->translate = (char *) malloc (CHAR_SET_SIZE);        preg->translate = malloc (CHAR_SET_SIZE
8024                                    * sizeof (*(RE_TRANSLATE_TYPE)0));
8025        if (preg->translate == NULL)        if (preg->translate == NULL)
8026          return (int) REG_ESPACE;          return (int) REG_ESPACE;
8027    
8028        /* Map uppercase characters to corresponding lowercase ones.  */        /* Map uppercase characters to corresponding lowercase ones.  */
8029        for (i = 0; i < CHAR_SET_SIZE; i++)        for (i = 0; i < CHAR_SET_SIZE; i++)
8030          preg->translate[i] = ISUPPER (i) ? tolower (i) : i;          preg->translate[i] = ISUPPER (i) ? TOLOWER (i) : i;
8031      }      }
8032    else    else
8033      preg->translate = NULL;      preg->translate = NULL;
# Line 5077  regcomp (preg, pattern, cflags) Line 8045  regcomp (preg, pattern, cflags)
8045    
8046    preg->no_sub = !!(cflags & REG_NOSUB);    preg->no_sub = !!(cflags & REG_NOSUB);
8047    
8048    /* POSIX says a null character in the pattern terminates it, so we    /* POSIX says a null character in the pattern terminates it, so we
8049       can use strlen here in compiling the pattern.  */       can use strlen here in compiling the pattern.  */
8050    ret = regex_compile (pattern, strlen (pattern), syntax, preg);  # ifdef MBS_SUPPORT
8051        if (MB_CUR_MAX != 1)
8052        ret = wcs_regex_compile (pattern, strlen (pattern), syntax, preg);
8053      else
8054    # endif
8055        ret = byte_regex_compile (pattern, strlen (pattern), syntax, preg);
8056    
8057    /* POSIX doesn't distinguish between an unmatched open-group and an    /* POSIX doesn't distinguish between an unmatched open-group and an
8058       unmatched close-group: both are REG_EPAREN.  */       unmatched close-group: both are REG_EPAREN.  */
8059    if (ret == REG_ERPAREN) ret = REG_EPAREN;    if (ret == REG_ERPAREN) ret = REG_EPAREN;
8060      
8061      if (ret == REG_NOERROR && preg->fastmap)
8062        {
8063          /* Compute the fastmap now, since regexec cannot modify the pattern
8064             buffer.  */
8065          if (re_compile_fastmap (preg) == -2)
8066            {
8067              /* Some error occurred while computing the fastmap, just forget
8068                 about it.  */
8069              free (preg->fastmap);
8070              preg->fastmap = NULL;
8071            }
8072        }
8073    
8074    return (int) ret;    return (int) ret;
8075  }  }
8076    #ifdef _LIBC
8077    weak_alias (__regcomp, regcomp)
8078    #endif
8079    
8080    
8081  /* regexec searches for a given pattern, specified by PREG, in the  /* regexec searches for a given pattern, specified by PREG, in the
8082     string STRING.     string STRING.
8083      
8084     If NMATCH is zero or REG_NOSUB was set in the cflags argument to     If NMATCH is zero or REG_NOSUB was set in the cflags argument to
8085     `regcomp', we ignore PMATCH.  Otherwise, we assume PMATCH has at     `regcomp', we ignore PMATCH.  Otherwise, we assume PMATCH has at
8086     least NMATCH elements, and we set them to the offsets of the     least NMATCH elements, and we set them to the offsets of the
8087     corresponding matched substrings.     corresponding matched substrings.
8088      
8089     EFLAGS specifies `execution flags' which affect matching: if     EFLAGS specifies `execution flags' which affect matching: if
8090     REG_NOTBOL is set, then ^ does not match at the beginning of the     REG_NOTBOL is set, then ^ does not match at the beginning of the
8091     string; if REG_NOTEOL is set, then $ does not match at the end.     string; if REG_NOTEOL is set, then $ does not match at the end.
8092      
8093     We return 0 if we find a match and REG_NOMATCH if not.  */     We return 0 if we find a match and REG_NOMATCH if not.  */
8094    
8095  int  int
8096  regexec (preg, string, nmatch, pmatch, eflags)  regexec (const regex_t *preg, const char *string,
8097      const regex_t *preg;           size_t nmatch, regmatch_t pmatch[], int eflags)
     const char *string;  
     size_t nmatch;  
     regmatch_t pmatch[];  
     int eflags;  
8098  {  {
8099    int ret;    int ret;
8100    struct re_registers regs;    struct re_registers regs;
# Line 5118  regexec (preg, string, nmatch, pmatch, e Line 8103  regexec (preg, string, nmatch, pmatch, e
8103    boolean want_reg_info = !preg->no_sub && nmatch > 0;    boolean want_reg_info = !preg->no_sub && nmatch > 0;
8104    
8105    private_preg = *preg;    private_preg = *preg;
8106      
8107    private_preg.not_bol = !!(eflags & REG_NOTBOL);    private_preg.not_bol = !!(eflags & REG_NOTBOL);
8108    private_preg.not_eol = !!(eflags & REG_NOTEOL);    private_preg.not_eol = !!(eflags & REG_NOTEOL);
8109      
8110    /* The user has told us exactly how many registers to return    /* The user has told us exactly how many registers to return
8111       information about, via `nmatch'.  We have to pass that on to the       information about, via `nmatch'.  We have to pass that on to the
8112       matching routines.  */       matching routines.  */
8113    private_preg.regs_allocated = REGS_FIXED;    private_preg.regs_allocated = REGS_FIXED;
8114      
8115    if (want_reg_info)    if (want_reg_info)
8116      {      {
8117        regs.num_regs = nmatch;        regs.num_regs = nmatch;
8118        regs.start = TALLOC (nmatch, regoff_t);        regs.start = TALLOC (nmatch * 2, regoff_t);
8119        regs.end = TALLOC (nmatch, regoff_t);        if (regs.start == NULL)
       if (regs.start == NULL || regs.end == NULL)  
8120          return (int) REG_NOMATCH;          return (int) REG_NOMATCH;
8121          regs.end = regs.start + nmatch;
8122      }      }
8123    
8124    /* Perform the searching operation.  */    /* Perform the searching operation.  */
8125    ret = re_search (&private_preg, string, len,    ret = re_search (&private_preg, string, len,
8126                     /* start: */ 0, /* range: */ len,                     /* start: */ 0, /* range: */ len,
8127                     want_reg_info ? &regs : (struct re_registers *) 0);                     want_reg_info ? &regs : 0);
8128      
8129    /* Copy the register information to the POSIX structure.  */    /* Copy the register information to the POSIX structure.  */
8130    if (want_reg_info)    if (want_reg_info)
8131      {      {
# Line 5157  regexec (preg, string, nmatch, pmatch, e Line 8142  regexec (preg, string, nmatch, pmatch, e
8142    
8143        /* If we needed the temporary register info, free the space now.  */        /* If we needed the temporary register info, free the space now.  */
8144        free (regs.start);        free (regs.start);
       free (regs.end);  
8145      }      }
8146    
8147    /* We want zero return to mean success, unlike `re_search'.  */    /* We want zero return to mean success, unlike `re_search'.  */
8148    return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;    return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
8149  }  }
8150    #ifdef _LIBC
8151    weak_alias (__regexec, regexec)
8152    #endif
8153    
8154    
8155  /* Returns a message corresponding to an error code, ERRCODE, returned  /* Returns a message corresponding to an error code, ERRCODE, returned
8156     from either regcomp or regexec.   We don't use PREG here.  */     from either regcomp or regexec.   We don't use PREG here.  */
8157    
8158  size_t  size_t
8159  regerror (errcode, preg, errbuf, errbuf_size)  regerror (int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
     int errcode;  
     const regex_t *preg;  
     char *errbuf;  
     size_t errbuf_size;  
8160  {  {
8161    const char *msg;    const char *msg;
8162    size_t msg_size;    size_t msg_size;
8163    
8164    if (errcode < 0    if (errcode < 0
8165        || errcode >= (sizeof (re_error_msg) / sizeof (re_error_msg[0])))        || errcode >= (int) (sizeof (re_error_msgid_idx)
8166      /* Only error codes returned by the rest of the code should be passed                             / sizeof (re_error_msgid_idx[0])))
8167        /* Only error codes returned by the rest of the code should be passed
8168         to this routine.  If we are given anything else, or if other regex         to this routine.  If we are given anything else, or if other regex
8169         code generates an invalid error code, then the program has a bug.         code generates an invalid error code, then the program has a bug.
8170         Dump core so we can fix it.  */         Dump core so we can fix it.  */
8171      abort ();      abort ();
8172    
8173    msg = re_error_msg[errcode];    msg = gettext (re_error_msgid + re_error_msgid_idx[errcode]);
   
   /* POSIX doesn't require that we do anything in this case, but why  
      not be nice.  */  
   if (! msg)  
     msg = "Success";  
8174    
8175    msg_size = strlen (msg) + 1; /* Includes the null.  */    msg_size = strlen (msg) + 1; /* Includes the null.  */
8176      
8177    if (errbuf_size != 0)    if (errbuf_size != 0)
8178      {      {
8179        if (msg_size > errbuf_size)        if (msg_size > errbuf_size)
8180          {          {
8181            strncpy (errbuf, msg, errbuf_size - 1);  #if defined HAVE_MEMPCPY || defined _LIBC
8182              *((char *) __mempcpy (errbuf, msg, errbuf_size - 1)) = '\0';
8183    #else
8184              memcpy (errbuf, msg, errbuf_size - 1);
8185            errbuf[errbuf_size - 1] = 0;            errbuf[errbuf_size - 1] = 0;
8186    #endif
8187          }          }
8188        else        else
8189          strcpy (errbuf, msg);          memcpy (errbuf, msg, msg_size);
8190      }      }
8191    
8192    return msg_size;    return msg_size;
8193  }  }
8194    #ifdef _LIBC
8195    weak_alias (__regerror, regerror)
8196    #endif
8197    
8198    
8199  /* Free dynamically allocated space used by PREG.  */  /* Free dynamically allocated space used by PREG.  */
8200    
8201  void  void
8202  regfree (preg)  regfree (regex_t *preg)
     regex_t *preg;  
8203  {  {
8204    if (preg->buffer != NULL)    if (preg->buffer != NULL)
8205      free (preg->buffer);      free (preg->buffer);
8206    preg->buffer = NULL;    preg->buffer = NULL;
8207      
8208    preg->allocated = 0;    preg->allocated = 0;
8209    preg->used = 0;    preg->used = 0;
8210    
# Line 5232  regfree (preg) Line 8217  regfree (preg)
8217      free (preg->translate);      free (preg->translate);
8218    preg->translate = NULL;    preg->translate = NULL;
8219  }  }
8220    #ifdef _LIBC
8221    weak_alias (__regfree, regfree)
8222    #endif
8223    
8224  #endif /* not emacs  */  #endif /* not emacs  */
8225    
8226    #endif /* not INSIDE_RECURSION */
8227    
8228    
8229  /*  #undef STORE_NUMBER
8230  Local variables:  #undef STORE_NUMBER_AND_INCR
8231  make-backup-files: t  #undef EXTRACT_NUMBER
8232  version-control: t  #undef EXTRACT_NUMBER_AND_INCR
8233  trim-versions-without-asking: nil  
8234  End:  #undef DEBUG_PRINT_COMPILED_PATTERN
8235  */  #undef DEBUG_PRINT_DOUBLE_STRING
8236    
8237    #undef INIT_FAIL_STACK
8238    #undef RESET_FAIL_STACK
8239    #undef DOUBLE_FAIL_STACK
8240    #undef PUSH_PATTERN_OP
8241    #undef PUSH_FAILURE_POINTER
8242    #undef PUSH_FAILURE_INT
8243    #undef PUSH_FAILURE_ELT
8244    #undef POP_FAILURE_POINTER
8245    #undef POP_FAILURE_INT
8246    #undef POP_FAILURE_ELT
8247    #undef DEBUG_PUSH
8248    #undef DEBUG_POP
8249    #undef PUSH_FAILURE_POINT
8250    #undef POP_FAILURE_POINT
8251    
8252    #undef REG_UNSET_VALUE
8253    #undef REG_UNSET
8254    
8255    #undef PATFETCH
8256    #undef PATFETCH_RAW
8257    #undef PATUNFETCH
8258    #undef TRANSLATE
8259    
8260    #undef INIT_BUF_SIZE
8261    #undef GET_BUFFER_SPACE
8262    #undef BUF_PUSH
8263    #undef BUF_PUSH_2
8264    #undef BUF_PUSH_3
8265    #undef STORE_JUMP
8266    #undef STORE_JUMP2
8267    #undef INSERT_JUMP
8268    #undef INSERT_JUMP2
8269    #undef EXTEND_BUFFER
8270    #undef GET_UNSIGNED_NUMBER
8271    #undef FREE_STACK_RETURN
8272    
8273    # undef POINTER_TO_OFFSET
8274    # undef MATCHING_IN_FRST_STRING
8275    # undef PREFETCH
8276    # undef AT_STRINGS_BEG
8277    # undef AT_STRINGS_END
8278    # undef WORDCHAR_P
8279    # undef FREE_VAR
8280    # undef FREE_VARIABLES
8281    # undef NO_HIGHEST_ACTIVE_REG
8282    # undef NO_LOWEST_ACTIVE_REG
8283    
8284    # undef CHAR_T
8285    # undef UCHAR_T
8286    # undef COMPILED_BUFFER_VAR
8287    # undef OFFSET_ADDRESS_SIZE
8288    # undef CHAR_CLASS_SIZE
8289    # undef PREFIX
8290    # undef ARG_PREFIX
8291    # undef PUT_CHAR
8292    # undef BYTE
8293    # undef WCHAR
8294    
8295    # define DEFINED_ONCE

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.1.2.1

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26