1pub struct ArcParser;
2#[allow(dead_code, non_camel_case_types)]
3#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
4pub enum Rule {
5 EOI,
6 program,
7 statement,
8 empty_line,
9 RestOfLine,
10 dict_scope,
11 dict_empty,
12 dict_head,
13 dict_pair,
14 list_scope,
15 list_empty,
16 list_head,
17 list_pair,
18 dict_literal,
19 list_literal,
20 Value,
21 Null,
22 Boolean,
23 True,
24 False,
25 cite_value,
26 Byte,
27 Byte_BIN,
28 Byte_OCT,
29 Byte_HEX,
30 Number,
31 SignedNumber,
32 Decimal,
33 DecimalBad,
34 Integer,
35 Complex,
36 Zero,
37 String,
38 StringLines,
39 StringCharacter,
40 StringNormal,
41 StringLiteralText,
42 StringText,
43 Accent,
44 Apostrophe,
45 Quotation,
46 Escape,
47 NameSpace,
48 Key,
49 SYMBOL,
50 COMMENT,
51 WHITESPACE,
52 LineComment,
53 MultiLineComment,
54 Cite,
55 Dot,
56 Insert,
57 Append,
58 Underline,
59 SEPARATOR,
60 Set,
61 Sign,
62}
63#[allow(clippy::all)]
64impl ::pest::Parser<Rule> for ArcParser {
65 fn parse<'i>(rule: Rule, input: &'i str) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> {
66 mod rules {
67 pub mod hidden {
68 use super::super::Rule;
69 #[inline]
70 #[allow(dead_code, non_snake_case, unused_variables)]
71 pub fn skip(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
72 if state.atomicity() == ::pest::Atomicity::NonAtomic { state.sequence(|state| state.repeat(|state| super::visible::WHITESPACE(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::visible::COMMENT(state).and_then(|state| state.repeat(|state| super::visible::WHITESPACE(state))))))) } else { Ok(state) }
73 }
74 }
75 pub mod visible {
76 use super::super::Rule;
77 #[inline]
78 #[allow(non_snake_case, unused_variables)]
79 pub fn program(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
80 state.sequence(|state| self::SOI(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_literal(state).or_else(|state| state.sequence(|state| state.optional(|state| self::statement(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::statement(state))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::EOI(state)))
81 }
82 #[inline]
83 #[allow(non_snake_case, unused_variables)]
84 pub fn statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
85 self::SEPARATOR(state).or_else(|state| state.sequence(|state| self::empty_line(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::empty_line(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::empty_line(state)))))))))).or_else(|state| self::dict_literal(state)).or_else(|state| self::dict_scope(state)).or_else(|state| self::dict_pair(state)).or_else(|state| self::list_scope(state))
86 }
87 #[inline]
88 #[allow(non_snake_case, unused_variables)]
89 pub fn empty_line(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
90 state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITESPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITESPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::NEWLINE(state)))
91 }
92 #[inline]
93 #[allow(non_snake_case, unused_variables)]
94 pub fn RestOfLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
95 state.rule(Rule::RestOfLine, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state))))))))))
96 }
97 #[inline]
98 #[allow(non_snake_case, unused_variables)]
99 pub fn dict_scope(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
100 state.rule(Rule::dict_scope, |state| state.sequence(|state| self::dict_head(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state))))))))))))
101 }
102 #[inline]
103 #[allow(non_snake_case, unused_variables)]
104 pub fn dict_empty(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
105 state.rule(Rule::dict_empty, |state| state.sequence(|state| state.match_string("{").and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("}"))))
106 }
107 #[inline]
108 #[allow(non_snake_case, unused_variables)]
109 pub fn dict_head(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
110 state.rule(Rule::dict_head, |state| state.sequence(|state| state.match_string("{").and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::Append(state).or_else(|state| self::Insert(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::NameSpace(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("}"))))
111 }
112 #[inline]
113 #[allow(non_snake_case, unused_variables)]
114 pub fn dict_pair(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
115 state.rule(Rule::dict_pair, |state| state.sequence(|state| self::NameSpace(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Set(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Value(state))))
116 }
117 #[inline]
118 #[allow(non_snake_case, unused_variables)]
119 pub fn list_scope(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
120 state.rule(Rule::list_scope, |state| state.sequence(|state| self::list_head(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::list_pair(state))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::list_pair(state))))))))))))
121 }
122 #[inline]
123 #[allow(non_snake_case, unused_variables)]
124 pub fn list_empty(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
125 state.rule(Rule::list_empty, |state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]"))))
126 }
127 #[inline]
128 #[allow(non_snake_case, unused_variables)]
129 pub fn list_head(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
130 state.rule(Rule::list_head, |state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::Append(state).or_else(|state| self::Insert(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::NameSpace(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]"))))
131 }
132 #[inline]
133 #[allow(non_snake_case, unused_variables)]
134 pub fn list_pair(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
135 state.rule(Rule::list_pair, |state| state.sequence(|state| self::Insert(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::dict_pair(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::dict_pair(state))))))))).or_else(|state| state.sequence(|state| self::Append(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Value(state)))))
136 }
137 #[inline]
138 #[allow(non_snake_case, unused_variables)]
139 pub fn dict_literal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
140 state.rule(Rule::dict_literal, |state| self::dict_empty(state).or_else(|state| state.sequence(|state| state.match_string("{").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state)))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::SEPARATOR(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("}")))))
141 }
142 #[inline]
143 #[allow(non_snake_case, unused_variables)]
144 pub fn list_literal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
145 state.rule(Rule::list_literal, |state| self::list_empty(state).or_else(|state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Value(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Value(state))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Value(state)))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::SEPARATOR(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]")))))
146 }
147 #[inline]
148 #[allow(non_snake_case, unused_variables)]
149 pub fn Value(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
150 state.rule(Rule::Value, |state| self::Byte(state).or_else(|state| self::Number(state)).or_else(|state| self::Boolean(state)).or_else(|state| self::Null(state)).or_else(|state| self::String(state)).or_else(|state| self::cite_value(state)).or_else(|state| self::dict_literal(state)).or_else(|state| self::list_literal(state)))
151 }
152 #[inline]
153 #[allow(non_snake_case, unused_variables)]
154 pub fn Null(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
155 state.rule(Rule::Null, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("null")))
156 }
157 #[inline]
158 #[allow(non_snake_case, unused_variables)]
159 pub fn Boolean(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
160 state.atomic(::pest::Atomicity::NonAtomic, |state| state.rule(Rule::Boolean, |state| self::True(state).or_else(|state| self::False(state))))
161 }
162 #[inline]
163 #[allow(non_snake_case, unused_variables)]
164 pub fn True(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
165 state.rule(Rule::True, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("true")))
166 }
167 #[inline]
168 #[allow(non_snake_case, unused_variables)]
169 pub fn False(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
170 state.rule(Rule::False, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("false")))
171 }
172 #[inline]
173 #[allow(non_snake_case, unused_variables)]
174 pub fn cite_value(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
175 state.rule(Rule::cite_value, |state| state.sequence(|state| self::Cite(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::NameSpace(state))))
176 }
177 #[inline]
178 #[allow(non_snake_case, unused_variables)]
179 pub fn Byte(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
180 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Byte, |state| self::Byte_BIN(state).or_else(|state| self::Byte_OCT(state)).or_else(|state| self::Byte_HEX(state))))
181 }
182 #[inline]
183 #[allow(non_snake_case, unused_variables)]
184 pub fn Byte_BIN(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
185 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Byte_BIN, |state| state.sequence(|state| self::Zero(state).and_then(|state| state.match_string("b").or_else(|state| state.match_string("B"))).and_then(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_BIN_DIGIT(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_BIN_DIGIT(state))))))))
186 }
187 #[inline]
188 #[allow(non_snake_case, unused_variables)]
189 pub fn Byte_OCT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
190 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Byte_OCT, |state| state.sequence(|state| self::Zero(state).and_then(|state| state.match_string("o").or_else(|state| state.match_string("O"))).and_then(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_OCT_DIGIT(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_OCT_DIGIT(state))))))))
191 }
192 #[inline]
193 #[allow(non_snake_case, unused_variables)]
194 pub fn Byte_HEX(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
195 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Byte_HEX, |state| state.sequence(|state| self::Zero(state).and_then(|state| state.match_string("x").or_else(|state| state.match_string("X"))).and_then(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_HEX_DIGIT(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_HEX_DIGIT(state))))))))
196 }
197 #[inline]
198 #[allow(non_snake_case, unused_variables)]
199 pub fn Number(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
200 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Number, |state| self::Complex(state).or_else(|state| self::DecimalBad(state)).or_else(|state| self::SignedNumber(state))))
201 }
202 #[inline]
203 #[allow(non_snake_case, unused_variables)]
204 pub fn SignedNumber(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
205 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::SignedNumber, |state| state.sequence(|state| state.optional(|state| self::Sign(state)).and_then(|state| self::Decimal(state).or_else(|state| self::Integer(state))))))
206 }
207 #[inline]
208 #[allow(non_snake_case, unused_variables)]
209 pub fn Decimal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
210 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Decimal, |state| state.sequence(|state| self::Integer(state).and_then(|state| self::Dot(state)).and_then(|state| self::ASCII_DIGIT(state)).and_then(|state| state.repeat(|state| self::ASCII_DIGIT(state))))))
211 }
212 #[inline]
213 #[allow(non_snake_case, unused_variables)]
214 pub fn DecimalBad(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
215 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::DecimalBad, |state| state.sequence(|state| self::Integer(state).and_then(|state| self::Dot(state))).or_else(|state| state.sequence(|state| self::Dot(state).and_then(|state| self::ASCII_DIGIT(state)).and_then(|state| state.repeat(|state| self::ASCII_DIGIT(state)))))))
216 }
217 #[inline]
218 #[allow(non_snake_case, unused_variables)]
219 pub fn Integer(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
220 state.rule(Rule::Integer, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::Zero(state).or_else(|state| state.sequence(|state| self::ASCII_NONZERO_DIGIT(state).and_then(|state| state.repeat(|state| state.sequence(|state| state.optional(|state| self::Underline(state)).and_then(|state| self::ASCII_DIGIT(state)))))))))
221 }
222 #[inline]
223 #[allow(non_snake_case, unused_variables)]
224 pub fn Complex(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
225 state.rule(Rule::Complex, |state| state.sequence(|state| self::SignedNumber(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::SYMBOL(state))))
226 }
227 #[inline]
228 #[allow(non_snake_case, unused_variables)]
229 pub fn Zero(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
230 state.match_string("0")
231 }
232 #[inline]
233 #[allow(non_snake_case, unused_variables)]
234 pub fn String(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
235 state.rule(Rule::String, |state| state.sequence(|state| state.optional(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::StringNormal(state).or_else(|state| self::StringLines(state)).or_else(|state| self::StringCharacter(state)))))
236 }
237 #[inline]
238 #[allow(non_snake_case, unused_variables)]
239 pub fn StringLines(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
240 state.rule(Rule::StringLines, |state| state.sequence(|state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::RestOfLine(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::RestOfLine(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::RestOfLine(state)))))))))))))
241 }
242 #[inline]
243 #[allow(non_snake_case, unused_variables)]
244 pub fn StringCharacter(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
245 state.rule(Rule::StringCharacter, |state| state.sequence(|state| self::Apostrophe(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::StringLiteralText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Apostrophe(state))))
246 }
247 #[inline]
248 #[allow(non_snake_case, unused_variables)]
249 pub fn StringNormal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
250 state.rule(Rule::StringNormal, |state| state.sequence(|state| self::Quotation(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::StringText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Quotation(state))))
251 }
252 #[inline]
253 #[allow(non_snake_case, unused_variables)]
254 pub fn StringLiteralText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
255 state.rule(Rule::StringLiteralText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Escape(state).or_else(|state| self::Apostrophe(state)))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| self::Apostrophe(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Escape(state).or_else(|state| self::Apostrophe(state)))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| self::Apostrophe(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))))))))))
256 }
257 #[inline]
258 #[allow(non_snake_case, unused_variables)]
259 pub fn StringText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
260 state.rule(Rule::StringText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Escape(state).or_else(|state| self::Quotation(state)))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| self::Quotation(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Escape(state).or_else(|state| self::Quotation(state)))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| self::Quotation(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))))))))))
261 }
262 #[inline]
263 #[allow(non_snake_case, unused_variables)]
264 pub fn Accent(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
265 state.rule(Rule::Accent, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("`")))
266 }
267 #[inline]
268 #[allow(non_snake_case, unused_variables)]
269 pub fn Apostrophe(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
270 state.rule(Rule::Apostrophe, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("'")))
271 }
272 #[inline]
273 #[allow(non_snake_case, unused_variables)]
274 pub fn Quotation(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
275 state.rule(Rule::Quotation, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("\"")))
276 }
277 #[inline]
278 #[allow(non_snake_case, unused_variables)]
279 pub fn Escape(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
280 state.rule(Rule::Escape, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("\\")))
281 }
282 #[inline]
283 #[allow(non_snake_case, unused_variables)]
284 pub fn NameSpace(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
285 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::NameSpace, |state| state.sequence(|state| self::Key(state).and_then(|state| state.repeat(|state| state.sequence(|state| self::Dot(state).and_then(|state| self::Key(state))))))))
286 }
287 #[inline]
288 #[allow(non_snake_case, unused_variables)]
289 pub fn Key(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
290 state.rule(Rule::Key, |state| self::StringNormal(state).or_else(|state| self::SYMBOL(state)).or_else(|state| self::Integer(state)))
291 }
292 #[inline]
293 #[allow(non_snake_case, unused_variables)]
294 pub fn SYMBOL(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
295 state.rule(Rule::SYMBOL, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::XID_CONTINUE(state).and_then(|state| state.repeat(|state| self::XID_CONTINUE(state))))))
296 }
297 #[inline]
298 #[allow(non_snake_case, unused_variables)]
299 pub fn COMMENT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
300 state.rule(Rule::COMMENT, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::MultiLineComment(state).or_else(|state| self::LineComment(state))))
301 }
302 #[inline]
303 #[allow(non_snake_case, unused_variables)]
304 pub fn WHITESPACE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
305 state.rule(Rule::WHITESPACE, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::NEWLINE(state).or_else(|state| self::SPACE_SEPARATOR(state)).or_else(|state| state.match_string("\t"))))
306 }
307 #[inline]
308 #[allow(non_snake_case, unused_variables)]
309 pub fn LineComment(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
310 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::LineComment, |state| state.sequence(|state| state.match_string("%").and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state)).and_then(|state| self::ANY(state))))))))
311 }
312 #[inline]
313 #[allow(non_snake_case, unused_variables)]
314 pub fn MultiLineComment(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
315 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::MultiLineComment, |state| state.sequence(|state| state.match_string("%%%").and_then(|state| state.repeat(|state| self::MultiLineComment(state).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.match_string("%%%")).and_then(|state| self::ANY(state)))))).and_then(|state| state.match_string("%%%")))))
316 }
317 #[inline]
318 #[allow(non_snake_case, unused_variables)]
319 pub fn Cite(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
320 state.rule(Rule::Cite, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("$")))
321 }
322 #[inline]
323 #[allow(non_snake_case, unused_variables)]
324 pub fn Dot(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
325 state.rule(Rule::Dot, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(".")))
326 }
327 #[inline]
328 #[allow(non_snake_case, unused_variables)]
329 pub fn Insert(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
330 state.rule(Rule::Insert, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("*")))
331 }
332 #[inline]
333 #[allow(non_snake_case, unused_variables)]
334 pub fn Append(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
335 state.rule(Rule::Append, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(">")))
336 }
337 #[inline]
338 #[allow(non_snake_case, unused_variables)]
339 pub fn Underline(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
340 state.rule(Rule::Underline, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("_")))
341 }
342 #[inline]
343 #[allow(non_snake_case, unused_variables)]
344 pub fn SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
345 state.rule(Rule::SEPARATOR, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(",").or_else(|state| state.match_string(";"))))
346 }
347 #[inline]
348 #[allow(non_snake_case, unused_variables)]
349 pub fn Set(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
350 state.rule(Rule::Set, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("=").or_else(|state| state.match_string(":"))))
351 }
352 #[inline]
353 #[allow(non_snake_case, unused_variables)]
354 pub fn Sign(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
355 state.rule(Rule::Sign, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("+").or_else(|state| state.match_string("-"))))
356 }
357 #[inline]
358 #[allow(dead_code, non_snake_case, unused_variables)]
359 pub fn ASCII_OCT_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
360 state.match_range('0'..'7')
361 }
362 #[inline]
363 #[allow(dead_code, non_snake_case, unused_variables)]
364 pub fn ASCII_HEX_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
365 state.match_range('0'..'9').or_else(|state| state.match_range('a'..'f')).or_else(|state| state.match_range('A'..'F'))
366 }
367 #[inline]
368 #[allow(dead_code, non_snake_case, unused_variables)]
369 fn SPACE_SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
370 state.match_char_by(::pest::unicode::SPACE_SEPARATOR)
371 }
372 #[inline]
373 #[allow(dead_code, non_snake_case, unused_variables)]
374 fn XID_CONTINUE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
375 state.match_char_by(::pest::unicode::XID_CONTINUE)
376 }
377 #[inline]
378 #[allow(dead_code, non_snake_case, unused_variables)]
379 pub fn SOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
380 state.start_of_input()
381 }
382 #[inline]
383 #[allow(dead_code, non_snake_case, unused_variables)]
384 pub fn ASCII_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
385 state.match_range('0'..'9')
386 }
387 #[inline]
388 #[allow(dead_code, non_snake_case, unused_variables)]
389 pub fn ANY(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
390 state.skip(1)
391 }
392 #[inline]
393 #[allow(dead_code, non_snake_case, unused_variables)]
394 pub fn ASCII_BIN_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
395 state.match_range('0'..'1')
396 }
397 #[inline]
398 #[allow(dead_code, non_snake_case, unused_variables)]
399 pub fn NEWLINE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
400 state.match_string("\n").or_else(|state| state.match_string("\r\n")).or_else(|state| state.match_string("\r"))
401 }
402 #[inline]
403 #[allow(dead_code, non_snake_case, unused_variables)]
404 pub fn EOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
405 state.rule(Rule::EOI, |state| state.end_of_input())
406 }
407 #[inline]
408 #[allow(dead_code, non_snake_case, unused_variables)]
409 pub fn ASCII_NONZERO_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
410 state.match_range('1'..'9')
411 }
412 }
413 pub use self::visible::*;
414 }
415 ::pest::state(input, |state| match rule {
416 Rule::program => rules::program(state),
417 Rule::statement => rules::statement(state),
418 Rule::empty_line => rules::empty_line(state),
419 Rule::RestOfLine => rules::RestOfLine(state),
420 Rule::dict_scope => rules::dict_scope(state),
421 Rule::dict_empty => rules::dict_empty(state),
422 Rule::dict_head => rules::dict_head(state),
423 Rule::dict_pair => rules::dict_pair(state),
424 Rule::list_scope => rules::list_scope(state),
425 Rule::list_empty => rules::list_empty(state),
426 Rule::list_head => rules::list_head(state),
427 Rule::list_pair => rules::list_pair(state),
428 Rule::dict_literal => rules::dict_literal(state),
429 Rule::list_literal => rules::list_literal(state),
430 Rule::Value => rules::Value(state),
431 Rule::Null => rules::Null(state),
432 Rule::Boolean => rules::Boolean(state),
433 Rule::True => rules::True(state),
434 Rule::False => rules::False(state),
435 Rule::cite_value => rules::cite_value(state),
436 Rule::Byte => rules::Byte(state),
437 Rule::Byte_BIN => rules::Byte_BIN(state),
438 Rule::Byte_OCT => rules::Byte_OCT(state),
439 Rule::Byte_HEX => rules::Byte_HEX(state),
440 Rule::Number => rules::Number(state),
441 Rule::SignedNumber => rules::SignedNumber(state),
442 Rule::Decimal => rules::Decimal(state),
443 Rule::DecimalBad => rules::DecimalBad(state),
444 Rule::Integer => rules::Integer(state),
445 Rule::Complex => rules::Complex(state),
446 Rule::Zero => rules::Zero(state),
447 Rule::String => rules::String(state),
448 Rule::StringLines => rules::StringLines(state),
449 Rule::StringCharacter => rules::StringCharacter(state),
450 Rule::StringNormal => rules::StringNormal(state),
451 Rule::StringLiteralText => rules::StringLiteralText(state),
452 Rule::StringText => rules::StringText(state),
453 Rule::Accent => rules::Accent(state),
454 Rule::Apostrophe => rules::Apostrophe(state),
455 Rule::Quotation => rules::Quotation(state),
456 Rule::Escape => rules::Escape(state),
457 Rule::NameSpace => rules::NameSpace(state),
458 Rule::Key => rules::Key(state),
459 Rule::SYMBOL => rules::SYMBOL(state),
460 Rule::COMMENT => rules::COMMENT(state),
461 Rule::WHITESPACE => rules::WHITESPACE(state),
462 Rule::LineComment => rules::LineComment(state),
463 Rule::MultiLineComment => rules::MultiLineComment(state),
464 Rule::Cite => rules::Cite(state),
465 Rule::Dot => rules::Dot(state),
466 Rule::Insert => rules::Insert(state),
467 Rule::Append => rules::Append(state),
468 Rule::Underline => rules::Underline(state),
469 Rule::SEPARATOR => rules::SEPARATOR(state),
470 Rule::Set => rules::Set(state),
471 Rule::Sign => rules::Sign(state),
472 Rule::EOI => rules::EOI(state),
473 })
474 }
475}