134 lines
3.4 KiB
C
134 lines
3.4 KiB
C
/*
|
|
* Copyright (c) Camden Dixie O'Brien
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
#include "desugar.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
|
|
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));
|
|
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 bool deep_copy_term(parse_term_t *dst, parse_term_t *src)
|
|
{
|
|
assert(PARSE_TERM_WILDCARD != src->type);
|
|
assert(PARSE_TERM_CLASS != src->type);
|
|
|
|
memcpy(dst, src, sizeof(parse_term_t));
|
|
if (PARSE_TERM_SUBEXPR == src->type) {
|
|
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) {
|
|
if (!deep_copy_sequence(
|
|
&dst->subexpr.contents[i], &src->subexpr.contents[i]))
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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));
|
|
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;
|
|
|
|
term->quantifier = PARSE_QUANTIFIER_NONE;
|
|
term->type = PARSE_TERM_SUBEXPR;
|
|
term->subexpr.count = term->subexpr.capacity = 1;
|
|
term->subexpr.contents = alternatives;
|
|
|
|
return true;
|
|
}
|
|
|
|
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;
|
|
|
|
term->quantifier = PARSE_QUANTIFIER_NONE;
|
|
term->type = PARSE_TERM_SUBEXPR;
|
|
term->subexpr.count = term->subexpr.capacity = 2;
|
|
term->subexpr.contents = alternatives;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool desugar_term(parse_term_t *term)
|
|
{
|
|
switch (term->quantifier) {
|
|
case PARSE_QUANTIFIER_PLUS:
|
|
if (!desugar_plus(term))
|
|
return false;
|
|
break;
|
|
case PARSE_QUANTIFIER_QMARK:
|
|
if (!desugar_qmark(term))
|
|
return false;
|
|
break;
|
|
case PARSE_QUANTIFIER_NONE:
|
|
case PARSE_QUANTIFIER_STAR:
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
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) {
|
|
if (!desugar_term(®ex->contents[i].contents[j]))
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|