Skip to content

Commit 0978415

Browse files
TheLartiansTheLartians
authored
Namespace rename and string_view bounds check (#54)
* rename grammar namespace from 'presets' to 'grammar' * return 0 character on end of string * enable windows workflow * apply clang-format * bump version in CMake
1 parent 7cc26d8 commit 0978415

File tree

12 files changed

+151
-157
lines changed

12 files changed

+151
-157
lines changed

‎.github/workflows/windows.yml

+3-7
Original file line numberDiff line numberDiff line change
@@ -25,11 +25,7 @@ jobs:
2525
- name: build
2626
run: cmake --build build --config Debug -j4
2727

28-
# I have absolutely no idea why the windows tests freeze here.
29-
# Abort for now and will come back later.
30-
# - name: test
31-
# run: |
32-
# cd build
33-
# ctest --build-config Debug
3428
- name: test
35-
run: cmake -E false
29+
run: |
30+
cd build
31+
ctest --build-config Debug

‎CMakeLists.txt

+1-1
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
33
# ---- Project ----
44

55
project(PEGParser
6-
VERSION 2.0
6+
VERSION 2.1
77
LANGUAGES CXX
88
)
99

‎example/CMakeLists.txt

+3
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,9 @@ cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
44

55
project(PEGParserExamples CXX)
66

7+
# --- Import tools ----
8+
9+
include(../cmake/tools.cmake)
710

811
# ---- Add dependencies ----
912

‎include/peg_parser/generator.h

+29-30
Original file line numberDiff line numberDiff line change
@@ -7,34 +7,34 @@ namespace peg_parser {
77
template <class R = void, typename... Args> class ParserGenerator : public Program<R, Args...> {
88
private:
99
presets::GrammarProgram grammarProgram;
10-
std::unordered_map<std::string, std::shared_ptr<presets::Rule>> rules;
11-
presets::GrammarNode::Shared separatorRule;
10+
std::unordered_map<std::string, std::shared_ptr<grammar::Rule>> rules;
11+
grammar::Node::Shared separatorRule;
1212

1313
public:
14-
ParserGenerator() { grammarProgram = presets::createGrammarProgram(); }
14+
ParserGenerator() { grammarProgram = presets::createPEGProgram(); }
1515

16-
std::shared_ptr<presets::Rule> getRule(const std::string &name) {
16+
std::shared_ptr<grammar::Rule> getRule(const std::string &name) {
1717
auto it = rules.find(name);
1818
if (it != rules.end()) {
1919
return it->second;
2020
}
21-
auto rule = presets::makeRule(name, presets::GrammarNode::Error());
21+
auto rule = grammar::makeRule(name, grammar::Node::Error());
2222
rules[name] = rule;
2323
return rule;
2424
}
2525

26-
presets::GrammarNode::Shared getRuleNode(const std::string &name) {
27-
auto rule = presets::GrammarNode::WeakRule(getRule(std::string(name)));
26+
grammar::Node::Shared getRuleNode(const std::string &name) {
27+
auto rule = grammar::Node::WeakRule(getRule(std::string(name)));
2828
if (separatorRule) {
29-
auto separator = presets::GrammarNode::ZeroOrMore(separatorRule);
30-
return presets::GrammarNode::Sequence({separator, rule, separator});
29+
auto separator = grammar::Node::ZeroOrMore(separatorRule);
30+
return grammar::Node::Sequence({separator, rule, separator});
3131
} else {
3232
return rule;
3333
}
3434
}
3535

36-
std::shared_ptr<presets::Rule> setRule(
37-
const std::string &name, const presets::GrammarNode::Shared &grammar,
36+
std::shared_ptr<grammar::Rule> setRule(
37+
const std::string &name, const grammar::Node::Shared &grammar,
3838
const typename Interpreter<R, Args...>::Callback &callback
3939
= typename Interpreter<R, Args...>::Callback()) {
4040
auto rule = getRule(name);
@@ -43,23 +43,23 @@ namespace peg_parser {
4343
return rule;
4444
}
4545

46-
presets::GrammarNode::Shared parseRule(const std::string_view &grammar) {
46+
grammar::Node::Shared parseRule(const std::string_view &grammar) {
4747
presets::RuleGetter rg = [this](const auto &name) { return getRuleNode(std::string(name)); };
4848
return grammarProgram.run(grammar, rg);
4949
}
5050

51-
std::shared_ptr<presets::Rule> setRule(
51+
std::shared_ptr<grammar::Rule> setRule(
5252
const std::string &name, const std::string_view &grammar,
5353
const typename Interpreter<R, Args...>::Callback &callback
5454
= typename Interpreter<R, Args...>::Callback()) {
5555
return setRule(name, parseRule(grammar), callback);
5656
}
5757

5858
template <class R2, typename... Args2, class C>
59-
std::shared_ptr<presets::Rule> setProgramRule(const std::string &name,
59+
std::shared_ptr<grammar::Rule> setProgramRule(const std::string &name,
6060
Program<R2, Args2...> subprogram, C &&callback) {
6161
auto rule = getRule(name);
62-
rule->node = presets::GrammarNode::Rule(subprogram.parser.grammar);
62+
rule->node = grammar::Node::Rule(subprogram.parser.grammar);
6363
this->interpreter.setEvaluator(
6464
rule, [callback = std::forward<C>(callback), interpreter = subprogram.interpreter](
6565
auto e, Args &&... args) {
@@ -73,42 +73,41 @@ namespace peg_parser {
7373
static_assert(sizeof...(Args2) == 0);
7474
static_assert(std::is_convertible<R2, R>::value);
7575
auto rule = getRule(name);
76-
rule->node = presets::GrammarNode::Rule(subprogram.parser.grammar);
76+
rule->node = grammar::Node::Rule(subprogram.parser.grammar);
7777
this->interpreter.setEvaluator(rule,
7878
[interpreter = subprogram.interpreter](auto e, auto &&...) {
7979
return R(interpreter.interpret(e[0].syntax()).evaluate());
8080
});
8181
}
8282

83-
std::shared_ptr<presets::Rule> setFilteredRule(
83+
std::shared_ptr<grammar::Rule> setFilteredRule(
8484
const std::string &name, const std::string_view &grammar,
85-
const presets::GrammarNode::FilterCallback &filter,
85+
const grammar::Node::FilterCallback &filter,
8686
const typename Interpreter<R, Args...>::Callback &callback
8787
= typename Interpreter<R, Args...>::Callback()) {
8888
return setRule(name,
89-
presets::GrammarNode::Sequence(
90-
{parseRule(grammar), presets::GrammarNode::Filter(filter)}),
89+
grammar::Node::Sequence({parseRule(grammar), grammar::Node::Filter(filter)}),
9190
callback);
9291
}
9392

94-
void setSeparator(const std::shared_ptr<presets::Rule> &rule) {
93+
void setSeparator(const std::shared_ptr<grammar::Rule> &rule) {
9594
rule->hidden = true;
96-
separatorRule = presets::GrammarNode::Rule(rule);
95+
separatorRule = grammar::Node::Rule(rule);
9796
}
9897

99-
std::shared_ptr<presets::Rule> setSeparatorRule(const std::string &name,
100-
const presets::GrammarNode::Shared &grammar) {
98+
std::shared_ptr<grammar::Rule> setSeparatorRule(const std::string &name,
99+
const grammar::Node::Shared &grammar) {
101100
auto rule = setRule(name, grammar);
102101
setSeparator(rule);
103102
return rule;
104103
}
105104

106-
std::shared_ptr<presets::Rule> setSeparatorRule(const std::string &name,
105+
std::shared_ptr<grammar::Rule> setSeparatorRule(const std::string &name,
107106
const std::string_view &grammar) {
108107
return setSeparatorRule(name, parseRule(grammar));
109108
}
110109

111-
void setStart(const std::shared_ptr<presets::Rule> &rule) { this->parser.grammar = rule; }
110+
void setStart(const std::shared_ptr<grammar::Rule> &rule) { this->parser.grammar = rule; }
112111

113112
void unsetSeparatorRule() { separatorRule.reset(); }
114113

@@ -119,7 +118,7 @@ namespace peg_parser {
119118
std::string ruleName;
120119
std::string grammar;
121120
typename Interpreter<R, Args...>::Callback callback;
122-
presets::GrammarNode::FilterCallback filter;
121+
grammar::Node::FilterCallback filter;
123122

124123
OperatorDelegate(ParserGenerator *p, const std::string &n) : parent(p), ruleName(n) {}
125124
OperatorDelegate(const OperatorDelegate &) = delete;
@@ -134,14 +133,14 @@ namespace peg_parser {
134133
return *this;
135134
}
136135

137-
OperatorDelegate &operator<<(const presets::GrammarNode::FilterCallback &ft) {
136+
OperatorDelegate &operator<<(const grammar::Node::FilterCallback &ft) {
138137
this->filter = ft;
139138
return *this;
140139
}
141140

142-
operator std::shared_ptr<presets::Rule>() { return parent->getRule(ruleName); }
141+
operator std::shared_ptr<grammar::Rule>() { return parent->getRule(ruleName); }
143142

144-
std::shared_ptr<presets::Rule> operator->() { return parent->getRule(ruleName); }
143+
std::shared_ptr<grammar::Rule> operator->() { return parent->getRule(ruleName); }
145144

146145
~OperatorDelegate() {
147146
if (grammar.size() > 0) {

‎include/peg_parser/grammar.h

+31-35
Original file line numberDiff line numberDiff line change
@@ -13,25 +13,25 @@ namespace peg_parser {
1313

1414
struct SyntaxTree;
1515

16-
namespace presets {
16+
namespace grammar {
1717

1818
using Letter = char;
19-
struct GrammarNode;
19+
struct Node;
2020

2121
struct Rule {
2222
std::string name;
23-
std::shared_ptr<GrammarNode> node;
23+
std::shared_ptr<Node> node;
2424
bool hidden = false;
2525
bool cacheable = true;
26-
Rule(const std::string_view &n, const std::shared_ptr<GrammarNode> &t) : name(n), node(t) {}
26+
Rule(const std::string_view &n, const std::shared_ptr<Node> &t) : name(n), node(t) {}
2727
};
2828

2929
inline std::shared_ptr<Rule> makeRule(const std::string_view &name,
30-
const std::shared_ptr<GrammarNode> &node) {
30+
const std::shared_ptr<Node> &node) {
3131
return std::make_shared<Rule>(name, node);
3232
}
3333

34-
struct GrammarNode {
34+
struct Node {
3535
using FilterCallback = std::function<bool(const std::shared_ptr<SyntaxTree> &)>;
3636

3737
enum class Symbol {
@@ -53,59 +53,55 @@ namespace peg_parser {
5353
FILTER
5454
};
5555

56-
using Shared = std::shared_ptr<GrammarNode>;
56+
using Shared = std::shared_ptr<Node>;
5757

5858
Symbol symbol;
5959

60-
std::variant<std::vector<Shared>, Shared, std::weak_ptr<presets::Rule>,
61-
std::shared_ptr<presets::Rule>, std::string, std::array<Letter, 2>,
60+
std::variant<std::vector<Shared>, Shared, std::weak_ptr<grammar::Rule>,
61+
std::shared_ptr<grammar::Rule>, std::string, std::array<Letter, 2>,
6262
FilterCallback>
6363
data;
6464

6565
private:
66-
GrammarNode(Symbol s) : symbol(s) {}
67-
template <class T> GrammarNode(Symbol s, const T &d) : symbol(s), data(d) {}
66+
Node(Symbol s) : symbol(s) {}
67+
template <class T> Node(Symbol s, const T &d) : symbol(s), data(d) {}
6868

6969
public:
70-
static Shared Word(const std::string &word) {
71-
return Shared(new GrammarNode(Symbol::WORD, word));
72-
}
73-
static Shared Any() { return Shared(new GrammarNode(Symbol::ANY)); }
70+
static Shared Word(const std::string &word) { return Shared(new Node(Symbol::WORD, word)); }
71+
static Shared Any() { return Shared(new Node(Symbol::ANY)); }
7472
static Shared Range(Letter a, Letter b) {
75-
return Shared(new GrammarNode(Symbol::RANGE, std::array<Letter, 2>({{a, b}})));
73+
return Shared(new Node(Symbol::RANGE, std::array<Letter, 2>({{a, b}})));
7674
}
7775
static Shared Sequence(const std::vector<Shared> &args) {
78-
return Shared(new GrammarNode(Symbol::SEQUENCE, args));
76+
return Shared(new Node(Symbol::SEQUENCE, args));
7977
}
8078
static Shared Choice(const std::vector<Shared> &args) {
81-
return Shared(new GrammarNode(Symbol::CHOICE, args));
79+
return Shared(new Node(Symbol::CHOICE, args));
8280
}
8381
static Shared ZeroOrMore(const Shared &arg) {
84-
return Shared(new GrammarNode(Symbol::ZERO_OR_MORE, arg));
82+
return Shared(new Node(Symbol::ZERO_OR_MORE, arg));
8583
}
8684
static Shared OneOrMore(const Shared &arg) {
87-
return Shared(new GrammarNode(Symbol::ONE_OR_MORE, arg));
88-
}
89-
static Shared Optional(const Shared &arg) {
90-
return Shared(new GrammarNode(Symbol::OPTIONAL, arg));
85+
return Shared(new Node(Symbol::ONE_OR_MORE, arg));
9186
}
92-
static Shared Also(const Shared &arg) { return Shared(new GrammarNode(Symbol::ALSO, arg)); }
93-
static Shared Not(const Shared &arg) { return Shared(new GrammarNode(Symbol::NOT, arg)); }
94-
static Shared Empty() { return Shared(new GrammarNode(Symbol::EMPTY)); }
95-
static Shared Error() { return Shared(new GrammarNode(Symbol::ERROR)); }
96-
static Shared Rule(const std::shared_ptr<presets::Rule> &rule) {
97-
return Shared(new GrammarNode(Symbol::RULE, rule));
87+
static Shared Optional(const Shared &arg) { return Shared(new Node(Symbol::OPTIONAL, arg)); }
88+
static Shared Also(const Shared &arg) { return Shared(new Node(Symbol::ALSO, arg)); }
89+
static Shared Not(const Shared &arg) { return Shared(new Node(Symbol::NOT, arg)); }
90+
static Shared Empty() { return Shared(new Node(Symbol::EMPTY)); }
91+
static Shared Error() { return Shared(new Node(Symbol::ERROR)); }
92+
static Shared Rule(const std::shared_ptr<grammar::Rule> &rule) {
93+
return Shared(new Node(Symbol::RULE, rule));
9894
}
99-
static Shared WeakRule(const std::weak_ptr<presets::Rule> &rule) {
100-
return Shared(new GrammarNode(Symbol::WEAK_RULE, rule));
95+
static Shared WeakRule(const std::weak_ptr<grammar::Rule> &rule) {
96+
return Shared(new Node(Symbol::WEAK_RULE, rule));
10197
}
102-
static Shared EndOfFile() { return Shared(new GrammarNode(Symbol::END_OF_FILE)); }
98+
static Shared EndOfFile() { return Shared(new Node(Symbol::END_OF_FILE)); }
10399
static Shared Filter(const FilterCallback &callback) {
104-
return Shared(new GrammarNode(Symbol::FILTER, callback));
100+
return Shared(new Node(Symbol::FILTER, callback));
105101
}
106102
};
107103

108-
std::ostream &operator<<(std::ostream &stream, const GrammarNode &node);
104+
std::ostream &operator<<(std::ostream &stream, const Node &node);
109105

110-
} // namespace presets
106+
} // namespace grammar
111107
} // namespace peg_parser

‎include/peg_parser/interpreter.h

+8-8
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ namespace peg_parser {
7979
};
8080

8181
private:
82-
std::unordered_map<presets::Rule *, Callback> evaluators;
82+
std::unordered_map<grammar::Rule *, Callback> evaluators;
8383

8484
static R __defaultEvaluator(const Expression &e, Args... args) {
8585
size_t N = e.size();
@@ -97,21 +97,21 @@ namespace peg_parser {
9797
public:
9898
Callback defaultEvaluator = __defaultEvaluator;
9999

100-
std::shared_ptr<presets::Rule> makeRule(const std::string_view &name,
101-
const presets::GrammarNode::Shared &node,
100+
std::shared_ptr<grammar::Rule> makeRule(const std::string_view &name,
101+
const grammar::Node::Shared &node,
102102
const Callback &callback) {
103-
auto rule = std::make_shared<presets::Rule>(name, node);
103+
auto rule = std::make_shared<grammar::Rule>(name, node);
104104
setEvaluator(rule, callback);
105105
return rule;
106106
}
107107

108-
std::shared_ptr<presets::Rule> makeRule(const std::string &name,
109-
const std::shared_ptr<presets::Rule> &rule,
108+
std::shared_ptr<grammar::Rule> makeRule(const std::string &name,
109+
const std::shared_ptr<grammar::Rule> &rule,
110110
const Callback &callback) {
111-
return makeRule(name, presets::GrammarNode::Rule(rule), callback);
111+
return makeRule(name, grammar::Node::Rule(rule), callback);
112112
}
113113

114-
void setEvaluator(const std::shared_ptr<presets::Rule> &rule, const Callback &callback) {
114+
void setEvaluator(const std::shared_ptr<grammar::Rule> &rule, const Callback &callback) {
115115
if (callback) {
116116
evaluators[rule.get()] = callback;
117117
} else {

‎include/peg_parser/parser.h

+9-9
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
namespace peg_parser {
88

99
struct SyntaxTree {
10-
std::shared_ptr<presets::Rule> rule;
10+
std::shared_ptr<grammar::Rule> rule;
1111
std::string_view fullString;
1212
std::vector<std::shared_ptr<SyntaxTree>> inner;
1313
size_t begin, end;
@@ -16,7 +16,7 @@ namespace peg_parser {
1616
bool active = true;
1717
bool recursive = false;
1818

19-
SyntaxTree(const std::shared_ptr<presets::Rule> &r, std::string_view s, size_t p);
19+
SyntaxTree(const std::shared_ptr<grammar::Rule> &r, std::string_view s, size_t p);
2020

2121
size_t length() const { return end - begin; }
2222
std::string_view view() const { return fullString.substr(begin, length()); }
@@ -31,21 +31,21 @@ namespace peg_parser {
3131

3232
struct GrammarError : std::exception {
3333
enum Type { UNKNOWN_SYMBOL, INVALID_RULE } type;
34-
presets::GrammarNode::Shared node;
34+
grammar::Node::Shared node;
3535
mutable std::string buffer;
36-
GrammarError(Type t, presets::GrammarNode::Shared n) : type(t), node(n) {}
36+
GrammarError(Type t, grammar::Node::Shared n) : type(t), node(n) {}
3737
const char *what() const noexcept override;
3838
};
3939

40-
std::shared_ptr<presets::Rule> grammar;
40+
std::shared_ptr<grammar::Rule> grammar;
4141

42-
Parser(const std::shared_ptr<presets::Rule> &grammar
43-
= std::make_shared<presets::Rule>("undefined", presets::GrammarNode::Error()));
42+
Parser(const std::shared_ptr<grammar::Rule> &grammar
43+
= std::make_shared<grammar::Rule>("undefined", grammar::Node::Error()));
4444

4545
static Result parseAndGetError(const std::string_view &str,
46-
std::shared_ptr<presets::Rule> grammar);
46+
std::shared_ptr<grammar::Rule> grammar);
4747
static std::shared_ptr<SyntaxTree> parse(const std::string_view &str,
48-
std::shared_ptr<presets::Rule> grammar);
48+
std::shared_ptr<grammar::Rule> grammar);
4949

5050
std::shared_ptr<SyntaxTree> parse(const std::string_view &str) const;
5151
Result parseAndGetError(const std::string_view &str) const;

0 commit comments

Comments
 (0)