AIR/cpp-peglib
1
0
Fork 0
mirror of https://github.com/yhirose/cpp-peglib.git synced 2024-12-22 20:05:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix #206

Browse Source
This commit is contained in:
yhirose 2022-06-02 15:42:03 -04:00
parent 05205a0ca1
commit bd99157bb5
3 changed files with 113 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
docs/native.wasm
View File

Binary file not shown.

124
peglib.h
View File

@ -2811,7 +2811,10 @@ inline size_t BackReference::parse_core(const char *s, size_t n,
return parse_literal(s, n, vs, c, dt, lit, init_is_word, is_word, false);
}
}
throw std::runtime_error("Invalid back reference...");
c.error_info.message_pos = s;
c.error_info.message = "undefined back reference '$" + name_ + "'...";
return static_cast<size_t>(-1);
}
inline Definition &
@ -3176,10 +3179,16 @@ private:
std::shared_ptr<Grammar> grammar;
std::string start;
const char *start_pos = nullptr;
std::vector<std::pair<std::string, const char *>> duplicates_of_definition;
std::vector<std::pair<std::string, const char *>> duplicates_of_instruction;
std::map<std::string, std::vector<Instruction>> instructions;
std::set<std::string_view> captures;
std::vector<std::pair<std::string, const char *>> undefined_back_references;
std::vector<std::set<std::string_view>> captures_stack{{}};
std::set<std::string_view> captures_in_current_definition;
bool enablePackratParsing = true;
Data() : grammar(std::make_shared<Grammar>()) {}
@ -3200,17 +3209,16 @@ private:
seq(g["Suffix"], opt(seq(g["LABEL"], g["Identifier"])));
g["Suffix"] <= seq(g["Primary"], opt(g["Loop"]));
g["Loop"] <= cho(g["QUESTION"], g["STAR"], g["PLUS"], g["Repetition"]);
g["Primary"] <=
cho(seq(g["Ignore"], g["IdentCont"], g["Arguments"],
g["Primary"] <= cho(seq(g["Ignore"], g["IdentCont"], g["Arguments"],
npd(g["LEFTARROW"])),
seq(g["Ignore"], g["Identifier"],
npd(seq(opt(g["Parameters"]), g["LEFTARROW"]))),
seq(g["OPEN"], g["Expression"], g["CLOSE"]),
seq(g["BeginTok"], g["Expression"], g["EndTok"]),
seq(g["BeginCapScope"], g["Expression"], g["EndCapScope"]),
seq(g["BeginCap"], g["Expression"], g["EndCap"]), g["BackRef"],
g["LiteralI"], g["Dictionary"], g["Literal"], g["NegatedClass"],
g["Class"], g["DOT"]);
g["CapScope"],
seq(g["BeginCap"], g["Expression"], g["EndCap"]),
g["BackRef"], g["LiteralI"], g["Dictionary"],
g["Literal"], g["NegatedClass"], g["Class"], g["DOT"]);
g["Identifier"] <= seq(g["IdentCont"], g["Spacing"]);
g["IdentCont"] <= seq(g["IdentStart"], zom(g["IdentRest"]));
@ -3268,6 +3276,8 @@ private:
seq(g["COMMA"], g["Number"]));
g["Number"] <= seq(oom(cls("0-9")), g["Spacing"]);
g["CapScope"] <= seq(g["BeginCapScope"], g["Expression"], g["EndCapScope"]);
g["LEFTARROW"] <= seq(cho(lit("<-"), lit(u8(u8"←"))), g["Spacing"]);
~g["SLASH"] <= seq(chr('/'), g["Spacing"]);
~g["PIPE"] <= seq(chr('|'), g["Spacing"]);
@ -3416,7 +3426,7 @@ private:
g["Definition"].enter = [](const char * /*s*/, size_t /*n*/, std::any &dt) {
auto &data = *std::any_cast<Data *>(dt);
data.captures.clear();
data.captures_in_current_definition.clear();
};
g["Expression"] = [&](const SemanticValues &vs) {
@ -3517,29 +3527,6 @@ private:
}
};
g["RepetitionRange"] = [&](const SemanticValues &vs) {
switch (vs.choice()) {
case 0: { // Number COMMA Number
auto min = std::any_cast<size_t>(vs[0]);
auto max = std::any_cast<size_t>(vs[1]);
return std::pair(min, max);
}
case 1: // Number COMMA
return std::pair(std::any_cast<size_t>(vs[0]),
std::numeric_limits<size_t>::max());
case 2: { // Number
auto n = std::any_cast<size_t>(vs[0]);
return std::pair(n, n);
}
default: // COMMA Number
return std::pair(std::numeric_limits<size_t>::min(),
std::any_cast<size_t>(vs[0]));
}
};
g["Number"] = [&](const SemanticValues &vs) {
return vs.token_to_number<size_t>();
};
g["Primary"] = [&](const SemanticValues &vs, std::any &dt) {
auto &data = *std::any_cast<Data *>(dt);
@ -3577,7 +3564,8 @@ private:
const auto &name = std::any_cast<std::string_view>(vs[0]);
auto ope = std::any_cast<std::shared_ptr<Ope>>(vs[1]);
data.captures.insert(name);
data.captures_stack.back().insert(name);
data.captures_in_current_definition.insert(name);
return cap(ope, [name](const char *a_s, size_t a_n, Context &c) {
auto &cs = c.capture_scope_stack[c.capture_scope_stack_size - 1];
@ -3641,6 +3629,40 @@ private:
return resolve_escape_sequence(vs.sv().data(), vs.sv().length());
};
g["RepetitionRange"] = [&](const SemanticValues &vs) {
switch (vs.choice()) {
case 0: { // Number COMMA Number
auto min = std::any_cast<size_t>(vs[0]);
auto max = std::any_cast<size_t>(vs[1]);
return std::pair(min, max);
}
case 1: // Number COMMA
return std::pair(std::any_cast<size_t>(vs[0]),
std::numeric_limits<size_t>::max());
case 2: { // Number
auto n = std::any_cast<size_t>(vs[0]);
return std::pair(n, n);
}
default: // COMMA Number
return std::pair(std::numeric_limits<size_t>::min(),
std::any_cast<size_t>(vs[0]));
}
};
g["Number"] = [&](const SemanticValues &vs) {
return vs.token_to_number<size_t>();
};
g["CapScope"].enter = [](const char * /*s*/, size_t /*n*/, std::any &dt) {
auto &data = *std::any_cast<Data *>(dt);
data.captures_stack.emplace_back();
};
g["CapScope"].leave = [](const char * /*s*/, size_t /*n*/,
size_t /*matchlen*/, std::any & /*value*/,
std::any &dt) {
auto &data = *std::any_cast<Data *>(dt);
data.captures_stack.pop_back();
};
g["AND"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
g["NOT"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
g["QUESTION"] = [](const SemanticValues &vs) { return *vs.sv().data(); };
@ -3655,9 +3677,31 @@ private:
g["BackRef"] = [&](const SemanticValues &vs, std::any &dt) {
auto &data = *std::any_cast<Data *>(dt);
if (data.captures.find(vs.token()) == data.captures.end()) {
// Undefined back reference check
{
auto found = false;
auto it = data.captures_stack.rbegin();
while (it != data.captures_stack.rend()) {
if (it->find(vs.token()) != it->end()) {
found = true;
break;
}
++it;
}
if (!found) {
auto ptr = vs.token().data() - 1; // include '$' symbol
data.undefined_back_references.emplace_back(vs.token(), ptr);
}
}
// NOTE: Disable packrat parsing if a back reference is not defined in
// captures in the current definition rule.
if (data.captures_in_current_definition.find(vs.token()) ==
data.captures_in_current_definition.end()) {
data.enablePackratParsing = false;
}
return bkr(vs.token_to_string());
};
@ -3831,6 +3875,18 @@ private:
ret = false;
}
// Check undefined back references
if (!data.undefined_back_references.empty()) {
for (const auto &[name, ptr] : data.undefined_back_references) {
if (log) {
auto line = line_info(s, ptr);
log(line.first, line.second,
"The back reference '" + name + "' is undefined.");
}
}
ret = false;
}
// Set root definition
auto &start_rule = grammar[data.start];

28
test/test2.cc
View File

@ -569,6 +569,11 @@ TEST(BackreferenceTest, Backreference_test) {
}
}
TEST(BackreferenceTest, Undefined_backreference_test) {
parser parser("S <- $bref");
EXPECT_FALSE(parser);
}
TEST(BackreferenceTest, Invalid_backreference_test) {
parser parser(R"(
START <- _ LQUOTE (!RQUOTE .)* RQUOTE _
@ -577,10 +582,10 @@ TEST(BackreferenceTest, Invalid_backreference_test) {
~_ <- [ \t\r\n]*
)");
EXPECT_THROW(parser.parse(R"delm(
EXPECT_FALSE(parser);
EXPECT_FALSE(parser.parse(R"delm(
R"foo("(hello world)")foo"
)delm"),
std::runtime_error);
)delm"));
}
TEST(BackreferenceTest, Nested_capture_test) {
@ -595,6 +600,7 @@ TEST(BackreferenceTest, Nested_capture_test) {
TEXT_DATA <- ![<] .
)");
EXPECT_TRUE(!!parser);
EXPECT_TRUE(parser.parse("This is <b>a <u>test</u> text</b>."));
EXPECT_FALSE(parser.parse("This is <b>a <u>test</b> text</u>."));
EXPECT_FALSE(parser.parse("This is <b>a <u>test text</b>."));
@ -614,7 +620,8 @@ TEST(BackreferenceTest, Backreference_with_Prioritized_Choice_test) {
CORRECT <- 'correct'
)");
EXPECT_THROW(parser.parse("branchthatiscorrect"), std::runtime_error);
EXPECT_TRUE(!!parser);
EXPECT_FALSE(parser.parse("branchthatiscorrect"));
}
TEST(BackreferenceTest, Backreference_with_Zero_or_More_test) {
@ -630,15 +637,15 @@ TEST(BackreferenceTest, Backreference_with_Zero_or_More_test) {
CORRECT <- 'correct'
)");
EXPECT_TRUE(!!parser);
EXPECT_TRUE(parser.parse("branchthatiswrongbranchthatiscorrect"));
EXPECT_FALSE(parser.parse("branchthatiswrongbranchthatIscorrect"));
EXPECT_FALSE(
parser.parse("branchthatiswrongbranchthatIswrongbranchthatiscorrect"));
EXPECT_TRUE(
parser.parse("branchthatiswrongbranchthatIswrongbranchthatIscorrect"));
EXPECT_THROW(parser.parse("branchthatiscorrect"), std::runtime_error);
EXPECT_THROW(parser.parse("branchthatiswron_branchthatiscorrect"),
std::runtime_error);
EXPECT_FALSE(parser.parse("branchthatiscorrect"));
EXPECT_FALSE(parser.parse("branchthatiswron_branchthatiscorrect"));
}
TEST(BackreferenceTest, Backreference_with_One_or_More_test) {
@ -654,6 +661,7 @@ TEST(BackreferenceTest, Backreference_with_One_or_More_test) {
CORRECT <- 'correct'
)");
EXPECT_TRUE(!!parser);
EXPECT_TRUE(parser.parse("branchthatiswrongbranchthatiscorrect"));
EXPECT_FALSE(parser.parse("branchthatiswrongbranchthatIscorrect"));
EXPECT_FALSE(
@ -677,15 +685,15 @@ TEST(BackreferenceTest, Backreference_with_Option_test) {
CORRECT <- 'correct'
)");
EXPECT_TRUE(!!parser);
EXPECT_TRUE(parser.parse("branchthatiswrongbranchthatiscorrect"));
EXPECT_FALSE(parser.parse("branchthatiswrongbranchthatIscorrect"));
EXPECT_FALSE(
parser.parse("branchthatiswrongbranchthatIswrongbranchthatiscorrect"));
EXPECT_FALSE(
parser.parse("branchthatiswrongbranchthatIswrongbranchthatIscorrect"));
EXPECT_THROW(parser.parse("branchthatiscorrect"), std::runtime_error);
EXPECT_THROW(parser.parse("branchthatiswron_branchthatiscorrect"),
std::runtime_error);
EXPECT_FALSE(parser.parse("branchthatiscorrect"));
EXPECT_FALSE(parser.parse("branchthatiswron_branchthatiscorrect"));
}
TEST(RepetitionTest, Repetition_0) {