119 lines
No EOL
3.5 KiB
C++
119 lines
No EOL
3.5 KiB
C++
#include "spec_helper.h"
|
|
#include "prepare_grammar/perform.h"
|
|
|
|
START_TEST
|
|
|
|
using namespace rules;
|
|
using prepare_grammar::perform;
|
|
|
|
describe("preparing a grammar", []() {
|
|
it("moves sub-rules that don't contain symbols into a separate 'lexical' grammar", [&]() {
|
|
pair<Grammar, Grammar> result = perform(Grammar({
|
|
{ "rule1", seq({
|
|
character('a'),
|
|
character('b'),
|
|
seq({
|
|
sym("rule2"),
|
|
sym("rule3") }),
|
|
seq({
|
|
character('a'),
|
|
character('b') }) }) }
|
|
}));
|
|
|
|
AssertThat(result.first, Equals(Grammar({
|
|
{ "rule1", seq({
|
|
aux_sym("token1"),
|
|
seq({
|
|
sym("rule2"),
|
|
sym("rule3") }),
|
|
aux_sym("token1") }) }
|
|
})));
|
|
|
|
AssertThat(result.second, Equals(Grammar("", map<const string, const rule_ptr>(), {
|
|
{ "token1", rules::seq({
|
|
rules::character('a'),
|
|
rules::character('b') }) },
|
|
})));
|
|
});
|
|
|
|
it("moves entire rules into the lexical grammar when possible, preserving their names", [&]() {
|
|
auto result = perform(Grammar({
|
|
{ "rule1", sym("rule2") },
|
|
{ "rule2", seq({
|
|
character('a'),
|
|
character('b') }) }
|
|
}));
|
|
|
|
AssertThat(result.first, Equals(Grammar({
|
|
{ "rule1", sym("rule2") }
|
|
})));
|
|
|
|
AssertThat(result.second, Equals(Grammar("", {
|
|
{ "rule2", seq({
|
|
character('a'),
|
|
character('b') }) },
|
|
})));
|
|
});
|
|
|
|
it("replaces repeat rules with pairs of recursive rules", [&]() {
|
|
Grammar result = perform(Grammar({
|
|
{ "rule1", seq({
|
|
sym("x"),
|
|
repeat(seq({ sym("a"), sym("b") })),
|
|
sym("y")
|
|
}) },
|
|
})).first;
|
|
|
|
AssertThat(result, Equals(Grammar("rule1", {
|
|
{ "rule1", seq({
|
|
sym("x"),
|
|
aux_sym("repeat_helper1"),
|
|
sym("y")
|
|
}) },
|
|
}, {
|
|
{ "repeat_helper1", seq({
|
|
seq({ sym("a"), sym("b") }),
|
|
choice({
|
|
aux_sym("repeat_helper1") ,
|
|
blank()
|
|
}),
|
|
}) }
|
|
})));
|
|
});
|
|
|
|
it("does not replace repeat rules that can be moved into the lexical grammar", [&]() {
|
|
pair<Grammar, Grammar> result = perform(Grammar({
|
|
{ "rule1", seq({
|
|
sym("x"),
|
|
repeat(seq({ str("a"), str("b") })),
|
|
sym("y")
|
|
}) },
|
|
}));
|
|
|
|
AssertThat(result.first, Equals(Grammar("rule1", {
|
|
{ "rule1", seq({
|
|
sym("x"),
|
|
aux_sym("token1"),
|
|
sym("y")
|
|
}) },
|
|
})));
|
|
|
|
AssertThat(result.second, Equals(Grammar("", map<const string, const rule_ptr>(), {
|
|
{ "token1", repeat(seq({ str("a"), str("b") })) },
|
|
})));
|
|
});
|
|
|
|
it("does not extract blanks into tokens", [&]() {
|
|
pair<Grammar, Grammar> result = perform(Grammar({
|
|
{ "rule1", choice({ sym("rule2"), blank() }) },
|
|
}));
|
|
|
|
AssertThat(result.first, Equals(Grammar("rule1", {
|
|
{ "rule1", choice({ sym("rule2"), blank() }) },
|
|
})));
|
|
|
|
AssertThat(result.second, Equals(Grammar("", map<const string, const rule_ptr>())));
|
|
});
|
|
});
|
|
|
|
END_TEST |