Skip to content

Commit

Permalink
Allow more than one instruction
Browse files Browse the repository at this point in the history
  • Loading branch information
@yhirose
yhirose committed Apr 2, 2022
1 parent b85606c commit 82fd01f
Showing 1 changed file with 80 additions and 35 deletions.
115 changes: 80 additions & 35 deletions peglib.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -463,7 +463,7 @@ class Context;

struct SemanticValues : protected std::vector<std::any> {
SemanticValues() = default;
SemanticValues(Context *c): c_(c) {}
SemanticValues(Context *c) : c_(c) {}

// Input text
const char *path = nullptr;
Expand Down Expand Up @@ -569,7 +569,7 @@ struct SemanticValues : protected std::vector<std::any> {
/*
* Semantic action
*/
template <typename F, typename... Args> std::any call(F fn, Args &&... args) {
template <typename F, typename... Args> std::any call(F fn, Args &&...args) {
using R = decltype(fn(std::forward<Args>(args)...));
if constexpr (std::is_void<R>::value) {
fn(std::forward<Args>(args)...);
Expand Down Expand Up @@ -975,7 +975,7 @@ class Ope {
class Sequence : public Ope {
public:
template <typename... Args>
Sequence(const Args &... args)
Sequence(const Args &...args)
: opes_{static_cast<std::shared_ptr<Ope>>(args)...} {}
Sequence(const std::vector<std::shared_ptr<Ope>> &opes) : opes_(opes) {}
Sequence(std::vector<std::shared_ptr<Ope>> &&opes) : opes_(opes) {}
Expand Down Expand Up @@ -1018,7 +1018,7 @@ class Sequence : public Ope {
class PrioritizedChoice : public Ope {
public:
template <typename... Args>
PrioritizedChoice(bool for_label, const Args &... args)
PrioritizedChoice(bool for_label, const Args &...args)
: opes_{static_cast<std::shared_ptr<Ope>>(args)...},
for_label_(for_label) {}
PrioritizedChoice(const std::vector<std::shared_ptr<Ope>> &opes)
Expand Down Expand Up @@ -1576,16 +1576,16 @@ class Cut : public Ope, public std::enable_shared_from_this<Cut> {
/*
* Factories
*/
template <typename... Args> std::shared_ptr<Ope> seq(Args &&... args) {
template <typename... Args> std::shared_ptr<Ope> seq(Args &&...args) {
return std::make_shared<Sequence>(static_cast<std::shared_ptr<Ope>>(args)...);
}

template <typename... Args> std::shared_ptr<Ope> cho(Args &&... args) {
template <typename... Args> std::shared_ptr<Ope> cho(Args &&...args) {
return std::make_shared<PrioritizedChoice>(
false, static_cast<std::shared_ptr<Ope>>(args)...);
}

template <typename... Args> std::shared_ptr<Ope> cho4label_(Args &&... args) {
template <typename... Args> std::shared_ptr<Ope> cho4label_(Args &&...args) {
return std::make_shared<PrioritizedChoice>(
true, static_cast<std::shared_ptr<Ope>>(args)...);
}
Expand Down Expand Up @@ -2467,9 +2467,7 @@ inline size_t parse_literal(const char *s, size_t n, SemanticValues &vs,
}

inline const std::vector<size_t> &SemanticValues::source_line_index() const {
if (!c_) {
std::vector<size_t>();
}
if (!c_) { std::vector<size_t>(); }
if (c_->source_line_index.empty()) {
for (size_t pos = 0; pos < c_->l; pos++) {
if (c_->s[pos] == '\n') { c_->source_line_index.push_back(pos); }
Expand Down Expand Up @@ -3058,14 +3056,16 @@ class ParserGenerator {
struct Instruction {
std::string type;
std::any data;
std::string_view sv;
};

struct Data {
std::shared_ptr<Grammar> grammar;
std::string start;
const char *start_pos = nullptr;
std::vector<std::pair<std::string, const char *>> duplicates;
std::map<std::string, Instruction> instructions;
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;
bool enablePackratParsing = true;

Expand Down Expand Up @@ -3194,10 +3194,14 @@ class ParserGenerator {
~g["COMMA"] <= seq(chr(','), g["Spacing"]);

// Instruction grammars
g["Instruction"] <= seq(g["BeginBlacket"],
cho(cho(g["PrecedenceClimbing"]),
cho(g["ErrorMessage"]), cho(g["NoAstOpt"])),
g["EndBlacket"]);
g["Instruction"] <=
seq(g["BeginBlacket"],
opt(seq(g["InstructionItem"], zom(seq(g["InstructionItemSeparator"],
g["InstructionItem"])))),
g["EndBlacket"]);
g["InstructionItem"] <=
cho(g["PrecedenceClimbing"], g["ErrorMessage"], g["NoAstOpt"]);
~g["InstructionItemSeparator"] <= seq(chr(';'), g["Spacing"]);

~g["SpacesZom"] <= zom(g["Space"]);
~g["SpacesOom"] <= oom(g["Space"]);
Expand Down Expand Up @@ -3245,16 +3249,34 @@ class ParserGenerator {

std::vector<std::string> params;
std::shared_ptr<Ope> ope;
auto has_instructions = false;

if (is_macro) {
params = std::any_cast<std::vector<std::string>>(vs[2]);
ope = std::any_cast<std::shared_ptr<Ope>>(vs[4]);
if (vs.size() == 6) {
data.instructions[name] = std::any_cast<Instruction>(vs[5]);
has_instructions = true;
}
} else {
ope = std::any_cast<std::shared_ptr<Ope>>(vs[3]);
if (vs.size() == 5) {
data.instructions[name] = std::any_cast<Instruction>(vs[4]);
has_instructions = true;
}
}

if (has_instructions) {
auto index = is_macro ? 5 : 4;
std::set<std::string> types;
for (const auto &instruction :
std::any_cast<std::vector<Instruction>>(vs[index])) {
const auto &type = instruction.type;
if (types.find(type) == types.end()) {
data.instructions[name].push_back(instruction);
types.insert(instruction.type);
} else {
// data.duplicates_of_instruction.emplace_back(type, vs.sv().data());
data.duplicates_of_instruction.emplace_back(type, instruction.sv.data());
}
}
}

Expand All @@ -3273,7 +3295,7 @@ class ParserGenerator {
data.start_pos = vs.sv().data();
}
} else {
data.duplicates.emplace_back(name, vs.sv().data());
data.duplicates_of_definition.emplace_back(name, vs.sv().data());
}
};

Expand Down Expand Up @@ -3548,6 +3570,7 @@ class ParserGenerator {
Instruction instruction;
instruction.type = "precedence";
instruction.data = binOpeInfo;
instruction.sv = vs.sv();
return instruction;
};
g["PrecedenceInfo"] = [](const SemanticValues &vs) {
Expand All @@ -3560,14 +3583,20 @@ class ParserGenerator {
Instruction instruction;
instruction.type = "message";
instruction.data = std::any_cast<std::string>(vs[0]);
instruction.sv = vs.sv();
return instruction;
};

g["NoAstOpt"] = [](const SemanticValues & /*vs*/) {
g["NoAstOpt"] = [](const SemanticValues & vs) {
Instruction instruction;
instruction.type = "no_ast_opt";
instruction.sv = vs.sv();
return instruction;
};

g["Instruction"] = [](const SemanticValues &vs) {
return vs.transform<Instruction>();
};
}

bool apply_precedence_instruction(Definition &rule,
Expand Down Expand Up @@ -3662,13 +3691,27 @@ class ParserGenerator {
}

// Check duplicated definitions
auto ret = data.duplicates.empty();
auto ret = true;

for (const auto &[name, ptr] : data.duplicates) {
if (log) {
auto line = line_info(s, ptr);
log(line.first, line.second, "'" + name + "' is already defined.");
if (!data.duplicates_of_definition.empty()) {
for (const auto &[name, ptr] : data.duplicates_of_definition) {
if (log) {
auto line = line_info(s, ptr);
log(line.first, line.second, "The definition '" + name + "' is already defined.");
}
}
ret = false;
}

// Check duplicated instructions
if (!data.duplicates_of_instruction.empty()) {
for (const auto &[type, ptr] : data.duplicates_of_instruction) {
if (log) {
auto line = line_info(s, ptr);
log(line.first, line.second, "The instruction '" + type + "' is already defined.");
}
}
ret = false;
}

// Set root definition
Expand Down Expand Up @@ -3778,20 +3821,22 @@ class ParserGenerator {
}

// Apply instructions
for (const auto &[name, instruction] : data.instructions) {
for (const auto &[name, instructions] : data.instructions) {
auto &rule = grammar[name];

if (instruction.type == "precedence") {
const auto &info =
std::any_cast<PrecedenceClimbing::BinOpeInfo>(instruction.data);
for (const auto& instruction: instructions) {
if (instruction.type == "precedence") {
const auto &info =
std::any_cast<PrecedenceClimbing::BinOpeInfo>(instruction.data);

if (!apply_precedence_instruction(rule, info, s, log)) {
return nullptr;
if (!apply_precedence_instruction(rule, info, s, log)) {
return nullptr;
}
} else if (instruction.type == "message") {
rule.error_message = std::any_cast<std::string>(instruction.data);
} else if (instruction.type == "no_ast_opt") {
rule.no_ast_opt = true;
}
} else if (instruction.type == "message") {
rule.error_message = std::any_cast<std::string>(instruction.data);
} else if (instruction.type == "no_ast_opt") {
rule.no_ast_opt = true;
}
}

Expand Down

0 comments on commit 82fd01f

Please sign in to comment.