Add success result to desugar_regex()

lib/desugar.c

@@ -9,17 +9,25 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void deep_copy_term(parse_term_t *dst, parse_term_t *src);
 
-static void deep_copy_sequence(parse_sequence_t *dst, parse_sequence_t *src)
+static bool deep_copy_term(parse_term_t *dst, parse_term_t *src);
+
+static bool deep_copy_sequence(parse_sequence_t *dst, parse_sequence_t *src)
 {
 	dst->count = dst->capacity = src->count;
 	dst->contents = malloc(dst->capacity * sizeof(parse_term_t));
-	for (int i = 0; i < dst->count; ++i)
-		deep_copy_term(&dst->contents[i], &src->contents[i]);
+	if (NULL == dst->contents)
+		return false;
+
+	for (int i = 0; i < dst->count; ++i) {
+		if (!deep_copy_term(&dst->contents[i], &src->contents[i]))
+			return false;
+	}
+
+	return true;
 }
 
-static void deep_copy_term(parse_term_t *dst, parse_term_t *src)
+static bool deep_copy_term(parse_term_t *dst, parse_term_t *src)
 {
 	assert(PARSE_TERM_WILDCARD != src->type);
 	assert(PARSE_TERM_CLASS != src->type);
@@ -29,21 +37,32 @@ static void deep_copy_term(parse_term_t *dst, parse_term_t *src)
 		dst->subexpr.capacity = src->subexpr.count;
 		dst->subexpr.contents
 		    = malloc(dst->subexpr.capacity * sizeof(parse_sequence_t));
+		if (NULL == dst->subexpr.contents)
+			return false;
+
 		for (int i = 0; i < dst->subexpr.count; ++i) {
-			deep_copy_sequence(
-			    &dst->subexpr.contents[i], &src->subexpr.contents[i]);
+			if (!deep_copy_sequence(
+			        &dst->subexpr.contents[i], &src->subexpr.contents[i]))
+				return false;
 		}
 	}
+
+	return true;
 }
 
-static void desugar_plus(parse_term_t *term)
+static bool desugar_plus(parse_term_t *term)
 {
 	parse_sequence_t *alternatives = malloc(sizeof(parse_sequence_t));
+	if (NULL == alternatives)
+		return false;
 	alternatives[0].count = alternatives[0].capacity = 2;
 	alternatives[0].contents = malloc(2 * sizeof(parse_term_t));
+	if (NULL == alternatives[0].contents)
+		return false;
 
 	memcpy(&alternatives[0].contents[0], term, sizeof(parse_term_t));
-	deep_copy_term(&alternatives[0].contents[1], term);
+	if (!deep_copy_term(&alternatives[0].contents[1], term))
+		return false;
 	alternatives[0].contents[0].quantifier = PARSE_QUANTIFIER_NONE;
 	alternatives[0].contents[1].quantifier = PARSE_QUANTIFIER_STAR;
 
@@ -51,19 +70,27 @@ static void desugar_plus(parse_term_t *term)
 	term->type = PARSE_TERM_SUBEXPR;
 	term->subexpr.count = term->subexpr.capacity = 1;
 	term->subexpr.contents = alternatives;
+
+	return true;
 }
 
-static void desugar_qmark(parse_term_t *term)
+static bool desugar_qmark(parse_term_t *term)
 {
 	parse_sequence_t *alternatives = malloc(2 * sizeof(parse_sequence_t));
+	if (NULL == alternatives)
+		return false;
 
 	alternatives[0].count = alternatives[0].capacity = 1;
 	alternatives[0].contents = malloc(sizeof(parse_term_t));
+	if (NULL == alternatives[0].contents)
+		return false;
 	alternatives[0].contents[0].quantifier = PARSE_QUANTIFIER_NONE;
 	alternatives[0].contents[0].type = PARSE_TERM_EMPTY;
 
 	alternatives[1].count = alternatives[0].capacity = 1;
 	alternatives[1].contents = malloc(sizeof(parse_term_t));
+	if (NULL == alternatives[1].contents)
+		return false;
 	memcpy(&alternatives[1].contents[0], term, sizeof(parse_term_t));
 	alternatives[1].contents[0].quantifier = PARSE_QUANTIFIER_NONE;
 
@@ -71,27 +98,36 @@ static void desugar_qmark(parse_term_t *term)
 	term->type = PARSE_TERM_SUBEXPR;
 	term->subexpr.count = term->subexpr.capacity = 2;
 	term->subexpr.contents = alternatives;
+
+	return true;
 }
 
-static void desugar_term(parse_term_t *term)
+static bool desugar_term(parse_term_t *term)
 {
 	switch (term->quantifier) {
 	case PARSE_QUANTIFIER_PLUS:
-		desugar_plus(term);
+		if (!desugar_plus(term))
+			return false;
 		break;
 	case PARSE_QUANTIFIER_QMARK:
-		desugar_qmark(term);
+		if (!desugar_qmark(term))
+			return false;
 		break;
 	case PARSE_QUANTIFIER_NONE:
 	case PARSE_QUANTIFIER_STAR:
 		break;
 	}
+
+	return true;
 }
 
-void desugar_regex(parse_tree_t *regex)
+bool desugar_regex(parse_tree_t *regex)
 {
 	for (int i = 0; i < regex->count; ++i) {
-		for (int j = 0; j < regex->contents[i].count; ++j)
-			desugar_term(&regex->contents[i].contents[j]);
+		for (int j = 0; j < regex->contents[i].count; ++j) {
+			if (!desugar_term(&regex->contents[i].contents[j]))
+				return false;
+		}
 	}
+	return true;
 }