compat/GnuRegex.h

   1 /*
   2  * $Id$
   3  */
   4 #ifndef SQUID_REGEXP_LIBRARY_H
   5 #define SQUID_REGEXP_LIBRARY_H
   6
   7 #if !USE_GNUREGEX /* try the system one by default */
   8
   9 /* POSIX says that <sys/types.h> must be included (by the caller) before
  10  * <regex.h>.  */
  11 #if HAVE_SYS_TYPES_H
  12 #include <sys/types.h>
  13 #endif
  14 #if HAVE_REGEX_H
  15 #include <regex.h>
  16 #endif
  17
  18
  19 #else  /* USE_GNUREGEX */
  20
  21 #ifdef __cplusplus
  22 extern "C" {
  23 #endif
  24
  25     /* Definitions for data structures and routines for the regular
  26      * expression library, version 0.12.
  27      *
  28      * Copyright (C) 1985, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  29      *
  30      * This program is free software; you can redistribute it and/or modify
  31      * it under the terms of the GNU General Public License as published by
  32      * the Free Software Foundation; either version 2, or (at your option)
  33      * any later version.
  34      *
  35      * This program is distributed in the hope that it will be useful,
  36      * but WITHOUT ANY WARRANTY; without even the implied warranty of
  37      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  38      * GNU General Public License for more details.
  39      *
  40      * You should have received a copy of the GNU General Public License
  41      * along with this program; if not, write to the Free Software
  42      * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.  */
  43
  44     /* POSIX says that <sys/types.h> must be included (by the caller) before
  45      * <regex.h>.  */
  46
  47     /* The following bits are used to determine the regexp syntax we
  48      * recognize.  The set/not-set meanings are chosen so that Emacs syntax
  49      * remains the value 0.  The bits are given in alphabetical order, and
  50      * the definitions shifted by one from the previous bit; thus, when we
  51      * add or remove a bit, only one other definition need change.  */
  52     typedef unsigned reg_syntax_t;
  53
  54     /* If this bit is not set, then \ inside a bracket expression is literal.
  55      * If set, then such a \ quotes the following character.  */
  56 #define RE_BACKSLASH_ESCAPE_IN_LISTS (1)
  57
  58     /* If this bit is not set, then + and ? are operators, and \+ and \? are
  59      * literals.
  60      * If set, then \+ and \? are operators and + and ? are literals.  */
  61 #define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
  62
  63     /* If this bit is set, then character classes are supported.  They are:
  64      * [:alpha:], [:upper:], [:lower:],  [:digit:], [:alnum:], [:xdigit:],
  65      * [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
  66      * If not set, then character classes are not supported.  */
  67 #define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
  68
  69     /* If this bit is set, then ^ and $ are always anchors (outside bracket
  70      * expressions, of course).
  71      * If this bit is not set, then it depends:
  72      * ^  is an anchor if it is at the beginning of a regular
  73      * expression or after an open-group or an alternation operator;
  74      * $  is an anchor if it is at the end of a regular expression, or
  75      * before a close-group or an alternation operator.
  76      *
  77      * This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
  78      * POSIX draft 11.2 says that * etc. in leading positions is undefined.
  79      * We already implemented a previous draft which made those constructs
  80      * invalid, though, so we haven't changed the code back.  */
  81 #define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
  82
  83     /* If this bit is set, then special characters are always special
  84      * regardless of where they are in the pattern.
  85      * If this bit is not set, then special characters are special only in
  86      * some contexts; otherwise they are ordinary.  Specifically,
  87      * * + ? and intervals are only special when not after the beginning,
  88      * open-group, or alternation operator.  */
  89 #define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
  90
  91     /* If this bit is set, then *, +, ?, and { cannot be first in an re or
  92      * immediately after an alternation or begin-group operator.  */
  93 #define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
  94
  95     /* If this bit is set, then . matches newline.
  96      * If not set, then it doesn't.  */
  97 #define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
  98
  99     /* If this bit is set, then . doesn't match NUL.
 100      * If not set, then it does.  */
 101 #define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
 102
 103     /* If this bit is set, nonmatching lists [^...] do not match newline.
 104      * If not set, they do.  */
 105 #define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
 106
 107     /* If this bit is set, either \{...\} or {...} defines an
 108      * interval, depending on RE_NO_BK_BRACES.
 109      * If not set, \{, \}, {, and } are literals.  */
 110 #define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
 111
 112     /* If this bit is set, +, ? and | aren't recognized as operators.
 113      * If not set, they are.  */
 114 #define RE_LIMITED_OPS (RE_INTERVALS << 1)
 115
 116     /* If this bit is set, newline is an alternation operator.
 117      * If not set, newline is literal.  */
 118 #define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
 119
 120     /* If this bit is set, then `{...}' defines an interval, and \{ and \}
 121      * are literals.
 122      * If not set, then `\{...\}' defines an interval.  */
 123 #define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
 124
 125     /* If this bit is set, (...) defines a group, and \( and \) are literals.
 126      * If not set, \(...\) defines a group, and ( and ) are literals.  */
 127 #define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
 128
 129     /* If this bit is set, then \<digit> matches <digit>.
 130      * If not set, then \<digit> is a back-reference.  */
 131 #define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
 132
 133     /* If this bit is set, then | is an alternation operator, and \| is literal.
 134      * If not set, then \| is an alternation operator, and | is literal.  */
 135 #define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
 136
 137     /* If this bit is set, then an ending range point collating higher
 138      * than the starting range point, as in [z-a], is invalid.
 139      * If not set, then when ending range point collates higher than the
 140      * starting range point, the range is ignored.  */
 141 #define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
 142
 143     /* If this bit is set, then an unmatched ) is ordinary.
 144      * If not set, then an unmatched ) is invalid.  */
 145 #define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
 146
 147     \f
 148     /* Define combinations of the above bits for the standard possibilities.
 149      * (The [[[ comments delimit what gets put into the Texinfo file, so
 150      * don't delete them!)  */
 151     /* [[[begin syntaxes]]] */
 152 #define RE_SYNTAX_EMACS 0
 153
 154 #define RE_SYNTAX_AWK                                                   \
 155   (RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DOT_NOT_NULL                       \
 156    | RE_NO_BK_PARENS            | RE_NO_BK_REFS                         \
 157    | RE_NO_BK_VBAR               | RE_NO_EMPTY_RANGES                   \
 158    | RE_UNMATCHED_RIGHT_PAREN_ORD)
 159
 160 #define RE_SYNTAX_POSIX_AWK                                             \
 161   (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS)
 162
 163 #define RE_SYNTAX_GREP                                                  \
 164   (RE_BK_PLUS_QM              | RE_CHAR_CLASSES                         \
 165    | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS                            \
 166    | RE_NEWLINE_ALT)
 167
 168 #define RE_SYNTAX_EGREP                                                 \
 169   (RE_CHAR_CLASSES        | RE_CONTEXT_INDEP_ANCHORS                    \
 170    | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE                    \
 171    | RE_NEWLINE_ALT       | RE_NO_BK_PARENS                             \
 172    | RE_NO_BK_VBAR)
 173
 174 #define RE_SYNTAX_POSIX_EGREP                                           \
 175   (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)
 176
 177     /* P1003.2/D11.2, section 4.20.7.1, lines 5078ff.  */
 178 #define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
 179
 180 #define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
 181
 182     /* Syntax bits common to both basic and extended POSIX regex syntax.  */
 183 #define _RE_SYNTAX_POSIX_COMMON                                         \
 184   (RE_CHAR_CLASSES | RE_DOT_NEWLINE      | RE_DOT_NOT_NULL              \
 185    | RE_INTERVALS  | RE_NO_EMPTY_RANGES)
 186
 187 #define RE_SYNTAX_POSIX_BASIC                                           \
 188   (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)
 189
 190     /* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
 191      * RE_LIMITED_OPS, i.e., \? \+ \| are not recognized.  Actually, this
 192      * isn't minimal, since other operators, such as \`, aren't disabled.  */
 193 #define RE_SYNTAX_POSIX_MINIMAL_BASIC                                   \
 194   (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
 195
 196 #define RE_SYNTAX_POSIX_EXTENDED                                        \
 197   (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS                   \
 198    | RE_CONTEXT_INDEP_OPS  | RE_NO_BK_BRACES                            \
 199    | RE_NO_BK_PARENS       | RE_NO_BK_VBAR                              \
 200    | RE_UNMATCHED_RIGHT_PAREN_ORD)
 201
 202     /* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS
 203      * replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added.  */
 204 #define RE_SYNTAX_POSIX_MINIMAL_EXTENDED                                \
 205   (_RE_SYNTAX_POSIX_COMMON  | RE_CONTEXT_INDEP_ANCHORS                  \
 206    | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES                           \
 207    | RE_NO_BK_PARENS        | RE_NO_BK_REFS                             \
 208    | RE_NO_BK_VBAR          | RE_UNMATCHED_RIGHT_PAREN_ORD)
 209     /* [[[end syntaxes]]] */
 210     \f
 211     /* Maximum number of duplicates an interval can allow.  Some systems
 212      * (erroneously) define this in other header files, but we want our
 213      * value, so remove any previous define.  */
 214 #ifdef RE_DUP_MAX
 215 #undef RE_DUP_MAX
 216 #endif
 217 #define RE_DUP_MAX ((1 << 15) - 1)
 218
 219
 220     /* POSIX `cflags' bits (i.e., information for `regcomp').  */
 221
 222     /* If this bit is set, then use extended regular expression syntax.
 223      * If not set, then use basic regular expression syntax.  */
 224 #define REG_EXTENDED 1
 225
 226     /* If this bit is set, then ignore case when matching.
 227      * If not set, then case is significant.  */
 228 #define REG_ICASE (REG_EXTENDED << 1)
 229
 230     /* If this bit is set, then anchors do not match at newline
 231      * characters in the string.
 232      * If not set, then anchors do match at newlines.  */
 233 #define REG_NEWLINE (REG_ICASE << 1)
 234
 235     /* If this bit is set, then report only success or fail in regexec.
 236      * If not set, then returns differ between not matching and errors.  */
 237 #define REG_NOSUB (REG_NEWLINE << 1)
 238
 239
 240     /* POSIX `eflags' bits (i.e., information for regexec).  */
 241
 242     /* If this bit is set, then the beginning-of-line operator doesn't match
 243      * the beginning of the string (presumably because it's not the
 244      * beginning of a line).
 245      * If not set, then the beginning-of-line operator does match the
 246      * beginning of the string.  */
 247 #define REG_NOTBOL 1
 248
 249     /* Like REG_NOTBOL, except for the end-of-line.  */
 250 #define REG_NOTEOL (1 << 1)
 251
 252
 253     /* If any error codes are removed, changed, or added, update the
 254      * `re_error_msg' table in regex.c.  */
 255     typedef enum {
 256         REG_NOERROR = 0,                /* Success.  */
 257         REG_NOMATCH,            /* Didn't find a match (for regexec).  */
 258
 259         /* POSIX regcomp return error codes.  (In the order listed in the
 260          * standard.)  */
 261         REG_BADPAT,                     /* Invalid pattern.  */
 262         REG_ECOLLATE,           /* Not implemented.  */
 263         REG_ECTYPE,                     /* Invalid character class name.  */
 264         REG_EESCAPE,            /* Trailing backslash.  */
 265         REG_ESUBREG,            /* Invalid back reference.  */
 266         REG_EBRACK,                     /* Unmatched left bracket.  */
 267         REG_EPAREN,                     /* Parenthesis imbalance.  */
 268         REG_EBRACE,                     /* Unmatched \{.  */
 269         REG_BADBR,                      /* Invalid contents of \{\}.  */
 270         REG_ERANGE,                     /* Invalid range end.  */
 271         REG_ESPACE,                     /* Ran out of memory.  */
 272         REG_BADRPT,                     /* No preceding re for repetition op.  */
 273
 274         /* Error codes we've added.  */
 275         REG_EEND,                       /* Premature end.  */
 276         REG_ESIZE,                      /* Compiled pattern bigger than 2^16 bytes.  */
 277         REG_ERPAREN                     /* Unmatched ) or \); not returned from regcomp.  */
 278     } reg_errcode_t;
 279     \f
 280     /* This data structure represents a compiled pattern.  Before calling
 281      * the pattern compiler, the fields `buffer', `allocated', `fastmap',
 282      * `translate', and `no_sub' can be set.  After the pattern has been
 283      * compiled, the `re_nsub' field is available.  All other fields are
 284      * private to the regex routines.  */
 285
 286     struct re_pattern_buffer {
 287         /* [[[begin pattern_buffer]]] */
 288         /* Space that holds the compiled pattern.  It is declared as
 289          * `unsigned char *' because its elements are
 290          * sometimes used as array indexes.  */
 291         unsigned char *buffer;
 292
 293         /* Number of bytes to which `buffer' points.  */
 294         unsigned long allocated;
 295
 296         /* Number of bytes actually used in `buffer'.  */
 297         unsigned long used;
 298
 299         /* Syntax setting with which the pattern was compiled.  */
 300         reg_syntax_t syntax;
 301
 302         /* Pointer to a fastmap, if any, otherwise zero.  re_search uses
 303          * the fastmap, if there is one, to skip over impossible
 304          * starting points for matches.  */
 305         char *fastmap;
 306
 307         /* Either a translate table to apply to all characters before
 308          * comparing them, or zero for no translation.  The translation
 309          * is applied to a pattern when it is compiled and to a string
 310          * when it is matched.  */
 311         char *translate;
 312
 313         /* Number of subexpressions found by the compiler.  */
 314         size_t re_nsub;
 315
 316         /* Zero if this pattern cannot match the empty string, one else.
 317          * Well, in truth it's used only in `re_search_2', to see
 318          * whether or not we should use the fastmap, so we don't set
 319          * this absolutely perfectly; see `re_compile_fastmap' (the
 320          * `duplicate' case).  */
 321         unsigned can_be_null:1;
 322
 323         /* If REGS_UNALLOCATED, allocate space in the `regs' structure
 324          * for `max (RE_NREGS, re_nsub + 1)' groups.
 325          * If REGS_REALLOCATE, reallocate space if necessary.
 326          * If REGS_FIXED, use what's there.  */
 327 #define REGS_UNALLOCATED 0
 328 #define REGS_REALLOCATE 1
 329 #define REGS_FIXED 2
 330         unsigned regs_allocated:2;
 331
 332         /* Set to zero when `regex_compile' compiles a pattern; set to one
 333          * by `re_compile_fastmap' if it updates the fastmap.  */
 334         unsigned fastmap_accurate:1;
 335
 336         /* If set, `re_match_2' does not return information about
 337          * subexpressions.  */
 338         unsigned no_sub:1;
 339
 340         /* If set, a beginning-of-line anchor doesn't match at the
 341          * beginning of the string.  */
 342         unsigned not_bol:1;
 343
 344         /* Similarly for an end-of-line anchor.  */
 345         unsigned not_eol:1;
 346
 347         /* If true, an anchor at a newline matches.  */
 348         unsigned newline_anchor:1;
 349
 350         /* [[[end pattern_buffer]]] */
 351     };
 352
 353     typedef struct re_pattern_buffer regex_t;
 354
 355
 356     /* search.c (search_buffer) in Emacs needs this one opcode value.  It is
 357      * defined both in `regex.c' and here.  */
 358 #define RE_EXACTN_VALUE 1
 359     \f
 360     /* Type for byte offsets within the string.  POSIX mandates this.  */
 361     typedef int regoff_t;
 362
 363
 364     /* This is the structure we store register match data in.  See
 365      * regex.texinfo for a full description of what registers match.  */
 366     struct re_registers {
 367         unsigned num_regs;
 368         regoff_t *start;
 369         regoff_t *end;
 370     };
 371
 372
 373     /* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
 374      * `re_match_2' returns information about at least this many registers
 375      * the first time a `regs' structure is passed.  */
 376 #ifndef RE_NREGS
 377 #define RE_NREGS 30
 378 #endif
 379
 380
 381     /* POSIX specification for registers.  Aside from the different names than
 382      * `re_registers', POSIX uses an array of structures, instead of a
 383      * structure of arrays.  */
 384     typedef struct {
 385         regoff_t rm_so;         /* Byte offset from string's start to substring's start.  */
 386         regoff_t rm_eo;         /* Byte offset from string's start to substring's end.  */
 387     } regmatch_t;
 388     \f
 389     /* Declarations for routines.  */
 390
 391     /* To avoid duplicating every routine declaration -- once with a
 392      * prototype (if we are ANSI), and once without (if we aren't) -- we
 393      * use the following macro to declare argument types.  This
 394      * unfortunately clutters up the declarations a bit, but I think it's
 395      * worth it.  */
 396
 397     /* POSIX compatibility.  */
 398     extern int regcomp(regex_t * preg, const char *pattern, int cflags);
 399     extern int regexec(const regex_t * preg, const char *string, size_t nmatch, regmatch_t pmatch[], int eflags);
 400     extern size_t regerror(int errcode, const regex_t * preg, char *errbuf, size_t errbuf_size);
 401     extern void regfree(regex_t * preg);
 402
 403 #ifdef __cplusplus
 404 }
 405 #endif
 406
 407 #endif /* USE_GNUREGEX */
 408 #endif /* SQUID_REGEXP_LIBRARY_H */
 409
 410 /*
 411  * Local variables:
 412  * make-backup-files: t
 413  * version-control: t
 414  * trim-versions-without-asking: nil
 415  * End:
 416  */