91 lines
1.9 KiB
C
91 lines
1.9 KiB
C
/*
|
|
* Copyright (c) Camden Dixie O'Brien
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
#include "fsa.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
|
|
#define FSA_START_CAPACITY 16
|
|
#define STATE_START_CAPACITY 16
|
|
|
|
void fsa_init(fsa_t *fsa)
|
|
{
|
|
fsa->count = 0;
|
|
fsa->capacity = FSA_START_CAPACITY;
|
|
fsa->states = malloc(fsa->capacity * sizeof(fsa_state_t));
|
|
assert(NULL != fsa->states);
|
|
|
|
fsa->initial = fsa_add_state(fsa);
|
|
fsa->states[fsa->initial].final = false;
|
|
}
|
|
|
|
void fsa_free(const fsa_t *fsa)
|
|
{
|
|
for (int i = 0; i < fsa->count; ++i)
|
|
free(fsa->states[i].rules);
|
|
free(fsa->states);
|
|
}
|
|
|
|
int fsa_add_state(fsa_t *fsa)
|
|
{
|
|
if (fsa->count >= fsa->capacity) {
|
|
fsa->capacity *= 2;
|
|
fsa->states
|
|
= realloc(fsa->states, fsa->capacity * sizeof(fsa_state_t));
|
|
assert(NULL != fsa->states);
|
|
}
|
|
|
|
fsa_state_t *state = &fsa->states[fsa->count];
|
|
state->final = false;
|
|
state->count = 0;
|
|
state->capacity = STATE_START_CAPACITY;
|
|
state->rules = malloc(state->capacity * sizeof(fsa_rule_t));
|
|
assert(state->rules);
|
|
|
|
return fsa->count++;
|
|
}
|
|
|
|
void fsa_add_rule(fsa_t *fsa, int from, int to, int input)
|
|
{
|
|
assert(fsa->count > from);
|
|
assert(fsa->count > to);
|
|
assert(input < ALPHABET_SIZE);
|
|
|
|
fsa_state_t *state = &fsa->states[from];
|
|
if (state->count >= state->capacity) {
|
|
state->capacity *= 2;
|
|
state->rules
|
|
= realloc(state->rules, state->capacity * sizeof(fsa_rule_t));
|
|
assert(NULL != state->rules);
|
|
}
|
|
|
|
fsa_rule_t *rule = &state->rules[state->count];
|
|
rule->input = input;
|
|
rule->next = to;
|
|
++state->count;
|
|
}
|
|
|
|
bool fsa_accepts(const fsa_t *dfa, const char *input, int len)
|
|
{
|
|
const char *end = input + len;
|
|
int current = dfa->initial;
|
|
while (input < end) {
|
|
bool found = false;
|
|
const fsa_rule_t *rules = dfa->states[current].rules;
|
|
for (int i = 0; i < dfa->states[current].count; ++i) {
|
|
if (rules[i].input == *input) {
|
|
current = rules[i].next;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
return false;
|
|
++input;
|
|
}
|
|
return dfa->states[current].final;
|
|
}
|