pike.git/ src/ modules/ Regexp/ pike_regexp.c > 5f58bdeecb41320455102b95b9180cba3c5d04f5 [Annotate]

/* 

|| This file is part of Pike. For copyright information see COPYRIGHT. 

|| Pike is distributed under GPL, LGPL and MPL. See the file COPYING 

|| for more information. 

*/ 

/* 

 * regexp.c - regular expression matching 

 * 

 * DESCRIPTION 

 * 

 *      Underneath the reformatting and comment blocks which were added to 

 *      make it consistent with the rest of the code, you will find a 

 *      modified version of Henry Specer's regular expression library. 

 *      Henry's functions were modified to provide the minimal regular 

 *      expression matching, as required by P1003.  Henry's code was 

 *      copyrighted, and copy of the copyright message and restrictions 

 *      are provided, verbatim, below: 

 * 

 *      Copyright (c) 1986 by University of Toronto. 

 *      Written by Henry Spencer.  Not derived from licensed software. 

 * 

 *      Permission is granted to anyone to use this software for any 

 *      purpose on any computer system, and to redistribute it freely, 

 *      subject to the following restrictions: 

 * 

 *      1. The author is not responsible for the consequences of use of 

 *         this software, no matter how awful, even if they arise 

 *         from defects in it. 

 * 

 *      2. The origin of this software must not be misrepresented, either 

 *         by explicit claim or by omission. 

 * 

 *      3. Altered versions must be plainly marked as such, and must not 

 *         be misrepresented as being the original software. 

 * 

 * 

 * This version modified by Ian Phillipps to return pointer to terminating 

 * NUL on substitution string. [ Temp mail address ex-igp@camcon.co.uk ] 

 * 

 *      Altered by amylaar to support excompatible option and the 

 *      operators \< and >\ . ( 7.Sep. 1991 ) 

 * 

 * regsub altered by amylaar to take an additional parameter specifying 

 * maximum number of bytes that can be written to the memory region 

 * pointed to by dest 

 * 

 * Also altered by Fredrik Hubinette to handle the + operator and 

 * eight-bit chars. Mars 22 1996 

 * 

 * 

 *      Beware that some of this code is subtly aware of the way operator 

 *      precedence is structured in regular expressions.  Serious changes in 

 *      regular-expression syntax might require a total rethink. 

 * 

 * AUTHORS 

 * 

 *     Mark H. Colburn, NAPS International (mark@jhereg.mn.org) 

 *     Henry Spencer, University of Torronto (henry@utzoo.edu) 

 * 

 * Sponsored by The USENIX Association for public distribution. 

 * 

 */ 

/* Headers */ 

#include "global.h" 

#include <ctype.h> 

#ifdef HAVE_STRING_H 

#include <string.h> 

#endif /* HAVE_STRING_H */ 

#include "pike_regexp.h" 

#include "pike_memory.h" 

#include "pike_error.h" 

#include "interpret.h" 

#undef NOTHING 

/* 

 * The "internal use only" fields in regexp.h are present to pass info from 

 * compile to execute that permits the execute phase to run lots faster on 

 * simple cases.  They are: 

 * 

 * regstart     char that must begin a match; '\0' if none obvious 

 * reganch      is the match anchored (at beginning-of-line only)? 

 * regmust      string (pointer into program) that match must include, or NULL 

 * regmlen      length of regmust string 

 * 

 * Regstart and reganch permit very fast decisions on suitable starting points 

 * for a match, cutting down the work a lot.  Regmust permits fast rejection 

 * of lines that cannot possibly match.  The regmust tests are costly enough 

 * that regcomp() supplies a regmust only if the r.e. contains something 

 * potentially expensive (at present, the only such thing detected is * or + 

 * at the start of the r.e., which can involve a lot of backup).  Regmlen is 

 * supplied because the test in regexec() needs it and regcomp() is computing 

 * it anyway. 

 */ 

/* 

 * Structure for regexp "program".  This is essentially a linear encoding 

 * of a nondeterministic finite-state machine (aka syntax charts or 

 * "railroad normal form" in parsing technology).  Each node is an opcode 

 * plus a "next" pointer, possibly plus an operand.  "Next" pointers of 

 * all nodes except BRANCH implement concatenation; a "next" pointer with 

 * a BRANCH on both ends of it is connecting two alternatives.  (Here we 

 * have one of the subtle syntax dependencies:  an individual BRANCH (as 

 * opposed to a collection of them) is never concatenated with anything 

 * because of operator precedence.)  The operand of some types of node is 

 * a literal string; for others, it is a node leading into a sub-FSM.  In 

 * particular, the operand of a BRANCH node is the first node of the branch. 

 * (NB this is *not* a tree structure:  the tail of the branch connects 

 * to the thing following the set of BRANCHes.)  The opcodes are: 

 */ 

/* definition   number        opnd?   meaning */ 

#define       END       0             /* no   End of program. */ 

#define     BOL       1             /* no   Match "" at beginning of line. */ 

#define     EOL       2             /* no   Match "" at end of line. */ 

#define     ANY       3             /* no   Match any one character. */ 

#define     ANYOF     4             /* str  Match any character in this string. */ 

#define     ANYBUT    5             /* str  Match any character not in this 

                               * string. */ 

#define       BRANCH    6             /* node Match this alternative, or the 

                               * next... */ 

#define       BACK      7             /* no   Match "", "next" ptr points backward. */ 

#define     EXACTLY   8             /* str  Match this string. */ 

#define     NOTHING   9             /* no   Match empty string. */ 

#define     STAR      10            /* node Match this (simple) thing 0 or more 

                               * times. */ 

#define WORDSTART 11          /* node matching a start of a word          */ 

#define WORDEND   12                /* node matching an end of a word           */ 

#define KPLUS         13            /* node Match this (simple) thing 1 or more 

                               * times. */ 

#define       OPEN      20            /* no   Mark this point in input as start of 

                               * #n. */ 

 /* OPEN+1 is number 1, etc. */ 

#define       CLOSE   (OPEN+NSUBEXP)  /* no   Analogous to OPEN. */ 

/* 

 * Opcode notes: 

 * 

 * BRANCH       The set of branches constituting a single choice are hooked 

 *              together with their "next" pointers, since precedence prevents 

 *              anything being concatenated to any individual branch.  The 

 *              "next" pointer of the last BRANCH in a choice points to the 

 *              thing following the whole choice.  This is also where the 

 *              final "next" pointer of each individual branch points; each 

 *              branch starts with the operand node of a BRANCH node. 

 * 

 * BACK         Normal "next" pointers all implicitly point forward; BACK 

 *              exists to make loop structures possible. 

 * 

 * STAR,KPLUS   Complex cases are implemented as circular BRANCH structures 

 *              using BACK.  Simple cases (one character per match) are 

 *              implemented with STAR or KPLUS for speed and to minimize 

 *              recursive plunges. 

 * 

 * OPEN,CLOSE   ...are numbered at compile time. 

 */ 

/* 

 * A node is one char of opcode followed by two chars of "next" pointer. 

 * "Next" pointers are stored as two 8-bit pieces, high order first.  The 

 * value is a positive offset from the opcode of the node containing it. 

 * An operand, if any, simply follows the node.  (Note that much of the 

 * code generation knows about this implicit relationship.) 

 * 

 * Using two bytes for the "next" pointer is vast overkill for most things, 

 * but allows patterns to get big without disasters. 

 */ 

#define       OP(p)   (*(p)) 

#define     NEXT(p) (((*((p)+1)&0377)<<8) + (*((p)+2)&0377)) 

#define     OPERAND(p)      ((p) + 3) 

/* 

 * Utility definitions. 

 */ 

#define regerror(X) Pike_error("Regexp: %s\n",X); 

#define SPECIAL 0x100 

#define LBRAC       ('('|SPECIAL) 

#define RBRAC       (')'|SPECIAL) 

#define ASTERIX     ('*'|SPECIAL) 

#define PLUS        ('+'|SPECIAL) 

#define OR_OP       ('|'|SPECIAL) 

#define DOLLAR      ('$'|SPECIAL) 

#define DOT ('.'|SPECIAL) 

#define CARET       ('^'|SPECIAL) 

#define LSQBRAC ('['|SPECIAL) 

#define RSQBRAC (']'|SPECIAL) 

#define LSHBRAC ('<'|SPECIAL) 

#define RSHBRAC ('>'|SPECIAL) 

#define     FAIL(m) { regerror(m); return(NULL); } 

#define     ISMULT(c)       ((c) == ASTERIX || (c)==PLUS) 

#define     META    "^$.[()|*+\\" 

#ifndef CHARBITS 

#define CHARBITS    0xff 

#define     UCHARAT(p)      ((int)*(unsigned char *)(p)) 

#else 

#define     UCHARAT(p)      ((int)*(p)&CHARBITS) 

#endif 

#define ISWORDPART(c) ( isalnum(c) || (c) == '_' ) 

/* 

 * Flags to be passed up and down. 

 */ 

#define       HASWIDTH        01      /* Known never to match null string. */ 

#define     SIMPLE          02      /* Simple enough to be STAR or KPLUS operand. */ 

#define     SPSTART         04      /* Starts with * */ 

#define     WORST           0       /* Worst case. */ 

/* 

 * Global work variables for regcomp(). 

 */ 

static short   *regparse;       /* Input-scan pointer. */ 

static int      regnpar;        /* () count. */ 

static char    *regcode;        /* Code-emit pointer; &regdummy = don't. */ 

static long     regsize;        /* Code size. */ 

static char     regdummy[3] = { NOTHING, 0, 0 }; 

/* 

 * Forward declarations for regcomp()'s friends. 

 */ 

static char    *reg(int, int *); 

static char    *regbranch(int *); 

static char    *regpiece(int *); 

static char    *regatom(int *); 

static char    *regnode(char); 

static char    *regnext(char *); 

static void     regc(char b); 

static void     reginsert(char, char *); 

static void     regtail(char *, const char *); 

static void     regoptail(char *, const char *); 

/* 

 - regcomp - compile a regular expression into internal code 

 * 

 * We can't allocate space until we know how big the compiled form will be, 

 * but we can't compile it (and thus know how big it is) until we've got a 

 * place to put the code.  So we cheat:  we compile it twice, once with code 

 * generation turned off and size counting turned on, and once "for real". 

 * This also means that we don't allocate space until we are sure that the 

 * thing really will compile successfully, and we never have to move the 

 * code and thus invalidate pointers into it.  (Note that it has to be in 

 * one piece because free() must be able to free it all.) 

 * 

 * Beware that the optimization-preparation code in here knows about some 

 * of the structure of the compiled regexp. 

 */ 

regexp *pike_regcomp(const char *exp) 

{ 

  regexp *r = NULL; 

  char   *scan; 

  int     flags; 

  short  *exp2,*dest,c; 

  if (exp == NULL) 

    FAIL("NULL argument"); 

  exp2=xcalloc( (strlen(exp)+1), sizeof(short) ); 

  for ( dest=exp2; (c=UCHARAT(exp++)); ) { 

    switch (c) { 

    case '(': 

    case ')': 

    case '.': 

    case '*': 

    case '+': 

    case '|': 

    case '$': 

    case '^': 

    case '[': 

    case ']': 

      *dest++ =  c | SPECIAL; 

      break; 

    case '\\': 

      switch ( c = *exp++ ) { 

      case '(': 

      case ')': 

        *dest++ = c; 

        break; 

      case '<': 

      case '>': 

        *dest++ = c | SPECIAL; 

        break; 

      case '{': 

      case '}': 

        FAIL("sorry, unimplemented operator"); 

      case 'b': *dest++ = '\b'; break; 

      case 't': *dest++ = '\t'; break; 

      case 'r': *dest++ = '\r'; break; 

      default: 

        *dest++ = c; 

      } 

      break; 

    default: 

      *dest++ = c; 

    } 

  } 

  /* First pass: determine size, legality. */ 

  regparse = exp2; 

  regnpar = 1; 

  regsize = 0L; 

  regcode = regdummy; 

  if (reg(0, &flags) == NULL) 

    goto exit_regcomp; 

  /* Small enough for pointer-storage convention? */ 

  if (regsize >= 32767L)    /* Probably could be 65535L. */ 

  { 

    free(exp2); 

    FAIL("regexp too big"); 

  } 

  /* Allocate space. */ 

  r = malloc(sizeof(regexp) + (unsigned) regsize); 

  if(!r) 

  { 

    free(exp2); 

    Pike_error(msg_out_of_mem); 

  } 

  /* Second pass: emit code. */ 

  regparse = exp2; 

  regnpar = 1; 

  regcode = r->program; 

  if (reg(0, &flags) == NULL) 

  { 

    free(r); 

    r = NULL; 

    goto exit_regcomp; 

  }