mirror of
git://sourceware.org/git/lvm2.git
synced 2024-12-22 17:35:59 +03:00
364 lines
6.3 KiB
C
364 lines
6.3 KiB
C
|
/*
|
||
|
* Copyright (C) 2001 Sistina Software (UK) Limited.
|
||
|
*
|
||
|
* This file is released under the GPL.
|
||
|
*/
|
||
|
|
||
|
#include "parse_rx.h"
|
||
|
#include "bitset.h"
|
||
|
#include "log.h"
|
||
|
|
||
|
#include <string.h>
|
||
|
#include <stdlib.h>
|
||
|
#include <stdio.h>
|
||
|
|
||
|
|
||
|
struct parse_sp { /* scratch pad for the parsing process */
|
||
|
struct pool *mem;
|
||
|
int type; /* token type, 0 indicates a charset */
|
||
|
bitset_t charset; /* The current charset */
|
||
|
const char *cursor; /* where we are in the regex */
|
||
|
const char *rx_end; /* 1pte for the expression being parsed */
|
||
|
};
|
||
|
|
||
|
|
||
|
static struct rx_node *_expr(struct parse_sp *ps, struct rx_node *l);
|
||
|
|
||
|
|
||
|
/*
|
||
|
* Get the next token from the regular expression.
|
||
|
* Returns: 1 success, 0 end of input, -1 error.
|
||
|
*/
|
||
|
static int _get_token(struct parse_sp *ps)
|
||
|
{
|
||
|
int neg = 0, range = 0;
|
||
|
char c, lc = 0;
|
||
|
const char *ptr = ps->cursor;
|
||
|
if(ptr == ps->rx_end) { /* end of input ? */
|
||
|
ps->type = -1;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
switch(*ptr) {
|
||
|
/* charsets and ncharsets */
|
||
|
case '[':
|
||
|
ptr++;
|
||
|
if(*ptr == '^') {
|
||
|
bit_set_all(ps->charset);
|
||
|
|
||
|
/* never transition on zero */
|
||
|
bit_clear(ps->charset, 0);
|
||
|
neg = 1;
|
||
|
ptr++;
|
||
|
|
||
|
} else
|
||
|
bit_clear_all(ps->charset);
|
||
|
|
||
|
while((ptr < ps->rx_end) && (*ptr != ']')) {
|
||
|
if(*ptr == '\\') {
|
||
|
/* an escaped character */
|
||
|
ptr++;
|
||
|
switch(*ptr) {
|
||
|
case 'n': c = '\n'; break;
|
||
|
case 'r': c = '\r'; break;
|
||
|
case 't': c = '\t'; break;
|
||
|
default:
|
||
|
c = *ptr;
|
||
|
}
|
||
|
} else if(*ptr == '-' && lc) {
|
||
|
/* we've got a range on our hands */
|
||
|
range = 1;
|
||
|
ptr++;
|
||
|
if(ptr == ps->rx_end) {
|
||
|
log_info("incomplete charset "
|
||
|
"specification");
|
||
|
return -1;
|
||
|
}
|
||
|
c = *ptr;
|
||
|
} else
|
||
|
c = *ptr;
|
||
|
|
||
|
if(range) {
|
||
|
/* add lc - c into the bitset */
|
||
|
if(lc > c) {
|
||
|
char tmp = c;
|
||
|
c = lc;
|
||
|
lc = tmp;
|
||
|
}
|
||
|
|
||
|
for(; lc <= c; lc++) {
|
||
|
if(neg)
|
||
|
bit_clear(ps->charset, lc);
|
||
|
else
|
||
|
bit_set(ps->charset, lc);
|
||
|
}
|
||
|
range = 0;
|
||
|
} else {
|
||
|
/* add c into the bitset */
|
||
|
if(neg)
|
||
|
bit_clear(ps->charset, c);
|
||
|
else
|
||
|
bit_set(ps->charset, c);
|
||
|
}
|
||
|
ptr++;
|
||
|
lc = c;
|
||
|
}
|
||
|
|
||
|
if(ptr >= ps->rx_end) {
|
||
|
ps->type = -1;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
ps->type = 0;
|
||
|
ps->cursor = ptr + 1;
|
||
|
break;
|
||
|
|
||
|
/* These characters are special, we just return their ASCII
|
||
|
codes as the type. Sorted into ascending order to help the
|
||
|
compiler */
|
||
|
case '(':
|
||
|
case ')':
|
||
|
case '*':
|
||
|
case '+':
|
||
|
case '?':
|
||
|
case '|':
|
||
|
case '^':
|
||
|
case '$':
|
||
|
ps->type = (int) *ptr;
|
||
|
ps->cursor = ptr + 1;
|
||
|
break;
|
||
|
|
||
|
case '.':
|
||
|
/* The 'all but newline' character set */
|
||
|
ps->type = 0;
|
||
|
ps->cursor = ptr + 1;
|
||
|
bit_set_all(ps->charset);
|
||
|
bit_clear(ps->charset, (int) '\n');
|
||
|
bit_clear(ps->charset, (int) '\r');
|
||
|
bit_clear(ps->charset, 0);
|
||
|
break;
|
||
|
|
||
|
case '\\':
|
||
|
/* escaped character */
|
||
|
ptr++;
|
||
|
if(ptr >= ps->rx_end) {
|
||
|
log_info("badly quoted character at end "
|
||
|
"of expression");
|
||
|
ps->type = -1;
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
ps->type = 0;
|
||
|
ps->cursor = ptr + 1;
|
||
|
bit_clear_all(ps->charset);
|
||
|
switch(*ptr) {
|
||
|
case 'n': bit_set(ps->charset, (int) '\n'); break;
|
||
|
case 'r': bit_set(ps->charset, (int) '\r'); break;
|
||
|
case 't': bit_set(ps->charset, (int) '\t'); break;
|
||
|
default:
|
||
|
bit_set(ps->charset, (int) *ptr);
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
/* add a single character to the bitset */
|
||
|
ps->type = 0;
|
||
|
ps->cursor = ptr + 1;
|
||
|
bit_clear_all(ps->charset);
|
||
|
bit_set(ps->charset, (int) *ptr);
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
static struct rx_node *_create_node(struct pool *mem, int type,
|
||
|
struct rx_node *l, struct rx_node *r)
|
||
|
{
|
||
|
struct rx_node *n = pool_zalloc(mem, sizeof(*n));
|
||
|
|
||
|
if (n) {
|
||
|
if (!(n->charset = bitset_create(mem, 256))) {
|
||
|
pool_free(mem, n);
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
n->type = type;
|
||
|
n->left = l;
|
||
|
n->right = r;
|
||
|
}
|
||
|
|
||
|
return n;
|
||
|
}
|
||
|
|
||
|
static struct rx_node *_term(struct parse_sp *ps)
|
||
|
{
|
||
|
struct rx_node *n;
|
||
|
|
||
|
switch(ps->type) {
|
||
|
case 0:
|
||
|
if (!(n = _create_node(ps->mem, CHARSET, NULL, NULL))) {
|
||
|
stack;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
bit_copy(n->charset, ps->charset);
|
||
|
_get_token(ps); /* match charset */
|
||
|
break;
|
||
|
|
||
|
case '(':
|
||
|
_get_token(ps); /* match '(' */
|
||
|
n = _expr(ps, 0);
|
||
|
if(ps->type != ')') {
|
||
|
log_debug("missing ')' in regular expression");
|
||
|
return 0;
|
||
|
}
|
||
|
_get_token(ps); /* match ')' */
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
n = 0;
|
||
|
}
|
||
|
|
||
|
return n;
|
||
|
}
|
||
|
|
||
|
static struct rx_node *_closure_term(struct parse_sp *ps)
|
||
|
{
|
||
|
struct rx_node *l, *n;
|
||
|
|
||
|
if(!(l = _term(ps)))
|
||
|
return NULL;
|
||
|
|
||
|
switch(ps->type) {
|
||
|
case '*':
|
||
|
n = _create_node(ps->mem, STAR, l, NULL);
|
||
|
break;
|
||
|
|
||
|
case '+':
|
||
|
n = _create_node(ps->mem, PLUS, l, NULL);
|
||
|
break;
|
||
|
|
||
|
case '?':
|
||
|
n = _create_node(ps->mem, QUEST, l, NULL);
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
return l;
|
||
|
}
|
||
|
|
||
|
if (!n) {
|
||
|
stack;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
_get_token(ps);
|
||
|
return n;
|
||
|
}
|
||
|
|
||
|
static struct rx_node *_cat_term(struct parse_sp *ps)
|
||
|
{
|
||
|
struct rx_node *l, *r, *n;
|
||
|
|
||
|
if (!(l = _closure_term(ps)))
|
||
|
return NULL;
|
||
|
|
||
|
if (ps->type == '|')
|
||
|
/* bail out */
|
||
|
return l;
|
||
|
|
||
|
/* catenate */
|
||
|
if (!(r = _cat_term(ps)))
|
||
|
return l;
|
||
|
|
||
|
if (!(n = _create_node(ps->mem, CAT, l, r))) {
|
||
|
stack;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
return n;
|
||
|
}
|
||
|
|
||
|
static struct rx_node *_expr(struct parse_sp *ps, struct rx_node *l)
|
||
|
{
|
||
|
struct rx_node *n = 0;
|
||
|
while((ps->type >= 0) && (ps->type != ')')) {
|
||
|
|
||
|
if (!(n = _create_node(ps->mem, CAT, l, NULL))) {
|
||
|
stack;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
switch(ps->type) {
|
||
|
case 0:
|
||
|
case '(':
|
||
|
/* implicit catenation */
|
||
|
if(!l)
|
||
|
n = _cat_term(ps);
|
||
|
else
|
||
|
n->right = _cat_term(ps);
|
||
|
|
||
|
break;
|
||
|
|
||
|
case '|':
|
||
|
/* 'or' */
|
||
|
if(!l) {
|
||
|
log_debug("badly formed '|' expression");
|
||
|
return 0;
|
||
|
}
|
||
|
n->type = OR;
|
||
|
_get_token(ps); /* match '|' */
|
||
|
n->right = _cat_term(ps);
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
log_debug("unexpected token");
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
if(!n) {
|
||
|
log_err("parse error in regex");
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
if((n->type != CHARSET) && !n->left) {
|
||
|
log_debug("badly formed regex");
|
||
|
ps->type = -1;
|
||
|
ps->cursor = ps->rx_end;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
l = n;
|
||
|
}
|
||
|
|
||
|
return n;
|
||
|
}
|
||
|
|
||
|
struct rx_node *rx_parse_tok(struct pool *mem,
|
||
|
const char *begin, const char *end)
|
||
|
{
|
||
|
struct rx_node *r;
|
||
|
struct parse_sp *ps = pool_alloc(mem, sizeof(*ps));
|
||
|
|
||
|
if (!ps) {
|
||
|
stack;
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
memset(ps, 0, sizeof(*ps));
|
||
|
ps->mem = mem;
|
||
|
ps->charset = bitset_create(mem, 256);
|
||
|
ps->cursor = begin;
|
||
|
ps->rx_end = end;
|
||
|
_get_token(ps); /* load the first token */
|
||
|
if (!(r = _expr(ps, NULL)))
|
||
|
pool_free(mem, ps);
|
||
|
|
||
|
return r;
|
||
|
}
|
||
|
|
||
|
struct rx_node *rx_parse_str(struct pool *mem, const char *str)
|
||
|
{
|
||
|
return rx_parse_tok(mem, str, str + strlen(str));
|
||
|
}
|