compat/GnuRegex.h

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