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