Remove class desugaring

lib/desugar.c

@@ -9,30 +9,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void desugar_class(regex_term_t *term)
-{
-	assert(!term->class.negated);
-
-	const int count = term->class.count;
-	regex_sequence_t *alternatives
-	    = malloc(count * sizeof(regex_sequence_t));
-	assert(NULL != alternatives);
-
-	for (int i = 0; i < count; ++i) {
-		regex_term_t *terms = malloc(sizeof(regex_term_t));
-		terms[0].quantifier = REGEX_QUANTIFIER_NONE;
-		terms[0].type = REGEX_TERM_LITERAL;
-		terms[0].literal = term->class.contents[i];
-		alternatives[i].count = alternatives[i].capacity = 1;
-		alternatives[i].contents = terms;
-	}
-
-	regex_class_free(&term->class);
-	term->type = REGEX_TERM_SUBEXPR;
-	term->subexpr.count = term->subexpr.capacity = count;
-	term->subexpr.contents = alternatives;
-}
-
 static void deep_copy_term(regex_term_t *dst, regex_term_t *src);
 
 static void deep_copy_sequence(regex_sequence_t *dst, regex_sequence_t *src)
@@ -48,10 +24,10 @@ static void deep_copy_sequence(regex_sequence_t *dst, regex_sequence_t *src)
 static void deep_copy_term(regex_term_t *dst, regex_term_t *src)
 {
 	assert(REGEX_TERM_WILDCARD != src->type);
-	assert(REGEX_TERM_CLASS != src->type);
 
 	memcpy(dst, src, sizeof(regex_term_t));
-	if (REGEX_TERM_SUBEXPR == src->type) {
+	switch (src->type) {
+	case REGEX_TERM_SUBEXPR:
 		dst->subexpr.capacity = src->subexpr.count;
 		dst->subexpr.contents
 		    = malloc(dst->subexpr.capacity * sizeof(regex_sequence_t));
@@ -61,6 +37,19 @@ static void deep_copy_term(regex_term_t *dst, regex_term_t *src)
 			deep_copy_sequence(
 			    &dst->subexpr.contents[i], &src->subexpr.contents[i]);
 		}
+		break;
+
+	case REGEX_TERM_CLASS:
+		dst->class.count = src->class.count;
+		dst->class.capacity = src->class.capacity;
+		dst->class.contents
+		    = malloc(dst->class.capacity * sizeof(regex_sequence_t));
+		assert(NULL != dst->class.contents);
+		memcpy(dst->class.contents, src->class.contents, src->class.count);
+		break;
+
+	default:
+		break;
 	}
 }
 
@@ -113,14 +102,12 @@ static void desugar_term(regex_term_t *term)
 	case REGEX_TERM_WILDCARD:
 		assert(false);
 		break;
-	case REGEX_TERM_CLASS:
-		desugar_class(term);
-		break;
 
 	case REGEX_TERM_SUBEXPR:
 		desugar_regex(&term->subexpr);
 		break;
 
+	case REGEX_TERM_CLASS:
 	case REGEX_TERM_LITERAL:
 	case REGEX_TERM_EMPTY:
 		break;
@@ -143,8 +130,7 @@ static void desugar_term(regex_term_t *term)
 void desugar_regex(regex_t *regex)
 {
 	for (int i = 0; i < regex->count; ++i) {
-		for (int j = 0; j < regex->contents[i].count; ++j) {
+		for (int j = 0; j < regex->contents[i].count; ++j)
 			desugar_term(&regex->contents[i].contents[j]);
 	}
-	}
 }

tests/desugar_tests.c

@@ -236,7 +236,7 @@ static void a_qmark_becomes_subexpr_empty_or_a(void)
 	regex_free(&t);
 }
 
-static void class_abc_becomes_subexpr_a_or_b_or_c(void)
+static void class_abc_is_unchanged(void)
 {
 	char *options = malloc(3 * sizeof(char));
 	options[0] = 'a';
@@ -256,33 +256,15 @@ static void class_abc_becomes_subexpr_a_or_b_or_c(void)
 	desugar_regex(&t);
 
 	ASSERT_EQ(1, t.count);
-	ASSERT_NOT_NULL(t.contents);
 	ASSERT_EQ(1, t.contents[0].count);
-	ASSERT_NOT_NULL(t.contents[0].contents);
 	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_TERM_CLASS, t.contents[0].contents[0].type);
 
-	const regex_t *inner = &t.contents[0].contents[0].subexpr;
+	const regex_class_t *class = &t.contents[0].contents[0].class;
-	ASSERT_EQ(3, inner->count);
+	ASSERT_EQ(3, class->count);
-	ASSERT_NOT_NULL(inner->contents);
+	ASSERT_EQ('a', class->contents[0]);
-	ASSERT_EQ(1, inner->contents[0].count);
+	ASSERT_EQ('b', class->contents[1]);
-	ASSERT_NOT_NULL(inner->contents[0].contents);
+	ASSERT_EQ('c', class->contents[2]);
-	ASSERT_EQ(
-	    REGEX_QUANTIFIER_NONE, inner->contents[0].contents[0].quantifier);
-	ASSERT_EQ(REGEX_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_NOT_NULL(inner->contents[1].contents);
-	ASSERT_EQ(
-	    REGEX_QUANTIFIER_NONE, inner->contents[1].contents[0].quantifier);
-	ASSERT_EQ(REGEX_TERM_LITERAL, inner->contents[1].contents[0].type);
-	ASSERT_EQ('b', inner->contents[1].contents[0].literal);
-	ASSERT_EQ(1, inner->contents[2].count);
-	ASSERT_NOT_NULL(inner->contents[2].contents);
-	ASSERT_EQ(
-	    REGEX_QUANTIFIER_NONE, inner->contents[2].contents[0].quantifier);
-	ASSERT_EQ(REGEX_TERM_LITERAL, inner->contents[2].contents[0].type);
-	ASSERT_EQ('c', inner->contents[2].contents[0].literal);
 
 	regex_free(&t);
 }
@@ -351,7 +333,7 @@ int main(void)
 	subexpr_a_is_unchanged();
 	a_plus_becomes_subexpr_aa_star();
 	a_qmark_becomes_subexpr_empty_or_a();
-	class_abc_becomes_subexpr_a_or_b_or_c();
+	class_abc_is_unchanged();
 	subexpr_a_qmark_becomes_subexpr_subexpr_empty_or_a();
 	return TESTING_END();
 }