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