home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / ixemul-45.0-src.tgz / tar.out / contrib / ixemul / static / regexec.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  7KB  |  188 lines
  1. /*    $NetBSD: regexec.c,v 1.6 1995/02/27 13:29:48 cgd Exp $    */
  2.  
  3. /*-
  4.  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  5.  * Copyright (c) 1992, 1993, 1994
  6.  *    The Regents of the University of California.  All rights reserved.
  7.  *
  8.  * This code is derived from software contributed to Berkeley by
  9.  * Henry Spencer.
  10.  *
  11.  * Redistribution and use in source and binary forms, with or without
  12.  * modification, are permitted provided that the following conditions
  13.  * are met:
  14.  * 1. Redistributions of source code must retain the above copyright
  15.  *    notice, this list of conditions and the following disclaimer.
  16.  * 2. Redistributions in binary form must reproduce the above copyright
  17.  *    notice, this list of conditions and the following disclaimer in the
  18.  *    documentation and/or other materials provided with the distribution.
  19.  * 3. All advertising materials mentioning features or use of this software
  20.  *    must display the following acknowledgement:
  21.  *    This product includes software developed by the University of
  22.  *    California, Berkeley and its contributors.
  23.  * 4. Neither the name of the University nor the names of its contributors
  24.  *    may be used to endorse or promote products derived from this software
  25.  *    without specific prior written permission.
  26.  *
  27.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37.  * SUCH DAMAGE.
  38.  *
  39.  *    @(#)regexec.c    8.3 (Berkeley) 3/20/94
  40.  */
  41.  
  42. #if defined(LIBC_SCCS) && !defined(lint)
  43. #if 0
  44. static char sccsid[] = "@(#)regexec.c    8.3 (Berkeley) 3/20/94";
  45. #else
  46. static char rcsid[] = "$NetBSD: regexec.c,v 1.6 1995/02/27 13:29:48 cgd Exp $";
  47. #endif
  48. #endif /* LIBC_SCCS and not lint */
  49.  
  50. /*
  51.  * the outer shell of regexec()
  52.  *
  53.  * This file includes engine.h *twice*, after muchos fiddling with the
  54.  * macros that code uses.  This lets the same code operate on two different
  55.  * representations for state sets.
  56.  */
  57. #include <sys/types.h>
  58. #include <stdio.h>
  59. #include <stdlib.h>
  60. #include <string.h>
  61. #include <limits.h>
  62. #include <ctype.h>
  63. #include <regex.h>
  64.  
  65. #include "utils.h"
  66. #include "regex2.h"
  67.  
  68. static int nope = 0;        /* for use in asserts; shuts lint up */
  69.  
  70. /* macros for manipulating states, small version */
  71. #define    states    long
  72. #define    states1    states        /* for later use in regexec() decision */
  73. #define    CLEAR(v)    ((v) = 0)
  74. #define    SET0(v, n)    ((v) &= ~((unsigned long)1 << (n)))
  75. #define    SET1(v, n)    ((v) |= (unsigned long)1 << (n))
  76. #define    ISSET(v, n)    (((v) & ((unsigned long)1 << (n))) != 0)
  77. #define    ASSIGN(d, s)    ((d) = (s))
  78. #define    EQ(a, b)    ((a) == (b))
  79. #define    STATEVARS    long dummy    /* dummy version */
  80. #define    STATESETUP(m, n)    /* nothing */
  81. #define    STATETEARDOWN(m)    /* nothing */
  82. #define    SETUP(v)    ((v) = 0)
  83. #define    onestate    long
  84. #define    INIT(o, n)    ((o) = (unsigned long)1 << (n))
  85. #define    INC(o)    ((unsigned long)(o) <<= 1)
  86. #define    ISSTATEIN(v, o)    (((v) & (o)) != 0)
  87. /* some abbreviations; note that some of these know variable names! */
  88. /* do "if I'm here, I can also be there" etc without branches */
  89. #define    FWD(dst, src, n)    ((dst) |= ((unsigned long)(src)&(here)) << (n))
  90. #define    BACK(dst, src, n)    ((dst) |= ((unsigned long)(src)&(here)) >> (n))
  91. #define    ISSETBACK(v, n)    (((v) & ((unsigned long)here >> (n))) != 0)
  92. /* function names */
  93. #define SNAMES            /* engine.h looks after details */
  94.  
  95. #include "engine.h"
  96.  
  97. /* now undo things */
  98. #undef    states
  99. #undef    CLEAR
  100. #undef    SET0
  101. #undef    SET1
  102. #undef    ISSET
  103. #undef    ASSIGN
  104. #undef    EQ
  105. #undef    STATEVARS
  106. #undef    STATESETUP
  107. #undef    STATETEARDOWN
  108. #undef    SETUP
  109. #undef    onestate
  110. #undef    INIT
  111. #undef    INC
  112. #undef    ISSTATEIN
  113. #undef    FWD
  114. #undef    BACK
  115. #undef    ISSETBACK
  116. #undef    SNAMES
  117.  
  118. /* macros for manipulating states, large version */
  119. #define    states    char *
  120. #define    CLEAR(v)    memset(v, 0, m->g->nstates)
  121. #define    SET0(v, n)    ((v)[n] = 0)
  122. #define    SET1(v, n)    ((v)[n] = 1)
  123. #define    ISSET(v, n)    ((v)[n])
  124. #define    ASSIGN(d, s)    memcpy(d, s, m->g->nstates)
  125. #define    EQ(a, b)    (memcmp(a, b, m->g->nstates) == 0)
  126. #define    STATEVARS    long vn; char *space
  127. #define    STATESETUP(m, nv)    { (m)->space = malloc((nv)*(m)->g->nstates); \
  128.                 if ((m)->space == NULL) return(REG_ESPACE); \
  129.                 (m)->vn = 0; }
  130. #define    STATETEARDOWN(m)    { free((m)->space); }
  131. #define    SETUP(v)    ((v) = &m->space[m->vn++ * m->g->nstates])
  132. #define    onestate    long
  133. #define    INIT(o, n)    ((o) = (n))
  134. #define    INC(o)    ((o)++)
  135. #define    ISSTATEIN(v, o)    ((v)[o])
  136. /* some abbreviations; note that some of these know variable names! */
  137. /* do "if I'm here, I can also be there" etc without branches */
  138. #define    FWD(dst, src, n)    ((dst)[here+(n)] |= (src)[here])
  139. #define    BACK(dst, src, n)    ((dst)[here-(n)] |= (src)[here])
  140. #define    ISSETBACK(v, n)    ((v)[here - (n)])
  141. /* function names */
  142. #define    LNAMES            /* flag */
  143.  
  144. #include "engine.h"
  145.  
  146. /*
  147.  - regexec - interface for matching
  148.  = extern int regexec(const regex_t *, const char *, size_t, \
  149.  =                    regmatch_t [], int);
  150.  = #define    REG_NOTBOL    00001
  151.  = #define    REG_NOTEOL    00002
  152.  = #define    REG_STARTEND    00004
  153.  = #define    REG_TRACE    00400    // tracing of execution
  154.  = #define    REG_LARGE    01000    // force large representation
  155.  = #define    REG_BACKR    02000    // force use of backref code
  156.  *
  157.  * We put this here so we can exploit knowledge of the state representation
  158.  * when choosing which matcher to call.  Also, by this point the matchers
  159.  * have been prototyped.
  160.  */
  161. int                /* 0 success, REG_NOMATCH failure */
  162. regexec(preg, string, nmatch, pmatch, eflags)
  163. const regex_t *preg;
  164. const char *string;
  165. size_t nmatch;
  166. regmatch_t pmatch[];
  167. int eflags;
  168. {
  169.     register struct re_guts *g = preg->re_g;
  170. #ifdef REDEBUG
  171. #    define    GOODFLAGS(f)    (f)
  172. #else
  173. #    define    GOODFLAGS(f)    ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
  174. #endif
  175.  
  176.     if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
  177.         return(REG_BADPAT);
  178.     assert(!(g->iflags&BAD));
  179.     if (g->iflags&BAD)        /* backstop for no-debug case */
  180.         return(REG_BADPAT);
  181.     eflags = GOODFLAGS(eflags);
  182.  
  183.     if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
  184.         return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
  185.     else
  186.         return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
  187. }
  188.