shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2024-12-22 17:35:59 +03:00
Code Releases Activity
6753ff894f
lvm2/old-tests/regex/parse_t.c

185 lines
3.4 KiB
C
Raw Normal View History

o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
/*
Update copyright notices.
2004-03-30 23:35:44 +04:00
* Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved.
Make matcher_t and parse_t compilable These two old-test/regex utils are usable for testing output of regex processing at core level. For getting them usable configure need to create Makefile. This is currently disable by default.
2010-04-21 12:01:51 +04:00
* Copyright (C) 2004-2010 Red Hat, Inc. All rights reserved.
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
*
Update copyright notices.
2004-03-30 23:35:44 +04:00
* This file is part of LVM2.
*
* This copyrighted material is made available to anyone wishing to use,
* modify, copy, or redistribute it subject to the terms and conditions
* of the GNU General Public License v.2.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
*/
Make matcher_t and parse_t compilable These two old-test/regex utils are usable for testing output of regex processing at core level. For getting them usable configure need to create Makefile. This is currently disable by default.
2010-04-21 12:01:51 +04:00
/* hack - using unexported internal function */
#include "regex/parse_rx.c"
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
#include <stdio.h>
#include <ctype.h>
static void _pretty_print(struct rx_node *rx, int depth)
{
int i;
for (i = 0; i < depth; i++)
printf(" ");
/* display info about the node */
switch (rx->type) {
case CAT:
printf("Cat");
break;
case OR:
printf("Or");
break;
case STAR:
printf("Star");
break;
case PLUS:
printf("Plus");
break;
case QUEST:
printf("Quest");
break;
case CHARSET:
printf("Charset : ");
for (i = 0; i < 256; i++) {
Make matcher_t and parse_t compilable These two old-test/regex utils are usable for testing output of regex processing at core level. For getting them usable configure need to create Makefile. This is currently disable by default.
2010-04-21 12:01:51 +04:00
if (dm_bit(rx->charset, i) && isprint(i))
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
printf("%c", (char) i);
}
break;
default:
printf("Unknown type");
}
printf("\n");
if (rx->left)
_pretty_print(rx->left, depth + 1);
if (rx->right)
_pretty_print(rx->right, depth + 1);
}
add -r to print out closer to original regex format
2010-04-22 07:12:01 +04:00
static void _regex_print(struct rx_node *rx, int depth)
{
int i, numchars;
int left_and_right = (rx->left && rx->right);
if (left_and_right && rx->type == CAT && rx->left->type == OR)
printf("(");
if (rx->left)
_regex_print(rx->left, depth + 1);
if (left_and_right && rx->type == CAT && rx->left->type == OR)
printf(")");
/* display info about the node */
switch (rx->type) {
case CAT:
//printf("Cat");
break;
case OR:
printf("|");
break;
case STAR:
printf("*");
break;
case PLUS:
printf("+");
break;
case QUEST:
printf("?");
break;
case CHARSET:
numchars = 0;
for (i = 0; i < 256; i++)
if (dm_bit(rx->charset, i) && (isprint(i) || i == HAT_CHAR || i == DOLLAR_CHAR))
numchars++;
if (numchars == 97) {
printf(".");
break;
}
if (numchars > 1)
printf("[");
for (i = 0; i < 256; i++)
if (dm_bit(rx->charset, i)) {
isprint
2010-04-22 07:42:00 +04:00
if (isprint(i))
add -r to print out closer to original regex format
2010-04-22 07:12:01 +04:00
printf("%c", (char) i);
else if (i == HAT_CHAR)
printf("^");
else if (i == DOLLAR_CHAR)
printf("$");
}
if (numchars > 1)
printf("]");
break;
default:
fprintf(stderr, "Unknown type");
}
if (left_and_right && rx->type == CAT && rx->right->type == OR)
printf("(");
if (rx->right)
_regex_print(rx->right, depth + 1);
if (left_and_right && rx->type == CAT && rx->right->type == OR)
printf(")");
if (!depth)
printf("\n");
}
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
int main(int argc, char **argv)
{
Use hash, bitset, malloc, pool from libdevmapper.
2005-10-17 03:03:59 +04:00
struct dm_pool *mem;
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
struct rx_node *rx;
add -r to print out closer to original regex format
2010-04-22 07:12:01 +04:00
int regex_print = 0;
int regex_arg = 1;
if (argc == 3 && !strcmp(argv[1], "-r")) {
regex_print++;
regex_arg++;
argc--;
}
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
if (argc != 2) {
add -r to print out closer to original regex format
2010-04-22 07:12:01 +04:00
fprintf(stderr, "Usage : %s [-r] <regex>\n", argv[0]);
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
exit(0);
}
Make matcher_t and parse_t compilable These two old-test/regex utils are usable for testing output of regex processing at core level. For getting them usable configure need to create Makefile. This is currently disable by default.
2010-04-21 12:01:51 +04:00
dm_log_init_verbose(_LOG_DEBUG);
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
Make matcher_t and parse_t compilable These two old-test/regex utils are usable for testing output of regex processing at core level. For getting them usable configure need to create Makefile. This is currently disable by default.
2010-04-21 12:01:51 +04:00
if (!(mem = dm_pool_create("parse_regex", 1024))) {
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
fprintf(stderr, "Couldn't create pool\n");
exit(1);
}
add -r to print out closer to original regex format
2010-04-22 07:12:01 +04:00
if (!(rx = rx_parse_str(mem, argv[regex_arg]))) {
Make matcher_t and parse_t compilable These two old-test/regex utils are usable for testing output of regex processing at core level. For getting them usable configure need to create Makefile. This is currently disable by default.
2010-04-21 12:01:51 +04:00
dm_pool_destroy(mem);
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
fprintf(stderr, "Couldn't parse regex\n");
exit(1);
}
add -r to print out closer to original regex format
2010-04-22 07:12:01 +04:00
if (regex_print)
_regex_print(rx, 0);
else
_pretty_print(rx, 0);
Use hash, bitset, malloc, pool from libdevmapper.
2005-10-17 03:03:59 +04:00
dm_pool_destroy(mem);
o First pass at the regex code. lib/regex/matcher takes an array of regex's and builds a *very* efficient engine that will tell you which regex a string matches with only a single pass through the string. To be used in the config file when specifying devices. o Anchor's aren't supported yet (^ and $) but that won't take long. o Also when we get some realistic config files we may want to consider adding an extra level of indirection to the dfa state in order to compress the table. It all depends on how large typical tables get.
2001-10-19 18:36:57 +04:00
return 0;
}
Copy Permalink