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