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 heads,
8 statement,
9 EmptyLine,
10 import_statement,
11 extend_statement,
12 Import,
13 dict_scope,
14 dict_head,
15 dict_pair,
16 dict_literal,
17 RestLineText,
18 Set,
19 list_scope,
20 list_head,
21 list_pair,
22 list_literal,
23 InlineString,
24 Insert,
25 Append,
26 data,
27 Special,
28 Cite,
29 Number,
30 SignedNumber,
31 Decimal,
32 DecimalBad,
33 Integer,
34 Exponent,
35 Sign,
36 String,
37 StringEmpty,
38 StringNormal,
39 NS1,
40 NS2,
41 S1,
42 S2,
43 namespace,
44 Key,
45 SYMBOL,
46 ExtraID,
47 Dot,
48 COMMENT,
49 WHITESPACE,
50 LineComment,
51 MultiLineComment,
52 SEPARATOR,
53 DEPRECATED,
54}
55#[allow(clippy::all)]
56impl ::pest::Parser<Rule> for ArcParser {
57 fn parse<'i>(rule: Rule, input: &'i str) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> {
58 mod rules {
59 pub mod hidden {
60 use super::super::Rule;
61 #[inline]
62 #[allow(dead_code, non_snake_case, unused_variables)]
63 pub fn skip(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
64 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) }
65 }
66 }
67 pub mod visible {
68 use super::super::Rule;
69 #[inline]
70 #[allow(non_snake_case, unused_variables)]
71 pub fn program(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
72 state.sequence(|state| self::SOI(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::heads(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::heads(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::statement(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::statement(state))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::EOI(state))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| self::data(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::EOI(state)))))))
73 }
74 #[inline]
75 #[allow(non_snake_case, unused_variables)]
76 pub fn heads(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
77 state.restore_on_err(|state| self::import_statement(state)).or_else(|state| state.restore_on_err(|state| self::extend_statement(state)))
78 }
79 #[inline]
80 #[allow(non_snake_case, unused_variables)]
81 pub fn statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
82 self::SEPARATOR(state).or_else(|state| state.sequence(|state| self::EmptyLine(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::EmptyLine(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::EmptyLine(state)))))))))).or_else(|state| state.restore_on_err(|state| self::dict_pair(state))).or_else(|state| state.restore_on_err(|state| self::dict_scope(state))).or_else(|state| state.restore_on_err(|state| self::list_scope(state)))
83 }
84 #[inline]
85 #[allow(non_snake_case, unused_variables)]
86 pub fn EmptyLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
87 state.rule(Rule::EmptyLine, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.repeat(|state| self::WHITESPACE(state)).and_then(|state| self::NEWLINE(state)))))
88 }
89 #[inline]
90 #[allow(non_snake_case, unused_variables)]
91 pub fn import_statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
92 state.rule(Rule::import_statement, |state| state.sequence(|state| self::Import(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::String(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("as")).and_then(|state| super::hidden::skip(state)).and_then(|state| self::SYMBOL(state))))
93 }
94 #[inline]
95 #[allow(non_snake_case, unused_variables)]
96 pub fn extend_statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
97 state.rule(Rule::extend_statement, |state| state.sequence(|state| state.match_string("@extend").and_then(|state| super::hidden::skip(state)).and_then(|state| self::String(state))))
98 }
99 #[inline]
100 #[allow(non_snake_case, unused_variables)]
101 pub fn Import(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
102 state.rule(Rule::Import, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("@import").or_else(|state| state.match_string("@import!"))))
103 }
104 #[inline]
105 #[allow(non_snake_case, unused_variables)]
106 pub fn dict_scope(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
107 state.sequence(|state| self::dict_head(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|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.restore_on_err(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::dict_pair(state))))))))))))
108 }
109 #[inline]
110 #[allow(non_snake_case, unused_variables)]
111 pub fn dict_head(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
112 state.rule(Rule::dict_head, |state| state.sequence(|state| state.match_string("{").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::Dot(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Dot(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("}"))))
113 }
114 #[inline]
115 #[allow(non_snake_case, unused_variables)]
116 pub fn dict_pair(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
117 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| state.restore_on_err(|state| self::data(state)).or_else(|state| self::RestLineText(state)))))
118 }
119 #[inline]
120 #[allow(non_snake_case, unused_variables)]
121 pub fn dict_literal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
122 state.rule(Rule::dict_literal, |state| state.sequence(|state| state.optional(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("{")).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("}").or_else(|state| state.restore_on_err(|state| state.sequence(|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.restore_on_err(|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.restore_on_err(|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("}"))))))))
123 }
124 #[inline]
125 #[allow(non_snake_case, unused_variables)]
126 pub fn RestLineText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
127 state.rule(Rule::RestLineText, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state).or_else(|state| state.match_string("]")).or_else(|state| state.match_string("}"))).and_then(|state| self::ANY(state))).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state).or_else(|state| state.match_string("]")).or_else(|state| state.match_string("}"))).and_then(|state| self::ANY(state))))))))
128 }
129 #[inline]
130 #[allow(non_snake_case, unused_variables)]
131 pub fn Set(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
132 state.rule(Rule::Set, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("=").or_else(|state| state.match_string(":"))))
133 }
134 #[inline]
135 #[allow(non_snake_case, unused_variables)]
136 pub fn list_scope(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
137 state.sequence(|state| self::list_head(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|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.restore_on_err(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::list_pair(state))))))))))))
138 }
139 #[inline]
140 #[allow(non_snake_case, unused_variables)]
141 pub fn list_head(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
142 state.rule(Rule::list_head, |state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::Dot(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Dot(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("]"))))
143 }
144 #[inline]
145 #[allow(non_snake_case, unused_variables)]
146 pub fn list_pair(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
147 state.rule(Rule::list_pair, |state| state.restore_on_err(|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| state.restore_on_err(|state| self::dict_pair(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::dict_pair(state))))))))))).or_else(|state| state.sequence(|state| self::Append(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.restore_on_err(|state| self::data(state)).or_else(|state| self::InlineString(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::data(state)).or_else(|state| self::InlineString(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::data(state)).or_else(|state| self::InlineString(state))))))))))))
148 }
149 #[inline]
150 #[allow(non_snake_case, unused_variables)]
151 pub fn list_literal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
152 state.rule(Rule::list_literal, |state| state.sequence(|state| state.optional(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("[")).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]").or_else(|state| state.sequence(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.restore_on_err(|state| self::data(state)).or_else(|state| self::InlineString(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| state.restore_on_err(|state| self::data(state)).or_else(|state| self::InlineString(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| state.restore_on_err(|state| self::data(state)).or_else(|state| self::InlineString(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("]")))))))
153 }
154 #[inline]
155 #[allow(non_snake_case, unused_variables)]
156 pub fn InlineString(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
157 state.rule(Rule::InlineString, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.sequence(|state| state.lookahead(false, |state| self::SEPARATOR(state).or_else(|state| self::NEWLINE(state)).or_else(|state| state.match_string("]")).or_else(|state| state.match_string("}"))).and_then(|state| self::ANY(state))).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::SEPARATOR(state).or_else(|state| self::NEWLINE(state)).or_else(|state| state.match_string("]")).or_else(|state| state.match_string("}"))).and_then(|state| self::ANY(state))))))))
158 }
159 #[inline]
160 #[allow(non_snake_case, unused_variables)]
161 pub fn Insert(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
162 state.rule(Rule::Insert, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("^")))
163 }
164 #[inline]
165 #[allow(non_snake_case, unused_variables)]
166 pub fn Append(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
167 state.rule(Rule::Append, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(">")))
168 }
169 #[inline]
170 #[allow(non_snake_case, unused_variables)]
171 pub fn data(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
172 state.rule(Rule::data, |state| self::Number(state).or_else(|state| self::Special(state)).or_else(|state| state.restore_on_err(|state| self::Cite(state))).or_else(|state| state.restore_on_err(|state| self::String(state))).or_else(|state| state.restore_on_err(|state| self::dict_literal(state))).or_else(|state| state.restore_on_err(|state| self::list_literal(state))))
173 }
174 #[inline]
175 #[allow(non_snake_case, unused_variables)]
176 pub fn Special(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
177 state.rule(Rule::Special, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("true").or_else(|state| state.match_string("false")).or_else(|state| state.match_string("null"))))
178 }
179 #[inline]
180 #[allow(non_snake_case, unused_variables)]
181 pub fn Cite(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
182 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Cite, |state| state.sequence(|state| state.match_string("$").and_then(|state| self::namespace(state)))))
183 }
184 #[inline]
185 #[allow(non_snake_case, unused_variables)]
186 pub fn Number(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
187 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Number, |state| state.sequence(|state| self::Exponent(state).or_else(|state| self::SignedNumber(state)).and_then(|state| state.optional(|state| self::SYMBOL(state))))))
188 }
189 #[inline]
190 #[allow(non_snake_case, unused_variables)]
191 pub fn SignedNumber(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
192 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::DecimalBad(state)).or_else(|state| self::Integer(state))))))
193 }
194 #[inline]
195 #[allow(non_snake_case, unused_variables)]
196 pub fn Decimal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
197 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| state.repeat(|state| state.sequence(|state| state.optional(|state| state.match_string("_")).and_then(|state| self::ASCII_DIGIT(state))))))))
198 }
199 #[inline]
200 #[allow(non_snake_case, unused_variables)]
201 pub fn DecimalBad(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
202 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| state.repeat(|state| state.sequence(|state| state.optional(|state| state.match_string("_")).and_then(|state| self::ASCII_DIGIT(state)))))))))
203 }
204 #[inline]
205 #[allow(non_snake_case, unused_variables)]
206 pub fn Integer(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
207 state.rule(Rule::Integer, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::ASCII_DIGIT(state).and_then(|state| state.repeat(|state| state.sequence(|state| state.optional(|state| state.match_string("_")).and_then(|state| self::ASCII_DIGIT(state))))))))
208 }
209 #[inline]
210 #[allow(non_snake_case, unused_variables)]
211 pub fn Exponent(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
212 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Exponent, |state| state.sequence(|state| self::SignedNumber(state).and_then(|state| state.match_string("e").or_else(|state| state.match_string("E")).or_else(|state| state.match_string("**"))).and_then(|state| state.optional(|state| self::Sign(state))).and_then(|state| self::ASCII_DIGIT(state)).and_then(|state| state.repeat(|state| self::ASCII_DIGIT(state))))))
213 }
214 #[inline]
215 #[allow(non_snake_case, unused_variables)]
216 pub fn Sign(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
217 state.rule(Rule::Sign, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("+").or_else(|state| state.match_string("-"))))
218 }
219 #[inline]
220 #[allow(non_snake_case, unused_variables)]
221 pub fn String(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
222 state.atomic(::pest::Atomicity::NonAtomic, |state| state.rule(Rule::String, |state| state.sequence(|state| state.optional(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.restore_on_err(|state| self::StringNormal(state)).or_else(|state| self::StringEmpty(state))))))
223 }
224 #[inline]
225 #[allow(non_snake_case, unused_variables)]
226 pub fn StringEmpty(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
227 state.rule(Rule::StringEmpty, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::S1(state).and_then(|state| self::S1(state))).or_else(|state| state.sequence(|state| self::S2(state).and_then(|state| self::S2(state))))))
228 }
229 #[inline]
230 #[allow(non_snake_case, unused_variables)]
231 pub fn StringNormal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
232 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::StringNormal, |state| state.restore_on_err(|state| state.sequence(|state| self::S1(state).and_then(|state| state.stack_push(|state| state.repeat(|state| self::S1(state)))).and_then(|state| state.sequence(|state| self::NS1(state).and_then(|state| state.repeat(|state| self::NS1(state))))).and_then(|state| self::POP(state)).and_then(|state| self::S1(state)))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| self::S2(state).and_then(|state| state.stack_push(|state| state.repeat(|state| self::S2(state)))).and_then(|state| state.sequence(|state| self::NS2(state).and_then(|state| state.repeat(|state| self::NS2(state))))).and_then(|state| self::POP(state)).and_then(|state| self::S2(state)))))))
233 }
234 #[inline]
235 #[allow(non_snake_case, unused_variables)]
236 pub fn NS1(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
237 state.rule(Rule::NS1, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::S1(state).and_then(|state| self::PEEK(state)))).and_then(|state| self::ANY(state))).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::S1(state).and_then(|state| self::PEEK(state)))).and_then(|state| self::ANY(state))))))))
238 }
239 #[inline]
240 #[allow(non_snake_case, unused_variables)]
241 pub fn NS2(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
242 state.rule(Rule::NS2, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.match_string("\\u").and_then(|state| self::ASCII_HEX_DIGIT(state)).and_then(|state| self::ASCII_HEX_DIGIT(state)).and_then(|state| self::ASCII_HEX_DIGIT(state)).and_then(|state| self::ASCII_HEX_DIGIT(state))).or_else(|state| state.sequence(|state| state.match_string("\\u").and_then(|state| state.match_string("{")).and_then(|state| state.sequence(|state| self::ASCII_HEX_DIGIT(state).or_else(|state| self::SPACE_SEPARATOR(state)).and_then(|state| state.repeat(|state| self::ASCII_HEX_DIGIT(state).or_else(|state| self::SPACE_SEPARATOR(state)))))).and_then(|state| state.match_string("}")))).or_else(|state| state.sequence(|state| state.match_string("\\").and_then(|state| self::ANY(state)))).or_else(|state| state.sequence(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::S2(state).and_then(|state| self::PEEK(state)))).and_then(|state| self::ANY(state))).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::S2(state).and_then(|state| self::PEEK(state)))).and_then(|state| self::ANY(state)))))))))
243 }
244 #[inline]
245 #[allow(non_snake_case, unused_variables)]
246 pub fn S1(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
247 state.rule(Rule::S1, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("'")))
248 }
249 #[inline]
250 #[allow(non_snake_case, unused_variables)]
251 pub fn S2(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
252 state.rule(Rule::S2, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("\"")))
253 }
254 #[inline]
255 #[allow(non_snake_case, unused_variables)]
256 pub fn namespace(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
257 state.rule(Rule::namespace, |state| state.sequence(|state| self::Key(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| state.sequence(|state| self::Dot(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Key(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| state.sequence(|state| self::Dot(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Key(state)))))))))))))
258 }
259 #[inline]
260 #[allow(non_snake_case, unused_variables)]
261 pub fn Key(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
262 state.restore_on_err(|state| self::StringNormal(state)).or_else(|state| self::SYMBOL(state)).or_else(|state| self::SignedNumber(state))
263 }
264 #[inline]
265 #[allow(non_snake_case, unused_variables)]
266 pub fn SYMBOL(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
267 state.rule(Rule::SYMBOL, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::XID_START(state).or_else(|state| self::ExtraID(state)).and_then(|state| state.repeat(|state| self::XID_CONTINUE(state).or_else(|state| self::ExtraID(state)))))))
268 }
269 #[inline]
270 #[allow(non_snake_case, unused_variables)]
271 pub fn ExtraID(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
272 state.rule(Rule::ExtraID, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("_")))
273 }
274 #[inline]
275 #[allow(non_snake_case, unused_variables)]
276 pub fn Dot(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
277 state.rule(Rule::Dot, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(".")))
278 }
279 #[inline]
280 #[allow(non_snake_case, unused_variables)]
281 pub fn COMMENT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
282 state.rule(Rule::COMMENT, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::MultiLineComment(state).or_else(|state| self::LineComment(state))))
283 }
284 #[inline]
285 #[allow(non_snake_case, unused_variables)]
286 pub fn WHITESPACE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
287 state.atomic(::pest::Atomicity::Atomic, |state| self::NEWLINE(state).or_else(|state| self::SPACE_SEPARATOR(state)).or_else(|state| state.match_string("\t")))
288 }
289 #[inline]
290 #[allow(non_snake_case, unused_variables)]
291 pub fn LineComment(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
292 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::LineComment, |state| state.sequence(|state| self::DEPRECATED(state).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state)).and_then(|state| self::ANY(state))))))))
293 }
294 #[inline]
295 #[allow(non_snake_case, unused_variables)]
296 pub fn MultiLineComment(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
297 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("*/")))))
298 }
299 #[inline]
300 #[allow(non_snake_case, unused_variables)]
301 pub fn SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
302 state.rule(Rule::SEPARATOR, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(",").or_else(|state| state.match_string(";"))))
303 }
304 #[inline]
305 #[allow(non_snake_case, unused_variables)]
306 pub fn DEPRECATED(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
307 state.rule(Rule::DEPRECATED, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("//").or_else(|state| state.match_string("#"))))
308 }
309 #[inline]
310 #[allow(dead_code, non_snake_case, unused_variables)]
311 pub fn ANY(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
312 state.skip(1)
313 }
314 #[inline]
315 #[allow(dead_code, non_snake_case, unused_variables)]
316 pub fn EOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
317 state.rule(Rule::EOI, |state| state.end_of_input())
318 }
319 #[inline]
320 #[allow(dead_code, non_snake_case, unused_variables)]
321 pub fn SOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
322 state.start_of_input()
323 }
324 #[inline]
325 #[allow(dead_code, non_snake_case, unused_variables)]
326 pub fn PEEK(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
327 state.stack_peek()
328 }
329 #[inline]
330 #[allow(dead_code, non_snake_case, unused_variables)]
331 pub fn POP(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
332 state.stack_pop()
333 }
334 #[inline]
335 #[allow(dead_code, non_snake_case, unused_variables)]
336 pub fn ASCII_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
337 state.match_range('0'..'9')
338 }
339 #[inline]
340 #[allow(dead_code, non_snake_case, unused_variables)]
341 pub fn ASCII_HEX_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
342 state.match_range('0'..'9').or_else(|state| state.match_range('a'..'f')).or_else(|state| state.match_range('A'..'F'))
343 }
344 #[inline]
345 #[allow(dead_code, non_snake_case, unused_variables)]
346 pub fn NEWLINE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
347 state.match_string("\n").or_else(|state| state.match_string("\r\n")).or_else(|state| state.match_string("\r"))
348 }
349 #[inline]
350 #[allow(dead_code, non_snake_case, unused_variables)]
351 fn XID_CONTINUE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
352 state.match_char_by(::pest::unicode::XID_CONTINUE)
353 }
354 #[inline]
355 #[allow(dead_code, non_snake_case, unused_variables)]
356 fn XID_START(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
357 state.match_char_by(::pest::unicode::XID_START)
358 }
359 #[inline]
360 #[allow(dead_code, non_snake_case, unused_variables)]
361 fn SPACE_SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
362 state.match_char_by(::pest::unicode::SPACE_SEPARATOR)
363 }
364 }
365 pub use self::visible::*;
366 }
367 ::pest::state(input, |state| match rule {
368 Rule::program => rules::program(state),
369 Rule::heads => rules::heads(state),
370 Rule::statement => rules::statement(state),
371 Rule::EmptyLine => rules::EmptyLine(state),
372 Rule::import_statement => rules::import_statement(state),
373 Rule::extend_statement => rules::extend_statement(state),
374 Rule::Import => rules::Import(state),
375 Rule::dict_scope => rules::dict_scope(state),
376 Rule::dict_head => rules::dict_head(state),
377 Rule::dict_pair => rules::dict_pair(state),
378 Rule::dict_literal => rules::dict_literal(state),
379 Rule::RestLineText => rules::RestLineText(state),
380 Rule::Set => rules::Set(state),
381 Rule::list_scope => rules::list_scope(state),
382 Rule::list_head => rules::list_head(state),
383 Rule::list_pair => rules::list_pair(state),
384 Rule::list_literal => rules::list_literal(state),
385 Rule::InlineString => rules::InlineString(state),
386 Rule::Insert => rules::Insert(state),
387 Rule::Append => rules::Append(state),
388 Rule::data => rules::data(state),
389 Rule::Special => rules::Special(state),
390 Rule::Cite => rules::Cite(state),
391 Rule::Number => rules::Number(state),
392 Rule::SignedNumber => rules::SignedNumber(state),
393 Rule::Decimal => rules::Decimal(state),
394 Rule::DecimalBad => rules::DecimalBad(state),
395 Rule::Integer => rules::Integer(state),
396 Rule::Exponent => rules::Exponent(state),
397 Rule::Sign => rules::Sign(state),
398 Rule::String => rules::String(state),
399 Rule::StringEmpty => rules::StringEmpty(state),
400 Rule::StringNormal => rules::StringNormal(state),
401 Rule::NS1 => rules::NS1(state),
402 Rule::NS2 => rules::NS2(state),
403 Rule::S1 => rules::S1(state),
404 Rule::S2 => rules::S2(state),
405 Rule::namespace => rules::namespace(state),
406 Rule::Key => rules::Key(state),
407 Rule::SYMBOL => rules::SYMBOL(state),
408 Rule::ExtraID => rules::ExtraID(state),
409 Rule::Dot => rules::Dot(state),
410 Rule::COMMENT => rules::COMMENT(state),
411 Rule::WHITESPACE => rules::WHITESPACE(state),
412 Rule::LineComment => rules::LineComment(state),
413 Rule::MultiLineComment => rules::MultiLineComment(state),
414 Rule::SEPARATOR => rules::SEPARATOR(state),
415 Rule::DEPRECATED => rules::DEPRECATED(state),
416 Rule::EOI => rules::EOI(state),
417 })
418 }
419}