1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
#pragma once
#include <absl/container/inlined_vector.h>
#include <algorithm>
#include <memory>
#include <Core/Defines.h>
#include <Parsers/IAST_fwd.h>
#include <Parsers/TokenIterator.h>
#include <base/types.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int TOO_DEEP_RECURSION;
extern const int LOGICAL_ERROR;
}
/** Collects variants, how parser could proceed further at rightmost position.
*/
struct Expected
{
absl::InlinedVector<const char *, 7> variants;
const char * max_parsed_pos = nullptr;
/// 'description' should be statically allocated string.
ALWAYS_INLINE void add(const char * current_pos, const char * description)
{
if (!max_parsed_pos || current_pos > max_parsed_pos)
{
variants.clear();
max_parsed_pos = current_pos;
variants.push_back(description);
return;
}
if ((current_pos == max_parsed_pos) && (std::find(variants.begin(), variants.end(), description) == variants.end()))
variants.push_back(description);
}
ALWAYS_INLINE void add(TokenIterator it, const char * description)
{
add(it->begin, description);
}
};
/** Interface for parser classes
*/
class IParser
{
public:
/// Token iterator augmented with depth information. This allows to control recursion depth.
struct Pos : TokenIterator
{
uint32_t depth = 0;
uint32_t max_depth = 0;
Pos(Tokens & tokens_, uint32_t max_depth_) : TokenIterator(tokens_), max_depth(max_depth_)
{
}
Pos(TokenIterator token_iterator_, uint32_t max_depth_) : TokenIterator(token_iterator_), max_depth(max_depth_) { }
ALWAYS_INLINE void increaseDepth()
{
++depth;
if (unlikely(max_depth > 0 && depth > max_depth))
throw Exception(ErrorCodes::TOO_DEEP_RECURSION, "Maximum parse depth ({}) exceeded. "
"Consider rising max_parser_depth parameter.", max_depth);
}
ALWAYS_INLINE void decreaseDepth()
{
if (unlikely(depth == 0))
throw Exception(ErrorCodes::LOGICAL_ERROR, "Logical error in parser: incorrect calculation of parse depth");
--depth;
}
};
/** Get the text of this parser parses. */
virtual const char * getName() const = 0;
/** Parse piece of text from position `pos`, but not beyond end of line (`end` - position after end of line),
* move pointer `pos` to the maximum position to which it was possible to parse,
* in case of success return `true` and the result in `node` if it is needed, otherwise false,
* in `expected` write what was expected in the maximum position,
* to which it was possible to parse if parsing was unsuccessful,
* or what this parser parse if parsing was successful.
* The string to which the [begin, end) range is included may be not 0-terminated.
*/
virtual bool parse(Pos & pos, ASTPtr & node, Expected & expected) = 0;
bool ignore(Pos & pos, Expected & expected)
{
ASTPtr ignore_node;
return parse(pos, ignore_node, expected);
}
bool ignore(Pos & pos)
{
Expected expected;
return ignore(pos, expected);
}
/** The same, but do not move the position and do not write the result to node.
*/
bool check(Pos & pos, Expected & expected)
{
Pos begin = pos;
ASTPtr node;
if (!parse(pos, node, expected))
{
pos = begin;
return false;
}
else
return true;
}
/** The same, but doesn't move the position even if parsing was successful.
*/
bool checkWithoutMoving(Pos pos, Expected & expected)
{
ASTPtr node;
return parse(pos, node, expected);
}
virtual ~IParser() = default;
};
using ParserPtr = std::unique_ptr<IParser>;
}
|
