From 656726a8c104c31fd604a8daecc1d11e9ab0f9cb Mon Sep 17 00:00:00 2001 From: Camden Dixie O'Brien Date: Sun, 3 Nov 2024 12:20:17 +0000 Subject: [PATCH] Move regex_t into parse.h and rename to parse_tree_t --- lib/CMakeLists.txt | 1 - lib/compile.c | 4 +- lib/construct.c | 28 ++--- lib/include/construct.h | 4 +- lib/include/parse.h | 47 +++++++- lib/include/regex.h | 56 --------- lib/parse.c | 68 ++++++++--- lib/regex.c | 42 ------- tests/construct_tests.c | 249 +++++++++++++++++++++------------------- tests/parse_tests.c | 144 +++++++++++------------ 10 files changed, 315 insertions(+), 328 deletions(-) delete mode 100644 lib/include/regex.h delete mode 100644 lib/regex.c diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt index 2225096..2d161fa 100644 --- a/lib/CMakeLists.txt +++ b/lib/CMakeLists.txt @@ -5,7 +5,6 @@ add_library(lib fsa.c min_heap.c parse.c - regex.c ) set_default_target_options(lib) target_include_directories(lib PUBLIC include) diff --git a/lib/compile.c b/lib/compile.c index 7615793..025ad4f 100644 --- a/lib/compile.c +++ b/lib/compile.c @@ -11,13 +11,13 @@ bool compile(const char *regex, int len, fsa_t *dfa_out) { - regex_t pt; + parse_tree_t pt; if (-1 == parse_expr(regex, len, &pt)) return false; fsa_t nfa; construct_nfa(&pt, &nfa); - regex_free(&pt); + parse_tree_free(&pt); convert_to_dfa(&nfa, dfa_out); fsa_free(&nfa); diff --git a/lib/construct.c b/lib/construct.c index 8ff33fc..c5737fb 100644 --- a/lib/construct.c +++ b/lib/construct.c @@ -128,7 +128,7 @@ static void construct_symbol(fsa_t *out, int symbol) fsa_add_rule(out, out->initial, 0, symbol); } -static bool in_class(const regex_class_t *class, char c) +static bool in_class(const parse_class_t *class, char c) { for (int i = 0; i < class->count; ++i) { if (class->contents[i] == c) @@ -137,7 +137,7 @@ static bool in_class(const regex_class_t *class, char c) return false; } -static void construct_class(fsa_t *out, const regex_class_t *class) +static void construct_class(fsa_t *out, const parse_class_t *class) { construct_base(out); if (class->negated) { @@ -190,36 +190,36 @@ static void construct_qmark(fsa_t *out) fsa_add_rule(out, out->initial, 0, EPSILON); } -static void construct_term(const regex_term_t *term, fsa_t *out) +static void construct_term(const parse_term_t *term, fsa_t *out) { switch (term->type) { - case REGEX_TERM_EMPTY: + case PARSE_TERM_EMPTY: construct_symbol(out, EPSILON); break; - case REGEX_TERM_LITERAL: + case PARSE_TERM_LITERAL: construct_symbol(out, term->literal); break; - case REGEX_TERM_SUBEXPR: + case PARSE_TERM_SUBEXPR: construct_nfa(&term->subexpr, out); break; - case REGEX_TERM_CLASS: + case PARSE_TERM_CLASS: construct_class(out, &term->class); break; - case REGEX_TERM_WILDCARD: + case PARSE_TERM_WILDCARD: construct_wildcard(out); break; } switch (term->quantifier) { - case REGEX_QUANTIFIER_NONE: + case PARSE_QUANTIFIER_NONE: break; - case REGEX_QUANTIFIER_STAR: + case PARSE_QUANTIFIER_STAR: construct_star(out); break; - case REGEX_QUANTIFIER_PLUS: + case PARSE_QUANTIFIER_PLUS: construct_plus(out); break; - case REGEX_QUANTIFIER_QMARK: + case PARSE_QUANTIFIER_QMARK: construct_qmark(out); break; } @@ -227,7 +227,7 @@ static void construct_term(const regex_term_t *term, fsa_t *out) assert(out->states[0].final); } -static void construct_sequence(const regex_sequence_t *seq, fsa_t *out) +static void construct_sequence(const parse_sequence_t *seq, fsa_t *out) { assert(seq->count > 0); @@ -261,7 +261,7 @@ static void construct_union(fsa_t *f, const fsa_t *o) fsa_add_rule(f, final, 0, EPSILON); } -void construct_nfa(const regex_t *regex, fsa_t *out) +void construct_nfa(const parse_tree_t *regex, fsa_t *out) { assert(regex->count > 0); diff --git a/lib/include/construct.h b/lib/include/construct.h index cdd0a30..04b9517 100644 --- a/lib/include/construct.h +++ b/lib/include/construct.h @@ -7,8 +7,8 @@ #define CONSTRUCT_H #include "fsa.h" -#include "regex.h" +#include "parse.h" -void construct_nfa(const regex_t *regex, fsa_t *out); +void construct_nfa(const parse_tree_t *regex, fsa_t *out); #endif diff --git a/lib/include/parse.h b/lib/include/parse.h index a496a37..c77e235 100644 --- a/lib/include/parse.h +++ b/lib/include/parse.h @@ -6,10 +6,53 @@ #ifndef PARSE_H #define PARSE_H -#include "regex.h" +#include #define PARSE_FAIL (-1) -int parse_expr(const char *input, int rem, regex_t *out); +typedef struct { + bool negated; + int count, capacity; + char *contents; +} parse_class_t; + +typedef enum { + PARSE_QUANTIFIER_NONE, + PARSE_QUANTIFIER_STAR, + PARSE_QUANTIFIER_PLUS, + PARSE_QUANTIFIER_QMARK, +} parse_quantifier_t; + +typedef enum { + PARSE_TERM_WILDCARD, + PARSE_TERM_CLASS, + PARSE_TERM_LITERAL, + PARSE_TERM_SUBEXPR, + PARSE_TERM_EMPTY, +} parse_term_type_t; + +struct _parse_term; +typedef struct { + int count, capacity; + struct _parse_term *contents; +} parse_sequence_t; + +typedef struct { + int count, capacity; + parse_sequence_t *contents; +} parse_tree_t; + +typedef struct _parse_term { + parse_quantifier_t quantifier; + parse_term_type_t type; + union { + parse_class_t class; + char literal; + parse_tree_t subexpr; + }; +} parse_term_t; + +int parse_expr(const char *input, int rem, parse_tree_t *out); +void parse_tree_free(const parse_tree_t *t); #endif diff --git a/lib/include/regex.h b/lib/include/regex.h deleted file mode 100644 index 4fbc2b3..0000000 --- a/lib/include/regex.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) Camden Dixie O'Brien - * SPDX-License-Identifier: AGPL-3.0-only - */ - -#ifndef REGEX_H -#define REGEX_H - -#include - -typedef struct { - bool negated; - int count, capacity; - char *contents; -} regex_class_t; - -typedef enum { - REGEX_QUANTIFIER_NONE, - REGEX_QUANTIFIER_STAR, - REGEX_QUANTIFIER_PLUS, - REGEX_QUANTIFIER_QMARK, -} regex_quantifier_t; - -typedef enum { - REGEX_TERM_WILDCARD, - REGEX_TERM_CLASS, - REGEX_TERM_LITERAL, - REGEX_TERM_SUBEXPR, - REGEX_TERM_EMPTY, -} regex_term_type_t; - -struct _regex_term; -typedef struct { - int count, capacity; - struct _regex_term *contents; -} regex_sequence_t; - -typedef struct { - int count, capacity; - regex_sequence_t *contents; -} regex_t; - -typedef struct _regex_term { - regex_quantifier_t quantifier; - regex_term_type_t type; - union { - regex_class_t class; - char literal; - regex_t subexpr; - }; -} regex_term_t; - -void regex_free(const regex_t *t); -void regex_class_free(const regex_class_t *c); - -#endif diff --git a/lib/parse.c b/lib/parse.c index ae404de..9b6c656 100644 --- a/lib/parse.c +++ b/lib/parse.c @@ -45,7 +45,7 @@ static int parse_literal(const char *input, int rem, char *out) } } -static int parse_class(const char *input, int rem, regex_class_t *out) +static int parse_class(const char *input, int rem, parse_class_t *out) { int result, used = 0; @@ -87,7 +87,7 @@ static int parse_class(const char *input, int rem, regex_class_t *out) return out->count > 0 ? used : -1; } -static int parse_term(const char *input, int rem, regex_term_t *out) +static int parse_term(const char *input, int rem, parse_term_t *out) { int result, used = 0; @@ -95,7 +95,7 @@ static int parse_term(const char *input, int rem, regex_term_t *out) return PARSE_FAIL; if ('.' == input[0]) { - out->type = REGEX_TERM_WILDCARD; + out->type = PARSE_TERM_WILDCARD; ++used; } else if ('(' == input[0]) { ++used; @@ -103,7 +103,7 @@ static int parse_term(const char *input, int rem, regex_term_t *out) result = parse_expr(input + used, rem - used, &out->subexpr); if (PARSE_FAIL == result) return PARSE_FAIL; - out->type = REGEX_TERM_SUBEXPR; + out->type = PARSE_TERM_SUBEXPR; used += result; if (')' != input[used]) @@ -113,54 +113,54 @@ static int parse_term(const char *input, int rem, regex_term_t *out) result = parse_class(input + used, rem - used, &out->class); if (PARSE_FAIL == result) return PARSE_FAIL; - out->type = REGEX_TERM_CLASS; + out->type = PARSE_TERM_CLASS; used += result; } else { result = parse_literal(input + used, rem - used, &out->literal); if (PARSE_FAIL == result) return PARSE_FAIL; - out->type = REGEX_TERM_LITERAL; + out->type = PARSE_TERM_LITERAL; used += result; } if (used < rem) { switch (input[used]) { case '*': - out->quantifier = REGEX_QUANTIFIER_STAR; + out->quantifier = PARSE_QUANTIFIER_STAR; ++used; break; case '+': - out->quantifier = REGEX_QUANTIFIER_PLUS; + out->quantifier = PARSE_QUANTIFIER_PLUS; ++used; break; case '?': - out->quantifier = REGEX_QUANTIFIER_QMARK; + out->quantifier = PARSE_QUANTIFIER_QMARK; ++used; break; default: - out->quantifier = REGEX_QUANTIFIER_NONE; + out->quantifier = PARSE_QUANTIFIER_NONE; } } else { - out->quantifier = REGEX_QUANTIFIER_NONE; + out->quantifier = PARSE_QUANTIFIER_NONE; } return used; } -static int parse_sequence(const char *input, int rem, regex_sequence_t *out) +static int parse_sequence(const char *input, int rem, parse_sequence_t *out) { int result, used = 0; out->count = 0; out->capacity = SEQUENCE_START_CAPACITY; - out->contents = malloc(out->capacity * sizeof(regex_term_t)); + out->contents = malloc(out->capacity * sizeof(parse_term_t)); assert(NULL != out->contents); while (used < rem) { if (out->count >= out->capacity) { out->capacity *= 2; out->contents = realloc( - out->contents, out->capacity * sizeof(regex_term_t)); + out->contents, out->capacity * sizeof(parse_term_t)); assert(NULL != out->contents); } @@ -175,13 +175,13 @@ static int parse_sequence(const char *input, int rem, regex_sequence_t *out) return out->count > 0 ? used : -1; } -int parse_expr(const char *input, int rem, regex_t *out) +int parse_expr(const char *input, int rem, parse_tree_t *out) { int result, used = 0; out->count = 0; out->capacity = TREE_START_CAPACITY; - out->contents = malloc(out->capacity * sizeof(regex_sequence_t)); + out->contents = malloc(out->capacity * sizeof(parse_sequence_t)); assert(NULL != out->contents); result = parse_sequence(input + used, rem - used, &out->contents[0]); @@ -198,7 +198,7 @@ int parse_expr(const char *input, int rem, regex_t *out) if (out->count >= out->capacity) { out->capacity *= 2; out->contents = realloc( - out->contents, out->capacity * sizeof(regex_sequence_t)); + out->contents, out->capacity * sizeof(parse_sequence_t)); assert(NULL != out->contents); } @@ -212,3 +212,37 @@ int parse_expr(const char *input, int rem, regex_t *out) return used; } + +static void class_free(const parse_class_t *c) +{ + if (NULL != c->contents) + free(c->contents); +} + +static void sequence_free(const parse_sequence_t *s) +{ + if (NULL != s->contents) { + for (int i = 0; i < s->count; ++i) { + switch (s->contents[i].type) { + case PARSE_TERM_CLASS: + class_free(&s->contents[i].class); + break; + case PARSE_TERM_SUBEXPR: + parse_tree_free(&s->contents[i].subexpr); + break; + default: + break; + } + } + free(s->contents); + } +} + +void parse_tree_free(const parse_tree_t *t) +{ + if (NULL != t->contents) { + for (int i = 0; i < t->count; ++i) + sequence_free(&t->contents[i]); + free(t->contents); + } +} diff --git a/lib/regex.c b/lib/regex.c deleted file mode 100644 index 74d7d1c..0000000 --- a/lib/regex.c +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) Camden Dixie O'Brien - * SPDX-License-Identifier: AGPL-3.0-only - */ - -#include "regex.h" - -#include - -static void sequence_free(const regex_sequence_t *s) -{ - if (NULL != s->contents) { - for (int i = 0; i < s->count; ++i) { - switch (s->contents[i].type) { - case REGEX_TERM_CLASS: - regex_class_free(&s->contents[i].class); - break; - case REGEX_TERM_SUBEXPR: - regex_free(&s->contents[i].subexpr); - break; - default: - break; - } - } - free(s->contents); - } -} - -void regex_free(const regex_t *t) -{ - if (NULL != t->contents) { - for (int i = 0; i < t->count; ++i) - sequence_free(&t->contents[i]); - free(t->contents); - } -} - -void regex_class_free(const regex_class_t *c) -{ - if (NULL != c->contents) - free(c->contents); -} diff --git a/tests/construct_tests.c b/tests/construct_tests.c index e5763c6..05bc9d5 100644 --- a/tests/construct_tests.c +++ b/tests/construct_tests.c @@ -34,13 +34,13 @@ static bool accepts(const fsa_t *nfa, const char *input) static void test_empty_expression(void) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_EMPTY; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_EMPTY; + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - const regex_t regex + const parse_tree_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; @@ -49,19 +49,19 @@ static void test_empty_expression(void) ASSERT_TRUE(accepts(&fsa, "")); ASSERT_FALSE(accepts(&fsa, "a")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_wildcard(void) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_WILDCARD; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_WILDCARD; + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - const regex_t regex + const parse_tree_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; @@ -74,20 +74,20 @@ static void test_wildcard(void) ASSERT_FALSE(accepts(&fsa, "")); ASSERT_FALSE(accepts(&fsa, "aa")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_literal_expression(void) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = 'a'; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - const regex_t regex + const parse_tree_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; @@ -96,26 +96,27 @@ static void test_literal_expression(void) ASSERT_TRUE(accepts(&fsa, "a")); ASSERT_FALSE(accepts(&fsa, "b")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_sequence(void) { - regex_term_t *terms = malloc(3 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(3 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = 'a'; - terms[1].quantifier = REGEX_QUANTIFIER_NONE; - terms[1].type = REGEX_TERM_LITERAL; + terms[1].quantifier = PARSE_QUANTIFIER_NONE; + terms[1].type = PARSE_TERM_LITERAL; terms[1].literal = 'b'; - terms[2].quantifier = REGEX_QUANTIFIER_NONE; - terms[2].type = REGEX_TERM_LITERAL; + terms[2].quantifier = PARSE_QUANTIFIER_NONE; + terms[2].type = PARSE_TERM_LITERAL; terms[2].literal = 'c'; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 3; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -126,24 +127,25 @@ static void test_sequence(void) ASSERT_FALSE(accepts(&fsa, "d")); ASSERT_FALSE(accepts(&fsa, "abcd")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_union(void) { const char *literals = "abc"; - regex_sequence_t *alternatives = malloc(3 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(3 * sizeof(parse_sequence_t)); for (int i = 0; i < 3; ++i) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = literals[i]; alternatives[i].count = alternatives[i].capacity = 1; alternatives[i].contents = terms; } - regex_t regex = { .count = 3, .capacity = 3, .contents = alternatives }; + parse_tree_t regex + = { .count = 3, .capacity = 3, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -154,20 +156,21 @@ static void test_union(void) ASSERT_FALSE(accepts(&fsa, "d")); ASSERT_FALSE(accepts(&fsa, "aa")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_star(void) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_STAR; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_STAR; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = 'a'; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -177,20 +180,21 @@ static void test_star(void) ASSERT_TRUE(accepts(&fsa, "aaaaaa")); ASSERT_FALSE(accepts(&fsa, "b")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_plus(void) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_PLUS; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_PLUS; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = 'a'; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -200,20 +204,21 @@ static void test_plus(void) ASSERT_FALSE(accepts(&fsa, "")); ASSERT_FALSE(accepts(&fsa, "b")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_qmark(void) { - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_QMARK; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_QMARK; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = 'a'; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -223,29 +228,30 @@ static void test_qmark(void) ASSERT_FALSE(accepts(&fsa, "aa")); ASSERT_FALSE(accepts(&fsa, "b")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_subexpression(void) { - regex_term_t *inner_terms = malloc(1 * sizeof(regex_term_t)); - inner_terms[0].quantifier = REGEX_QUANTIFIER_NONE; - inner_terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *inner_terms = malloc(1 * sizeof(parse_term_t)); + inner_terms[0].quantifier = PARSE_QUANTIFIER_NONE; + inner_terms[0].type = PARSE_TERM_LITERAL; inner_terms[0].literal = 'a'; - regex_sequence_t *inner_alternatives - = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *inner_alternatives + = malloc(1 * sizeof(parse_sequence_t)); inner_alternatives[0].count = inner_alternatives[0].capacity = 1; inner_alternatives[0].contents = inner_terms; - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_SUBEXPR; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_SUBEXPR; terms[0].subexpr.count = terms[0].subexpr.capacity = 1; terms[0].subexpr.contents = inner_alternatives; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -253,7 +259,7 @@ static void test_subexpression(void) ASSERT_TRUE(accepts(&fsa, "a")); ASSERT_FALSE(accepts(&fsa, "b")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } @@ -263,16 +269,16 @@ static void test_class(void) class_contents[0] = 'a'; class_contents[1] = 'b'; class_contents[2] = 'c'; - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_CLASS; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_CLASS; terms[0].class.negated = false; terms[0].class.count = terms[0].class.capacity = 3; terms[0].class.contents = class_contents; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - const regex_t regex + const parse_tree_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; @@ -285,7 +291,7 @@ static void test_class(void) ASSERT_FALSE(accepts(&fsa, "aa")); ASSERT_FALSE(accepts(&fsa, "d")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } @@ -295,16 +301,16 @@ static void test_negated_class(void) class_contents[0] = 'a'; class_contents[1] = 'b'; class_contents[2] = 'c'; - regex_term_t *terms = malloc(1 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_CLASS; + parse_term_t *terms = malloc(1 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_CLASS; terms[0].class.negated = true; terms[0].class.count = terms[0].class.capacity = 3; terms[0].class.contents = class_contents; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms; - const regex_t regex + const parse_tree_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; @@ -318,42 +324,43 @@ static void test_negated_class(void) ASSERT_FALSE(accepts(&fsa, "")); ASSERT_FALSE(accepts(&fsa, "aa")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_sequence_containing_starred_union(void) { // ab(c|d)* - regex_term_t *inner_terms0 = malloc(1 * sizeof(regex_term_t)); - inner_terms0[0].quantifier = REGEX_QUANTIFIER_NONE; - inner_terms0[0].type = REGEX_TERM_LITERAL; + parse_term_t *inner_terms0 = malloc(1 * sizeof(parse_term_t)); + inner_terms0[0].quantifier = PARSE_QUANTIFIER_NONE; + inner_terms0[0].type = PARSE_TERM_LITERAL; inner_terms0[0].literal = 'c'; - regex_term_t *inner_terms1 = malloc(1 * sizeof(regex_term_t)); - inner_terms1[0].quantifier = REGEX_QUANTIFIER_NONE; - inner_terms1[0].type = REGEX_TERM_LITERAL; + parse_term_t *inner_terms1 = malloc(1 * sizeof(parse_term_t)); + inner_terms1[0].quantifier = PARSE_QUANTIFIER_NONE; + inner_terms1[0].type = PARSE_TERM_LITERAL; inner_terms1[0].literal = 'd'; - regex_sequence_t *inner_alternatives - = malloc(2 * sizeof(regex_sequence_t)); + parse_sequence_t *inner_alternatives + = malloc(2 * sizeof(parse_sequence_t)); inner_alternatives[0].count = inner_alternatives[0].capacity = 1; inner_alternatives[0].contents = inner_terms0; inner_alternatives[1].count = inner_alternatives[1].capacity = 1; inner_alternatives[1].contents = inner_terms1; - regex_term_t *terms = malloc(3 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms = malloc(3 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_LITERAL; terms[0].literal = 'a'; - terms[1].quantifier = REGEX_QUANTIFIER_NONE; - terms[1].type = REGEX_TERM_LITERAL; + terms[1].quantifier = PARSE_QUANTIFIER_NONE; + terms[1].type = PARSE_TERM_LITERAL; terms[1].literal = 'b'; - terms[2].quantifier = REGEX_QUANTIFIER_STAR; - terms[2].type = REGEX_TERM_SUBEXPR; + terms[2].quantifier = PARSE_QUANTIFIER_STAR; + terms[2].type = PARSE_TERM_SUBEXPR; terms[2].subexpr.count = terms[2].subexpr.capacity = 2; terms[2].subexpr.contents = inner_alternatives; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 3; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -369,7 +376,7 @@ static void test_sequence_containing_starred_union(void) ASSERT_FALSE(accepts(&fsa, "d")); ASSERT_FALSE(accepts(&fsa, "foo")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } @@ -377,23 +384,24 @@ static void test_union_of_single_term_and_sequence_containing_starred_term(void) { // a|b*c - regex_term_t *terms0 = malloc(1 * sizeof(regex_term_t)); - terms0[0].quantifier = REGEX_QUANTIFIER_NONE; - terms0[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms0 = malloc(1 * sizeof(parse_term_t)); + terms0[0].quantifier = PARSE_QUANTIFIER_NONE; + terms0[0].type = PARSE_TERM_LITERAL; terms0[0].literal = 'a'; - regex_term_t *terms1 = malloc(2 * sizeof(regex_term_t)); - terms1[0].quantifier = REGEX_QUANTIFIER_STAR; - terms1[0].type = REGEX_TERM_LITERAL; + parse_term_t *terms1 = malloc(2 * sizeof(parse_term_t)); + terms1[0].quantifier = PARSE_QUANTIFIER_STAR; + terms1[0].type = PARSE_TERM_LITERAL; terms1[0].literal = 'b'; - terms1[1].quantifier = REGEX_QUANTIFIER_NONE; - terms1[1].type = REGEX_TERM_LITERAL; + terms1[1].quantifier = PARSE_QUANTIFIER_NONE; + terms1[1].type = PARSE_TERM_LITERAL; terms1[1].literal = 'c'; - regex_sequence_t *alternatives = malloc(2 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(2 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 1; alternatives[0].contents = terms0; alternatives[1].count = alternatives[1].capacity = 2; alternatives[1].contents = terms1; - regex_t regex = { .count = 2, .capacity = 2, .contents = alternatives }; + parse_tree_t regex + = { .count = 2, .capacity = 2, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -405,38 +413,39 @@ test_union_of_single_term_and_sequence_containing_starred_term(void) ASSERT_FALSE(accepts(&fsa, "foo")); ASSERT_FALSE(accepts(&fsa, "ba")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } static void test_sequence_of_subexpr_a_or_empty_and_b(void) { // (a|ε)b - regex_term_t *inner_terms0 = malloc(1 * sizeof(regex_term_t)); - inner_terms0[0].quantifier = REGEX_QUANTIFIER_NONE; - inner_terms0[0].type = REGEX_TERM_LITERAL; + parse_term_t *inner_terms0 = malloc(1 * sizeof(parse_term_t)); + inner_terms0[0].quantifier = PARSE_QUANTIFIER_NONE; + inner_terms0[0].type = PARSE_TERM_LITERAL; inner_terms0[0].literal = 'a'; - regex_term_t *inner_terms1 = malloc(1 * sizeof(regex_term_t)); - inner_terms1[0].quantifier = REGEX_QUANTIFIER_NONE; - inner_terms1[0].type = REGEX_TERM_EMPTY; - regex_sequence_t *inner_alternatives - = malloc(2 * sizeof(regex_sequence_t)); + parse_term_t *inner_terms1 = malloc(1 * sizeof(parse_term_t)); + inner_terms1[0].quantifier = PARSE_QUANTIFIER_NONE; + inner_terms1[0].type = PARSE_TERM_EMPTY; + parse_sequence_t *inner_alternatives + = malloc(2 * sizeof(parse_sequence_t)); inner_alternatives[0].count = inner_alternatives[0].capacity = 1; inner_alternatives[0].contents = inner_terms0; inner_alternatives[1].count = inner_alternatives[1].capacity = 1; inner_alternatives[1].contents = inner_terms1; - regex_term_t *terms = malloc(2 * sizeof(regex_term_t)); - terms[0].quantifier = REGEX_QUANTIFIER_NONE; - terms[0].type = REGEX_TERM_SUBEXPR; + parse_term_t *terms = malloc(2 * sizeof(parse_term_t)); + terms[0].quantifier = PARSE_QUANTIFIER_NONE; + terms[0].type = PARSE_TERM_SUBEXPR; terms[0].subexpr.count = terms[0].subexpr.capacity = 2; terms[0].subexpr.contents = inner_alternatives; - terms[1].quantifier = REGEX_QUANTIFIER_NONE; - terms[1].type = REGEX_TERM_LITERAL; + terms[1].quantifier = PARSE_QUANTIFIER_NONE; + terms[1].type = PARSE_TERM_LITERAL; terms[1].literal = 'b'; - regex_sequence_t *alternatives = malloc(1 * sizeof(regex_sequence_t)); + parse_sequence_t *alternatives = malloc(1 * sizeof(parse_sequence_t)); alternatives[0].count = alternatives[0].capacity = 2; alternatives[0].contents = terms; - regex_t regex = { .count = 1, .capacity = 1, .contents = alternatives }; + parse_tree_t regex + = { .count = 1, .capacity = 1, .contents = alternatives }; fsa_t fsa; construct_nfa(®ex, &fsa); @@ -446,7 +455,7 @@ static void test_sequence_of_subexpr_a_or_empty_and_b(void) ASSERT_FALSE(accepts(&fsa, "")); ASSERT_FALSE(accepts(&fsa, "a")); - regex_free(®ex); + parse_tree_free(®ex); fsa_free(&fsa); } diff --git a/tests/parse_tests.c b/tests/parse_tests.c index 5e4bb6e..822c12e 100644 --- a/tests/parse_tests.c +++ b/tests/parse_tests.c @@ -10,268 +10,268 @@ static void a_has_1_alternative(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("a", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); - regex_free(&t); + parse_tree_free(&t); } static void a_pipe_b_has_2_alternatives(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("a|b", &t); ASSERT_NE(-1, result); ASSERT_EQ(2, t.count); - regex_free(&t); + parse_tree_free(&t); } static void a_pipe_b_pipe_c_has_3_alternatives(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("a|b|c", &t); ASSERT_NE(-1, result); ASSERT_EQ(3, t.count); - regex_free(&t); + parse_tree_free(&t); } static void a_is_parsed_as_unquantified_literal(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("a", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type); ASSERT_EQ('a', t.contents[0].contents[0].literal); - regex_free(&t); + parse_tree_free(&t); } static void b_is_parsed_as_unquantified_literal(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("b", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type); ASSERT_EQ('b', t.contents[0].contents[0].literal); - regex_free(&t); + parse_tree_free(&t); } static void abc_is_parsed_as_sequence_of_unquantified_literals(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("abc", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(3, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type); ASSERT_EQ('a', t.contents[0].contents[0].literal); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[1].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[1].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[1].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[1].type); ASSERT_EQ('b', t.contents[0].contents[1].literal); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[2].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[2].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[2].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[2].type); ASSERT_EQ('c', t.contents[0].contents[2].literal); - regex_free(&t); + parse_tree_free(&t); } static void dot_is_parsed_as_unquantified_wildcard_term(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING(".", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_WILDCARD, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type); - regex_free(&t); + parse_tree_free(&t); } static void backslash_dot_is_parsed_as_unquantified_literal(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("\\.", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type); ASSERT_EQ('.', t.contents[0].contents[0].literal); - regex_free(&t); + parse_tree_free(&t); } static void backslash_backslash_is_parsed_as_unquantified_literal(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("\\\\", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[0].type); ASSERT_EQ('\\', t.contents[0].contents[0].literal); - regex_free(&t); + parse_tree_free(&t); } static void a_pipe_b_in_parens_is_parsed_as_subexpr_term(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("(a|b)", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_SUBEXPR, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_SUBEXPR, t.contents[0].contents[0].type); - const regex_t *inner = &t.contents[0].contents[0].subexpr; + const parse_tree_t *inner = &t.contents[0].contents[0].subexpr; ASSERT_EQ(2, inner->count); ASSERT_EQ(1, inner->contents[0].count); ASSERT_EQ( - REGEX_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, inner->contents[0].contents[0].type); + PARSE_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[0].contents[0].type); ASSERT_EQ('a', inner->contents[0].contents[0].literal); ASSERT_EQ(1, inner->contents[1].count); ASSERT_EQ( - REGEX_QUANTIFIER_NONE, inner->contents[1].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, inner->contents[1].contents[0].type); + PARSE_QUANTIFIER_NONE, inner->contents[1].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[1].contents[0].type); ASSERT_EQ('b', inner->contents[1].contents[0].literal); - regex_free(&t); + parse_tree_free(&t); } static void a_in_parens_b_is_parsed_as_sequence_with_subexpr_term(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("(a)b", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(2, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_SUBEXPR, t.contents[0].contents[0].type); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[1].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, t.contents[0].contents[1].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_SUBEXPR, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[1].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, t.contents[0].contents[1].type); ASSERT_EQ('b', t.contents[0].contents[1].literal); - const regex_t *inner = &t.contents[0].contents[0].subexpr; + const parse_tree_t *inner = &t.contents[0].contents[0].subexpr; ASSERT_EQ(1, inner->contents[0].count); ASSERT_EQ( - REGEX_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_LITERAL, inner->contents[0].contents[0].type); + PARSE_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_LITERAL, inner->contents[0].contents[0].type); ASSERT_EQ('a', inner->contents[0].contents[0].literal); - regex_free(&t); + parse_tree_free(&t); } static void dot_star_is_parsed_as_star_quantified_wildcard(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING(".*", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_STAR, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_WILDCARD, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_STAR, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type); - regex_free(&t); + parse_tree_free(&t); } static void dot_plus_is_parsed_as_plus_quantified_wildcard(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING(".+", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_PLUS, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_WILDCARD, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_PLUS, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type); - regex_free(&t); + parse_tree_free(&t); } static void dot_question_mark_is_parsed_as_qmrk_quantified_wildcard(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING(".?", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_QMARK, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_WILDCARD, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_QMARK, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_WILDCARD, t.contents[0].contents[0].type); - regex_free(&t); + parse_tree_free(&t); } static void a_in_brackets_is_parsed_as_class_containing_only_a(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("[a]", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_CLASS, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_CLASS, t.contents[0].contents[0].type); ASSERT_FALSE(t.contents[0].contents[0].class.negated); ASSERT_EQ(1, t.contents[0].contents[0].class.count); ASSERT_NOT_NULL(t.contents[0].contents[0].class.contents); ASSERT_EQ('a', t.contents[0].contents[0].class.contents[0]); - regex_free(&t); + parse_tree_free(&t); } static void caret_a_in_brackets_parses_as_negated_class(void) { - regex_t t; + parse_tree_t t; const int result = PARSE_EXPR_STRING("[^a]", &t); ASSERT_NE(-1, result); ASSERT_EQ(1, t.count); ASSERT_NOT_NULL(t.contents); ASSERT_EQ(1, t.contents[0].count); - ASSERT_EQ(REGEX_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); - ASSERT_EQ(REGEX_TERM_CLASS, t.contents[0].contents[0].type); + ASSERT_EQ(PARSE_QUANTIFIER_NONE, t.contents[0].contents[0].quantifier); + ASSERT_EQ(PARSE_TERM_CLASS, t.contents[0].contents[0].type); ASSERT_TRUE(t.contents[0].contents[0].class.negated); ASSERT_EQ(1, t.contents[0].contents[0].class.count); ASSERT_NOT_NULL(t.contents[0].contents[0].class.contents); ASSERT_EQ('a', t.contents[0].contents[0].class.contents[0]); - regex_free(&t); + parse_tree_free(&t); } int main(void)