regex.c File Reference

#include <sys/types.h>
#include <string.h>
#include <regex.h>
#include <ctype.h>
#include "regex.c"

Include dependency graph for regex.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	_GNU_SOURCE
#define	BYTE
#define	BYTEWIDTH   8 /* In bits. */
#define	bzero(s, n)   (memset (s, '\0', n), (s))
#define	CHAR_SET_SIZE   256
#define	DEFINED_ONCE
#define	false   0
#define	FIRST_STRING_P(ptr)   (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
#define	gettext(msgid)   (msgid)
#define	gettext_noop(String)   String
#define	HAVE_STRING_H
#define	HAVE_UINTPTR_T
#define	INSIDE_RECURSION
#define	ISALNUM(c)   (ISASCII (c) && isalnum (c))
#define	ISALPHA(c)   (ISASCII (c) && isalpha (c))
#define	ISASCII(c)   1
#define	ISBLANK(c)   ((c) == ' ' || (c) == '\t')
#define	ISCNTRL(c)   (ISASCII (c) && iscntrl (c))
#define	ISDIGIT(c)   (ISASCII (c) && isdigit (c))
#define	ISGRAPH(c)   (ISASCII (c) && isprint (c) && !isspace (c))
#define	ISLOWER(c)   (ISASCII (c) && islower (c))
#define	ISPRINT(c)   (ISASCII (c) && isprint (c))
#define	ISPUNCT(c)   (ISASCII (c) && ispunct (c))
#define	ISSPACE(c)   (ISASCII (c) && isspace (c))
#define	ISUPPER(c)   (ISASCII (c) && isupper (c))
#define	ISXDIGIT(c)   (ISASCII (c) && isxdigit (c))
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	MB_LEN_MAX   1
#define	MIN(a, b)   ((a) < (b) ? (a) : (b))
#define	NULL   (void *)0
#define	PARAMS(args)   ()
#define	REG_BADBR_IDX   (REG_EBRACE_IDX + sizeof "Unmatched \\{")
#define	REG_BADPAT_IDX   (REG_NOMATCH_IDX + sizeof "No match")
#define	REG_BADRPT_IDX   (REG_ESPACE_IDX + sizeof "Memory exhausted")
#define	REG_EBRACE_IDX   (REG_EPAREN_IDX + sizeof "Unmatched ( or \\(")
#define	REG_EBRACK_IDX   (REG_ESUBREG_IDX + sizeof "Invalid back reference")
#define	REG_ECOLLATE_IDX   (REG_BADPAT_IDX + sizeof "Invalid regular expression")
#define	REG_ECTYPE_IDX   (REG_ECOLLATE_IDX + sizeof "Invalid collation character")
#define	REG_EEND_IDX   (REG_BADRPT_IDX + sizeof "Invalid preceding regular expression")
#define	REG_EESCAPE_IDX   (REG_ECTYPE_IDX + sizeof "Invalid character class name")
#define	REG_EPAREN_IDX   (REG_EBRACK_IDX + sizeof "Unmatched [ or [^")
#define	REG_ERANGE_IDX   (REG_BADBR_IDX + sizeof "Invalid content of \\{\\}")
#define	REG_ERPAREN_IDX   (REG_ESIZE_IDX + sizeof "Regular expression too big")
#define	REG_ESIZE_IDX   (REG_EEND_IDX + sizeof "Premature end of regular expression")
#define	REG_ESPACE_IDX   (REG_ERANGE_IDX + sizeof "Invalid range end")
#define	REG_ESUBREG_IDX   (REG_EESCAPE_IDX + sizeof "Trailing backslash")
#define	REG_NOERROR_IDX   0
#define	REG_NOMATCH_IDX   (REG_NOERROR_IDX + sizeof "Success")
#define	REGEX_ALLOCATE   alloca
#define	REGEX_ALLOCATE_STACK   alloca
#define	REGEX_FREE(arg)   ((void)0) /* Do nothing! But inhibit gcc warning. */
#define	REGEX_FREE_STACK(arg)
#define	REGEX_REALLOCATE(source, osize, nsize)
#define	REGEX_REALLOCATE_STACK(source, osize, nsize)   REGEX_REALLOCATE (source, osize, nsize)
#define	REGEX_TALLOC(n, t)   ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))
#define	RETALLOC(addr, n, t)   ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
#define	RETALLOC_IF(addr, n, t)   if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
#define	SIGN_EXTEND_CHAR(c)   ((((unsigned char) (c)) ^ 128) - 128)
#define	STREQ(s1, s2)   ((strcmp (s1, s2) == 0))
#define	SWITCH_ENUM_CAST(x)   (x)
#define	Sword   1
#define	SYNTAX(c)   re_syntax_table[(unsigned char) (c)]
#define	TALLOC(n, t)   ((t *) malloc ((n) * sizeof (t)))
#define	TOLOWER(c)   tolower(c)
#define	true   1
#define	WIDE_CHAR_SUPPORT   (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)

Typedefs
typedef char	boolean

Enumerations
enum	re_opcode_t {   no_op = 0, succeed, exactn, anychar,   charset, charset_not, start_memory, stop_memory,   duplicate, begline, endline, begbuf,   endbuf, jump, jump_past_alt, on_failure_jump,   on_failure_keep_string_jump, pop_failure_jump, maybe_pop_jump, dummy_failure_jump,   push_dummy_failure, succeed_n, jump_n, set_number_at,   wordchar, notwordchar, wordbeg, wordend,   wordbound, notwordbound }

Functions
static reg_errcode_t byte_regex_compile	_RE_ARGS ((const char *pattern, size_t size, reg_syntax_t syntax, struct re_pattern_buffer *bufp))
	for (this_element=compile_stack.avail-1;this_element >=0;this_element--)
	free (preg->fastmap)
return	gettext (re_error_msgid+re_error_msgid_idx[(int) ret])
	if (cflags &REG_ICASE)
	if (ret==REG_ERPAREN)
	if (errcode< 0||errcode >=(int)(sizeof(re_error_msgid_idx)/sizeof(re_error_msgid_idx[0])))
static void	init_syntax_once ()
char *	malloc ()
static void init_syntax_once	PARAMS ((void))
static int byte_re_match_2_internal	PARAMS ((struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int pos, struct re_registers *regs, int stop))
static int byte_re_search_2	PARAMS ((struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int startpos, int range, struct re_registers *regs, int stop))
static int byte_re_compile_fastmap	PARAMS ((struct re_pattern_buffer *bufp))
char *	realloc ()
	return (int)

Variables
preg	allocated = 0
preg	buffer = 0
void struct re_pattern_buffer *	bufp
int	cflags
static boolean compile_stack_type	compile_stack
regoff_t *	ends
char *	errbuf
size_t	errbuf_size
size_t int	errcode
preg	fastmap = (char *) malloc (1 << BYTEWIDTH)
preg	fastmap_accurate = 0
size_t	length
size_t	msg_size
bufp	newline_anchor = 1
bufp	no_sub = 0
return	NULL
unsigned	num_regs
const char *const char *	pattern
int	pos
int regex_t *	preg
int	range
static const char	re_error_msgid []
static const size_t	re_error_msgid_idx []
reg_syntax_t	re_syntax_options = syntax
static char	re_syntax_table [CHAR_SET_SIZE]
regnum_t	regnum
struct re_registers *	regs
bufp	regs_allocated = REGS_UNALLOCATED
	result
reg_syntax_t	ret = re_syntax_options
int	size
int	size1
int	size2
int	startpos
regoff_t *	starts
int	stop
const char *	string
const char *	string1
const char *	string2
reg_syntax_t reg_syntax_t	syntax
else preg	translate = NULL
preg	used = 0

Macro Definition Documentation

#define _GNU_SOURCE

Definition at line 29 of file regex.c.

#define BYTE

Definition at line 640 of file regex.c.

#define BYTEWIDTH   8 /* In bits. */

Definition at line 397 of file regex.c.

#define bzero	(		s,
			n
	)		(memset (s, '\0', n), (s))

Definition at line 151 of file regex.c.

#define CHAR_SET_SIZE   256

Definition at line 265 of file regex.c.

#define DEFINED_ONCE

Definition at line 8383 of file regex.c.

#define false   0

Definition at line 407 of file regex.c.

#define FIRST_STRING_P

(

ptr

)

(size1 && string1 <= (ptr) && (ptr) <= string1 + size1)

Definition at line 387 of file regex.c.

#define gettext

(

msgid

)

(msgid)

Definition at line 101 of file regex.c.

#define gettext_noop

(

String

)

String

Definition at line 107 of file regex.c.

#define HAVE_STRING_H

Definition at line 145 of file regex.c.

#define HAVE_UINTPTR_T

Definition at line 302 of file regex.c.

#define INSIDE_RECURSION

Definition at line 641 of file regex.c.

#define ISALNUM

(

c

)

(ISASCII (c) && isalnum (c))

Definition at line 231 of file regex.c.

#define ISALPHA

(

c

)

(ISASCII (c) && isalpha (c))

Definition at line 232 of file regex.c.

#define ISASCII

(

c

)

1

Definition at line 212 of file regex.c.

#define ISBLANK

(

c

)

((c) == ' ' || (c) == '\t')

Definition at line 220 of file regex.c.

#define ISCNTRL

(

c

)

(ISASCII (c) && iscntrl (c))

Definition at line 233 of file regex.c.

#define ISDIGIT

(

c

)

(ISASCII (c) && isdigit (c))

Definition at line 230 of file regex.c.

#define ISGRAPH

(

c

)

(ISASCII (c) && isprint (c) && !isspace (c))

Definition at line 225 of file regex.c.

#define ISLOWER

(

c

)

(ISASCII (c) && islower (c))

Definition at line 234 of file regex.c.

#define ISPRINT

(

c

)

(ISASCII (c) && isprint (c))

Definition at line 229 of file regex.c.

#define ISPUNCT

(

c

)

(ISASCII (c) && ispunct (c))

Definition at line 235 of file regex.c.

#define ISSPACE

(

c

)

(ISASCII (c) && isspace (c))

Definition at line 236 of file regex.c.

#define ISUPPER

(

c

)

(ISASCII (c) && isupper (c))

Definition at line 237 of file regex.c.

#define ISXDIGIT

(

c

)

(ISASCII (c) && isxdigit (c))

Definition at line 238 of file regex.c.

#define MAX	(		a,
			b
	)		((a) > (b) ? (a) : (b))

Definition at line 403 of file regex.c.

#define MB_LEN_MAX   1

Definition at line 188 of file regex.c.

#define MIN	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 404 of file regex.c.

#define NULL   (void *)0

Definition at line 247 of file regex.c.

#define PARAMS

(

args

)

()

Definition at line 39 of file regex.c.

#define REG_BADBR_IDX   (REG_EBRACE_IDX + sizeof "Unmatched \\{")

#define REG_BADPAT_IDX   (REG_NOMATCH_IDX + sizeof "No match")

#define REG_BADRPT_IDX   (REG_ESPACE_IDX + sizeof "Memory exhausted")

#define REG_EBRACE_IDX   (REG_EPAREN_IDX + sizeof "Unmatched ( or \\(")

#define REG_EBRACK_IDX   (REG_ESUBREG_IDX + sizeof "Invalid back reference")

#define REG_ECOLLATE_IDX   (REG_BADPAT_IDX + sizeof "Invalid regular expression")

#define REG_ECTYPE_IDX   (REG_ECOLLATE_IDX + sizeof "Invalid collation character")

#define REG_EEND_IDX   (REG_BADRPT_IDX + sizeof "Invalid preceding regular expression")

#define REG_EESCAPE_IDX   (REG_ECTYPE_IDX + sizeof "Invalid character class name")

#define REG_EPAREN_IDX   (REG_EBRACK_IDX + sizeof "Unmatched [ or [^")

#define REG_ERANGE_IDX   (REG_BADBR_IDX + sizeof "Invalid content of \\{\\}")

#define REG_ERPAREN_IDX   (REG_ESIZE_IDX + sizeof "Regular expression too big")

#define REG_ESIZE_IDX   (REG_EEND_IDX + sizeof "Premature end of regular expression")

#define REG_ESPACE_IDX   (REG_ERANGE_IDX + sizeof "Invalid range end")

#define REG_ESUBREG_IDX   (REG_EESCAPE_IDX + sizeof "Trailing backslash")

#define REG_NOERROR_IDX   0

#define REG_NOMATCH_IDX   (REG_NOERROR_IDX + sizeof "Success")

#define REGEX_ALLOCATE   alloca

Definition at line 340 of file regex.c.

#define REGEX_ALLOCATE_STACK   alloca

Definition at line 373 of file regex.c.

#define REGEX_FREE

(

arg

)

((void)0) /* Do nothing! But inhibit gcc warning. */

Definition at line 348 of file regex.c.

#define REGEX_FREE_STACK

(

arg

)

Definition at line 378 of file regex.c.

#define REGEX_REALLOCATE	(		source,
			osize,
			nsize
	)

Value:

(destination = (char *) alloca (nsize),             \
   memcpy (destination, source, osize))

Definition at line 343 of file regex.c.

#define REGEX_REALLOCATE_STACK	(		source,
			osize,
			nsize
	)		REGEX_REALLOCATE (source, osize, nsize)

Definition at line 375 of file regex.c.

#define REGEX_TALLOC	(		n,
			t
	)		((t *) REGEX_ALLOCATE ((n) * sizeof (t)))

Definition at line 395 of file regex.c.

#define RETALLOC	(		addr,
			n,
			t
	)		((addr) = (t *) realloc (addr, (n) * sizeof (t)))

Definition at line 392 of file regex.c.

#define RETALLOC_IF	(		addr,
			n,
			t
	)		if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)

Definition at line 393 of file regex.c.

#define SIGN_EXTEND_CHAR

(

c

)

((((unsigned char) (c)) ^ 128) - 128)

Definition at line 259 of file regex.c.

#define STREQ	(		s1,
			s2
	)		((strcmp (s1, s2) == 0))

Definition at line 399 of file regex.c.

#define SWITCH_ENUM_CAST

(

x

)

(x)

Definition at line 178 of file regex.c.

#define Sword   1

Definition at line 172 of file regex.c.

#define SYNTAX

(

c

)

re_syntax_table[(unsigned char) (c)]

Definition at line 298 of file regex.c.

#define TALLOC	(		n,
			t
	)		((t *) malloc ((n) * sizeof (t)))

Definition at line 391 of file regex.c.

#define TOLOWER

(

c

)

tolower(c)

Definition at line 243 of file regex.c.

#define true   1

Definition at line 408 of file regex.c.

#define WIDE_CHAR_SUPPORT   (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)

Definition at line 52 of file regex.c.

Typedef Documentation

typedef char boolean

Definition at line 406 of file regex.c.

Enumeration Type Documentation

enum re_opcode_t

Enumerator
no_op
succeed
exactn
anychar
charset
charset_not
start_memory
stop_memory
duplicate
begline
endline
begbuf
endbuf
jump
jump_past_alt
on_failure_jump
on_failure_keep_string_jump
pop_failure_jump
maybe_pop_jump
dummy_failure_jump
push_dummy_failure
succeed_n
jump_n
set_number_at
wordchar
notwordchar
wordbeg
wordend
wordbound
notwordbound

Definition at line 456 of file regex.c.

{
  no_op = 0,

  /* Succeed right away--no more backtracking.  */
  succeed,

        /* Followed by one byte giving n, then by n literal bytes.  */
  exactn,

# ifdef MBS_SUPPORT
    /* Same as exactn, but contains binary data.  */
  exactn_bin,
# endif

        /* Matches any (more or less) character.  */
  anychar,

        /* Matches any one char belonging to specified set.  First
           following byte is number of bitmap bytes.  Then come bytes
           for a bitmap saying which chars are in.  Bits in each byte
           are ordered low-bit-first.  A character is in the set if its
           bit is 1.  A character too large to have a bit in the map is
           automatically not in the set.  */
        /* ifdef MBS_SUPPORT, following element is length of character
       classes, length of collating symbols, length of equivalence
       classes, length of character ranges, and length of characters.
       Next, character class element, collating symbols elements,
       equivalence class elements, range elements, and character
       elements follow.
       See regex_compile function.  */
  charset,

        /* Same parameters as charset, but match any character that is
           not one of those specified.  */
  charset_not,

        /* Start remembering the text that is matched, for storing in a
           register.  Followed by one byte with the register number, in
           the range 0 to one less than the pattern buffer's re_nsub
           field.  Then followed by one byte with the number of groups
           inner to this one.  (This last has to be part of the
           start_memory only because we need it in the on_failure_jump
           of re_match_2.)  */
  start_memory,

        /* Stop remembering the text that is matched and store it in a
           memory register.  Followed by one byte with the register
           number, in the range 0 to one less than `re_nsub' in the
           pattern buffer, and one byte with the number of inner groups,
           just like `start_memory'.  (We need the number of inner
           groups here because we don't have any easy way of finding the
           corresponding start_memory when we're at a stop_memory.)  */
  stop_memory,

        /* Match a duplicate of something remembered. Followed by one
           byte containing the register number.  */
  duplicate,

        /* Fail unless at beginning of line.  */
  begline,

        /* Fail unless at end of line.  */
  endline,

        /* Succeeds if at beginning of buffer (if emacs) or at beginning
           of string to be matched (if not).  */
  begbuf,

        /* Analogously, for end of buffer/string.  */
  endbuf,

        /* Followed by two byte relative address to which to jump.  */
  jump,

    /* Same as jump, but marks the end of an alternative.  */
  jump_past_alt,

        /* Followed by two-byte relative address of place to resume at
           in case of failure.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  on_failure_jump,

        /* Like on_failure_jump, but pushes a placeholder instead of the
           current string position when executed.  */
  on_failure_keep_string_jump,

        /* Throw away latest failure point and then jump to following
           two-byte relative address.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  pop_failure_jump,

        /* Change to pop_failure_jump if know won't have to backtrack to
           match; otherwise change to jump.  This is used to jump
           back to the beginning of a repeat.  If what follows this jump
           clearly won't match what the repeat does, such that we can be
           sure that there is no use backtracking out of repetitions
           already matched, then we change it to a pop_failure_jump.
           Followed by two-byte address.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  maybe_pop_jump,

        /* Jump to following two-byte address, and push a dummy failure
           point. This failure point will be thrown away if an attempt
           is made to use it for a failure.  A `+' construct makes this
           before the first repeat.  Also used as an intermediary kind
           of jump when compiling an alternative.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  dummy_failure_jump,

    /* Push a dummy failure point and continue.  Used at the end of
       alternatives.  */
  push_dummy_failure,

        /* Followed by two-byte relative address and two-byte number n.
           After matching N times, jump to the address upon failure.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  succeed_n,

        /* Followed by two-byte relative address, and two-byte number n.
           Jump to the address N times, then fail.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  jump_n,

        /* Set the following two-byte relative address to the
           subsequent two-byte number.  The address *includes* the two
           bytes of number.  */
        /* ifdef MBS_SUPPORT, the size of address is 1.  */
  set_number_at,

  wordchar, /* Matches any word-constituent character.  */
  notwordchar,  /* Matches any char that is not a word-constituent.  */

  wordbeg,  /* Succeeds if at word beginning.  */
  wordend,  /* Succeeds if at word end.  */

  wordbound,    /* Succeeds if at a word boundary.  */
  notwordbound  /* Succeeds if not at a word boundary.  */

# ifdef emacs
  ,before_dot,  /* Succeeds if before point.  */
  at_dot,   /* Succeeds if at point.  */
  after_dot,    /* Succeeds if after point.  */

    /* Matches any character whose syntax is specified.  Followed by
           a byte which contains a syntax code, e.g., Sword.  */
  syntaxspec,

    /* Matches any character whose syntax is not that specified.  */
  notsyntaxspec
# endif /* emacs */
} re_opcode_t;

Function Documentation

static reg_errcode_t byte_regex_compile _RE_ARGS ( (const char *pattern, size_t size, reg_syntax_t syntax, struct re_pattern_buffer *bufp)  )

static

for

(

this_element

= compile_stack.avail - 1; this_element >= 0; this_element--

)

Definition at line 4437 of file regex.c.

{
  register CHAR_T *pto = end;
  register CHAR_T *pfrom = end - num;

  while (pfrom >= loc)
    *pto-- = *pfrom--;
}
#endif /* WCHAR */

#ifdef WCHAR
static reg_errcode_t
wcs_compile_range (range_start_char, p_ptr, pend, translate, syntax, b,
           char_set)
     CHAR_T range_start_char;
     const CHAR_T **p_ptr, *pend;
     CHAR_T *char_set, *b;
     RE_TRANSLATE_TYPE translate;
     reg_syntax_t syntax;
{
  const CHAR_T *p = *p_ptr;
  CHAR_T range_start, range_end;
  reg_errcode_t ret;
# ifdef _LIBC
  uint32_t nrules;
  uint32_t start_val, end_val;
# endif
  if (p == pend)
    return REG_ERANGE;

# ifdef _LIBC
  nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
  if (nrules != 0)
    {
      const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE,
                               _NL_COLLATE_COLLSEQWC);
      const unsigned char *extra = (const unsigned char *)
    _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);

      if (range_start_char < -1)
    {
      /* range_start is a collating symbol.  */
      int32_t *wextra;
      /* Retreive the index and get collation sequence value.  */
      wextra = (int32_t*)(extra + char_set[-range_start_char]);
      start_val = wextra[1 + *wextra];
    }
      else
    start_val = collseq_table_lookup(collseq, TRANSLATE(range_start_char));

      end_val = collseq_table_lookup (collseq, TRANSLATE (p[0]));

      /* Report an error if the range is empty and the syntax prohibits
     this.  */
      ret = ((syntax & RE_NO_EMPTY_RANGES)
         && (start_val > end_val))? REG_ERANGE : REG_NOERROR;

      /* Insert space to the end of the char_ranges.  */
      insert_space(2, b - char_set[5] - 2, b - 1);
      *(b - char_set[5] - 2) = (wchar_t)start_val;
      *(b - char_set[5] - 1) = (wchar_t)end_val;
      char_set[4]++; /* ranges_index */
    }
  else
# endif
    {
      range_start = (range_start_char >= 0)? TRANSLATE (range_start_char):
    range_start_char;
      range_end = TRANSLATE (p[0]);
      /* Report an error if the range is empty and the syntax prohibits
     this.  */
      ret = ((syntax & RE_NO_EMPTY_RANGES)
         && (range_start > range_end))? REG_ERANGE : REG_NOERROR;

      /* Insert space to the end of the char_ranges.  */
      insert_space(2, b - char_set[5] - 2, b - 1);
      *(b - char_set[5] - 2) = range_start;
      *(b - char_set[5] - 1) = range_end;
      char_set[4]++; /* ranges_index */
    }
  /* Have to increment the pointer into the pattern string, so the
     caller isn't still at the ending character.  */
  (*p_ptr)++;

  return ret;
}
#else /* BYTE */
/* Read the ending character of a range (in a bracket expression) from the
   uncompiled pattern *P_PTR (which ends at PEND).  We assume the
   starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)
   Then we set the translation of all bits between the starting and
   ending characters (inclusive) in the compiled pattern B.

   Return an error code.

   We use these short variable names so we can use the same macros as
   `regex_compile' itself.  */

static reg_errcode_t
byte_compile_range (range_start_char, p_ptr, pend, translate, syntax, b)
     unsigned int range_start_char;
     const char **p_ptr, *pend;
     RE_TRANSLATE_TYPE translate;
     reg_syntax_t syntax;
     unsigned char *b;
{
  unsigned this_char;
  const char *p = *p_ptr;
  reg_errcode_t ret;
# if _LIBC
  const unsigned char *collseq;
  unsigned int start_colseq;
  unsigned int end_colseq;
# else
  unsigned end_char;
# endif

  if (p == pend)
    return REG_ERANGE;

  /* Have to increment the pointer into the pattern string, so the
     caller isn't still at the ending character.  */
  (*p_ptr)++;

  /* Report an error if the range is empty and the syntax prohibits this.  */
  ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;

# if _LIBC
  collseq = (const unsigned char *) _NL_CURRENT (LC_COLLATE,
                         _NL_COLLATE_COLLSEQMB);

  start_colseq = collseq[(unsigned char) TRANSLATE (range_start_char)];
  end_colseq = collseq[(unsigned char) TRANSLATE (p[0])];
  for (this_char = 0; this_char <= (unsigned char) -1; ++this_char)
    {
      unsigned int this_colseq = collseq[(unsigned char) TRANSLATE (this_char)];

      if (start_colseq <= this_colseq && this_colseq <= end_colseq)
    {
      SET_LIST_BIT (TRANSLATE (this_char));
      ret = REG_NOERROR;
    }
    }
# else
  /* Here we see why `this_char' has to be larger than an `unsigned
     char' -- we would otherwise go into an infinite loop, since all
     characters <= 0xff.  */
  range_start_char = TRANSLATE (range_start_char);
  /* TRANSLATE(p[0]) is casted to char (not unsigned char) in TRANSLATE,
     and some compilers cast it to int implicitly, so following for_loop
     may fall to (almost) infinite loop.
     e.g. If translate[p[0]] = 0xff, end_char may equals to 0xffffffff.
     To avoid this, we cast p[0] to unsigned int and truncate it.  */
  end_char = ((unsigned)TRANSLATE(p[0]) & ((1 << BYTEWIDTH) - 1));

  for (this_char = range_start_char; this_char <= end_char; ++this_char)
    {
      SET_LIST_BIT (TRANSLATE (this_char));
      ret = REG_NOERROR;
    }
# endif

  return ret;
}
#endif /* WCHAR */


/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
   BUFP.  A fastmap records which of the (1 << BYTEWIDTH) possible
   characters can start a string that matches the pattern.  This fastmap
   is used by re_search to skip quickly over impossible starting points.

   The caller must supply the address of a (1 << BYTEWIDTH)-byte data
   area as BUFP->fastmap.

   We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
   the pattern buffer.

   Returns 0 if we succeed, -2 if an internal error.   */

#ifdef WCHAR
/* local function for re_compile_fastmap.
   truncate wchar_t character to char.  */
static unsigned char truncate_wchar (CHAR_T c);

static unsigned char
truncate_wchar (c)
     CHAR_T c;
{
  unsigned char buf[MB_CUR_MAX];
  mbstate_t state;
  int retval;
  memset (&state, '\0', sizeof (state));
# ifdef _LIBC
  retval = __wcrtomb (buf, c, &state);
# else
  retval = wcrtomb (buf, c, &state);
# endif
  return retval > 0 ? buf[0] : (unsigned char) c;
}
#endif /* WCHAR */

static int
PREFIX(re_compile_fastmap) (bufp)
     struct re_pattern_buffer *bufp;
{
  int j, k;
#ifdef MATCH_MAY_ALLOCATE
  PREFIX(fail_stack_type) fail_stack;
#endif
#ifndef REGEX_MALLOC
  char *destination;
#endif

  register char *fastmap = bufp->fastmap;

#ifdef WCHAR
  /* We need to cast pattern to (wchar_t*), because we casted this compiled
     pattern to (char*) in regex_compile.  */
  UCHAR_T *pattern = (UCHAR_T*)bufp->buffer;
  register UCHAR_T *pend = (UCHAR_T*) (bufp->buffer + bufp->used);
#else /* BYTE */
  UCHAR_T *pattern = bufp->buffer;
  register UCHAR_T *pend = pattern + bufp->used;
#endif /* WCHAR */
  UCHAR_T *p = pattern;

#ifdef REL_ALLOC
  /* This holds the pointer to the failure stack, when
     it is allocated relocatably.  */
  fail_stack_elt_t *failure_stack_ptr;
#endif

  /* Assume that each path through the pattern can be null until
     proven otherwise.  We set this false at the bottom of switch
     statement, to which we get only if a particular path doesn't
     match the empty string.  */
  boolean path_can_be_null = true;

  /* We aren't doing a `succeed_n' to begin with.  */
  boolean succeed_n_p = false;

  assert (fastmap != NULL && p != NULL);

  INIT_FAIL_STACK ();
  bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
  bufp->fastmap_accurate = 1;       /* It will be when we're done.  */
  bufp->can_be_null = 0;

  while (1)
    {
      if (p == pend || *p == succeed)
    {
      /* We have reached the (effective) end of pattern.  */
      if (!FAIL_STACK_EMPTY ())
        {
          bufp->can_be_null |= path_can_be_null;

          /* Reset for next path.  */
          path_can_be_null = true;

          p = fail_stack.stack[--fail_stack.avail].pointer;

          continue;
        }
      else
        break;
    }

      /* We should never be about to go beyond the end of the pattern.  */
      assert (p < pend);

      switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
    {

        /* I guess the idea here is to simply not bother with a fastmap
           if a backreference is used, since it's too hard to figure out
           the fastmap for the corresponding group.  Setting
           `can_be_null' stops `re_search_2' from using the fastmap, so
           that is all we do.  */
    case duplicate:
      bufp->can_be_null = 1;
          goto done;


      /* Following are the cases which match a character.  These end
         with `break'.  */

#ifdef WCHAR
    case exactn:
          fastmap[truncate_wchar(p[1])] = 1;
      break;
#else /* BYTE */
    case exactn:
          fastmap[p[1]] = 1;
      break;
#endif /* WCHAR */
#ifdef MBS_SUPPORT
    case exactn_bin:
      fastmap[p[1]] = 1;
      break;
#endif

#ifdef WCHAR
        /* It is hard to distinguish fastmap from (multi byte) characters
           which depends on current locale.  */
        case charset:
    case charset_not:
    case wordchar:
    case notwordchar:
          bufp->can_be_null = 1;
          goto done;
#else /* BYTE */
        case charset:
          for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
        if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
              fastmap[j] = 1;
      break;


    case charset_not:
      /* Chars beyond end of map must be allowed.  */
      for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
            fastmap[j] = 1;

      for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
        if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
              fastmap[j] = 1;
          break;


    case wordchar:
      for (j = 0; j < (1 << BYTEWIDTH); j++)
        if (SYNTAX (j) == Sword)
          fastmap[j] = 1;
      break;


    case notwordchar:
      for (j = 0; j < (1 << BYTEWIDTH); j++)
        if (SYNTAX (j) != Sword)
          fastmap[j] = 1;
      break;
#endif /* WCHAR */

        case anychar:
      {
        int fastmap_newline = fastmap['\n'];

        /* `.' matches anything ...  */
        for (j = 0; j < (1 << BYTEWIDTH); j++)
          fastmap[j] = 1;

        /* ... except perhaps newline.  */
        if (!(bufp->syntax & RE_DOT_NEWLINE))
          fastmap['\n'] = fastmap_newline;

        /* Return if we have already set `can_be_null'; if we have,
           then the fastmap is irrelevant.  Something's wrong here.  */
        else if (bufp->can_be_null)
          goto done;

        /* Otherwise, have to check alternative paths.  */
        break;
      }

#ifdef emacs
        case syntaxspec:
      k = *p++;
      for (j = 0; j < (1 << BYTEWIDTH); j++)
        if (SYNTAX (j) == (enum syntaxcode) k)
          fastmap[j] = 1;
      break;


    case notsyntaxspec:
      k = *p++;
      for (j = 0; j < (1 << BYTEWIDTH); j++)
        if (SYNTAX (j) != (enum syntaxcode) k)
          fastmap[j] = 1;
      break;


      /* All cases after this match the empty string.  These end with
         `continue'.  */


    case before_dot:
    case at_dot:
    case after_dot:
          continue;
#endif /* emacs */


        case no_op:
        case begline:
        case endline:
    case begbuf:
    case endbuf:
    case wordbound:
    case notwordbound:
    case wordbeg:
    case wordend:
        case push_dummy_failure:
          continue;


    case jump_n:
        case pop_failure_jump:
    case maybe_pop_jump:
    case jump:
        case jump_past_alt:
    case dummy_failure_jump:
          EXTRACT_NUMBER_AND_INCR (j, p);
      p += j;
      if (j > 0)
        continue;

          /* Jump backward implies we just went through the body of a
             loop and matched nothing.  Opcode jumped to should be
             `on_failure_jump' or `succeed_n'.  Just treat it like an
             ordinary jump.  For a * loop, it has pushed its failure
             point already; if so, discard that as redundant.  */
          if ((re_opcode_t) *p != on_failure_jump
          && (re_opcode_t) *p != succeed_n)
        continue;

          p++;
          EXTRACT_NUMBER_AND_INCR (j, p);
          p += j;

          /* If what's on the stack is where we are now, pop it.  */
          if (!FAIL_STACK_EMPTY ()
          && fail_stack.stack[fail_stack.avail - 1].pointer == p)
            fail_stack.avail--;

          continue;


        case on_failure_jump:
        case on_failure_keep_string_jump:
    handle_on_failure_jump:
          EXTRACT_NUMBER_AND_INCR (j, p);

          /* For some patterns, e.g., `(a?)?', `p+j' here points to the
             end of the pattern.  We don't want to push such a point,
             since when we restore it above, entering the switch will
             increment `p' past the end of the pattern.  We don't need
             to push such a point since we obviously won't find any more
             fastmap entries beyond `pend'.  Such a pattern can match
             the null string, though.  */
          if (p + j < pend)
            {
              if (!PUSH_PATTERN_OP (p + j, fail_stack))
        {
          RESET_FAIL_STACK ();
          return -2;
        }
            }
          else
            bufp->can_be_null = 1;

          if (succeed_n_p)
            {
              EXTRACT_NUMBER_AND_INCR (k, p);   /* Skip the n.  */
              succeed_n_p = false;
        }

          continue;


    case succeed_n:
          /* Get to the number of times to succeed.  */
          p += OFFSET_ADDRESS_SIZE;

          /* Increment p past the n for when k != 0.  */
          EXTRACT_NUMBER_AND_INCR (k, p);
          if (k == 0)
        {
              p -= 2 * OFFSET_ADDRESS_SIZE;
          succeed_n_p = true;  /* Spaghetti code alert.  */
              goto handle_on_failure_jump;
            }
          continue;


    case set_number_at:
          p += 2 * OFFSET_ADDRESS_SIZE;
          continue;


    case start_memory:
        case stop_memory:
      p += 2;
      continue;


    default:
          abort (); /* We have listed all the cases.  */
        } /* switch *p++ */

      /* Getting here means we have found the possible starting
         characters for one path of the pattern -- and that the empty
         string does not match.  We need not follow this path further.
         Instead, look at the next alternative (remembered on the
         stack), or quit if no more.  The test at the top of the loop
         does these things.  */
      path_can_be_null = false;
      p = pend;
    } /* while p */

  /* Set `can_be_null' for the last path (also the first path, if the
     pattern is empty).  */
  bufp->can_be_null |= path_can_be_null;

 done:
  RESET_FAIL_STACK ();
  return 0;
}

#else /* not INSIDE_RECURSION */

int
re_compile_fastmap (bufp)
     struct re_pattern_buffer *bufp;
{
# ifdef MBS_SUPPORT
  if (MB_CUR_MAX != 1)
    return wcs_re_compile_fastmap(bufp);
  else
# endif
    return byte_re_compile_fastmap(bufp);
} /* re_compile_fastmap */

free

(

preg->

fastmap

)

return gettext

(

re_error_msgid+

re_error_msgid_idx[(int) ret]

)

if

(

cflags &

REG_ICASE

)

Definition at line 8096 of file regex.c.

    {
      unsigned i;

      preg->translate
    = (RE_TRANSLATE_TYPE) malloc (CHAR_SET_SIZE
                      * sizeof (*(RE_TRANSLATE_TYPE)0));
      if (preg->translate == NULL)
        return (int) REG_ESPACE;

      /* Map uppercase characters to corresponding lowercase ones.  */
      for (i = 0; i < CHAR_SET_SIZE; i++)
        preg->translate[i] = ISUPPER (i) ? TOLOWER (i) : i;
    }

if

(

ret

= = REG_ERPAREN

)

Definition at line 8137 of file regex.c.

    {
      /* Compute the fastmap now, since regexec cannot modify the pattern
     buffer.  */
      if (re_compile_fastmap (preg) == -2)
    {
      /* Some error occurred while computing the fastmap, just forget
         about it.  */
      free (preg->fastmap);
      preg->fastmap = NULL;
    }
    }

if

(

errcode< 0||errcode >

= (int) (sizeof (re_error_msgid_idx)    / sizeof (re_error_msgid_idx[0]))

)

Definition at line 8250 of file regex.c.

    {
      if (msg_size > errbuf_size)
        {
#if defined HAVE_MEMPCPY || defined _LIBC
      *((char *) __mempcpy (errbuf, msg, errbuf_size - 1)) = '\0';
#else
          memcpy (errbuf, msg, errbuf_size - 1);
          errbuf[errbuf_size - 1] = 0;
#endif
        }
      else
        memcpy (errbuf, msg, msg_size);
    }

static void init_syntax_once ( )

static

Definition at line 278 of file regex.c.

{
   register int c;
   static int done = 0;

   if (done)
     return;
   bzero (re_syntax_table, sizeof re_syntax_table);

   for (c = 0; c < CHAR_SET_SIZE; ++c)
     if (ISALNUM (c))
    re_syntax_table[c] = Sword;

   re_syntax_table['_'] = Sword;

   done = 1;
}

char* malloc

(

)

static void init_syntax_once PARAMS ( (void)  )

static

static int byte_re_match_2_internal PARAMS ( (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int pos, struct re_registers *regs, int stop)  )

static

static int byte_re_search_2 PARAMS ( (struct re_pattern_buffer *bufp, const char *string1, int size1, const char *string2, int size2, int startpos, int range, struct re_registers *regs, int stop)  )

static

static int byte_re_compile_fastmap PARAMS ( (struct re_pattern_buffer *bufp)  )

static

char* realloc

(

)

return

(

int

)

Definition at line 8152 of file regex.c.

{
  int ret;
  struct re_registers regs;
  regex_t private_preg;
  int len = strlen (string);
  boolean want_reg_info = !preg->no_sub && nmatch > 0;

  private_preg = *preg;

  private_preg.not_bol = !!(eflags & REG_NOTBOL);
  private_preg.not_eol = !!(eflags & REG_NOTEOL);

  /* The user has told us exactly how many registers to return
     information about, via `nmatch'.  We have to pass that on to the
     matching routines.  */
  private_preg.regs_allocated = REGS_FIXED;

  if (want_reg_info)
    {
      regs.num_regs = nmatch;
      regs.start = TALLOC (nmatch * 2, regoff_t);
      if (regs.start == NULL)
        return (int) REG_NOMATCH;
      regs.end = regs.start + nmatch;
    }

  /* Perform the searching operation.  */
  ret = re_search (&private_preg, string, len,
                   /* start: */ 0, /* range: */ len,
                   want_reg_info ? &regs : (struct re_registers *) 0);

  /* Copy the register information to the POSIX structure.  */
  if (want_reg_info)
    {
      if (ret >= 0)
        {
          unsigned r;

          for (r = 0; r < nmatch; r++)
            {
              pmatch[r].rm_so = regs.start[r];
              pmatch[r].rm_eo = regs.end[r];
            }
        }

      /* If we needed the temporary register info, free the space now.  */
      free (regs.start);
    }

  /* We want zero return to mean success, unlike `re_search'.  */
  return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
}

Variable Documentation

preg allocated = 0

Definition at line 8090 of file regex.c.

preg buffer = 0

Definition at line 8089 of file regex.c.

struct re_pattern_buffer * bufp

Initial value:

{
  return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
              regs, size)

Definition at line 5010 of file regex.c.

int cflags

Definition at line 8081 of file regex.c.

boolean compile_stack_type compile_stack

static

Definition at line 4432 of file regex.c.

regoff_t * ends

Definition at line 5013 of file regex.c.

char* errbuf

Definition at line 8244 of file regex.c.

size_t errbuf_size

Definition at line 8245 of file regex.c.

size_t int errcode

Definition at line 8242 of file regex.c.

preg fastmap = (char *) malloc (1 << BYTEWIDTH)

Definition at line 8094 of file regex.c.

preg fastmap_accurate = 0

Definition at line 8301 of file regex.c.

size_t length

Definition at line 7928 of file regex.c.

return msg_size

Initial value:

{
  const char *msg

Definition at line 8246 of file regex.c.

else preg newline_anchor = 1

Definition at line 7943 of file regex.c.

preg no_sub = 0

Definition at line 7940 of file regex.c.

return NULL

Definition at line 7953 of file regex.c.

unsigned num_regs

Definition at line 5012 of file regex.c.

const char * pattern

Definition at line 7927 of file regex.c.

int pos

Definition at line 5534 of file regex.c.

void regex_t * preg

Definition at line 8079 of file regex.c.

int range

Definition at line 5043 of file regex.c.

const char re_error_msgid[]

static

Definition at line 1372 of file regex.c.

const size_t re_error_msgid_idx[]

static

Initial value:

=
  {
    REG_NOERROR_IDX,
    REG_NOMATCH_IDX,
    REG_BADPAT_IDX,
    REG_ECOLLATE_IDX,
    REG_ECTYPE_IDX,
    REG_EESCAPE_IDX,
    REG_ESUBREG_IDX,
    REG_EBRACK_IDX,
    REG_EPAREN_IDX,
    REG_EBRACE_IDX,
    REG_BADBR_IDX,
    REG_ERANGE_IDX,
    REG_ESPACE_IDX,
    REG_BADRPT_IDX,
    REG_EEND_IDX,
    REG_ESIZE_IDX,
    REG_ERPAREN_IDX
  }

Definition at line 1426 of file regex.c.

re_syntax_options = syntax

Definition at line 1337 of file regex.c.

char re_syntax_table[CHAR_SET_SIZE]

static

Definition at line 273 of file regex.c.

regnum_t regnum

Definition at line 4433 of file regex.c.

struct re_registers * regs

Definition at line 5011 of file regex.c.

bufp regs_allocated = REGS_UNALLOCATED

Definition at line 7935 of file regex.c.

return result

Initial value:

= byte_re_match_2_internal (bufp, NULL, 0, string, size,
                  pos, regs, size)

Definition at line 5545 of file regex.c.

return ret = re_syntax_options

Definition at line 1351 of file regex.c.

int size

Definition at line 5043 of file regex.c.

int size1

Definition at line 5079 of file regex.c.

int size2

Definition at line 5079 of file regex.c.

int startpos

Definition at line 5043 of file regex.c.

regoff_t* starts

Definition at line 5013 of file regex.c.

int stop

Definition at line 5083 of file regex.c.

const char * string

Initial value:

{
  if (num_regs)
    {
      bufp->regs_allocated = REGS_REALLOCATE;
      regs->num_regs = num_regs;
      regs->start = starts;
      regs->end = ends;
    }
  else
    {
      bufp->regs_allocated = REGS_UNALLOCATED;
      regs->num_regs = 0;
      regs->start = regs->end = (regoff_t *) 0;
    }
}









int

     struct re_pattern_buffer *bufp

Definition at line 5014 of file regex.c.

const char * string1

Definition at line 5078 of file regex.c.

const char * string2

Definition at line 5078 of file regex.c.

reg_syntax_t syntax

Initial value:

= (cflags & REG_EXTENDED) ?
      RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC

Definition at line 1349 of file regex.c.

preg translate = NULL

Definition at line 8111 of file regex.c.

preg used = 0

Definition at line 8091 of file regex.c.