Logo Search packages:      
Sourcecode: x11-apps version File versions  Download package

re.c

/*
 * Copyright (c) 2002 by The XFree86 Project, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * Except as contained in this notice, the name of the XFree86 Project shall
 * not be used in advertising or otherwise to promote the sale, use or other
 * dealings in this Software without prior written authorization from the
 * XFree86 Project.
 *
 * Author: Paulo C├ęsar Pereira de Andrade
 */

/* $XFree86: xc/programs/xedit/lisp/re/re.c,v 1.8 2002/11/17 07:51:30 paulo Exp $ */

#include <stdio.h>
#include "rep.h"
#define DEBUG
/*
 * Types
 */

/*  Information used when generating the final form of the compiled re.
 */
struct _re_inf {
    rec_alt *alt;
    unsigned char *cod;
    long len;
    long spc;

    /* Start offset of special repetition instruction */
    long sr[MAX_DEPTH];

    /* Jump offset of special repetition instruction */
    long sj[MAX_DEPTH];

    /* Just a flag, to know if this nesting is for a special repetition */
    char sp[MAX_DEPTH];

    int bas;                  /* Alternatives/repetitions depth */
    int par;                  /* Open parenthesis counter */
    int ref;                  /* Backreference counter */

    rec_pat *apat;            /*  Alternatives duplicate patterns
                         * if a special repetition is found,
                         * this is done to somewhat simplify
                         * the bytecode engine and still allow
                         * some complex (and time consuming)
                         * patterns. */

    int flags;
    int ecode;
};

/*  This structure is not associated with re_cod as it's data only matters
 * to the current match search.
 */
struct _re_eng {
    unsigned char *bas;       /* Base string pointer */
    unsigned char *str;       /* String to search for pattern */
    unsigned char *end;       /* Where to stop searching */
    unsigned char *cod;       /* Pointer in the re_cod structure */
    long off;                 /* Number of used entries in so/eo etc */

    /* Match offset/nesting information */
    long so[MAX_DEPTH];       /* (s)tart of (m)atch */
    long eo[MAX_DEPTH];       /* (e)nd of (m)atch */
    long sv[MAX_DEPTH];       /* (s)a(v)e match end offset */
    long re[MAX_DEPTH];       /* (re)petition count */
    long ss[MAX_DEPTH];       /* (s)ave (s)tart of match */
    unsigned char *rcod[MAX_DEPTH]; /* restart position in regex code */
    unsigned char *rstr[MAX_DEPTH]; /* restart position in string */

    /* Group/backreference information */
    long goff;
    long gso[9];
    long geo[9];
};

/*
 * Prototypes
 */
static void reinit(void);
static int rec_check(re_inf*, int);
static int rec_code(re_inf*, ReCode);
static int rec_byte(re_inf*, int);
static int rec_byte_byte(re_inf*, int, int);
static int rec_code_byte(re_inf*, ReCode, int);
static int rec_length(re_inf*, int);
static int rec_code_byte_byte(re_inf*, ReCode, int, int);
static int rec_build_alt(re_inf*, rec_alt*);
static int rec_build_pat(re_inf*, rec_pat*);
static int rec_build_rng(re_inf*, rec_rng*);
static int rec_build_grp(re_inf*, rec_grp*);
static int rec_build_stl(re_inf*, rec_stl*);
static int rec_build_rep(re_inf*, rec_rep*);
static int rec_inc_spc(re_inf*);
static int rec_dec_spc(re_inf*);
static int rec_add_spc(re_inf*, int);
static int rec_off_spc(re_inf*);
static int rec_alt_spc(re_inf*, int);
static int rec_rep_spc(re_inf*, int);
#ifdef DEBUG
static void redump(re_cod*);
#endif

/*
 * Initialization
 */
unsigned char re__alnum[256];
unsigned char re__odigit[256];
unsigned char re__ddigit[256];
unsigned char re__xdigit[256];
unsigned char re__control[256];

/*
 * Implementation
 */
int
recomp(re_cod *preg, const char *pattern, int flags)
{
    int i, ecode;
    re_inf inf;

    reinit();

    preg->cod = NULL;
    inf.alt = irec_comp(pattern,
                  flags & RE_PEND ? preg->re_endp :
                        pattern + strlen(pattern),
                  flags, &ecode);
    if (ecode != 0)
      return (ecode);

    inf.cod = NULL;
    inf.len = inf.spc = 0;
    inf.bas = 0;
    inf.par = 0;
    inf.ref = 0;
    inf.apat = NULL;
    inf.flags = flags;
    inf.ecode = 0;
    for (i = 0; i < MAX_DEPTH; i++)
      inf.sp[i] = 0;

    /* First byte is runtime modifier flags */
    if (rec_byte(&inf, flags & (RE_NEWLINE | RE_NOSUB)) == 0 &&
      rec_byte(&inf, 0xff) == 0 &&
      rec_build_alt(&inf, inf.alt) == 0 &&
      rec_rep_spc(&inf, 0) == 0 &&
      rec_code(&inf, Re_Done) == 0) {
      /*  Number of possible references, loops will not leave this
       * value correct, but it is cheap to read it from the second
       * byte, instead of adding several extra checks in the bytecode. */
      if (inf.ref)
          inf.cod[1] = inf.ref - 1;
      preg->cod = inf.cod;
      /*  Public structure member */
      preg->re_nsub = inf.ref;
    }

    irec_free_alt(inf.alt);
    if (inf.ecode)
      free(inf.cod);
#ifdef DEBUG
    else if (flags & RE_DUMP)
      redump(preg);
#endif

    return (inf.ecode);
}

int
reexec(const re_cod *preg, const char *string,
       int nmatch, re_mat pmat[], int flags)
{
    unsigned char *ptr, *str, newline, nosub;
    int len, si, ci, bas, i, j, k, l, m;
    re_eng eng;

    if (preg == NULL || preg->cod == NULL || nmatch < 0 ||
      ((flags & RE_STARTEND) &&
       (pmat == NULL || pmat[0].rm_eo < pmat[0].rm_so)))
      return (RE_INVARG);

    eng.str = (unsigned char*)string;
    if (flags & RE_STARTEND) {
      eng.end = eng.str + pmat[0].rm_eo;
      eng.str += pmat[0].rm_so;
    }
    else
      eng.end = eng.str + strlen(string);
    eng.bas = eng.str;
    nosub = preg->cod[0] & RE_NOSUB;
    newline = preg->cod[0] & RE_NEWLINE;
    eng.cod = preg->cod + 2;

    if (!nosub && preg->cod[1] != 0xff) {
      for (i = 0; i <= preg->cod[1]; i++) {
          eng.gso[i] = 0;
          eng.geo[i] = -1;
      }
    }

    /* Setup to search for start of match from the first character */
    eng.so[0] = 0;
    eng.eo[0] = eng.sv[0] = -1;
    eng.rcod[0] = eng.cod;
    eng.rstr[0] = eng.str + 1;
    eng.off = 0;
    eng.goff = -1;
    for (ci = si = 1;;) {
reset:
      switch (*eng.cod) {
          /****************************************************
           * One byte codes                           *
           ****************************************************/
          case Re_Any:
            if (eng.str == eng.end || (newline && eng.str[0] == '\n'))
                goto fail;
            goto match;
          case Re_AnyEatAnyTimes:
            if (newline) {
                for (ptr = eng.str; ptr < eng.end; ptr++) {
                  if (*ptr == '\n')
                      break;
                }
                si = ptr - eng.str;
            }
            else
                si = eng.end - eng.str;
            goto match;
          case Re_AnyEatMaybe:
            si = eng.end > eng.str;
            if (newline && si && eng.str[0] == '\n')
                si = 0;
            goto match;
          case Re_AnyEatAtLeast:
            if (newline) {
                for (ptr = eng.str; ptr < eng.end; ptr++) {
                  if (*ptr == '\n')
                      break;
                }
                si = ptr - eng.str;
            }
            else
                si = eng.end - eng.str;
            if (si == 0) {
                si = 1;
                goto fail;
            }
            goto match;
          case Re_Odigit:
            if (eng.str >= eng.end)
                goto fail;
            if (re__odigit[eng.str[0]])
                goto match;
            goto fail;
          case Re_OdigitNot:
            if (eng.str >= eng.end || re__odigit[eng.str[0]])
                goto fail;
            goto match;
          case Re_Digit:
            if (eng.str >= eng.end)
                goto fail;
            if (re__ddigit[eng.str[0]])
                goto match;
            goto fail;
          case Re_DigitNot:
            if (eng.str >= eng.end || re__ddigit[eng.str[0]])
                goto fail;
            goto match;
          case Re_Xdigit:
            if (eng.str >= eng.end)
                goto fail;
            if (re__xdigit[eng.str[0]])
                goto match;
            goto fail;
          case Re_XdigitNot:
            if (eng.str >= eng.end || re__xdigit[eng.str[0]])
                goto fail;
            goto match;
          case Re_Space:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] == ' ' || eng.str[0] == '\t')
                goto match;
            goto fail;
          case Re_SpaceNot:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] != ' ' && eng.str[0] != '\t')
                goto match;
            goto fail;
          case Re_Tab:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] == '\t')
                goto match;
            goto fail;
          case Re_Newline:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] == '\n')
                goto match;
            goto fail;
          case Re_Lower:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] >= 'a' && eng.str[0] <= 'z')
                goto match;
            goto fail;
          case Re_Upper:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] >= 'A' && eng.str[0] <= 'Z')
                goto match;
            goto fail;
          case Re_Alnum:
            if (eng.str >= eng.end)
                goto fail;
            if (re__alnum[eng.str[0]])
                goto match;
            goto fail;
          case Re_AlnumNot:
            if (eng.str >= eng.end)
                goto fail;
            if (re__alnum[eng.str[0]])
                goto fail;
            goto match;
          case Re_Control:
            if (eng.str >= eng.end)
                goto fail;
            if (re__control[eng.str[0]])
                goto match;
            goto fail;
          case Re_ControlNot:
            if (eng.str >= eng.end || re__control[eng.str[0]])
                goto fail;
            goto match;

          /****************************************************
           * One byte codes, match special emtpy strings    *
           ****************************************************/
          case Re_Bol:
            if (eng.str == eng.bas) {
                if ((flags & RE_NOTBOL)) {
                  /* String does not start at the beginning of a line */
                  if (newline)
                      goto fail;
                  goto wont;
                }
                si = 0;
                goto match;
            }
            if (newline && eng.str[-1] == '\n') {
                si = 0;
                goto match;
            }
            goto fail;
          case Re_Eol:
            if (eng.str == eng.end) {
                if (flags & RE_NOTEOL)
                  /* String does not finish at the end of a line */
                  goto wont;
                si = 0;
                goto match;
            }
            if (newline && eng.str[0] == '\n') {
                si = 0;
                goto match;
            }
            goto fail;
          case Re_Bow:
            if (eng.str >= eng.end ||
                (eng.str > eng.bas &&
                 (re__alnum[eng.str[-1]])))
                goto fail;
            if (re__alnum[eng.str[0]]) {
                si = 0;
                goto match;
            }
            goto fail;
          case Re_Eow:
            if (eng.str == eng.bas ||
                (eng.str < eng.end &&
                 re__alnum[eng.str[0]]))
                goto fail;
            if (re__alnum[eng.str[-1]]) {
                si = 0;
                goto match;
            }
            goto fail;

          /****************************************************
           * One byte code, one byte argument               *
           ****************************************************/
          case Re_Literal:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] == eng.cod[1]) {
                ci = 2;
                goto match;
            }
            goto fail;
          case Re_LiteralNot:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] != eng.cod[1]) {
                ci = 2;
                goto match;
            }
            goto fail;
          case Re_SearchLiteral:
            for (str = eng.str; str < eng.end; str++) {
                if (*str == eng.cod[1]) {
                  ci = 2;
                  eng.str = str;
                  goto match;
                }
            }
            /* This bytecode only happens in the toplevel */
            eng.so[0] = str - eng.bas;
            eng.str = str;
            goto fail;

          /****************************************************
           * One byte code, two bytes argument        *
           ****************************************************/
          case Re_CaseLiteral:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] == eng.cod[1] || eng.str[0] == eng.cod[2]) {
                ci = 3;
                goto match;
            }
            goto fail;
          case Re_CaseLiteralNot:
            if (eng.str >= eng.end)
                goto fail;
            if (eng.str[0] != eng.cod[1] && eng.str[0] != eng.cod[2]) {
                ci = 3;
                goto match;
            }
            goto fail;
          case Re_SearchCaseLiteral:
            for (str = eng.str; str < eng.end; str++) {
                if (*str == eng.cod[1] || *str == eng.cod[2]) {
                  ci = 3;
                  eng.str = str;
                  goto match;
                }
            }
            eng.so[0] = str - eng.bas;
            eng.str = str;
            goto fail;

          /****************************************************
           * One byte codes, two arguments, n bytes         *
           ****************************************************/
          case Re_String:
            len = eng.cod[1];
            if (len & 0x80) {
                i = 3;
                len = (len & 0x7f) + (eng.cod[2] << 7);
            }
            else
                i = 2;
            if (eng.end - eng.str < len)
                goto fail;
            ptr = eng.cod + i;
            str = eng.str;
            for (k = len; k > 0; k--) {
                if (*ptr++ != *str++)
                  goto fail;
            }
            ci = i + len;
            si = len;
            goto match;
          case Re_SearchString:
            len = eng.cod[1];
            if (len & 0x80) {
                i = 3;
                len = (len & 0x7f) + (eng.cod[2] << 7);
            }
            else
                i = 2;
            for (str = eng.str; eng.end - str >= len; str = eng.str++) {
                for (ptr = eng.cod + i, str = eng.str, k = len; k > 0; k--)
                  if (*ptr++ != *str++)
                      break;
                if (k == 0) {
                  /* Substring found */
                  ci = i + len;
                  si = str - eng.str;
                  goto match;
                }
            }
            eng.so[0] = eng.end - eng.bas;
            eng.str = eng.end;
            goto fail;

          case Re_CaseString:
            len = eng.cod[1];
            if (len & 0x80) {
                i = 3;
                len = (len & 0x7f) + (eng.cod[2] << 7);
            }
            else
                i = 2;

            len >>= 1;
            /*  Check if there are at least len/2 bytes left, string
             * is represented as two bytes, lower and upper case */
            if (eng.end - eng.str < len)
                goto fail;
            ptr = eng.cod + i;
            str = eng.str;
            for (k = len; k > 0; str++, ptr += 2, k--) {
                if (*str != ptr[0] && *str != ptr[1])
                  goto fail;
            }
            ci = i + (len << 1);
            si = len;
            goto match;
          case Re_SearchCaseString:
            len = eng.cod[1];
            if (len & 0x80) {
                i = 3;
                len = (len & 0x7f) + (eng.cod[2] << 7);
            }
            else
                i = 2;
            len >>= 1;
            for (str = eng.str; eng.end - str >= len; str = eng.str++) {
                for (ptr = eng.cod + i, str = eng.str, k = len;
                   k > 0; k--, ptr += 2, str++)
                  if (ptr[0] != str[0] && ptr[1] != str[0])
                      break;
                if (k == 0) {
                  /* Substring found */
                  ci = i + (len << 1);
                  si = str - eng.str;
                  goto match;
                }
            }
            eng.so[0] = eng.end - eng.bas;
            eng.str = eng.end;
            goto fail;

          case Re_StringList:
            /* Number of strings */
            k = eng.cod[1];

            /* Where to jump after match */
            bas = eng.cod[2] | (eng.cod[3] << 8);

            str = eng.str;
            ptr = eng.cod + k + 4;
            l = eng.end - eng.str;
            for (j = 0; j < k; j++) {
                len = eng.cod[j + 4];
                if (len <= l) {
                  for (i = 0; i < len; i++)
                      if (ptr[i] != str[i])
                        goto next_stl;
                  goto stl_match;
                }
next_stl:
                ptr += len;
            }
            goto fail;
stl_match:
            ci = bas;
            si = len;
            goto match;

          case Re_CaseStringList:
            /* Number of strings */
            k = eng.cod[1];

            /* Where to jump after match */
            bas = eng.cod[2] | (eng.cod[3] << 8);

            str = eng.str;
            ptr = eng.cod + k + 4;
            l = eng.end - eng.str;
            for (j = 0; j < k; j++) {
                len = eng.cod[j + 4];
                if ((len >> 1) <= l) {
                  for (i = m = 0; i < len; m++, i += 2)
                      if (ptr[i] != str[m] && ptr[i + 1] != str[m])
                        goto next_cstl;
                  goto cstl_match;
                }
next_cstl:
                ptr += len;
            }
            goto fail;
cstl_match:
            ci = bas;
            si = len >> 1;
            goto match;


          case Re_LargeStringList:
            /* Where to jump after match */
            bas = eng.cod[1] | (eng.cod[2] << 8);

            str = eng.str;

            /* First entry in index map */
            ptr = eng.cod + 3;
            i = (int)str[0] << 1;
            j = ptr[i] | (ptr[i + 1] << 8);
            if (j == 0xffff)
                /* No entry with this byte */
                goto fail;

            /* Bytes left in input */
            l = eng.end - eng.str;

            /* First entry matching initial byte */
            ptr += 512 + j;

            for (len = ptr[0];
                 str[0] == ptr[1];
                 ptr += len + 1, len = ptr[0]) {
                if (len <= l) {
                  for (i = 1; i < len; i++) {
                      if (ptr[i + 1] != str[i])
                        goto next_lstl;
                  }
                  ci = bas;
                  si = len;
                  goto match;
                }
next_lstl:;
            }
            goto fail;

          case Re_LargeCaseStringList:
            /* Where to jump after match */
            bas = eng.cod[1] | (eng.cod[2] << 8);

            str = eng.str;

            /* First entry in index map */
            ptr = eng.cod + 3;
            i = (int)str[0] << 1;
            j = ptr[i] | (ptr[i + 1] << 8);
            if (j == 0xffff)
                /* No entry with this byte */
                goto fail;

            /* Bytes left in input */
            l = eng.end - eng.str;

            /* First entry matching initial byte */
            ptr += 512 + j;

            for (len = ptr[0];
                 str[0] == ptr[1] || str[0] == ptr[2];
                 ptr += len + 1, len = ptr[0]) {
                if ((k = (len >> 1)) <= l) {
                  for (i = 2, j = 1; i < len; i += 2, j++) {
                      if (ptr[i + 1] != str[j] && ptr[i + 2] != str[j])
                        goto next_lcstl;
                  }
                  ci = bas;
                  si = k;
                  goto match;
                }
next_lcstl:;
            }
            goto fail;


          /****************************************************
           * Character range matching                       *
           ****************************************************/
          case Re_Range:
            if (eng.str < eng.end && eng.cod[eng.str[0] + 1]) {
                ci = 257;
                goto match;
            }
            goto fail;
          case Re_RangeNot:
            if (eng.str >= eng.end || eng.cod[eng.str[0] + 1])
                goto fail;
            ci = 257;
            goto match;

          /****************************************************
           * Group handling                           *
           ****************************************************/
          case Re_Open:
            if (++eng.goff >= 9)
                return (RE_ASSERT);
            eng.gso[eng.goff] = eng.str - eng.bas;
            ++eng.cod;
            continue;
          case Re_Close:
            eng.geo[eng.goff] = eng.str - eng.bas;
            ++eng.cod;
            continue;
          case Re_Update:
            bas = eng.cod[1];
            eng.geo[eng.goff] = eng.str - eng.bas;
            eng.cod += 2;           /* + Update + bas */
            continue;

          /****************************************************
           * Backreference                            *
           ****************************************************/
          case Re_Backref:
            i = eng.cod[1];
            j = eng.gso[i];
            k = eng.geo[i];
            len = k - j;
            if (k < j || eng.end - eng.str < len)
                goto fail;
            ptr = eng.bas + j;
            str = eng.str;
            for (l = len; l > 0; l--) {
                if (*ptr++ != *str++)
                  goto fail;
            }
            ci = 2;
            si = len;
            goto match;

          /****************************************************
           * Alternatives handling                    *
           ****************************************************/
          case Re_Alt:
            bas = eng.off;
            if (++eng.off >= MAX_DEPTH)
                return (RE_ASSERT);

            /* Get offset of next alternative */
            i = eng.cod[1] | (eng.cod[2] << 8);

            /* Setup for next alternative if the current fails */
            eng.rcod[eng.off] = eng.cod + i + 1;      /* + Alt */

            /* If fail, test the next alternative in the same string */
            eng.rstr[eng.off] = eng.str;

            /* Setup match offsets */
            if (eng.so[bas] <= eng.eo[bas])
                eng.so[eng.off] = eng.eo[bas];
            else
                eng.so[eng.off] = eng.so[bas];
            eng.sv[eng.off] = eng.eo[eng.off] = eng.so[eng.off] - 1;

            /* Save start of possible previous matches */
            eng.ss[eng.off] = eng.so[bas];

            /* Skip code */
            eng.cod += 3;

            /* Go try the first alternative */
            continue;

          case Re_AltNext:
            bas = eng.off - 1;
            /* Check if matched and if it is a better match */
            if (eng.sv[eng.off] - eng.so[eng.off] <
                eng.eo[eng.off] - eng.so[eng.off])
                eng.sv[eng.off] = eng.eo[eng.off];

            /* Get offset of next alternative */
            i = eng.cod[1] | (eng.cod[2] << 8);

            /* Setup for next alternative if the current fails */
            eng.rcod[eng.off] = eng.cod + i + 1;      /* + AltNext */

            /* Setup match offset */
            eng.eo[eng.off] = eng.so[eng.off] - 1;

            /* Reset string for next alternative */
            eng.str = eng.rstr[eng.off];

            /* Skip code */
            eng.cod += 3;

            /* Go try the next alternative */
            continue;

          case Re_AltDone:
            bas = eng.off - 1;
            /* Check if matched and if it is a better match */
            if (eng.sv[eng.off] - eng.so[eng.off] <
                eng.eo[eng.off] - eng.so[eng.off])
                eng.sv[eng.off] = eng.eo[eng.off];

            /* If there is a match */
            if (eng.sv[eng.off] >= eng.so[eng.off]) {
                eng.so[bas] = eng.ss[eng.off];
                eng.eo[bas] = eng.sv[eng.off];
                eng.str = eng.bas + eng.eo[bas];

                /* Pop stack and skip code */
                --eng.off;
                ++eng.cod;

                /* Go try next regular expression pattern */
                continue;
            }

            /* Failed, reset string and pop stack */
            eng.str = eng.rstr[eng.off];
            --eng.off;
            goto fail;


          /****************************************************
           * Repetition                         *
           ****************************************************/

            /*  Note that the repetition counter is not
             * updated for <re>*, <re>+ and <re>?
             * it is easy to updated, but since it is not
             * really useful, code to do it was removed
             * to save a few cpu cicles. */

#define REPETITION_SETUP()                            \
      if (++eng.off >= MAX_DEPTH)                     \
          return (RE_ASSERT);                         \
                                                \
      /* Return here for recovery if match fail */          \
      eng.rcod[eng.off] = eng.cod;                    \
                                                \
      /* Setup match offsets */                       \
      if (eng.so[bas] <= eng.eo[bas])                       \
          eng.so[eng.off] = eng.eo[bas];              \
      else                                      \
          eng.so[eng.off] = eng.so[bas];              \
      eng.ss[eng.off] = eng.so[bas];                        \
      eng.sv[eng.off] = eng.eo[eng.off] = eng.so[eng.off] - 1;\
                                                \
      /* Skip repetition instruction */               \
      eng.cod += 4;


          case Re_AnyTimes:
            bas = eng.cod[1];
            if (eng.off == bas) {
                /* First iteration */
                REPETITION_SETUP();
            }
            else {
                if (eng.eo[eng.off] >= eng.so[eng.off] &&
                  eng.eo[eng.off] > eng.sv[eng.off]) {
                  /* Update offset of match */
                  eng.sv[eng.off] = eng.eo[eng.off];

                  /* Skip repetition instruction */
                  eng.cod += 4;
                }
                else {
                  /* Match failed but it is ok */
                  len = eng.cod[2] | (eng.cod[3] << 8);
                  eng.so[bas] = eng.ss[eng.off];
                  if (eng.sv[eng.off] >= eng.so[eng.off])
                      /* Something matched earlier, update */
                      eng.eo[bas] = eng.sv[eng.off];
                  else if (eng.eo[bas] < eng.so[bas])
                      /* Empty match */
                      eng.eo[bas] = eng.so[bas];

                  /* Try next pattern at correct offset */
                  eng.str = eng.bas + eng.eo[bas];

                  /* Pop stack and skip code */
                  --eng.off;
                  eng.cod += len;
                }
            }
            continue;

          case Re_Maybe:
            bas = eng.cod[1];
            if (eng.off == bas) {
                /* First iteration */
                REPETITION_SETUP();
            }
            else {
                /* Matched or first iteration is done */
                len = eng.cod[2] | (eng.cod[3] << 8);
                eng.so[bas] = eng.ss[eng.off];
                if (eng.eo[eng.off] > eng.so[eng.off]) {
                  /* Something matched earlier, update */
                  eng.eo[bas] = eng.eo[eng.off];
                  eng.str = eng.bas + eng.eo[bas];
                  /* Don't need to update counter */
                }
                else {
                  /* Empty match */
                  if (eng.eo[bas] < eng.so[bas])
                      eng.eo[bas] = eng.so[bas];

                  /* Try next pattern at correct offset */
                  eng.str = eng.bas + eng.eo[bas];
                }

                /* Pop stack */
                --eng.off;

                /* Skip code */
                eng.cod += len;
            }
            continue;

          case Re_AtLeast:
            bas = eng.cod[1];
            if (eng.off == bas) {
                /* First iteration */
                REPETITION_SETUP();
            }
            else {
                if (eng.eo[eng.off] >= eng.so[eng.off] &&
                  eng.eo[eng.off] > eng.sv[eng.off]) {
                  /* Update offset of match */
                  eng.sv[eng.off] = eng.eo[eng.off];

                  /* Skip repetition instruction */
                  eng.cod += 4;
                }
                else {
                  /* Last try failed */
                  len = eng.cod[2] | (eng.cod[3] << 8);
                  if (eng.sv[eng.off] >= eng.so[eng.off]) {
                      /* Something matched earlier, update */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];
                  }
                  else {
                      /*      Do it here, so that the fail label does
                       * not need to do too expensive work for
                       * simple patterns. */
                      eng.so[bas] = eng.str - eng.bas;

                      /* Zero matches, pop stack and restart */
                      --eng.off;
                      goto fail;
                  }

                  /* Pop stack and skip code */
                  --eng.off;
                  eng.cod += len;
                }
            }
            continue;


          /****************************************************
           * Repetition with arguments                *
           ****************************************************/
          case Re_Exact:
#define COMPLEX_REPETITION_SETUP_0()                        \
      i = eng.cod[1];                                 \
      bas = eng.cod[2];

#define COMPLEX_REPETITION_SETUP()                    \
      /* First iteration */                           \
      if (++eng.off >= MAX_DEPTH)                     \
          return (RE_ASSERT);                         \
                                                \
      /*  Remeber number or repetitions */                  \
      eng.re[eng.off] = 0;                            \
                                                \
      /* Return here for recovery if match fail */          \
      eng.rcod[eng.off] = eng.cod;                    \
                                                \
      /* Setup match offsets */                       \
      if (eng.so[bas] <= eng.eo[bas])                       \
          eng.so[eng.off] = eng.eo[bas];              \
      else                                      \
          eng.so[eng.off] = eng.so[bas];              \
      eng.sv[eng.off] = eng.eo[eng.off] = eng.so[eng.off] - 1;\
      eng.ss[eng.off] = eng.so[bas];                        \
                                                \
      /* Skip repetition instruction */               \
      eng.cod += 5;

            COMPLEX_REPETITION_SETUP_0();
            if (eng.off == bas) {
                /* First iteration */
                COMPLEX_REPETITION_SETUP();
            }
            else {
                if (eng.eo[eng.off] >= eng.so[eng.off] &&
                  eng.eo[eng.off] > eng.sv[eng.off]) {
                  /* Update offset of match */
                  eng.sv[eng.off] = eng.eo[eng.off];

                  /* Update repetition counter */
                  if (++eng.re[eng.off] == i) {
                      /* Matched the required times */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];

                      /* Update code */
                      k = eng.cod[3] | (eng.cod[4] << 8);
                      eng.cod += k;

                      /* Pop stack and go for next pattern */
                      --eng.off;
                      continue;
                  }

                  /* Skip repetition instruction */
                  eng.cod += 5;
                }
                else {
                  /*  Do it here, so that the fail label does
                   * not need to do too expensive work for
                   * simple patterns. */
                  eng.so[bas] = eng.str - eng.bas;

                  /* Pop stack and restart */
                  --eng.off;
                  goto fail;
                }
            }
            continue;

          case Re_Min:
            COMPLEX_REPETITION_SETUP_0();
            if (eng.off == bas) {
                /* First iteration */
                COMPLEX_REPETITION_SETUP();
            }
            else {
                if (eng.eo[eng.off] >= eng.so[eng.off] &&
                  eng.eo[eng.off] > eng.sv[eng.off]) {
                  /* Update offset of match */
                  eng.sv[eng.off] = eng.eo[eng.off];

                  /* Update repetition counter */
                  ++eng.re[eng.off];

                  /* Skip repetition instruction and try again */
                  eng.cod += 5;
                }
                else {
                  /* Match failed! */
                  if (eng.re[eng.off] < i) {
                      /*      Do it here, so that the fail label does
                       * not need to do too expensive work for
                       * simple patterns. */
                      eng.so[bas] = eng.str - eng.bas;

                      /* Didn't match required number of times */
                      --eng.off;
                      goto fail;
                  }
                  else {
                      /* Matched minimum number of times */
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];
                      k = eng.cod[3] | (eng.cod[4] << 8);

                      /* Update code and pop stack */
                      eng.cod += k;
                      --eng.off;
                  }
                }
            }
            continue;

          case Re_Max:
            COMPLEX_REPETITION_SETUP_0();
            if (eng.off == bas) {
                /* First iteration */
                COMPLEX_REPETITION_SETUP();
            }
            else {
                if (eng.eo[eng.off] >= eng.so[eng.off] &&
                  eng.eo[eng.off] > eng.sv[eng.off]) {
                  /* Update offset of match */
                  eng.sv[eng.off] = eng.eo[eng.off];

                  /* Update repetition counter */
                  if (++eng.re[eng.off] == i) {
                      /* Matched the maximum times */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];

                      k = eng.cod[3] | (eng.cod[4] << 8);

                      /* Update code and pop stack */
                      eng.cod += k;
                      --eng.off;
                      continue;
                  }

                  /* Skip repetition instruction and try again */
                  eng.cod += 5;
                }
                else {
                  /* No matches, but zero matches are ok */
                  k = eng.cod[3] | (eng.cod[4] << 8);
                  if (eng.sv[eng.off] >= eng.so[eng.off]) {
                      /* Something matched earlier, update */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];
                  }
                  else {
                      /* Empty match */
                      if (eng.eo[bas] < eng.so[bas])
                        eng.eo[bas] = eng.so[bas];

                      /* Try next pattern at correct offset */
                      eng.str = eng.bas + eng.eo[bas];
                  }

                  /* Pop stack and update code */
                  --eng.off;
                  eng.cod += k;
                }
            }
            continue;

          case Re_MinMax:
            bas = eng.cod[3];
            if (eng.off == bas) {
                /* First iteration */
                COMPLEX_REPETITION_SETUP();
            }
            else {
                if (eng.eo[eng.off] >= eng.so[eng.off] &&
                  eng.eo[eng.off] > eng.sv[eng.off]) {
                  /* Update offset of match */
                  eng.sv[eng.off] = eng.eo[eng.off];

                  /* Update repetition counter */
                  if (++eng.re[eng.off] == eng.cod[2]) {
                      /* Matched the maximum times */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];
                      k = eng.cod[4] | (eng.cod[5] << 8);

                      /* Update code and pop stack */
                      eng.cod += k;
                      --eng.off;
                      continue;
                  }

                  /* Skip repetition instruction and try again */
                  eng.cod += 6;
                }
                else {
                  /* Match failed! */
                  if (eng.re[eng.off] < eng.cod[1]) {
                      /*      Do it here, so that the fail label does
                       * not need to do too expensive work for
                       * simple patterns. */
                      eng.so[bas] = eng.str - eng.bas;

                      /* Didn't match required number of times */
                      --eng.off;
                      goto fail;
                  }
                  else {
                      /* Matched minimum number of times */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.sv[eng.off];
                      eng.str = eng.bas + eng.eo[bas];
                      k = eng.cod[4] | (eng.cod[5] << 8);

                      /* Update code and pop stack */
                      eng.cod += k;
                      --eng.off;
                  }
                }
            }
            continue;


          /****************************************************
           * Special repetition handling              *
           ****************************************************/
          case Re_AnyAnyTimes:
            /* code(1) + bas(1) + gbas(1) + jump(2) */
            bas = eng.cod[1];
            if (eng.off == bas) {
                /* First iteration */
                if (++eng.off >= MAX_DEPTH)
                  return (RE_ASSERT);

                /* Return here for recovery if match fail */
                eng.rcod[eng.off] = eng.cod;

                /* If fail, test the next pattern at the same point */
                eng.rstr[eng.off] = eng.str;

                /* Setup match offsets */
                eng.so[eng.off] = eng.str - eng.bas;
                eng.eo[eng.off] = eng.so[eng.off] - 1;

                if (newline)
                  /*  Use the repetition counter to store start of
                   * skipped string, to later check if skipping a
                   * newline. */
                  eng.re[eng.off] = eng.so[eng.off];

                /* Save start of possible previous matches */
                eng.ss[eng.off] = eng.so[bas];

                /* Skip repetition instruction */
                eng.cod += 5;
            }
            else {
                /* -1 as an unsigned char */
                if (eng.cod[2] != 0xff)
                  eng.goff = eng.cod[2];
                else
                  eng.goff = -1;

                if (newline) {
                  ptr = eng.bas + eng.re[eng.off];
                  str = eng.bas + eng.so[eng.off];
                  for (; ptr < str; ptr++)
                      if (*ptr == '\n') {
                        eng.cod = eng.rcod[0];
                        eng.so[0] = ptr - eng.bas + 1;
                        eng.eo[0] = eng.so[0] - 1;
                        eng.rstr[0] = eng.str = ptr + 1;
                        eng.off = 0;
                        goto reset;
                      }
                  /* If looping, don't do too many noops */
                  eng.re[eng.off] = ptr - eng.bas;
                }

                if (eng.eo[eng.off] >= eng.so[eng.off]) {
                  /* Note that this is only true if all possibly
                   * nested special repetitions also matched. */

                  if (eng.goff >= 0) {
                      if (eng.cod[5] == Re_Update)
                        eng.gso[eng.goff] = eng.eo[bas] +
                                        (eng.so[bas] > eng.eo[bas]);
                      else if (eng.geo[eng.goff] < eng.so[eng.off])
                        eng.geo[eng.goff] = eng.so[eng.off];
                  }

                  /* Jump relative offset */
                  len = eng.cod[3] | (eng.cod[4] << 8);

                  /* Restore offset from where started trying */
                  eng.so[bas] = eng.ss[eng.off];
                  eng.eo[bas] = eng.eo[eng.off];

                  /* Pop stack and skip code */
                  --eng.off;
                  eng.cod += len;
                }
                else {
                  /* Only give up if the entire string was scanned */
                  if (eng.str < eng.end) {
                      /* Update restart point for next pattern */
                      eng.str = ++eng.rstr[eng.off];

                      /* Reset start of nested match */
                      eng.so[eng.off] = eng.str - eng.bas;

                      /* Skip repetition instruction */
                      eng.cod += 5;
                  }
                  else {
                      /* Entire string scanned and failed */

                      /* Jump relative offset */
                      len = eng.cod[3] | (eng.cod[4] << 8);

                      /* Restore offset from where started trying */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.ss[eng.off] - 1;

                      /* Pop stack and skip code */
                      --eng.off;
                      eng.cod += len;
                  }
                }
            }
            continue;

          /*  This is significantly different than matching <re>.*<re>
           * because it may need to restart several times since it is
           * possible to find too many false positives, for example:
           *      a.*b  => once one "a" is found, scan all
           *               the remaining string searching for a "b"
           *  a.?b      => the string may have too many "a"s, but the
           *               first occurrences of "a" may not be followed
           *               by any-character and a "b" or a single "b".
           */
          case Re_AnyMaybe:
            bas = eng.cod[1];
            if (eng.off == bas) {
                /* First iteration */
                if (++eng.off >= MAX_DEPTH)
                  return (RE_ASSERT);

                /* Return here for recovery if match fail */
                eng.rcod[eng.off] = eng.cod;

                /* First try without eating a byte */
                eng.rstr[eng.off] = eng.str;

                /* Remember this is the first try if match fail */
                eng.re[eng.off] = 0;

                /* Setup match offsets */
                eng.so[eng.off] = eng.str - eng.bas;
                eng.eo[eng.off] = eng.so[eng.off] - 1;

                /* Save start of possible previous matches */
                eng.ss[eng.off] = eng.so[bas];

                /* Skip repetition instruction */
                eng.cod += 5;
            }
            else {
                /* -1 as an unsigned char */
                if (eng.cod[2] != 0xff)
                  eng.goff = eng.cod[2];
                else
                  eng.goff = -1;

                if (eng.eo[eng.off] >= eng.so[eng.off]) {
                  /* Something matched */

                  if (eng.goff >= 0) {
                      if (eng.cod[5] == Re_Update)
                        eng.gso[eng.goff] = eng.eo[bas] +
                                        (eng.so[bas] > eng.eo[bas]);
                      else if (eng.geo[eng.goff] < eng.so[eng.off])
                        eng.geo[eng.goff] = eng.so[eng.off];
                  }

                  /* Jump relative offset */
                  len = eng.cod[3] | (eng.cod[4] << 8);

                  /* Update offset of match */
                  eng.eo[bas] = eng.eo[eng.off];

                  /* Pop stack and skip code */
                  --eng.off;
                  eng.cod += len;
                }
                else if (eng.re[eng.off] == 0 &&
                       (!newline || eng.rstr[eng.off][1] != '\n')) {
                  /* Try this time skiping a byte */
                  ++eng.re[eng.off];

                  /* Reset string, skip code and go try one time more */
                  eng.str = ++eng.rstr[eng.off];
                  eng.cod += 5;
                }
                else {
                  /* Failed to match */

                  /* Update offsets */
                  eng.eo[bas] = eng.ss[eng.off];
                  eng.so[bas] = eng.eo[bas] + 1;

                  eng.str = eng.rstr[eng.off] + (eng.re[eng.off] == 0);

                  /* Pop stack and return to toplevel code */
                  --eng.off;
                  if (eng.str >= eng.end)
                      goto wont;
                  eng.cod = eng.rcod[bas];
                }
            }
            continue;

          /* .+ almost identical to .* but requires eating at least one byte */
          case Re_AnyAtLeast:
            bas = eng.cod[1];
            if (eng.off == bas) {
                /* First iteration */
                if (++eng.off >= MAX_DEPTH)
                  return (RE_ASSERT);

                /* Return here for recovery if match fail */
                eng.rcod[eng.off] = eng.cod;

                /* Skip one byte for the restart string */
                if (newline && eng.str[0] == '\n') {
                  /* Cannot skip newline */
                  eng.cod = eng.rcod[0];
                  eng.rstr[0] = ++eng.str;
                  eng.so[0] = eng.str - eng.bas;
                  eng.eo[0] = eng.so[0] - 1;
                  eng.off = 0;
                  goto reset;
                }
                eng.rstr[eng.off] = ++eng.str;

                /* Setup match offsets */
                eng.so[eng.off] = eng.str - eng.bas;
                eng.eo[eng.off] = eng.so[eng.off] - 1;

                if (newline)
                  /*  Use the repetition counter to store start of
                   * skipped string, to later check if skipping a
                   * newline. */
                  eng.re[eng.off] = eng.so[eng.off];

                /* Save start of possible previous matches */
                eng.ss[eng.off] = eng.so[bas];

                /* Skip repetition instruction */
                eng.cod += 5;
            }
            else {
                /* -1 as an unsigned char */
                if (eng.cod[2] != 0xff)
                  eng.goff = eng.cod[2];
                else
                  eng.goff = -1;

                if (newline) {
                  ptr = eng.bas + eng.re[eng.off];
                  str = eng.bas + eng.so[eng.off];
                  for (; ptr < str; ptr++)
                      if (*ptr == '\n') {
                        eng.cod = eng.rcod[0];
                        eng.so[0] = ptr - eng.bas + 1;
                        eng.eo[0] = eng.so[0] - 1;
                        eng.rstr[0] = eng.str = ptr + 1;
                        eng.off = 0;
                        goto reset;
                      }
                  /* If looping, don't do too many noops */
                  eng.re[eng.off] = ptr - eng.bas;
                }

                if (eng.eo[eng.off] >= eng.so[eng.off]) {
                  /* Note that this is only true if all possibly
                   * nested special repetitions also matched. */

                  if (eng.goff >= 0) {
                      if (eng.cod[5] == Re_Update)
                        eng.gso[eng.goff] = eng.eo[bas] +
                                        (eng.so[bas] > eng.eo[bas]);
                      else if (eng.geo[eng.goff] < eng.so[eng.off])
                        eng.geo[eng.goff] = eng.so[eng.off];
                  }

                  /* Jump relative offset */
                  len = eng.cod[3] | (eng.cod[4] << 8);

                  /* Restore offset from where started trying */
                  eng.so[bas] = eng.ss[eng.off];
                  eng.eo[bas] = eng.eo[eng.off];

                  /* Pop stack and skip code */
                  --eng.off;
                  eng.cod += len;
                }
                else {
                  /* Only give up if the entire string was scanned */
                  if (eng.str < eng.end) {
                      /* Update restart point for next pattern */
                      eng.str = ++eng.rstr[eng.off];

                      /* Reset start of nested match */
                      eng.so[eng.off] = eng.str - eng.bas;

                      /* Skip repetition instruction */
                      eng.cod += 5;
                  }
                  else {
                      /* Entire string scanned and failed */

                      /* Jump relative offset */
                      len = eng.cod[3] | (eng.cod[4] << 8);

                      /* Restore offset from where started trying */
                      eng.so[bas] = eng.ss[eng.off];
                      eng.eo[bas] = eng.ss[eng.off] - 1;

                      /* Pop stack and skip code */
                      --eng.off;
                      eng.cod += len;
                  }
                }
            }
            continue;


          /****************************************************
           * Repetition matched!                      *
           ****************************************************/
          case Re_RepJump:
            /* eng.cod[1] is toplevel offset of repetition */
            if (eng.off > eng.cod[1])
                /* If still needs to try matches */
                eng.cod -= eng.cod[2];
            else
                eng.cod += 3; /* + RepJump + bas + len-size */
            continue;

          case Re_RepLongJump:
            /* eng.cod[1] is toplevel offset of repetition */
            if (eng.off > eng.cod[1])
                /* If still needs to try matches */
                eng.cod -= eng.cod[2] | (eng.cod[3] << 8);
            else
                eng.cod += 4; /* + RepLongJump + bas + len-size */
            continue;

          /****************************************************
           * Finished                                 *
           ****************************************************/
          case Re_DoneIf:
            if (eng.eo[eng.off] >= eng.so[eng.off]) {
                eng.so[0] = eng.ss[eng.off];
                eng.eo[0] = eng.eo[eng.off];
                goto done;
            }
            ++eng.cod;
            continue;
          case Re_MaybeDone:
            if (eng.eo[eng.off] >= eng.so[eng.off]) {
                eng.so[0] = eng.ss[eng.off];
                eng.eo[0] = eng.eo[eng.off];
                goto done;
            }
            ++eng.cod;
            continue;
          case Re_Done:
            goto done;

          default:
            /* Fatal internal error */
            return (RE_ASSERT);
      }


wont:
      /* Surely won't match */
      if (eng.off == 0) {
          eng.eo[0] = eng.so[0] - 1;
          break;
      }


fail:
      if (eng.off == 0) {
          /* If the entire string scanned */
          if (++eng.str > eng.end) {
            eng.eo[0] = eng.so[0] - 1;
            break;
          }
          eng.goff = -1;
          /* Update start of possible match after restart */
          if (eng.eo[0] >= eng.so[0]) {
            /* If first fail */
            eng.str = eng.rstr[0];
            ++eng.rstr[0];
            eng.so[0] = eng.str - eng.bas;
            eng.eo[0] = eng.so[eng.off] - 1;
          }
          else
            /* Just trying at next byte */
            ++eng.so[0];
      }
      else
          /* Remember this match failed */
          eng.eo[eng.off] = eng.so[eng.off] - 1;

      /* Restart code */
      eng.cod = eng.rcod[eng.off];
      continue;


match:
      /* If first match */
      if (eng.eo[eng.off] < eng.so[eng.off]) {
          if (eng.off == 0)
            eng.rstr[0] = eng.str + 1;
          eng.so[eng.off] = eng.eo[eng.off] = eng.str - eng.bas;
      }
      eng.eo[eng.off] += si;
      eng.cod += ci;
      eng.str += si;
      ci = si = 1;
      continue;

done:
      break;
    }

    if (nmatch) {
      if (flags & RE_STARTEND)
          len = pmat[0].rm_so;
      else
          len = 0;
      if (!nosub) {
          if (preg->cod[1] != 0xff)
            eng.goff = preg->cod[1];
          pmat[0].rm_so = eng.so[0];
          pmat[0].rm_eo = eng.eo[0];
          for (i = 1; i < nmatch; i++) {
            if (i - 1 <= eng.goff) {
                pmat[i].rm_so = eng.gso[i - 1];
                pmat[i].rm_eo = eng.geo[i - 1];
            }
            else {
                pmat[i].rm_so = 0;
                pmat[i].rm_eo = -1;
            }
          }
          if (len) {
            /* Update offsets, since the match was done in a substring */
            j = eng.goff + 2 > nmatch ? nmatch : eng.goff + 2;
            for (i = 0; i < j; i++) {
                pmat[i].rm_so += len;
                pmat[i].rm_eo += len;
            }
          }
      }
      else {
          /*      Already know these values, allow compiling the regex with
           * RE_NOSUB to use parenthesis only for grouping, but avoiding
           * the runtime overhead of keeping track of the subexpression
           * offsets. */
          pmat[0].rm_so = eng.so[0] + len;
          pmat[0].rm_eo = eng.eo[0] + len;
      }
    }

    return (eng.so[0] <= eng.eo[0] ? 0 : RE_NOMATCH);
}

int
reerror(int ecode, const re_cod *preg, char *ebuffer, int ebuffer_size)
{
    static char *errors[] = {
      "No error",
      "Failed to match",                  /* NOMATCH */

      /* Errors not generated */
      "Invalid regular expression",       /* BADPAT */
      "Invalid collating element",        /* ECOLLATE */
      "Invalid character class",          /* ECTYPE */

      "`\' applied to unescapable character",   /* EESCAPE */
      "Invalid backreference number",           /* ESUBREG */
      "Brackets `[ ]' not balanced",            /* EBRACK */
      "Parentheses `( )' not balanced",   /* EPAREN */
      "Braces `{ }' not balanced",        /* EBRACE */
      "Invalid repetition count(s) in `{ }'",   /* BADBR */
      "Invalid character range in `[ ]'", /* ERANGE */
      "Out of memory",              /* ESPACE */
      "`?', `*', or `+' operand invalid", /* BADRPT */
      "Empty (sub)expression",            /* EMPTY */
      "Assertion error - you found a bug",      /* ASSERT */
      "Invalid argument"                  /* INVARG */
    };
    char *str;

    if (ecode >= 0 && ecode < sizeof(errors) / sizeof(errors[0]))
      str = errors[ecode];
    else
      str = "Unknown error";

    return (snprintf(ebuffer, ebuffer_size, "%s", str));
}

void
refree(re_cod *cod)
{
    free(cod->cod);
    cod->cod = NULL;
}

static void
reinit(void)
{
    int i;
    static int first = 1;

    if (!first)
      return;
    first = 0;

    re__alnum['_'] = 1;

    for (i = '0'; i <= '7'; i++)
      re__alnum[i] = re__odigit[i] = re__ddigit[i] = re__xdigit[i] = 1;

    for (; i <= '9'; i++)
      re__alnum[i] = re__ddigit[i] = re__xdigit[i] = 1;

    for (i = 'a'; i <= 'f'; i++)
      re__alnum[i] = re__xdigit[i] = 1;
    for (; i <= 'z'; i++)
      re__alnum[i] = 1;

    for (i = 'A'; i <= 'F'; i++)
      re__alnum[i] = re__xdigit[i] = 1;
    for (; i <= 'Z'; i++)
      re__alnum[i] = 1;

    for (i = 1; i < 32; i++)
      re__control[i] = 1;
    re__control[127] = 1;
    /* Don't show tabs as control characters */
    re__control['\t'] = 0;
}

static int
rec_check(re_inf *inf, int count)
{
    if (inf->len + count >= inf->spc) {
      int spc;
      unsigned char *cod;

      if ((spc = (count % 64)) != 0)
          spc = 64 - spc;
      spc += count + inf->spc;
      if ((cod = realloc(inf->cod, spc)) == NULL)
          return (inf->ecode = RE_ESPACE);
      inf->cod = cod;
      inf->spc = spc;
    }

    return (inf->ecode);
}

static int
rec_code(re_inf *inf, ReCode code)
{
    if (rec_check(inf, 1) == 0)
      inf->cod[inf->len++] = code;

    return (inf->ecode);
}

static int
rec_byte(re_inf *inf, int value)
{
    if (rec_check(inf, 1) == 0)
      inf->cod[inf->len++] = value;

    return (inf->ecode);
}

static int
rec_code_byte(re_inf *inf, ReCode code, int value)
{
    if (rec_check(inf, 2) == 0) {
      inf->cod[inf->len++] = code;
      inf->cod[inf->len++] = value;
    }

    return (inf->ecode);
}

static int
rec_length(re_inf *inf, int length)
{
    int lo, hi, two;

    if (length >= 16384)
      return (inf->ecode = RE_ESPACE);

    lo = length & 0xff;
    hi = length & 0xff00;
    two = ((length > 0x7f) != 0) + 1;
    if (two == 2) {
      hi <<= 1;
      hi |= (lo & 0x80) != 0;
      lo |= 0x80;
    }

    if (rec_check(inf, two) == 0) {
      inf->cod[inf->len++] = lo;
      if (two == 2)
          inf->cod[inf->len++] = hi >> 8;
    }

    return (inf->ecode);
}

static int
rec_byte_byte(re_inf *inf, int value0, int value1)
{
    if (rec_check(inf, 2) == 0) {
      inf->cod[inf->len++] = value0;
      inf->cod[inf->len++] = value1;
    }

    return (inf->ecode);
}

static int
rec_code_byte_byte(re_inf *inf, ReCode code, int value0, int value1)
{
    if (rec_check(inf, 3) == 0) {
      inf->cod[inf->len++] = code;
      inf->cod[inf->len++] = value0;
      inf->cod[inf->len++] = value1;
    }

    return (inf->ecode);
}

static int
rec_build_alt(re_inf *inf, rec_alt *alt)
{
    int offset, value, bas = inf->bas + 1;

    if (alt) {
      if (alt->next) {
          if (rec_inc_spc(inf))
            return (inf->ecode);

          /* A real a list of alternatives */
          rec_code(inf, Re_Alt);

          offset = inf->len;        /* Remember current offset */
          rec_byte_byte(inf, 0, 0); /* Reserve two bytes for retry address */
          while (alt && inf->ecode == 0) {
            if (rec_build_pat(inf, alt->pat))
                break;
            alt = alt->next;
            if (alt && inf->ecode == 0) {
                /* Handle (hyper)complex repetitions */
                if (inf->bas != bas) {
                  /* Duplicate patterns up to end of expression */
                  rec_build_pat(inf, inf->apat);
                  /* Restore engine state for next alternative(s) */
                  rec_alt_spc(inf, bas - 1);
                }

                /* If the jump would be so long */
                if ((value = inf->len - offset) >= 16384) {
                  inf->ecode = RE_ESPACE;
                  break;
                }
                inf->cod[offset] = value & 0xff;
                inf->cod[offset + 1] = (value & 0xff00) >> 8;

                rec_code(inf, Re_AltNext);
                offset = inf->len;
                rec_byte_byte(inf, 0, 0);
            }
          }
          if (inf->ecode == 0) {
            /* Handle (hyper)complex repetitions */
            if (inf->bas != bas) {
                /* Duplicate patterns up to end of expression */
                rec_build_pat(inf, inf->apat);
                /* Restore engine state for next alternative(s) */
                rec_alt_spc(inf, bas - 1);
            }

            /* If the jump would be so long */
            if ((value = inf->len - offset) >= 16384)
                return (inf->ecode = RE_ESPACE);
            inf->cod[offset] = value & 0xff;
            inf->cod[offset + 1] = (value & 0xff00) >> 8;
            /* Last jump is here */
            rec_code(inf, Re_AltDone);
          }
          rec_dec_spc(inf);
      }
      else
          /* Single alternative */
          rec_build_pat(inf, alt->pat);
    }

    return (inf->ecode);
}

static int
rec_build_pat(re_inf *inf, rec_pat *pat)
{
    rec_pat *apat;
    int length, offset = 0, distance, jump = 0, bas = 0;

    while (pat && inf->ecode == 0) {
      if (pat->rep) {
          bas = inf->bas;
          if (pat->type == Rep_Group && !inf->par && rec_code(inf, Re_Open))
            return (inf->ecode);
          if (rec_inc_spc(inf))
            return (inf->ecode);
          offset = inf->len;
          if (rec_build_rep(inf, pat->rep))
            break;
          /* Reserve space to jump after repetition done */
          jump = inf->len;
          rec_byte_byte(inf, 0, 0);
      }
      switch (pat->type) {
          case Rep_AnyAnyTimes:
          case Rep_AnyMaybe:
          case Rep_AnyAtLeast:
            if (rec_add_spc(inf, pat->type == Rep_AnyMaybe))
                return (inf->ecode);
            if (rec_code(inf, (ReCode)pat->type) == 0 &&
                rec_byte(inf, inf->bas - 1) == 0 &&
                rec_byte(inf, inf->ref - 1) == 0)
                rec_off_spc(inf);
            break;
          case Rep_Literal:
          case Rep_LiteralNot:
          case Rep_SearchLiteral:
            rec_code_byte(inf, (ReCode)pat->type, pat->data.chr);
            break;
          case Rep_CaseLiteral:
          case Rep_CaseLiteralNot:
          case Rep_SearchCaseLiteral:
            rec_code_byte_byte(inf, (ReCode)pat->type,
                           pat->data.cse.lower, pat->data.cse.upper);
            break;
          case Rep_Range:
          case Rep_RangeNot:
            if (rec_code(inf, (ReCode)pat->type) == 0)
                rec_build_rng(inf, pat->data.rng);
            break;
          case Rep_String:
          case Rep_SearchString:
          case Rep_CaseString:
          case Rep_SearchCaseString:
            rec_code(inf, (ReCode)pat->type);
            length = strlen((char*)pat->data.str);
            if (rec_length(inf, length) == 0 && rec_check(inf, length) == 0) {
                memcpy(inf->cod + inf->len, pat->data.str, length);
                inf->len += length;
            }
            break;
          case Rep_Any:
          case Rep_AnyEatAnyTimes:
          case Rep_AnyEatMaybe:
          case Rep_AnyEatAtLeast:
          case Rep_Odigit:
          case Rep_OdigitNot:
          case Rep_Digit:
          case Rep_DigitNot:
          case Rep_Xdigit:
          case Rep_XdigitNot:
          case Rep_Space:
          case Rep_SpaceNot:
          case Rep_Tab:
          case Rep_Newline:
          case Rep_Lower:
          case Rep_Upper:
          case Rep_Alnum:
          case Rep_AlnumNot:
          case Rep_Control:
          case Rep_ControlNot:
          case Rep_Bol:
          case Rep_Eol:
          case Rep_Bow:
          case Rep_Eow:
            rec_code(inf, (ReCode)pat->type);
            break;
          case Rep_Backref:
            rec_code_byte(inf, Re_Backref, pat->data.chr);
            break;
          case Rep_Group:
            if (pat->rep == NULL && !inf->par && rec_code(inf, Re_Open))
                break;
            apat = inf->apat;
            inf->apat = pat->next;
            rec_build_grp(inf, pat->data.grp);
            inf->apat = apat;
            break;
          case Rep_StringList:
            rec_build_stl(inf, pat->data.stl);
            break;
      }
      if (pat->rep) {
#if 0
          if (rec_dec_spc(inf))
            return (inf->ecode);
#else
          if (rec_rep_spc(inf, bas))
            return (inf->ecode);
#endif
          distance = inf->len - offset;
          if (distance > 255) {
            if (rec_code(inf, Re_RepLongJump) ||
                rec_byte(inf, inf->bas) ||
                rec_byte(inf, distance & 0xff) ||
                rec_byte(inf, (distance & 0xff00) >> 8))
            break;
          }
          else if (rec_code(inf, Re_RepJump) ||
                 rec_byte(inf, inf->bas) ||
                 rec_byte(inf, distance))
            break;
          distance = inf->len - offset;
          inf->cod[jump] = distance & 0xff;
          inf->cod[jump + 1] = (distance & 0xff00) >> 8;
      }
      pat = pat->next;
    }

    return (inf->ecode);
}

static int
rec_build_rng(re_inf *inf, rec_rng *rng)
{
    if (rec_check(inf, sizeof(rng->range)) == 0) {
      memcpy(inf->cod + inf->len, rng->range, sizeof(rng->range));
      inf->len += sizeof(rng->range);
    }

    return (inf->ecode);
}

static int
rec_build_grp(re_inf *inf, rec_grp *grp)
{
    int par = inf->par;

    if (!(inf->flags & RE_NOSUB)) {
      ++inf->par;
      if (par == 0)
          ++inf->ref;
      if (rec_build_alt(inf, grp->alt) == 0) {
          if (par == 0) {
            if (grp->comp)
                rec_code_byte(inf, Re_Update, inf->ref - 1);
            else
                rec_code(inf, Re_Close);
          }
      }
      --inf->par;
    }
    else
      rec_build_alt(inf, grp->alt);

    return (inf->ecode);
}

static int
rec_build_stl(re_inf *inf, rec_stl *stl)
{
    int i, len, rlen;
    ReCode code;

    /* Calculate jump distance information */
    rlen = stl->tlen + stl->nstrs + 4;
    /* + code + nstrs + place-offset + data-length */

    if (stl->nstrs >= LARGE_STL_COUNT) {
      rlen += 511;            /* Don't write number of strings */
      code = stl->type == Rep_StringList ?
            Re_LargeStringList : Re_LargeCaseStringList;
    }
    else
      code = (ReCode)stl->type;

    if (rlen >= 16386)
      return (inf->ecode = RE_ESPACE);
    if (rec_check(inf, rlen) ||
      rec_code(inf, code))
      return (inf->ecode);

    /* Space is allocated, just write the data */
    if (stl->nstrs < LARGE_STL_COUNT)
      inf->cod[inf->len++] = stl->nstrs;

    inf->cod[inf->len++] = rlen & 0xff;
    inf->cod[inf->len++] = (rlen & 0xff00) >> 8;

    if (stl->nstrs < LARGE_STL_COUNT) {
      for (i = 0; i < stl->nstrs; i++)
          inf->cod[inf->len++] = stl->lens[i];
      for (i = 0; i < stl->nstrs; i++) {
          len = stl->lens[i];
          if (len > 2) {
            memcpy(inf->cod + inf->len, stl->strs[i], len);
            inf->len += len;
          }
          else {
            if (len == 1)
                inf->cod[inf->len++] = (long)stl->strs[i];
            else {
                inf->cod[inf->len++] = (long)stl->strs[i] & 0xff;
                inf->cod[inf->len++] = ((long)stl->strs[i] & 0xff00) >> 8;
            }
          }
      }
    }
    else {
      /* The string length goes before the string itself */
      int j, chl, chu;

      /* Fill everything with an invalid jump address */
      memset(inf->cod + inf->len, 0xff, 512);
      for (i = len = 0, j = -1; i < stl->nstrs; i++) {
          chl = stl->lens[i] > 2 ? stl->strs[i][0] : (long)stl->strs[i] & 0xff;
          if (chl != j) {
            inf->cod[inf->len + (chl << 1)] = len & 0xff;
            inf->cod[inf->len + (chl << 1) + 1] = (len & 0xff00) >> 8;
            if (code == Re_LargeCaseStringList) {
                chu = stl->lens[i] > 2 ?
                  stl->strs[i][1] : ((long)(stl->strs[i]) & 0xff00) >> 8;
                inf->cod[inf->len + (chu << 1)] = len & 0xff;
                inf->cod[inf->len + (chu << 1) + 1] = (len & 0xff00) >> 8;
            }
            j = chl;
          }
          len += stl->lens[i] + 1;
      }
      inf->len += 512;

      for (i = 0; i < stl->nstrs; i++) {
          len = stl->lens[i];
          inf->cod[inf->len++] = len;
          if (len > 2) {
            memcpy(inf->cod + inf->len, stl->strs[i], len);
            inf->len += len;
          }
          else {
            if (len == 1)
                inf->cod[inf->len++] = (long)stl->strs[i];
            else {
                inf->cod[inf->len++] = (long)stl->strs[i] & 0xff;
                inf->cod[inf->len++] = ((long)stl->strs[i] & 0xff00) >> 8;
            }
          }
      }
    }

    return (inf->ecode);
}

static int
rec_build_rep(re_inf *inf, rec_rep *rep)
{
    if (rep) {
      switch (rep->type) {
          case Rer_AnyTimes:
          case Rer_AtLeast:
          case Rer_Maybe:
            rec_code(inf, (ReCode)rep->type);
            break;
          case Rer_Exact:
            if (rec_code(inf, Re_Exact) == 0)
                rec_byte(inf, rep->mine);
            break;
          case Rer_Min:
            if (rec_code(inf, Re_Min) == 0)
                rec_byte(inf, rep->mine);
            break;
          case Rer_Max:
            if (rec_code(inf, Re_Max) == 0)
                rec_byte(inf, rep->maxc);
            break;
          case Rer_MinMax:
            if (rec_code(inf, Re_MinMax) == 0 &&
                rec_byte(inf, rep->mine) == 0)
                rec_byte(inf, rep->maxc);
            break;
      }
      /* It is incremented in rec_build_pat */
      rec_byte(inf, inf->bas - 1);
    }

    return (inf->ecode);
}

static int
rec_inc_spc(re_inf *inf)
{
    if (++inf->bas >= MAX_DEPTH)
      return (inf->ecode = RE_ESPACE);

    return (inf->ecode);
}

static int
rec_dec_spc(re_inf *inf)
{
    if (--inf->bas < 0)
      return (inf->ecode = RE_ASSERT);

    return (inf->ecode);
}

static int
rec_add_spc(re_inf *inf, int maybe)
{
    if (++inf->bas >= MAX_DEPTH)
      return (inf->ecode = RE_ESPACE);
    inf->sp[inf->bas] = maybe + 1;

    return (inf->ecode);
}

/* Could be joined with rec_rep_spc, code almost identical */
static int
rec_alt_spc(re_inf *inf, int top)
{
    int distance, i, bas = inf->bas;

    while ((inf->bas > top) && inf->sp[inf->bas]) {
      /* Jump to this repetition for cleanup */
      distance = inf->len - inf->sr[inf->bas];

      /* This will generate a jump to a jump decision opcode */
      inf->sj[inf->bas] = inf->len;

      if (distance > 255) {
          if (rec_code(inf, Re_RepLongJump) ||
            rec_byte(inf, inf->bas - 1) ||
            rec_byte(inf, distance & 0xff) ||
            rec_byte(inf, (distance & 0xff00) >> 8))
          break;
      }
      else if (rec_code(inf, Re_RepJump) ||
             rec_byte(inf, inf->bas - 1) ||
             rec_byte(inf, distance))
          break;

      /* Top of stack value before repetition, or end condition value */
      --inf->bas;
    }

    i = inf->bas + 1;

    if (inf->ecode == 0 && i <= bas && inf->sp[i]) {
      /*  Only the repetition at the bottom jump to code after testing
       * all possibilities */
      distance = inf->len - inf->sr[i];
      inf->cod[inf->sr[i] + 3] = distance & 0xff;
      inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;

      /* The bottom jump is here */
      if (rec_code(inf, inf->sp[i] == 1 ? Re_DoneIf : Re_MaybeDone))
         return (inf->ecode);

      /*  Generate jumps to the previous special repetition */
      for (++i; i <= bas; i++) {
          if (inf->sp[i]) {
            distance = inf->sj[i] - inf->sr[i];
            inf->cod[inf->sr[i] + 3] = distance & 0xff;
            inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;
          }
      }
    }

    return (inf->ecode);
}

static int
rec_rep_spc(re_inf *inf, int top)
{
    int distance, i, bas = inf->bas;

    while (inf->bas > top) {
      if (inf->sp[inf->bas]) {
          /* Jump to this repetition for cleanup */
          distance = inf->len - inf->sr[inf->bas];

          /* This will generate a jump to a jump decision opcode */
          inf->sj[inf->bas] = inf->len;

          if (distance > 255) {
            if (rec_code(inf, Re_RepLongJump) ||
                rec_byte(inf, inf->bas - 1) ||
                rec_byte(inf, distance & 0xff) ||
                rec_byte(inf, (distance & 0xff00) >> 8))
            break;
          }
          else if (rec_code(inf, Re_RepJump) ||
                 rec_byte(inf, inf->bas - 1) ||
                 rec_byte(inf, distance))
            break;
      }

      /* Top of stack value before repetition, or end condition value */
      --inf->bas;
    }

    /* Find first special repetition offset. XXX This should be a noop */
    for (i = 0; i < bas; i++)
      if (inf->sp[i])
          break;

    if (inf->ecode == 0 && i <= bas && inf->sp[i]) {
      /*  Only the repetition at the bottom jump to code after testing
       * all possibilities */
      distance = inf->len - inf->sr[i];
      inf->cod[inf->sr[i] + 3] = distance & 0xff;
      inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;

      /*  Generate jumps to the previous special repetition */
      for (++i; i <= bas; i++) {
          if (inf->sp[i]) {
            distance = inf->sj[i] - inf->sr[i];
            inf->cod[inf->sr[i] + 3] = distance & 0xff;
            inf->cod[inf->sr[i] + 4] = (distance & 0xff00) >> 8;
          }
      }
    }

    return (inf->ecode);
}

static int
rec_off_spc(re_inf *inf)
{
    /* The jump address before the three bytes instruction */
    inf->sr[inf->bas] = inf->len - 3;
    /*  Don't know yet where to go after done with the special
     * repetition, just reserve two bytes for the jump address. */
    return (rec_byte_byte(inf, 0, 0));
}

#ifdef DEBUG
static void
redump(re_cod *code)
{
    int i, j, k;
    unsigned char *cod = code->cod, *stl;

    if (cod[0] & RE_NOSUB)
      printf("Nosub\n");
    if (cod[0] & RE_NEWLINE)
      printf("Newline\n");
    ++cod;
    if (cod[0] != 0xff)
      printf("%d backrefs\n", cod[0] + 1);
    ++cod;
    for (;;) {
      switch (*cod++) {
          case Re_Open:
            printf("Open");
            break;
          case Re_Close:
            printf("Close");
            break;
          case Re_Update:
            printf("Update (%d)", (int)*cod++);
            break;
          case Re_Alt:
            printf("Alt");
            i = cod[0] | cod[1];
            cod += 2;
            printf(" %d", i);
            break;
          case Re_AltNext:
            printf("Alt-next");
            i = cod[0] | cod[1];
            cod += 2;
            printf(" %d", i);
            break;
          case Re_AltDone:
            printf("Alt-done");
            break;
          case Re_AnyTimes:
            printf("-> Anytimes %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_AnyEatAnyTimes:
            printf("Any-eat-anytimes");
            break;
          case Re_AnyAnyTimes:
            printf("-> Any-anytimes %d", (int)*cod++);
            printf(" (%d)", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_AnyEatMaybe:
            printf("Any-eat-maybe");
            break;
          case Re_AnyMaybe:
            printf("-> Any-maybe %d", (int)*cod++);
            printf(" (%d)", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_AnyAtLeast:
            printf("-> Any-atleast %d", (int)*cod++);
            printf(" (%d)", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_AnyEatAtLeast:
            printf("Any-eat-atleast");
            break;
          case Re_Maybe:
            printf("-> Maybe %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_AtLeast:
            printf("-> Atleast %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_Exact:
            printf("-> Exact ");
            i = *cod++;
            printf("%d", i);
            printf(" %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_Min:
            printf("-> Min ");
            i = *cod++;
            printf("%d", i);
            printf(" %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_Max:
            printf("-> Max ");
            i = *cod++;
            printf("%d", i);
            printf(" %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_MinMax:
            printf("-> Min-max ");
            i = *cod++;
            printf("%d ", i);
            i = *cod++;
            printf("%d", i);
            printf(" %d", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            cod += 2;
            printf(" /%d", i);
            break;
          case Re_RepJump:
            printf("<- Rep-jump %d ", (int)*cod++);
            i = *cod++;
            printf("%d", i);
            break;
          case Re_RepLongJump:
            printf("<- Rep-long-jump %d ", (int)*cod++);
            i = cod[0] | (cod[1] << 8);
            printf("%d", i);
            break;
          case Re_Any:
            printf("Any");
            break;
          case Re_Odigit:
            printf("Odigit");
            break;
          case Re_OdigitNot:
            printf("Odigit-not");
            break;
          case Re_Digit:
            printf("Digit");
            break;
          case Re_DigitNot:
            printf("Digit-not");
            break;
          case Re_Xdigit:
            printf("Xdigit");
            break;
          case Re_XdigitNot:
            printf("Xdigit-not");
            break;
          case Re_Space:
            printf("Space");
            break;
          case Re_SpaceNot:
            printf("Space-not");
            break;
          case Re_Tab:
            printf("Tab");
            break;
          case Re_Newline:
            printf("Newline");
            break;
          case Re_Lower:
            printf("Lower");
            break;
          case Re_Upper:
            printf("Upper");
            break;
          case Re_Alnum:
            printf("Alnum");
            break;
          case Re_AlnumNot:
            printf("Alnum-not");
            break;
          case Re_Control:
            printf("Control");
            break;
          case Re_ControlNot:
            printf("Control-not");
            break;
          case Re_Bol:
            printf("Bol");
            break;
          case Re_Eol:
            printf("Eol");
            break;
          case Re_Bow:
            printf("Bow");
            break;
          case Re_Eow:
            printf("Eow");
            break;
          case Re_Range:
            printf("Range ");
            goto range;
          case Re_RangeNot:
            printf("Range-not ");
range:
            for (i = 0; i < 256; i += 32) {
                for (j = k = 0; j < 32; j++)
                  k |= (*cod++ & 1) << (31 - j);
                printf("%x ", k);
            }
            break;
          case Re_Literal:
            printf("Literal %c", *cod++);
            break;
          case Re_LiteralNot:
            printf("Literal-not %c", *cod++);
            break;
          case Re_SearchLiteral:
            printf("Search-literal %c", *cod++);
            break;
          case Re_CaseLiteral:
            printf("Case-literal %c", *cod++);
            putchar(*cod++);
            break;
          case Re_CaseLiteralNot:
            printf("Case-literal-not %c", *cod++);
            putchar(*cod++);
            break;
          case Re_SearchCaseLiteral:
            printf("Search-case-literal %c", *cod++);
            putchar(*cod++);
            break;
          case Re_String:
            printf("String ");
            goto string;
          case Re_SearchString:
            printf("Search-string ");
            goto string;
          case Re_CaseString:
            printf("Case-string ");
            goto string;
          case Re_SearchCaseString:
            printf("Search-case-string ");
string:
            i = *cod++;
            if (i & 0x80)
                i = (i & 0x7f) | (*cod++ << 7);
            for (j = 0; j < i; j++)
                putchar(*cod++);
            break;
          case Re_StringList:
            printf("String-list");
            goto string_list;
          case Re_CaseStringList:
            printf("Case-string-list");
string_list:
            j = *cod++;
            cod += 2;
            stl = cod + j;
            for (i = 0; i < j; i++) {
                k = *cod++;
                putchar(i ? ',' : ' ');
                fwrite(stl, k, 1, stdout);
                stl += k;
            }
            cod = stl;
            break;
          case Re_LargeStringList:
            printf("Large-string-list");
large_string_list:
            i = cod[0] | (cod[1] << 8);
            stl = cod + i - 1;
            for (i = 0, cod += 514; cod < stl; i++) {
                k = *cod++;
                putchar(i ? ',' : ' ');
                fwrite(cod, k, 1, stdout);
                cod += k;
            }
            cod = stl;
            break;
          case Re_LargeCaseStringList:
            printf("Large-case-string-list");
            goto large_string_list;
          case Re_Backref:
            printf("Backref %d", (int)*cod++);
            break;
          case Re_DoneIf:
            printf("Done-if");
            break;
          case Re_MaybeDone:
            printf("Maybe-done");
            break;
          case Re_Done:
            printf("Done\n");
            return;
      }
      putchar('\n');
    }
}
#endif

Generated by  Doxygen 1.6.0   Back to index