AIR
/
cpp-peglib
mirror of https://github.com/yhirose/cpp-peglib.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Changed interface of parse in Definition.

Browse Source
pull/3/head
yhirose 9 years ago
parent 09ce72b25e
commit 6e8ea2b471
4 changed files with 311 additions and 353 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      example/calc.cc
  2. 2
      example/calc2.cc
  3. 316
      peglib.h
  4. 344
      test/test.cc

2
example/calc.cc
Unescape View File

@ -55,7 +55,7 @@ int main(int argc, const char** argv)
" NUMBER <- [0-9]+ "
;
Parser parser = make_parser(syntax);
Parser parser(syntax);
parser["EXPRESSION"] = reduce;
parser["TERM"] = reduce;

2
example/calc2.cc
Unescape View File

@ -56,7 +56,7 @@ int main(int argc, const char** argv)
NUMBER <= oom(cls("0-9")), [](const char* s, size_t l) { return atol(s); };
long val = 0;
if (EXPRESSION.parse(s, val)) {
if (EXPRESSION.parse(s, val).ret) {
cout << s << " = " << val << endl;
return 0;
}

316
peglib.h
Unescape View File

@ -359,15 +359,15 @@ struct Result
size_t len;
size_t choice;
const char* ptr;
const std::string msg;
const std::string err; // TODO: should be `int`.
};
Result success(size_t len, size_t choice = 0) {
return Result{ true, len, choice, nullptr, std::string() };
}
Result fail(const char* ptr, std::string msg = std::string(), std::string name = std::string()) {
return Result{ false, 0, (size_t)-1, ptr, msg };
Result fail(const char* ptr, std::string err = std::string(), std::string name = std::string()) {
return Result{ false, 0, (size_t)-1, ptr, err };
}
/*
@ -408,15 +408,15 @@ public:
size_t i = 0;
for (const auto& ope : opes_) {
const auto& rule = *ope;
auto m = rule.parse(s + i, l - i, v);
if (!m.ret) {
auto msg = m.msg;
if (msg.empty()) {
msg = "missing an element in the 'sequence'";
auto r = rule.parse(s + i, l - i, v);
if (!r.ret) {
auto err = r.err;
if (err.empty()) {
err = "missing an element in the 'sequence'";
}
return fail(m.ptr, msg);
return fail(r.ptr, err);
}
i += m.len;
i += r.len;
}
return success(i);
}
@ -452,8 +452,8 @@ public:
for (const auto& ope : opes_) {
const auto& rule = *ope;
Values chldsv;
auto m = rule.parse(s, l, chldsv);
if (m.ret) {
auto r = rule.parse(s, l, chldsv);
if (r.ret) {
if (!chldsv.values.empty()) {
for (const auto& x: chldsv.values) {
v.values.push_back(x);
@ -462,7 +462,7 @@ public:
v.names.push_back(x);
}
}
return success(m.len, id);
return success(r.len, id);
}
id++;
}
@ -484,11 +484,11 @@ public:
auto i = 0;
while (l - i > 0) {
const auto& rule = *ope_;
auto m = rule.parse(s + i, l - i, v);
if (!m.ret) {
auto r = rule.parse(s + i, l - i, v);
if (!r.ret) {
break;
}
i += m.len;
i += r.len;
}
return success(i);
}
@ -503,22 +503,23 @@ public:
OneOrMore(const std::shared_ptr<Ope>& ope) : ope_(ope) {}
Result parse(const char* s, size_t l, Values& v) const {
auto m = ope_->parse(s, l, v);
if (!m.ret) {
auto msg = m.msg;
if (msg.empty()) {
msg = "nothing occurred in the 'one-or-more'";
const auto& rule = *ope_;
auto r = rule.parse(s, l, v);
if (!r.ret) {
auto err = r.err;
if (err.empty()) {
err = "nothing occurred in the 'one-or-more'";
}
return fail(m.ptr, m.msg);
return fail(r.ptr, r.err);
}
auto i = m.len;
auto i = r.len;
while (l - i > 0) {
const auto& rule = *ope_;
auto m = rule.parse(s + i, l - i, v);
if (!m.ret) {
auto r = rule.parse(s + i, l - i, v);
if (!r.ret) {
break;
}
i += m.len;
i += r.len;
}
return success(i);
}
@ -534,8 +535,8 @@ public:
Result parse(const char* s, size_t l, Values& v) const {
const auto& rule = *ope_;
auto m = rule.parse(s, l, v);
return success(m.ret ? m.len : 0);
auto r = rule.parse(s, l, v);
return success(r.ret ? r.len : 0);
}
private:
@ -549,11 +550,11 @@ public:
Result parse(const char* s, size_t l, Values& v) const {
const auto& rule = *ope_;
auto m = rule.parse(s, l, v);
if (m.ret) {
auto r = rule.parse(s, l, v);
if (r.ret) {
return success(0);
} else {
return fail(m.ptr, m.msg);
return fail(r.ptr, r.err);
}
}
@ -568,8 +569,8 @@ public:
Result parse(const char* s, size_t l, Values& v) const {
const auto& rule = *ope_;
auto m = rule.parse(s, l, v);
if (m.ret) {
auto r = rule.parse(s, l, v);
if (r.ret) {
return fail(s);
} else {
return success(0);
@ -670,11 +671,11 @@ public:
Result parse(const char* s, size_t l, Values& v) const {
assert(ope_);
const auto& rule = *ope_;
auto m = rule.parse(s, l, v);
if (m.ret && match_) {
match_(s, m.len);
auto r = rule.parse(s, l, v);
if (r.ret && match_) {
match_(s, r.len);
}
return m;
return r;
}
private:
@ -740,42 +741,26 @@ public:
return *this;
}
Definition& ope(const std::shared_ptr<Ope>& ope) {
holder_->ope_ = ope;
return *this;
}
Result parse_with_match(const char* s, size_t l) const {
Values v;
return holder_->parse(s, l, v);
}
template <typename T>
bool parse(const char* s, size_t l, T& val, bool exact = true) const {
Result parse(const char* s, size_t l, T& val) const {
Values v;
auto m = holder_->parse(s, l, v);
auto ret = m.ret && (!exact || m.len == l);
if (ret && !v.values.empty() && !v.values.front().is_undefined()) {
auto r = holder_->parse(s, l, v);
if (r.ret && !v.values.empty() && !v.values.front().is_undefined()) {
val = v.values[0].get<T>();
}
return ret;
return r;
}
template <typename T>
bool parse(const char* s, T& val, bool exact = true) const {
Result parse(const char* s, T& val) const {
auto l = strlen(s);
return parse(s, l, val, exact);
}
bool parse(const char* s, size_t l, bool exact = true) const {
Values v;
auto m = holder_->parse(s, l, v);
return m.ret && (!exact || m.len == l);
return parse(s, l, val);
}
bool parse(const char* s, bool exact = true) const {
Result parse(const char* s) const {
auto l = strlen(s);
return parse(s, l, exact);
Values v;
return holder_->parse(s, l, v);
}
Definition& operator=(Action ac) {
@ -814,20 +799,20 @@ private:
const auto& rule = *ope_;
Values chldsv;
auto m = rule.parse(s, l, chldsv);
if (m.ret) {
auto r = rule.parse(s, l, chldsv);
if (r.ret) {
v.names.push_back(outer_->name);
assert(!outer_->actions.empty());
auto id = m.choice + 1;
auto id = r.choice + 1;
const auto& ac = (id < outer_->actions.size() && outer_->actions[id])
? outer_->actions[id]
: outer_->actions[0];
v.values.push_back(reduce(s, m.len, chldsv, ac));
v.values.push_back(reduce(s, r.len, chldsv, ac));
}
return m;
return r;
}
private:
@ -1018,69 +1003,14 @@ inline std::pair<size_t, size_t> line_info(const char* s, const char* ptr) {
return std::make_pair(no, col);
}
typedef std::function<void (size_t, size_t, const std::string&)> Log;
class GrammarGenerator
{
public:
static GrammarGenerator& instance() {
static std::shared_ptr<Grammar> perform(const char* s, size_t l, std::string& start, Log log) {
static GrammarGenerator instance;
return instance;
}
std::shared_ptr<Grammar> perform(
const char* syntax,
size_t syntax_len,
std::string& start,
std::function<void (size_t, size_t, const std::string&)> log = nullptr) {
auto grammar = std::make_shared<Grammar>();
start.clear();
std::map<std::string, const char*> refs;
peg["Definition"] = [&](const std::vector<Any>& v) {
const auto& name = v[0].get<std::string>();
(*grammar)[name] <= v[2].get<std::shared_ptr<Ope>>();
(*grammar)[name].name = name;
if (start.empty()) {
start = name;
}
};
peg["Primary"].actions = {
[&](const std::vector<Any>& v) {
return v[0];
},
[&](const char* s, size_t l, const std::vector<Any>& v) {
refs[v[0]] = s;
return ref(*grammar, v[0]);
},
[&](const std::vector<Any>& v) {
return v[1];
}
};
auto m = peg["Grammar"].parse_with_match(syntax, syntax_len);
if (!m.ret) {
if (log) {
auto line = line_info(syntax, m.ptr);
log(line.first, line.second, m.msg.empty() ? "syntax error" : m.msg);
}
return nullptr;
}
for (const auto& x : refs) {
const auto& name = x.first;
auto ptr = x.second;
if (grammar->find(name) == grammar->end()) {
if (log) {
auto line = line_info(syntax, ptr);
log(line.first, line.second, "'" + name + "' is not defined.");
}
return nullptr;
}
}
return grammar;
return instance.perform_core(s, l, start, log);
}
private:
@ -1176,9 +1106,62 @@ private:
};
}
std::shared_ptr<Grammar> perform_core(const char* s, size_t l, std::string& start, Log log) {
auto grammar = std::make_shared<Grammar>();
start.clear();
std::map<std::string, const char*> refs;
peg["Definition"] = [&](const std::vector<Any>& v) {
const auto& name = v[0].get<std::string>();
(*grammar)[name] <= v[2].get<std::shared_ptr<Ope>>();
(*grammar)[name].name = name;
if (start.empty()) {
start = name;
}
};
peg["Primary"].actions = {
[&](const std::vector<Any>& v) {
return v[0];
},
[&](const char* s, size_t l, const std::vector<Any>& v) {
refs[v[0]] = s;
return ref(*grammar, v[0]);
},
[&](const std::vector<Any>& v) {
return v[1];
}
};
auto r = peg["Grammar"].parse(s, l);
if (!r.ret) {
if (log) {
auto line = line_info(s, r.ptr);
log(line.first, line.second, r.err.empty() ? "syntax error" : r.err);
}
return nullptr;
}
for (const auto& x : refs) {
const auto& name = x.first;
auto ptr = x.second;
if (grammar->find(name) == grammar->end()) {
if (log) {
auto line = line_info(s, ptr);
log(line.first, line.second, "'" + name + "' is not defined.");
}
return nullptr;
}
}
return grammar;
}
std::string resolve_escape_sequence(const char*s, size_t l) {
std::string r;
r.reserve(l);
for (auto i = 0u; i < l; i++) {
auto ch = s[i];
if (ch == '\\') {
@ -1208,20 +1191,6 @@ private:
Grammar peg;
};
inline std::shared_ptr<Grammar> make_grammar(
const char* syntax, size_t syntax_len, std::string& start,
std::function<void (size_t, size_t, const std::string&)> log = nullptr)
{
return GrammarGenerator::instance().perform(syntax, syntax_len, start, log);
}
inline std::shared_ptr<Grammar> make_grammar(
const char* syntax, std::string& start,
std::function<void (size_t, size_t, const std::string&)> log = nullptr)
{
return make_grammar(syntax, strlen(syntax), start, log);
}
/*-----------------------------------------------------------------------------
* Parser
*---------------------------------------------------------------------------*/
@ -1229,68 +1198,64 @@ inline std::shared_ptr<Grammar> make_grammar(
class Parser
{
public:
operator bool() {
return grammar_ != nullptr;
Parser(const char* s, size_t l, Log log = nullptr) {
grammar_ = GrammarGenerator::perform(s, l, start_, log);
}
bool load_syntax(
const char* s, size_t l,
std::function<void (size_t, size_t, const std::string&)> log = nullptr) {
Parser(const char* s, Log log = nullptr) {
auto l = strlen(s);
grammar_ = GrammarGenerator::perform(s, l, start_, log);
}
grammar_ = make_grammar(s, l, start_, log);
operator bool() {
return grammar_ != nullptr;
}
template <typename T>
bool parse(const char* s, size_t l, T& out) const {
bool parse(const char* s, size_t l, T& out, bool exact = true) const {
if (grammar_ != nullptr) {
const auto& rule = (*grammar_)[start_];
Any val;
auto ret = rule.parse(s, l, val);
if (ret) {
out = val.get<T>();
}
return ret;
auto r = rule.parse(s, l, out);
return r.ret && (!exact || r.len == l);
}
return false;
}
bool parse(const char* s, size_t l) const {
bool parse(const char* s, size_t l, bool exact = true) const {
if (grammar_ != nullptr) {
const auto& rule = (*grammar_)[start_];
return rule.parse(s, l);
auto r = rule.parse(s, l);
return r.ret && (!exact || r.len == l);
}
return false;
}
template <typename T>
bool parse(const char* s, T& out) const {
bool parse(const char* s, T& out, bool exact = true) const {
auto l = strlen(s);
return parse(s, l, out);
return parse(s, l, out, exact);
}
bool parse(const char* s) const {
bool parse(const char* s, bool exact = true) const {
auto l = strlen(s);
return parse(s, l);
return parse(s, l, exact);
}
bool lint(const char* s, size_t l, bool exact,
std::function<void (size_t, size_t, const std::string&)> log = nullptr) {
bool lint(const char* s, size_t l, bool exact, Log log = nullptr) {
assert(grammar_);
if (grammar_ != nullptr) {
const auto& rule = (*grammar_)[start_];
auto m = rule.parse_with_match(s, l);
if (!m.ret) {
auto r = rule.parse(s, l);
if (!r.ret) {
if (log) {
auto line = line_info(s, m.ptr);
log(line.first, line.second, m.msg.empty() ? "syntax error" : m.msg);
auto line = line_info(s, r.ptr);
log(line.first, line.second, r.err.empty() ? "syntax error" : r.err);
}
} else if (exact && m.len != l) {
auto line = line_info(s, s + m.len);
} else if (exact && r.len != l) {
auto line = line_info(s, s + r.len);
log(line.first, line.second, "garbage string at the end");
}
return m.ret && (!exact || m.len == l);
return r.ret && (!exact || r.len == l);
}
return false;
}
@ -1304,19 +1269,6 @@ private:
std::string start_;
};
inline Parser make_parser(const char* s, size_t l, std::function<void (size_t, size_t, const std::string&)> log = nullptr) {
Parser parser;
parser.load_syntax(s, l, log);
return parser;
}
inline Parser make_parser(const char* s, std::function<void (size_t, size_t, const std::string&)> log = nullptr) {
Parser parser;
auto l = strlen(s);
parser.load_syntax(s, l, log);
return parser;
}
} // namespace peglib
#endif

344
test/test.cc
Unescape View File

@ -7,14 +7,14 @@
TEST_CASE("Empty syntax test", "[general]")
{
auto parser = peglib::make_parser("");
peglib::Parser parser("");
bool ret = parser;
REQUIRE(ret == false);
}
TEST_CASE("String capture test", "[general]")
{
auto parser = peglib::make_parser(
peglib::Parser parser(
" ROOT <- _ ('[' TAG_NAME ']' _)* "
" TAG_NAME <- (!']' .)+ "
" _ <- [ \t]* "
@ -48,9 +48,9 @@ TEST_CASE("String capture test2", "[general]")
TAG_NAME <= oom(seq(npd(chr(']')), any())), [&](const char* s, size_t l) { tags.push_back(string(s, l)); };
WS <= zom(cls(" \t"));
auto ret = ROOT.parse(" [tag1] [tag:2] [tag-3] ");
auto m = ROOT.parse(" [tag1] [tag:2] [tag-3] ");
REQUIRE(ret == true);
REQUIRE(m.ret == true);
REQUIRE(tags.size() == 3);
REQUIRE(tags[0] == "tag1");
REQUIRE(tags[1] == "tag:2");
@ -68,9 +68,9 @@ TEST_CASE("String capture test with embedded match action", "[general]")
TAG_NAME <= oom(seq(npd(chr(']')), any()));
WS <= zom(cls(" \t"));
auto ret = ROOT.parse(" [tag1] [tag:2] [tag-3] ");
auto m = ROOT.parse(" [tag1] [tag:2] [tag-3] ");
REQUIRE(ret == true);
REQUIRE(m.ret == true);
REQUIRE(tags.size() == 3);
REQUIRE(tags[0] == "tag1");
REQUIRE(tags[1] == "tag:2");
@ -88,7 +88,7 @@ TEST_CASE("Cyclic grammer test", "[general]")
TEST_CASE("Lambda action test", "[general]")
{
auto parser = make_parser(
Parser parser(
" START <- (CHAR)* "
" CHAR <- . ");
@ -104,7 +104,7 @@ TEST_CASE("Lambda action test", "[general]")
TEST_CASE("Backtracking test", "[general]")
{
auto parser = make_parser(
Parser parser(
" START <- PAT1 / PAT2 "
" PAT1 <- HELLO ' One' "
" PAT2 <- HELLO ' Two' "
@ -129,7 +129,7 @@ TEST_CASE("Simple calculator test", "[general]")
" Primary <- '(' Additive ')' / Number "
" Number <- [0-9]+ ";
auto parser = make_parser(syntax);
Parser parser(syntax);
parser["Additive"] = {
// Default action
@ -192,11 +192,11 @@ TEST_CASE("Calculator test", "[general]")
NUMBER = [&](const char* s, size_t l) { return stol(string(s, l), nullptr, 10); };
// Parse
Any val;
auto ret = EXPRESSION.parse("1+2*3*(4-5+6)/7-8", val);
long val;
auto m = EXPRESSION.parse("1+2*3*(4-5+6)/7-8", val);
REQUIRE(ret == true);
REQUIRE(val.get<long>() == -3);
REQUIRE(m.ret == true);
REQUIRE(val == -3);
}
TEST_CASE("Calculator test2", "[general]")
@ -213,7 +213,7 @@ TEST_CASE("Calculator test2", "[general]")
;
string start;
auto grammar = make_grammar(syntax, start);
auto grammar = GrammarGenerator::perform(syntax, strlen(syntax), start, nullptr);
auto& g = *grammar;
// Setup actions
@ -238,17 +238,17 @@ TEST_CASE("Calculator test2", "[general]")
g["NUMBER"] = [](const char* s, size_t l) { return stol(string(s, l), nullptr, 10); };
// Parse
Any val;
auto ret = g[start].parse("1+2*3*(4-5+6)/7-8", val);
long val;
auto m = g[start].parse("1+2*3*(4-5+6)/7-8", val);
REQUIRE(ret == true);
REQUIRE(val.get<long>() == -3);
REQUIRE(m.ret == true);
REQUIRE(val == -3);
}
TEST_CASE("Calculator test3", "[general]")
{
// Parse syntax
auto parser = make_parser(
Parser parser(
" # Grammar for Calculator...\n "
" EXPRESSION <- TERM (TERM_OPERATOR TERM)* "
" TERM <- FACTOR (FACTOR_OPERATOR FACTOR)* "
@ -287,249 +287,255 @@ TEST_CASE("Calculator test3", "[general]")
REQUIRE(val == -3);
}
bool exact(Grammar& g, const char* d, const char* s) {
auto l = strlen(s);
auto r = g[d].parse(s, l);
return r.ret && r.len == l;
}
TEST_CASE("PEG Grammar", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Grammar"].parse(" Definition <- a / ( b c ) / d \n rule2 <- [a-zA-Z][a-z0-9-]+ ") == true);
REQUIRE(exact(g, "Grammar", " Definition <- a / ( b c ) / d \n rule2 <- [a-zA-Z][a-z0-9-]+ ") == true);
}
TEST_CASE("PEG Definition", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Definition"].parse("Definition <- a / (b c) / d ") == true);
REQUIRE(g["Definition"].parse("Definition <- a / b c / d ") == true);
REQUIRE(g["Definition"].parse("Definition ") == false);
REQUIRE(g["Definition"].parse(" ") == false);
REQUIRE(g["Definition"].parse("") == false);
REQUIRE(g["Definition"].parse("Definition = a / (b c) / d ") == false);
REQUIRE(exact(g, "Definition", "Definition <- a / (b c) / d ") == true);
REQUIRE(exact(g, "Definition", "Definition <- a / b c / d ") == true);
REQUIRE(exact(g, "Definition", "Definition ") == false);
REQUIRE(exact(g, "Definition", " ") == false);
REQUIRE(exact(g, "Definition", "") == false);
REQUIRE(exact(g, "Definition", "Definition = a / (b c) / d ") == false);
}
TEST_CASE("PEG Expression", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Expression"].parse("a / (b c) / d ") == true);
REQUIRE(g["Expression"].parse("a / b c / d ") == true);
REQUIRE(g["Expression"].parse("a b ") == true);
REQUIRE(g["Expression"].parse("") == true);
REQUIRE(g["Expression"].parse(" ") == false);
REQUIRE(g["Expression"].parse(" a b ") == false);
REQUIRE(exact(g, "Expression", "a / (b c) / d ") == true);
REQUIRE(exact(g, "Expression", "a / b c / d ") == true);
REQUIRE(exact(g, "Expression", "a b ") == true);
REQUIRE(exact(g, "Expression", "") == true);
REQUIRE(exact(g, "Expression", " ") == false);
REQUIRE(exact(g, "Expression", " a b ") == false);
}
TEST_CASE("PEG Sequence", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Sequence"].parse("a b c d ") == true);
REQUIRE(g["Sequence"].parse("") == true);
REQUIRE(g["Sequence"].parse("!") == false);
REQUIRE(g["Sequence"].parse("<-") == false);
REQUIRE(g["Sequence"].parse(" a") == false);
REQUIRE(exact(g, "Sequence", "a b c d ") == true);
REQUIRE(exact(g, "Sequence", "") == true);
REQUIRE(exact(g, "Sequence", "!") == false);
REQUIRE(exact(g, "Sequence", "<-") == false);
REQUIRE(exact(g, "Sequence", " a") == false);
}
TEST_CASE("PEG Prefix", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Prefix"].parse("&[a]") == true);
REQUIRE(g["Prefix"].parse("![']") == true);
REQUIRE(g["Prefix"].parse("-[']") == false);
REQUIRE(g["Prefix"].parse("") == false);
REQUIRE(g["Sequence"].parse(" a") == false);
REQUIRE(exact(g, "Prefix", "&[a]") == true);
REQUIRE(exact(g, "Prefix", "![']") == true);
REQUIRE(exact(g, "Prefix", "-[']") == false);
REQUIRE(exact(g, "Prefix", "") == false);
REQUIRE(exact(g, "Sequence", " a") == false);
}
TEST_CASE("PEG Suffix", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Suffix"].parse("aaa ") == true);
REQUIRE(g["Suffix"].parse("aaa? ") == true);
REQUIRE(g["Suffix"].parse("aaa* ") == true);
REQUIRE(g["Suffix"].parse("aaa+ ") == true);
REQUIRE(g["Suffix"].parse(". + ") == true);
REQUIRE(g["Suffix"].parse("?") == false);
REQUIRE(g["Suffix"].parse("") == false);
REQUIRE(g["Sequence"].parse(" a") == false);
REQUIRE(exact(g, "Suffix", "aaa ") == true);
REQUIRE(exact(g, "Suffix", "aaa? ") == true);
REQUIRE(exact(g, "Suffix", "aaa* ") == true);
REQUIRE(exact(g, "Suffix", "aaa+ ") == true);
REQUIRE(exact(g, "Suffix", ". + ") == true);
REQUIRE(exact(g, "Suffix", "?") == false);
REQUIRE(exact(g, "Suffix", "") == false);
REQUIRE(exact(g, "Sequence", " a") == false);
}
TEST_CASE("PEG Primary", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Primary"].parse("_Identifier0_ ") == true);
REQUIRE(g["Primary"].parse("_Identifier0_<-") == false);
REQUIRE(g["Primary"].parse("( _Identifier0_ _Identifier1_ )") == true);
REQUIRE(g["Primary"].parse("'Literal String'") == true);
REQUIRE(g["Primary"].parse("\"Literal String\"") == true);
REQUIRE(g["Primary"].parse("[a-zA-Z]") == true);
REQUIRE(g["Primary"].parse(".") == true);
REQUIRE(g["Primary"].parse("") == false);
REQUIRE(g["Primary"].parse(" ") == false);
REQUIRE(g["Primary"].parse(" a") == false);
REQUIRE(g["Primary"].parse("") == false);
REQUIRE(exact(g, "Primary", "_Identifier0_ ") == true);
REQUIRE(exact(g, "Primary", "_Identifier0_<-") == false);
REQUIRE(exact(g, "Primary", "( _Identifier0_ _Identifier1_ )") == true);
REQUIRE(exact(g, "Primary", "'Literal String'") == true);
REQUIRE(exact(g, "Primary", "\"Literal String\"") == true);
REQUIRE(exact(g, "Primary", "[a-zA-Z]") == true);
REQUIRE(exact(g, "Primary", ".") == true);
REQUIRE(exact(g, "Primary", "") == false);
REQUIRE(exact(g, "Primary", " ") == false);
REQUIRE(exact(g, "Primary", " a") == false);
REQUIRE(exact(g, "Primary", "") == false);
}
TEST_CASE("PEG Identifier", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Identifier"].parse("_Identifier0_ ") == true);
REQUIRE(g["Identifier"].parse("0Identifier_ ") == false);
REQUIRE(g["Identifier"].parse("Iden|t ") == false);
REQUIRE(g["Identifier"].parse(" ") == false);
REQUIRE(g["Identifier"].parse(" a") == false);
REQUIRE(g["Identifier"].parse("") == false);
REQUIRE(exact(g, "Identifier", "_Identifier0_ ") == true);
REQUIRE(exact(g, "Identifier", "0Identifier_ ") == false);
REQUIRE(exact(g, "Identifier", "Iden|t ") == false);
REQUIRE(exact(g, "Identifier", " ") == false);
REQUIRE(exact(g, "Identifier", " a") == false);
REQUIRE(exact(g, "Identifier", "") == false);
}
TEST_CASE("PEG IdentStart", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["IdentStart"].parse("_") == true);
REQUIRE(g["IdentStart"].parse("a") == true);
REQUIRE(g["IdentStart"].parse("Z") == true);
REQUIRE(g["IdentStart"].parse("") == false);
REQUIRE(g["IdentStart"].parse(" ") == false);
REQUIRE(g["IdentStart"].parse("0") == false);
REQUIRE(exact(g, "IdentStart", "_") == true);
REQUIRE(exact(g, "IdentStart", "a") == true);
REQUIRE(exact(g, "IdentStart", "Z") == true);
REQUIRE(exact(g, "IdentStart", "") == false);
REQUIRE(exact(g, "IdentStart", " ") == false);
REQUIRE(exact(g, "IdentStart", "0") == false);
}
TEST_CASE("PEG IdentRest", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["IdentRest"].parse("_") == true);
REQUIRE(g["IdentRest"].parse("a") == true);
REQUIRE(g["IdentRest"].parse("Z") == true);
REQUIRE(g["IdentRest"].parse("") == false);
REQUIRE(g["IdentRest"].parse(" ") == false);
REQUIRE(g["IdentRest"].parse("0") == true);
REQUIRE(exact(g, "IdentRest", "_") == true);
REQUIRE(exact(g, "IdentRest", "a") == true);
REQUIRE(exact(g, "IdentRest", "Z") == true);
REQUIRE(exact(g, "IdentRest", "") == false);
REQUIRE(exact(g, "IdentRest", " ") == false);
REQUIRE(exact(g, "IdentRest", "0") == true);
}
TEST_CASE("PEG Literal", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Literal"].parse("'abc' ") == true);
REQUIRE(g["Literal"].parse("'a\\nb\\tc' ") == true);
REQUIRE(g["Literal"].parse("'a\\277\tc' ") == true);
REQUIRE(g["Literal"].parse("'a\\77\tc' ") == true);
REQUIRE(g["Literal"].parse("'a\\80\tc' ") == false);
REQUIRE(g["Literal"].parse("'\n' ") == true);
REQUIRE(g["Literal"].parse("'a\\'b' ") == true);
REQUIRE(g["Literal"].parse("'a'b' ") == false);
REQUIRE(g["Literal"].parse("'a\"'b' ") == false);
REQUIRE(g["Literal"].parse("\"'\\\"abc\\\"'\" ") == true);
REQUIRE(g["Literal"].parse("\"'\"abc\"'\" ") == false);
REQUIRE(g["Literal"].parse("abc") == false);
REQUIRE(g["Literal"].parse("") == false);
REQUIRE(g["Literal"].parse("日本語") == false);
REQUIRE(exact(g, "Literal", "'abc' ") == true);
REQUIRE(exact(g, "Literal", "'a\\nb\\tc' ") == true);
REQUIRE(exact(g, "Literal", "'a\\277\tc' ") == true);
REQUIRE(exact(g, "Literal", "'a\\77\tc' ") == true);
REQUIRE(exact(g, "Literal", "'a\\80\tc' ") == false);
REQUIRE(exact(g, "Literal", "'\n' ") == true);
REQUIRE(exact(g, "Literal", "'a\\'b' ") == true);
REQUIRE(exact(g, "Literal", "'a'b' ") == false);
REQUIRE(exact(g, "Literal", "'a\"'b' ") == false);
REQUIRE(exact(g, "Literal", "\"'\\\"abc\\\"'\" ") == true);
REQUIRE(exact(g, "Literal", "\"'\"abc\"'\" ") == false);
REQUIRE(exact(g, "Literal", "abc") == false);
REQUIRE(exact(g, "Literal", "") == false);
REQUIRE(exact(g, "Literal", "日本語") == false);
}
TEST_CASE("PEG Class", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Class"].parse("[]") == true);
REQUIRE(g["Class"].parse("[a]") == true);
REQUIRE(g["Class"].parse("[a-z]") == true);
REQUIRE(g["Class"].parse("[az]") == true);
REQUIRE(g["Class"].parse("[a-zA-Z-]") == true);
REQUIRE(g["Class"].parse("[a-zA-Z-0-9]") == true);
REQUIRE(g["Class"].parse("[a-]") == false);
REQUIRE(g["Class"].parse("[-a]") == true);
REQUIRE(g["Class"].parse("[") == false);
REQUIRE(g["Class"].parse("[a") == false);
REQUIRE(g["Class"].parse("]") == false);
REQUIRE(g["Class"].parse("a]") == false);
REQUIRE(g["Class"].parse("あ-ん") == false);
REQUIRE(g["Class"].parse("[-+]") == true);
REQUIRE(g["Class"].parse("[+-]") == false);
REQUIRE(exact(g, "Class", "[]") == true);
REQUIRE(exact(g, "Class", "[a]") == true);
REQUIRE(exact(g, "Class", "[a-z]") == true);
REQUIRE(exact(g, "Class", "[az]") == true);
REQUIRE(exact(g, "Class", "[a-zA-Z-]") == true);
REQUIRE(exact(g, "Class", "[a-zA-Z-0-9]") == true);
REQUIRE(exact(g, "Class", "[a-]") == false);
REQUIRE(exact(g, "Class", "[-a]") == true);
REQUIRE(exact(g, "Class", "[") == false);
REQUIRE(exact(g, "Class", "[a") == false);
REQUIRE(exact(g, "Class", "]") == false);
REQUIRE(exact(g, "Class", "a]") == false);
REQUIRE(exact(g, "Class", "あ-ん") == false);
REQUIRE(exact(g, "Class", "[-+]") == true);
REQUIRE(exact(g, "Class", "[+-]") == false);
}
TEST_CASE("PEG Range", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Range"].parse("a") == true);
REQUIRE(g["Range"].parse("a-z") == true);
REQUIRE(g["Range"].parse("az") == false);
REQUIRE(g["Range"].parse("") == false);
REQUIRE(g["Range"].parse("a-") == false);
REQUIRE(g["Range"].parse("-a") == false);
REQUIRE(exact(g, "Range", "a") == true);
REQUIRE(exact(g, "Range", "a-z") == true);
REQUIRE(exact(g, "Range", "az") == false);
REQUIRE(exact(g, "Range", "") == false);
REQUIRE(exact(g, "Range", "a-") == false);
REQUIRE(exact(g, "Range", "-a") == false);
}
TEST_CASE("PEG Char", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Char"].parse("\\n") == true);
REQUIRE(g["Char"].parse("\\r") == true);
REQUIRE(g["Char"].parse("\\t") == true);
REQUIRE(g["Char"].parse("\\'") == true);
REQUIRE(g["Char"].parse("\\\"") == true);
REQUIRE(g["Char"].parse("\\[") == true);
REQUIRE(g["Char"].parse("\\]") == true);
REQUIRE(g["Char"].parse("\\\\") == true);
REQUIRE(g["Char"].parse("\\000") == true);
REQUIRE(g["Char"].parse("\\277") == true);
REQUIRE(g["Char"].parse("\\377") == false);
REQUIRE(g["Char"].parse("\\087") == false);
REQUIRE(g["Char"].parse("\\079") == false);
REQUIRE(g["Char"].parse("\\00") == true);
REQUIRE(g["Char"].parse("\\77") == true);
REQUIRE(g["Char"].parse("\\80") == false);
REQUIRE(g["Char"].parse("\\08") == false);
REQUIRE(g["Char"].parse("\\0") == true);
REQUIRE(g["Char"].parse("\\7") == true);
REQUIRE(g["Char"].parse("\\8") == false);
REQUIRE(g["Char"].parse("a") == true);
REQUIRE(g["Char"].parse(".") == true);
REQUIRE(g["Char"].parse("0") == true);
REQUIRE(g["Char"].parse("\\") == false);
REQUIRE(g["Char"].parse(" ") == true);
REQUIRE(g["Char"].parse(" ") == false);
REQUIRE(g["Char"].parse("") == false);
REQUIRE(g["Char"].parse("あ") == false);
REQUIRE(exact(g, "Char", "\\n") == true);
REQUIRE(exact(g, "Char", "\\r") == true);
REQUIRE(exact(g, "Char", "\\t") == true);
REQUIRE(exact(g, "Char", "\\'") == true);
REQUIRE(exact(g, "Char", "\\\"") == true);
REQUIRE(exact(g, "Char", "\\[") == true);
REQUIRE(exact(g, "Char", "\\]") == true);
REQUIRE(exact(g, "Char", "\\\\") == true);
REQUIRE(exact(g, "Char", "\\000") == true);
REQUIRE(exact(g, "Char", "\\277") == true);
REQUIRE(exact(g, "Char", "\\377") == false);
REQUIRE(exact(g, "Char", "\\087") == false);
REQUIRE(exact(g, "Char", "\\079") == false);
REQUIRE(exact(g, "Char", "\\00") == true);
REQUIRE(exact(g, "Char", "\\77") == true);
REQUIRE(exact(g, "Char", "\\80") == false);
REQUIRE(exact(g, "Char", "\\08") == false);
REQUIRE(exact(g, "Char", "\\0") == true);
REQUIRE(exact(g, "Char", "\\7") == true);
REQUIRE(exact(g, "Char", "\\8") == false);
REQUIRE(exact(g, "Char", "a") == true);
REQUIRE(exact(g, "Char", ".") == true);
REQUIRE(exact(g, "Char", "0") == true);
REQUIRE(exact(g, "Char", "\\") == false);
REQUIRE(exact(g, "Char", " ") == true);
REQUIRE(exact(g, "Char", " ") == false);
REQUIRE(exact(g, "Char", "") == false);
REQUIRE(exact(g, "Char", "あ") == false);
}
TEST_CASE("PEG Operators", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["LEFTARROW"].parse("<-") == true);
REQUIRE(g["SLASH"].parse("/ ") == true);
REQUIRE(g["AND"].parse("& ") == true);
REQUIRE(g["NOT"].parse("! ") == true);
REQUIRE(g["QUESTION"].parse("? ") == true);
REQUIRE(g["STAR"].parse("* ") == true);
REQUIRE(g["PLUS"].parse("+ ") == true);
REQUIRE(g["OPEN"].parse("( ") == true);
REQUIRE(g["CLOSE"].parse(") ") == true);
REQUIRE(g["DOT"].parse(". ") == true);
REQUIRE(exact(g, "LEFTARROW", "<-") == true);
REQUIRE(exact(g, "SLASH", "/ ") == true);
REQUIRE(exact(g, "AND", "& ") == true);
REQUIRE(exact(g, "NOT", "! ") == true);
REQUIRE(exact(g, "QUESTION", "? ") == true);
REQUIRE(exact(g, "STAR", "* ") == true);
REQUIRE(exact(g, "PLUS", "+ ") == true);
REQUIRE(exact(g, "OPEN", "( ") == true);
REQUIRE(exact(g, "CLOSE", ") ") == true);
REQUIRE(exact(g, "DOT", ". ") == true);
}
TEST_CASE("PEG Comment", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Comment"].parse("# Comment.\n") == true);
REQUIRE(g["Comment"].parse("# Comment.") == false);
REQUIRE(g["Comment"].parse(" ") == false);
REQUIRE(g["Comment"].parse("a") == false);
REQUIRE(exact(g, "Comment", "# Comment.\n") == true);
REQUIRE(exact(g, "Comment", "# Comment.") == false);
REQUIRE(exact(g, "Comment", " ") == false);
REQUIRE(exact(g, "Comment", "a") == false);
}
TEST_CASE("PEG Space", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["Space"].parse(" ") == true);
REQUIRE(g["Space"].parse("\t") == true);
REQUIRE(g["Space"].parse("\n") == true);
REQUIRE(g["Space"].parse("") == false);
REQUIRE(g["Space"].parse("a") == false);
REQUIRE(exact(g, "Space", " ") == true);
REQUIRE(exact(g, "Space", "\t") == true);
REQUIRE(exact(g, "Space", "\n") == true);
REQUIRE(exact(g, "Space", "") == false);
REQUIRE(exact(g, "Space", "a") == false);
}
TEST_CASE("PEG EndOfLine", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["EndOfLine"].parse("\r\n") == true);
REQUIRE(g["EndOfLine"].parse("\n") == true);
REQUIRE(g["EndOfLine"].parse("\r") == true);
REQUIRE(g["EndOfLine"].parse(" ") == false);
REQUIRE(g["EndOfLine"].parse("") == false);
REQUIRE(g["EndOfLine"].parse("a") == false);
REQUIRE(exact(g, "EndOfLine", "\r\n") == true);
REQUIRE(exact(g, "EndOfLine", "\n") == true);
REQUIRE(exact(g, "EndOfLine", "\r") == true);
REQUIRE(exact(g, "EndOfLine", " ") == false);
REQUIRE(exact(g, "EndOfLine", "") == false);
REQUIRE(exact(g, "EndOfLine", "a") == false);
}
TEST_CASE("PEG EndOfFile", "[peg]")
{
Grammar g = make_peg_grammar();
REQUIRE(g["EndOfFile"].parse("") == true);
REQUIRE(g["EndOfFile"].parse(" ") == false);
REQUIRE(exact(g, "EndOfFile", "") == true);
REQUIRE(exact(g, "EndOfFile", " ") == false);
}
// vim: et ts=4 sw=4 cin cino={1s ff=unix

Write Preview
Loading…
Cancel
Save