home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / regex / regexec.c < prev    next >
C/C++ Source or Header  |  2000-08-31  |  4KB  |  140 lines
  1. /*
  2.  * the outer shell of regexec()
  3.  *
  4.  * This file includes engine.c *twice*, after muchos fiddling with the
  5.  * macros that code uses.  This lets the same code operate on two different
  6.  * representations for state sets.
  7.  */
  8. #include <global.h>
  9. #include <m_string.h>
  10. #include <m_ctype.h>
  11. #include <regex.h>
  12. #ifdef __WIN__
  13. #include  <limits.h>
  14. #endif
  15.  
  16. #include "utils.h"
  17. #include "regex2.h"
  18.  
  19. static int nope = 0;        /* for use in asserts; shuts lint up */
  20.  
  21. /* macros for manipulating states, small version */
  22. #define    states    long
  23. #define    states1    states        /* for later use in regexec() decision */
  24. #define    CLEAR(v)    ((v) = 0)
  25. #define    SET0(v, n)    ((v) &= ~(1 << (n)))
  26. #define    SET1(v, n)    ((v) |= 1 << (n))
  27. #define    ISSET(v, n)    ((v) & (1 << (n)))
  28. #define    ASSIGN(d, s)    ((d) = (s))
  29. #define    EQ(a, b)    ((a) == (b))
  30. #define    STATEVARS    int dummy    /* dummy version */
  31. #define    STATESETUP(m, n)    /* nothing */
  32. #define    STATETEARDOWN(m)    /* nothing */
  33. #define    SETUP(v)    ((v) = 0)
  34. #define    onestate    int
  35. #define    INIT(o, n)    ((o) = (unsigned)1 << (n))
  36. #define    INC(o)    ((o) <<= 1)
  37. #define    ISSTATEIN(v, o)    ((v) & (o))
  38. /* some abbreviations; note that some of these know variable names! */
  39. /* do "if I'm here, I can also be there" etc without branches */
  40. #define    FWD(dst, src, n)    ((dst) |= ((unsigned)(src)&(here)) << (n))
  41. #define    BACK(dst, src, n)    ((dst) |= ((unsigned)(src)&(here)) >> (n))
  42. #define    ISSETBACK(v, n)    ((v) & ((unsigned)here >> (n)))
  43. /* function names */
  44. #define SNAMES            /* engine.c looks after details */
  45.  
  46. #include "engine.c"
  47.  
  48. /* now undo things */
  49. #undef    states
  50. #undef    CLEAR
  51. #undef    SET0
  52. #undef    SET1
  53. #undef    ISSET
  54. #undef    ASSIGN
  55. #undef    EQ
  56. #undef    STATEVARS
  57. #undef    STATESETUP
  58. #undef    STATETEARDOWN
  59. #undef    SETUP
  60. #undef    onestate
  61. #undef    INIT
  62. #undef    INC
  63. #undef    ISSTATEIN
  64. #undef    FWD
  65. #undef    BACK
  66. #undef    ISSETBACK
  67. #undef    SNAMES
  68.  
  69. /* macros for manipulating states, large version */
  70. #define    states    char *
  71. #define    CLEAR(v)    memset(v, 0, m->g->nstates)
  72. #define    SET0(v, n)    ((v)[n] = 0)
  73. #define    SET1(v, n)    ((v)[n] = 1)
  74. #define    ISSET(v, n)    ((v)[n])
  75. #define    ASSIGN(d, s)    memcpy(d, s, m->g->nstates)
  76. #define    EQ(a, b)    (memcmp(a, b, m->g->nstates) == 0)
  77. #define    STATEVARS    int vn; char *space
  78. #define    STATESETUP(m, nv)    { (m)->space = malloc((nv)*(m)->g->nstates); \
  79.                 if ((m)->space == NULL) return(REG_ESPACE); \
  80.                 (m)->vn = 0; }
  81. #define    STATETEARDOWN(m)    { free((m)->space); }
  82. #define    SETUP(v)    ((v) = &m->space[m->vn++ * m->g->nstates])
  83. #define    onestate    int
  84. #define    INIT(o, n)    ((o) = (n))
  85. #define    INC(o)    ((o)++)
  86. #define    ISSTATEIN(v, o)    ((v)[o])
  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)[here+(n)] |= (src)[here])
  90. #define    BACK(dst, src, n)    ((dst)[here-(n)] |= (src)[here])
  91. #define    ISSETBACK(v, n)    ((v)[here - (n)])
  92. /* function names */
  93. #define    LNAMES            /* flag */
  94.  
  95. #include "engine.c"
  96.  
  97. /*
  98.  - regexec - interface for matching
  99.  = extern int regexec(const regex_t *, const char *, size_t, \
  100.  =                    regmatch_t [], int);
  101.  = #define    REG_NOTBOL    00001
  102.  = #define    REG_NOTEOL    00002
  103.  = #define    REG_STARTEND    00004
  104.  = #define    REG_TRACE    00400    // tracing of execution
  105.  = #define    REG_LARGE    01000    // force large representation
  106.  = #define    REG_BACKR    02000    // force use of backref code
  107.  *
  108.  * We put this here so we can exploit knowledge of the state representation
  109.  * when choosing which matcher to call.  Also, by this point the matchers
  110.  * have been prototyped.
  111.  */
  112. int                /* 0 success, REG_NOMATCH failure */
  113. regexec(preg, str, nmatch, pmatch, eflags)
  114. const regex_t *preg;
  115. const char *str;
  116. size_t nmatch;
  117. regmatch_t pmatch[];
  118. int eflags;
  119. {
  120.     register struct re_guts *g = preg->re_g;
  121. #ifdef REDEBUG
  122. #    define    GOODFLAGS(f)    (f)
  123. #else
  124. #    define    GOODFLAGS(f)    ((f)&(REG_NOTBOL|REG_NOTEOL|REG_STARTEND))
  125. #endif
  126.  
  127.     if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
  128.         return(REG_BADPAT);
  129.     assert(!(g->iflags&BAD));
  130.     if (g->iflags&BAD)        /* backstop for no-debug case */
  131.         return(REG_BADPAT);
  132.     eflags = GOODFLAGS(eflags);
  133.  
  134.     if ((size_t) g->nstates <= CHAR_BIT*sizeof(states1) &&
  135.         !(eflags®_LARGE))
  136.         return(smatcher(g, (char *)str, nmatch, pmatch, eflags));
  137.     else
  138.         return(lmatcher(g, (char *)str, nmatch, pmatch, eflags));
  139. }
  140.