qbit/xenocara
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
d95c5d8cd8
xenocara/app/xedit/lisp/re/rec.c
matthieu 616b6f15ab Importing from X.Org 7.2RC2
2006-11-25 20:07:29 +00:00

1016 lines
23 KiB
C
Raw Blame History

/*
* Copyright (c) 2002 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
* Except as contained in this notice, the name of the XFree86 Project shall
* not be used in advertising or otherwise to promote the sale, use or other
* dealings in this Software without prior written authorization from the
* XFree86 Project.
*
* Author: Paulo César Pereira de Andrade
*/
/* $XFree86: xc/programs/xedit/lisp/re/rec.c,v 1.3 2002/11/15 07:01:33 paulo Exp $ */
#include "rep.h"
/*
* Types
*/
/* Information used while compiling the intermediate format of the re. */
typedef struct _irec_info {
unsigned char *ptr; /* Pointer in the given regex pattern */
unsigned char *end; /* End of regex pattern */
int flags; /* Compile flags */
rec_alt *alt; /* Toplevel first/single alternative */
rec_alt *palt; /* Current alternative being compiled */
rec_grp *pgrp; /* Current group, if any */
rec_pat *ppat; /* Current pattern, if any */
/* Number of open parenthesis, for error checking */
int nparens;
int ngrps; /* Number of groups, for backreference */
int ecode;
} irec_info;
/*
* Prototypes
*/
/* (i)ntermediate (r)egular (e)xpression (c)ompile
* Generates an intermediate stage compiled regex from
* the specified pattern argument. Basically builds an
* intermediate data structure to analyse and do syntax
* error checking.
*/
static void irec_simple_pattern(irec_info*, rec_pat_t);
static void irec_literal_pattern(irec_info*, int);
static void irec_case_literal_pattern(irec_info*, int);
static void irec_open_group(irec_info*);
static void irec_close_group(irec_info*);
static void irec_range(irec_info*);
static void irec_range_single(irec_info*, int);
static void irec_range_complex(irec_info*, int, int);
static void irec_escape(irec_info*);
static void irec_simple_repetition(irec_info*, rec_rep_t);
static void irec_complex_repetition(irec_info*);
static void irec_add_repetition(irec_info*, rec_rep*);
static void irec_free(irec_info*);
static void irec_free_grp(rec_grp*);
static void irec_free_pats(rec_pat*);
/*
* Implementation
*/
rec_alt *
irec_comp(const char *pattern, const char *endp, int flags, int *ecode)
{
unsigned char *ptr;
rec_alt *alt;
irec_info inf;
if (pattern == NULL || endp < pattern) {
*ecode = RE_INVARG;
return (NULL);
}
if (endp == pattern) {
*ecode = RE_EMPTY;
return (NULL);
}
alt = calloc(1, sizeof(rec_alt));
if (alt == NULL) {
*ecode = RE_ESPACE;
return (NULL);
}
inf.ptr = (unsigned char*)pattern;
inf.end = (unsigned char*)endp;
inf.flags = flags;
inf.alt = inf.palt = alt;
inf.pgrp = NULL;
inf.ppat = NULL;
inf.nparens = inf.ngrps = 0;
inf.ecode = 0;
if (flags & RE_NOSPEC) {
/* Just searching for a character or substring */
for (; inf.ecode == 0 && inf.ptr < inf.end; inf.ptr++) {
if (!(flags & RE_ICASE) ||
(!isupper(*inf.ptr) && !islower(*inf.ptr)))
irec_literal_pattern(&inf, *inf.ptr);
else
irec_case_literal_pattern(&inf, *inf.ptr);
}
}
/* inf.ptr = inf.end is nul if flags & RE_NOSPEC */
for (; inf.ecode == 0 && inf.ptr < inf.end;) {
switch (*inf.ptr++) {
case '*':
irec_simple_repetition(&inf, Rer_AnyTimes);
break;
case '+':
irec_simple_repetition(&inf, Rer_AtLeast);
break;
case '?':
irec_simple_repetition(&inf, Rer_Maybe);
break;
case '.':
irec_simple_pattern(&inf, Rep_Any);
break;
case '^':
if (flags & RE_NEWLINE)
/* It is up to the user decide if this can match */
irec_simple_pattern(&inf, Rep_Bol);
else {
for (ptr = inf.ptr - 1;
ptr > (unsigned char*)pattern && *ptr == '('; ptr--)
;
/* If at the start of a pattern */
if (ptr == (unsigned char*)pattern || *ptr == '|')
irec_simple_pattern(&inf, Rep_Bol);
else
/* In the middle of a pattern, treat as literal */
irec_literal_pattern(&inf, '^');
}
break;
case '$':
if (flags & RE_NEWLINE)
irec_simple_pattern(&inf, Rep_Eol);
else {
/* Look ahead to check if is the last char of a group */
for (ptr = inf.ptr; ptr < inf.end && *ptr == ')'; ptr++)
;
if (*ptr == '\0' || *ptr == '|')
/* Last character of pattern, an EOL match */
irec_simple_pattern(&inf, Rep_Eol);
else
/* Normal character */
irec_literal_pattern(&inf, '$');
}
break;
case '(':
irec_open_group(&inf);
break;
case ')':
/* Look ahead to check if need to close the group now */
ptr = inf.ptr;
if (*ptr != '*' && *ptr != '+' && *ptr != '?' && *ptr != '{')
/* If a repetition does not follow */
irec_close_group(&inf);
else if (inf.pgrp == NULL)
/* A repetition follows, but current group is implicit */
inf.ecode = RE_EPAREN;
else
/* Can do this as next character is known */
inf.ppat = NULL;
break;
case '[':
irec_range(&inf);
break;
case ']':
irec_literal_pattern(&inf, ']');
break;
case '{':
irec_complex_repetition(&inf);
break;
case '}':
irec_literal_pattern(&inf, '}');
break;
case '|':
/* If first character in the pattern */
if (inf.ptr - 1 == (unsigned char*)pattern ||
/* If last character in the pattern */
inf.ptr >= inf.end ||
/* If empty pattern */
inf.ptr[0] == '|' ||
inf.ptr[0] == ')')
inf.ecode = RE_EMPTY;
else {
rec_alt *alt = calloc(1, sizeof(rec_alt));
if (alt) {
alt->prev = inf.palt;
inf.palt->next = alt;
inf.palt = alt;
inf.ppat = NULL;
}
else
inf.ecode = RE_ESPACE;
}
break;
case '\\':
irec_escape(&inf);
break;
default:
if (!(flags & RE_ICASE) ||
(!isupper(inf.ptr[-1]) && !islower(inf.ptr[-1])))
irec_literal_pattern(&inf, inf.ptr[-1]);
else
irec_case_literal_pattern(&inf, inf.ptr[-1]);
break;
}
}
/* Check if not all groups closed */
if (inf.ecode == 0 && inf.nparens)
inf.ecode = RE_EPAREN;
if (inf.ecode == 0)
inf.ecode = orec_comp(inf.alt, flags);
/* If an error generated */
if (inf.ecode) {
irec_free(&inf);
alt = NULL;
}
*ecode = inf.ecode;
return (alt);
}
void
irec_free_alt(rec_alt *alt)
{
rec_alt *next;
while (alt) {
next = alt->next;
irec_free_pats(alt->pat);
free(alt);
alt = next;
}
}
static void
irec_simple_pattern(irec_info *inf, rec_pat_t type)
{
rec_pat *pat;
/* Always add a new pattern to list */
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
pat->type = type;
if ((pat->prev = inf->ppat) != NULL)
inf->ppat->next = pat;
else
inf->palt->pat = pat;
inf->ppat = pat;
}
static void
irec_literal_pattern(irec_info *inf, int value)
{
int length;
rec_pat *pat;
unsigned char chr, *str;
/* If there is a current pattern */
if (inf->ppat && inf->ppat->rep == NULL) {
switch (inf->ppat->type) {
case Rep_Literal:
/* Start literal string */
chr = inf->ppat->data.chr;
if ((str = malloc(16)) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
inf->ppat->type = Rep_String;
inf->ppat->data.str = str;
str[0] = chr;
str[1] = value;
str[2] = '\0';
return;
case Rep_String:
/* Augments literal string */
length = strlen((char*)inf->ppat->data.str);
if ((length % 16) >= 14) {
if ((str = realloc(inf->ppat->data.str,
length + 18)) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
inf->ppat->data.str = str;
}
inf->ppat->data.str[length] = value;
inf->ppat->data.str[length + 1] = '\0';
return;
default:
/* Anything else is added as a new pattern list element */
break;
}
}
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
pat->type = Rep_Literal;
pat->data.chr = value;
if ((pat->prev = inf->ppat) != NULL)
inf->ppat->next = pat;
else
inf->palt->pat = pat;
inf->ppat = pat;
}
static void
irec_case_literal_pattern(irec_info *inf, int value)
{
int length;
rec_pat *pat;
unsigned char plower, pupper, lower, upper, *str;
lower = tolower(value);
upper = toupper(value);
/* If there is a current pattern */
if (inf->ppat && inf->ppat->rep == NULL) {
switch (inf->ppat->type) {
case Rep_CaseLiteral:
/* Start case literal string */
plower = inf->ppat->data.cse.lower;
pupper = inf->ppat->data.cse.upper;
if ((str = malloc(32)) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
inf->ppat->type = Rep_CaseString;
inf->ppat->data.str = str;
str[0] = plower;
str[1] = pupper;
str[2] = lower;
str[3] = upper;
str[4] = '\0';
return;
case Rep_CaseString:
/* Augments case literal string */
length = strlen((char*)inf->ppat->data.str);
if (((length) % 32) >= 28) {
if ((str = realloc(inf->ppat->data.str,
length + 36)) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
inf->ppat->data.str = str;
}
inf->ppat->data.str[length] = lower;
inf->ppat->data.str[length + 1] = upper;
inf->ppat->data.str[length + 2] = '\0';
return;
default:
/* Anything else is added as a new pattern list element */
break;
}
}
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
pat->type = Rep_CaseLiteral;
pat->data.cse.lower = lower;
pat->data.cse.upper = upper;
pat->prev = inf->ppat;
if ((pat->prev = inf->ppat) != NULL)
inf->ppat->next = pat;
else
inf->palt->pat = pat;
inf->ppat = pat;
}
static void
irec_open_group(irec_info *inf)
{
rec_pat *pat;
rec_alt *alt;
rec_grp *grp;
if ((grp = calloc(1, sizeof(rec_grp))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
free(grp);
inf->ecode = RE_ESPACE;
return;
}
if ((alt = calloc(1, sizeof(rec_alt))) == NULL) {
free(grp);
free(pat);
inf->ecode = RE_ESPACE;
return;
}
pat->type = Rep_Group;
pat->data.grp = grp;
grp->parent = pat;
grp->palt = inf->palt;
grp->pgrp = inf->pgrp;
grp->alt = alt;
grp->comp = 0;
if ((pat->prev = inf->ppat) != NULL)
inf->ppat->next = pat;
else
inf->palt->pat = pat;
inf->palt = alt;
inf->ppat = NULL;
/* Only toplevel parenthesis supported */
if (++inf->nparens == 1)
++inf->ngrps;
inf->pgrp = grp;
}
static void
irec_close_group(irec_info *inf)
{
if (inf->pgrp == NULL) {
inf->ecode = RE_EPAREN;
return;
}
inf->palt = inf->pgrp->palt;
inf->ppat = inf->pgrp->parent;
inf->pgrp = inf->pgrp->pgrp;
--inf->nparens;
}
static void
irec_range(irec_info *inf)
{
int count;
rec_pat *pat;
rec_rng *rng;
int not = inf->ptr[0] == '^';
if (not)
++inf->ptr;
pat = calloc(1, sizeof(rec_pat));
if (pat == NULL) {
inf->ecode = RE_ESPACE;
return;
}
rng = calloc(1, sizeof(rec_rng));
if (pat == NULL) {
free(pat);
inf->ecode = RE_ESPACE;
return;
}
pat->data.rng = rng;
pat->type = not ? Rep_RangeNot : Rep_Range;
if ((pat->prev = inf->ppat) != NULL)
inf->ppat->next = pat;
else
inf->palt->pat = pat;
inf->ppat = pat;
/* First pass, add everything seen */
for (count = 0; inf->ecode == 0; count++) {
/* If bracket not closed */
if (inf->ptr == inf->end) {
inf->ecode = RE_EBRACK;
return;
}
/* If not the first character */
else if (inf->ptr[0] == ']' && count)
break;
else {
/* If not a range of characters */
if (inf->ptr[1] != '-' || inf->ptr[2] == ']') {
irec_range_single(inf, inf->ptr[0]);
++inf->ptr;
}
else {
if ((inf->flags & RE_NEWLINE) &&
inf->ptr[0] < '\n' && inf->ptr[2] > '\n') {
/* Unless it is forced to be a delimiter, don't allow
* a newline in a character range */
if (inf->ptr[0] == '\n' - 1)
irec_range_single(inf, inf->ptr[0]);
else
irec_range_complex(inf, inf->ptr[0], '\n' - 1);
if (inf->ptr[2] == '\n' + 1)
irec_range_single(inf, inf->ptr[2]);
else
irec_range_complex(inf, '\n' + 1, inf->ptr[2]);
}
else
irec_range_complex(inf, inf->ptr[0], inf->ptr[2]);
inf->ptr += 3;
}
}
}
/* Skip ] */
++inf->ptr;
}
static void
irec_range_single(irec_info *inf, int value)
{
if (value >= 0 && value <= 255)
inf->ppat->data.rng->range[value] = 1;
if (inf->flags & RE_ICASE) {
if (islower(value)) {
value = toupper(value);
if (value >= 0 && value <= 255)
inf->ppat->data.rng->range[value] = 1;
}
else if (isupper(value)) {
value = tolower(value);
if (value >= 0 && value <= 255)
inf->ppat->data.rng->range[value] = 1;
}
}
}
static void
irec_range_complex(irec_info *inf, int chrf, int chrt)
{
if (chrf > chrt) {
inf->ecode = RE_ERANGE;
return;
}
for (; chrf <= chrt; chrf++)
irec_range_single(inf, chrf);
}
static void
irec_escape(irec_info *inf)
{
rec_pat *pat;
unsigned char chr = inf->ptr[0];
if (chr == 0) {
inf->ecode = RE_EESCAPE;
return;
}
++inf->ptr;
switch (chr) {
case 'o':
irec_simple_pattern(inf, Rep_Odigit);
break;
case 'O':
irec_simple_pattern(inf, Rep_OdigitNot);
break;
case 'd':
irec_simple_pattern(inf, Rep_Digit);
break;
case 'D':
irec_simple_pattern(inf, Rep_DigitNot);
break;
case 'x':
irec_simple_pattern(inf, Rep_Xdigit);
break;
case 'X':
irec_simple_pattern(inf, Rep_XdigitNot);
break;
case 's':
irec_simple_pattern(inf, Rep_Space);
break;
case 'S':
irec_simple_pattern(inf, Rep_SpaceNot);
break;
case 't':
irec_simple_pattern(inf, Rep_Tab);
break;
case 'n':
irec_simple_pattern(inf, Rep_Newline);
break;
case 'l':
irec_simple_pattern(inf, Rep_Lower);
break;
case 'u':
irec_simple_pattern(inf, Rep_Upper);
break;
case 'w':
irec_simple_pattern(inf, Rep_Alnum);
break;
case 'W':
irec_simple_pattern(inf, Rep_AlnumNot);
break;
case 'c':
irec_simple_pattern(inf, Rep_Control);
break;
case 'C':
irec_simple_pattern(inf, Rep_ControlNot);
break;
case '<':
irec_simple_pattern(inf, Rep_Bow);
break;
case '>':
irec_simple_pattern(inf, Rep_Eow);
break;
case '1': case '2': case '3':
case '4': case '5': case '6':
case '7': case '8': case '9':
if ((inf->flags & RE_NOSUB) || (chr -= '1') >= inf->ngrps) {
inf->ecode = RE_ESUBREG;
return;
}
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
pat->type = Rep_Backref;
pat->data.chr = chr;
pat->prev = inf->ppat;
if (inf->ppat)
inf->ppat->next = pat;
else
inf->palt->pat = pat;
inf->ppat = pat;
break;
/* True literals */
case '0':
irec_literal_pattern(inf, '\0');
break;
case 'a':
irec_literal_pattern(inf, '\a');
break;
case 'b':
irec_literal_pattern(inf, '\b');
break;
case 'f':
irec_literal_pattern(inf, '\f');
break;
case 'r':
irec_literal_pattern(inf, '\r');
break;
case 'v':
irec_literal_pattern(inf, '\v');
break;
default:
/* Don't check if case insensitive regular expression */
irec_literal_pattern(inf, chr);
break;
}
}
static void
irec_simple_repetition(irec_info *inf, rec_rep_t type)
{
rec_rep *rep;
/* If nowhere to add repetition */
if ((inf->pgrp == NULL && inf->ppat == NULL) ||
/* If repetition already added to last/current pattern */
(inf->pgrp == NULL && inf->ppat->rep != NULL) ||
/* If repetition already added to last/current group */
(inf->ppat == NULL && inf->pgrp->parent->rep != NULL)) {
inf->ecode = RE_BADRPT;
return;
}
if ((rep = calloc(1, sizeof(rec_rep))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
rep->type = type;
irec_add_repetition(inf, rep);
}
static void
irec_complex_repetition(irec_info *inf)
{
int exact;
rec_rep *rep;
long mine, maxc;
unsigned char *end;
/* If nowhere to add repetition */
if ((inf->pgrp == NULL && inf->ppat == NULL) ||
/* If repetition already added to last/current pattern */
(inf->pgrp == NULL && inf->ppat->rep != NULL) ||
/* If repetition already added to last/current group */
(inf->ppat == NULL && inf->pgrp->parent->rep != NULL)) {
inf->ecode = RE_EBADBR;
return;
}
exact = 0;
mine = maxc = -1;
if (inf->ptr[0] == ',')
/* Specify max number of ocurrences only */
goto domax;
else if (!isdigit(inf->ptr[0]))
goto badbr;
mine = strtol((char*)inf->ptr, (char**)&end, 10);
inf->ptr = end;
if (inf->ptr[0] == '}') {
exact = 1;
++inf->ptr;
goto redone;
}
else if (inf->ptr[0] != ',')
goto badbr;
domax:
/* Add one to skip comma */
++inf->ptr;
if (inf->ptr[0] == '}') {
++inf->ptr;
goto redone;
}
else if (!isdigit(inf->ptr[0]))
goto badbr;
maxc = strtol((char*)inf->ptr, (char**)&end, 10);
inf->ptr = end;
if (inf->ptr[0] != '}')
goto badbr;
++inf->ptr;
redone:
if (mine == maxc) {
maxc = -1;
exact = 1;
}
/* Check range and if min-max parameters are valid */
if (mine >= 255 || maxc >= 255 ||
(mine >= 0 && maxc >= 0 && mine > maxc))
goto badbr;
/* Check for noop */
if (exact && mine == 1)
return;
if ((rep = calloc(1, sizeof(rec_rep))) == NULL) {
inf->ecode = RE_ESPACE;
return;
}
/* Convert {0,1} to ? */
if (mine == 0 && maxc == 1)
rep->type = Rer_Maybe;
else if (exact) {
rep->type = Rer_Exact;
rep->mine = mine;
}
/* Convert {0,} to * */
else if (mine == 0 && maxc == -1)
rep->type = Rer_AnyTimes;
/* Convert {1,} to + */
else if (mine == 1 && maxc == -1)
rep->type = Rer_AtLeast;
else if (maxc == -1) {
rep->type = Rer_Min;
rep->mine = mine;
}
else if (mine < 1) {
rep->type = Rer_Max;
rep->maxc = maxc;
}
else {
rep->type = Rer_MinMax;
rep->mine = mine;
rep->maxc = maxc;
}
irec_add_repetition(inf, rep);
return;
badbr:
inf->ecode = RE_EBADBR;
}
/* The rep argument is allocated and has no reference yet,
* if something fails it must be freed before returning.
*/
static void
irec_add_repetition(irec_info *inf, rec_rep *rep)
{
int length;
rec_pat *pat;
rec_grp *grp;
rec_rep_t rept;
unsigned char value, upper;
rept = rep->type;
if (inf->ppat == NULL) {
rec_pat *any;
rec_grp *grp = inf->pgrp;
if (rept == Rer_AnyTimes || rept == Rer_Maybe || rept == Re_AtLeast) {
/* Convert (.)* to (.*), ((.))* not handled and may not match */
any = NULL;
if (grp->alt && grp->alt->pat) {
for (any = grp->alt->pat; any->next; any = any->next)
;
switch (any->type) {
case Rep_Any:
break;
case Rep_AnyAnyTimes:
case Rep_AnyMaybe:
case Rep_AnyAtLeast:
free(rep);
inf->ecode = RE_BADRPT;
return;
default:
any = NULL;
break;
}
}
if (any) {
free(rep);
rep = NULL;
any->type = (rept == Rer_AnyTimes) ? Rep_AnyAnyTimes :
(rept == Rer_AtLeast) ? Rep_AnyAtLeast :
Rep_AnyMaybe;
while (grp) {
++grp->comp;
grp = grp->pgrp;
}
}
}
inf->pgrp->parent->rep = rep;
irec_close_group(inf);
return;
}
switch (inf->ppat->type) {
case Rep_Bol:
case Rep_Eol:
case Rep_Bow:
case Rep_Eow:
case Rep_AnyAnyTimes:
case Rep_AnyMaybe:
case Rep_AnyAtLeast:
/* Markers that cannot repeat */
free(rep);
inf->ecode = RE_BADRPT;
return;
case Rep_Any:
grp = inf->pgrp;
free(rep);
if (rept == Rer_AnyTimes ||
rept == Rer_Maybe ||
rept == Rer_AtLeast) {
inf->ppat->type = (rept == Rer_AnyTimes) ?
Rep_AnyAnyTimes :
(rept == Rer_Maybe) ?
Rep_AnyMaybe :
Rep_AnyAtLeast;
while (grp) {
++grp->comp;
grp = grp->pgrp;
}
}
else
/* XXX Not (yet) implemented */
inf->ecode = RE_BADRPT;
rep = NULL;
break;
case Rep_String:
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
free(rep);
inf->ecode = RE_ESPACE;
return;
}
length = strlen((char*)inf->ppat->data.str);
pat->type = Rep_Literal;
pat->prev = inf->ppat;
pat->data.chr = inf->ppat->data.str[length - 1];
if (length == 2) {
/* Must convert to two Rep_Literals */
value = inf->ppat->data.str[0];
free(inf->ppat->data.str);
inf->ppat->data.chr = value;
inf->ppat->type = Rep_Literal;
}
else
/* Must remove last character from string */
inf->ppat->data.str[length - 1] = '\0';
inf->ppat->next = pat;
inf->ppat = pat;
break;
case Rep_CaseString:
if ((pat = calloc(1, sizeof(rec_pat))) == NULL) {
free(rep);
inf->ecode = RE_ESPACE;
return;
}
length = strlen((char*)inf->ppat->data.str);
pat->type = Rep_CaseLiteral;
pat->prev = inf->ppat;
pat->data.cse.lower = inf->ppat->data.str[length - 2];
pat->data.cse.upper = inf->ppat->data.str[length - 1];
if (length == 4) {
/* Must convert to two Rep_CaseLiterals */
value = inf->ppat->data.str[0];
upper = inf->ppat->data.str[1];
free(inf->ppat->data.str);
inf->ppat->data.cse.lower = value;
inf->ppat->data.cse.upper = upper;
inf->ppat->next = pat;
inf->ppat->type = Rep_CaseLiteral;
}
else
/* Must remove last character pair from string */
inf->ppat->data.str[length - 2] = '\0';
inf->ppat->next = pat;
inf->ppat = pat;
break;
default:
/* Anything else does not need special handling */
break;
}
inf->ppat->rep = rep;
}
static void
irec_free(irec_info *inf)
{
irec_free_alt(inf->alt);
}
static void
irec_free_grp(rec_grp *grp)
{
if (grp->alt)
irec_free_alt(grp->alt);
free(grp);
}
static void
irec_free_pats(rec_pat *pat)
{
rec_pat *next;
rec_pat_t rect;
while (pat) {
next = pat->next;
if (pat->rep)
free(pat->rep);
rect = pat->type;
if (rect == Rep_Range || rect == Rep_RangeNot)
free(pat->data.rng);
else if (rect == Rep_Group)
irec_free_grp(pat->data.grp);
else if (rect == Rep_StringList)
orec_free_stl(pat->data.stl);
free(pat);
pat = next;
}
}
Reference in New Issue View Git Blame Copy Permalink