1pub struct NoteDownParser;
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 EmptyLine,
9 BlockEnd,
10 RestOfLine,
11 Header,
12 TextBlock,
13 TextElement,
14 TextRest,
15 URL,
16 Code,
17 CodeAction,
18 CodeLevel,
19 CodeText,
20 CodeMark,
21 Table,
22 TableFirstLine,
23 TableRestLine,
24 List,
25 ListFirstLine,
26 ListRestLine,
27 ListMark,
28 Checkmark,
29 HorizontalRule,
30 MathStatement,
31 Math,
32 MathLevel,
33 MathText,
34 MathBlock,
35 MathRest,
36 RawStatement,
37 Raw,
38 RawLevel,
39 RawText,
40 RawRest,
41 StyleStatement,
42 Style,
43 StyleLevel,
44 StyleText,
45 StyleRest,
46 TildeStatement,
47 TildeLine,
48 TildeLevel,
49 TildeText,
50 TildeRest,
51 Template,
52 HTMLOpenClose,
53 HTMLOpen,
54 HTMLClose,
55 HTMLSelfClose,
56 Command,
57 CommandLine,
58 CommandBlock,
59 call,
60 arguments,
61 argument_literal,
62 argument,
63 key_value,
64 key,
65 value,
66 Number,
67 Decimal,
68 DecimalBad,
69 Integer,
70 Sign,
71 String,
72 S1,
73 S2,
74 SYMBOL,
75 Escaped,
76 Keywords,
77 LINE_SEPARATOR,
78 WHITE_SPACE,
79 PATTERN_WHITE_SPACE,
80 Escape,
81 At,
82 Sharp,
83 Underline,
84 Asterisk,
85 Comma,
86 Dot,
87 Set,
88 Colon,
89 Vertical,
90 Plus,
91 Minus,
92 QuoteMark,
93 Accent,
94 Dollar,
95 Tilde,
96}
97#[allow(clippy::all)]
98impl ::pest::Parser<Rule> for NoteDownParser {
99 fn parse<'i>(rule: Rule, input: &'i str) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> {
100 mod rules {
101 pub mod hidden {
102 use super::super::Rule;
103 #[inline]
104 #[allow(dead_code, non_snake_case, unused_variables)]
105 pub fn skip(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
106 Ok(state)
107 }
108 }
109 pub mod visible {
110 use super::super::Rule;
111 #[inline]
112 #[allow(non_snake_case, unused_variables)]
113 pub fn program(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
114 state.sequence(|state| self::SOI(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)))
115 }
116 #[inline]
117 #[allow(non_snake_case, unused_variables)]
118 pub fn statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
119 state.restore_on_err(|state| self::Header(state)).or_else(|state| self::HorizontalRule(state)).or_else(|state| state.restore_on_err(|state| self::Code(state))).or_else(|state| state.restore_on_err(|state| self::Table(state))).or_else(|state| state.restore_on_err(|state| self::List(state))).or_else(|state| state.restore_on_err(|state| self::Template(state))).or_else(|state| self::Command(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::TextBlock(state)))
120 }
121 #[inline]
122 #[allow(non_snake_case, unused_variables)]
123 pub fn EmptyLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
124 state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)))
125 }
126 #[inline]
127 #[allow(non_snake_case, unused_variables)]
128 pub fn BlockEnd(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
129 state.atomic(::pest::Atomicity::NonAtomic, |state| state.rule(Rule::BlockEnd, |state| state.sequence(|state| self::EmptyLine(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::EmptyLine(state))).or_else(|state| state.sequence(|state| self::EmptyLine(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::EOI(state)))).or_else(|state| self::EOI(state))))
130 }
131 #[inline]
132 #[allow(non_snake_case, unused_variables)]
133 pub fn RestOfLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
134 state.atomic(::pest::Atomicity::NonAtomic, |state| state.rule(Rule::RestOfLine, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.lookahead(false, |state| self::LINE_SEPARATOR(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::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))))))))))
135 }
136 #[inline]
137 #[allow(non_snake_case, unused_variables)]
138 pub fn Header(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
139 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Header, |state| state.sequence(|state| state.repeat(|state| self::WHITE_SPACE(state)).and_then(|state| state.sequence(|state| self::Sharp(state).and_then(|state| state.optional(|state| self::Sharp(state))).and_then(|state| state.optional(|state| self::Sharp(state))).and_then(|state| state.optional(|state| self::Sharp(state))).and_then(|state| state.optional(|state| self::Sharp(state))).and_then(|state| state.optional(|state| self::Sharp(state))))).and_then(|state| self::WHITE_SPACE(state)).and_then(|state| self::TextElement(state)).and_then(|state| state.repeat(|state| state.restore_on_err(|state| self::TextElement(state)))))))
140 }
141 #[inline]
142 #[allow(non_snake_case, unused_variables)]
143 pub fn TextBlock(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
144 state.rule(Rule::TextBlock, |state| state.sequence(|state| state.restore_on_err(|state| self::TextElement(state)).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state)))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::TextElement(state)).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state)))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::TextElement(state)).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state)))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)))))))))))))
145 }
146 #[inline]
147 #[allow(non_snake_case, unused_variables)]
148 pub fn TextElement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
149 state.restore_on_err(|state| self::StyleStatement(state)).or_else(|state| state.restore_on_err(|state| self::TildeStatement(state))).or_else(|state| state.restore_on_err(|state| self::MathStatement(state))).or_else(|state| state.restore_on_err(|state| self::RawStatement(state))).or_else(|state| self::CommandLine(state)).or_else(|state| self::CommandBlock(state)).or_else(|state| self::HTMLSelfClose(state)).or_else(|state| state.restore_on_err(|state| self::HTMLOpenClose(state))).or_else(|state| self::URL(state)).or_else(|state| self::Escaped(state)).or_else(|state| self::TextRest(state))
150 }
151 #[inline]
152 #[allow(non_snake_case, unused_variables)]
153 pub fn TextRest(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
154 state.rule(Rule::TextRest, |state| state.sequence(|state| state.sequence(|state| state.lookahead(false, |state| self::LINE_SEPARATOR(state).or_else(|state| self::Escape(state)).or_else(|state| self::Vertical(state)).or_else(|state| self::Tilde(state)).or_else(|state| self::Asterisk(state)).or_else(|state| self::Dollar(state)).or_else(|state| self::Accent(state)).or_else(|state| self::Colon(state)).or_else(|state| state.match_string("<"))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.lookahead(false, |state| self::LINE_SEPARATOR(state).or_else(|state| self::Escape(state)).or_else(|state| self::Vertical(state)).or_else(|state| self::Tilde(state)).or_else(|state| self::Asterisk(state)).or_else(|state| self::Dollar(state)).or_else(|state| self::Accent(state)).or_else(|state| self::Colon(state)).or_else(|state| state.match_string("<"))).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::LINE_SEPARATOR(state).or_else(|state| self::Escape(state)).or_else(|state| self::Vertical(state)).or_else(|state| self::Tilde(state)).or_else(|state| self::Asterisk(state)).or_else(|state| self::Dollar(state)).or_else(|state| self::Accent(state)).or_else(|state| self::Colon(state)).or_else(|state| state.match_string("<"))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state))))))))))))
155 }
156 #[inline]
157 #[allow(non_snake_case, unused_variables)]
158 pub fn URL(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
159 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::URL, |state| state.sequence(|state| state.sequence(|state| self::ASCII_ALPHA(state).and_then(|state| state.repeat(|state| self::ASCII_ALPHA(state)))).and_then(|state| state.match_string("://")).and_then(|state| state.sequence(|state| state.lookahead(false, |state| self::PATTERN_WHITE_SPACE(state)).and_then(|state| self::ANY(state)))).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::PATTERN_WHITE_SPACE(state)).and_then(|state| self::ANY(state))))))))
160 }
161 #[inline]
162 #[allow(non_snake_case, unused_variables)]
163 pub fn Code(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
164 state.rule(Rule::Code, |state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeLevel(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::CodeAction(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::SYMBOL(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::arguments(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::POP(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeMark(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeMark(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeMark(state))))
165 }
166 #[inline]
167 #[allow(non_snake_case, unused_variables)]
168 pub fn CodeAction(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
169 state.rule(Rule::CodeAction, |state| self::At(state).or_else(|state| self::Asterisk(state)).or_else(|state| self::Sharp(state)))
170 }
171 #[inline]
172 #[allow(non_snake_case, unused_variables)]
173 pub fn CodeLevel(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
174 state.rule(Rule::CodeLevel, |state| state.sequence(|state| state.sequence(|state| self::CodeMark(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeMark(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CodeMark(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.stack_push(|state| state.sequence(|state| state.optional(|state| self::CodeMark(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::CodeMark(state)))))))))))
175 }
176 #[inline]
177 #[allow(non_snake_case, unused_variables)]
178 pub fn CodeText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
179 state.rule(Rule::CodeText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::CodeMark(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(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| state.sequence(|state| self::CodeMark(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state))))))))))
180 }
181 #[inline]
182 #[allow(non_snake_case, unused_variables)]
183 pub fn CodeMark(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
184 state.rule(Rule::CodeMark, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::Accent(state)))
185 }
186 #[inline]
187 #[allow(non_snake_case, unused_variables)]
188 pub fn Table(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
189 state.rule(Rule::Table, |state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TableFirstLine(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::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TableRestLine(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::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TableRestLine(state)))))))))))))
190 }
191 #[inline]
192 #[allow(non_snake_case, unused_variables)]
193 pub fn TableFirstLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
194 state.rule(Rule::TableFirstLine, |state| state.sequence(|state| self::Vertical(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Vertical(state))).or_else(|state| self::Vertical(state)).or_else(|state| state.restore_on_err(|state| self::TextElement(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::Vertical(state))).or_else(|state| self::Vertical(state)).or_else(|state| state.restore_on_err(|state| self::TextElement(state))))))))))))
195 }
196 #[inline]
197 #[allow(non_snake_case, unused_variables)]
198 pub fn TableRestLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
199 state.rule(Rule::TableRestLine, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Vertical(state))).or_else(|state| self::Vertical(state)).or_else(|state| state.restore_on_err(|state| self::TextElement(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::Vertical(state))).or_else(|state| self::Vertical(state)).or_else(|state| state.restore_on_err(|state| self::TextElement(state))))))))))
200 }
201 #[inline]
202 #[allow(non_snake_case, unused_variables)]
203 pub fn List(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
204 state.rule(Rule::List, |state| state.sequence(|state| self::ListFirstLine(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::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ListRestLine(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::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ListRestLine(state)))))))))))))
205 }
206 #[inline]
207 #[allow(non_snake_case, unused_variables)]
208 pub fn ListFirstLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
209 state.rule(Rule::ListFirstLine, |state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ListMark(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.restore_on_err(|state| state.sequence(|state| self::Checkmark(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TextElement(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::TextElement(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::TextElement(state))))))))))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| self::TextElement(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::TextElement(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::TextElement(state)))))))))))))))
210 }
211 #[inline]
212 #[allow(non_snake_case, unused_variables)]
213 pub fn ListRestLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
214 state.rule(Rule::ListRestLine, |state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ListMark(state).or_else(|state| self::Vertical(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.restore_on_err(|state| state.sequence(|state| self::Checkmark(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TextElement(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::TextElement(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::TextElement(state))))))))))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| self::TextElement(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::TextElement(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::TextElement(state)))))))))))))))
215 }
216 #[inline]
217 #[allow(non_snake_case, unused_variables)]
218 pub fn ListMark(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
219 state.rule(Rule::ListMark, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::Minus(state).or_else(|state| self::Plus(state)).or_else(|state| self::QuoteMark(state)).or_else(|state| state.sequence(|state| self::Integer(state).and_then(|state| self::Dot(state)))).and_then(|state| self::WHITE_SPACE(state)).and_then(|state| state.repeat(|state| self::WHITE_SPACE(state))))))
220 }
221 #[inline]
222 #[allow(non_snake_case, unused_variables)]
223 pub fn Checkmark(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
224 state.rule(Rule::Checkmark, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.match_string("[").and_then(|state| self::ANY(state)).and_then(|state| state.match_string("]")))))
225 }
226 #[inline]
227 #[allow(non_snake_case, unused_variables)]
228 pub fn HorizontalRule(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
229 state.rule(Rule::HorizontalRule, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.repeat(|state| self::WHITE_SPACE(state)).and_then(|state| state.sequence(|state| self::Minus(state).and_then(|state| self::Minus(state)).and_then(|state| self::Minus(state)).and_then(|state| state.repeat(|state| self::Minus(state)))).or_else(|state| state.sequence(|state| self::Set(state).and_then(|state| self::Set(state)).and_then(|state| self::Set(state)).and_then(|state| state.repeat(|state| self::Set(state)))))))))
230 }
231 #[inline]
232 #[allow(non_snake_case, unused_variables)]
233 pub fn MathStatement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
234 state.restore_on_err(|state| self::Math(state)).or_else(|state| self::MathRest(state))
235 }
236 #[inline]
237 #[allow(non_snake_case, unused_variables)]
238 pub fn Math(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
239 state.rule(Rule::Math, |state| state.sequence(|state| self::MathLevel(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::MathText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::POP(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Dollar(state))))
240 }
241 #[inline]
242 #[allow(non_snake_case, unused_variables)]
243 pub fn MathLevel(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
244 state.rule(Rule::MathLevel, |state| state.sequence(|state| self::Dollar(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.stack_push(|state| state.sequence(|state| state.optional(|state| self::Dollar(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Dollar(state)))))))))))
245 }
246 #[inline]
247 #[allow(non_snake_case, unused_variables)]
248 pub fn MathText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
249 state.rule(Rule::MathText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Dollar(state))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Dollar(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(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::Dollar(state))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Dollar(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))))))))))
250 }
251 #[inline]
252 #[allow(non_snake_case, unused_variables)]
253 pub fn MathBlock(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
254 state.rule(Rule::MathBlock, |state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(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("$$"))))
255 }
256 #[inline]
257 #[allow(non_snake_case, unused_variables)]
258 pub fn MathRest(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
259 state.rule(Rule::MathRest, |state| state.sequence(|state| self::Dollar(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::Dollar(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Dollar(state))))))))))
260 }
261 #[inline]
262 #[allow(non_snake_case, unused_variables)]
263 pub fn RawStatement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
264 state.restore_on_err(|state| self::Raw(state)).or_else(|state| self::RawRest(state))
265 }
266 #[inline]
267 #[allow(non_snake_case, unused_variables)]
268 pub fn Raw(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
269 state.rule(Rule::Raw, |state| state.sequence(|state| self::RawLevel(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::RawText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::POP(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Accent(state))))
270 }
271 #[inline]
272 #[allow(non_snake_case, unused_variables)]
273 pub fn RawLevel(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
274 state.rule(Rule::RawLevel, |state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.stack_push(|state| state.sequence(|state| state.optional(|state| self::Accent(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Accent(state)))))))))))
275 }
276 #[inline]
277 #[allow(non_snake_case, unused_variables)]
278 pub fn RawText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
279 state.rule(Rule::RawText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Accent(state))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(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::Accent(state))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state)))))))))))
280 }
281 #[inline]
282 #[allow(non_snake_case, unused_variables)]
283 pub fn RawRest(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
284 state.rule(Rule::RawRest, |state| state.sequence(|state| self::Accent(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::Accent(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Accent(state))))))))))
285 }
286 #[inline]
287 #[allow(non_snake_case, unused_variables)]
288 pub fn StyleStatement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
289 state.restore_on_err(|state| self::Style(state)).or_else(|state| self::StyleRest(state))
290 }
291 #[inline]
292 #[allow(non_snake_case, unused_variables)]
293 pub fn Style(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
294 state.rule(Rule::Style, |state| state.sequence(|state| self::StyleLevel(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::StyleText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::POP(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Asterisk(state))))
295 }
296 #[inline]
297 #[allow(non_snake_case, unused_variables)]
298 pub fn StyleLevel(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
299 state.rule(Rule::StyleLevel, |state| state.sequence(|state| self::Asterisk(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.stack_push(|state| state.sequence(|state| state.optional(|state| self::Asterisk(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Asterisk(state)))))))))))
300 }
301 #[inline]
302 #[allow(non_snake_case, unused_variables)]
303 pub fn StyleText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
304 state.rule(Rule::StyleText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Asterisk(state))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Asterisk(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TextElement(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::Asterisk(state))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Asterisk(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TextElement(state))))))))))))
305 }
306 #[inline]
307 #[allow(non_snake_case, unused_variables)]
308 pub fn StyleRest(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
309 state.rule(Rule::StyleRest, |state| state.sequence(|state| self::Asterisk(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::Asterisk(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Asterisk(state))))))))))
310 }
311 #[inline]
312 #[allow(non_snake_case, unused_variables)]
313 pub fn TildeStatement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
314 state.restore_on_err(|state| self::TildeLine(state)).or_else(|state| self::TildeRest(state))
315 }
316 #[inline]
317 #[allow(non_snake_case, unused_variables)]
318 pub fn TildeLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
319 state.rule(Rule::TildeLine, |state| state.sequence(|state| self::TildeLevel(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TildeText(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::POP(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Tilde(state))))
320 }
321 #[inline]
322 #[allow(non_snake_case, unused_variables)]
323 pub fn TildeLevel(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
324 state.rule(Rule::TildeLevel, |state| state.sequence(|state| self::Tilde(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.stack_push(|state| state.sequence(|state| state.optional(|state| self::Tilde(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Tilde(state)))))))))))
325 }
326 #[inline]
327 #[allow(non_snake_case, unused_variables)]
328 pub fn TildeText(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
329 state.rule(Rule::TildeText, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::Tilde(state))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Tilde(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TextElement(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::Tilde(state))).or_else(|state| state.restore_on_err(|state| state.sequence(|state| state.lookahead(false, |state| state.sequence(|state| self::Tilde(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.lookahead(false, |state| state.sequence(|state| self::LINE_SEPARATOR(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::LINE_SEPARATOR(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::LINE_SEPARATOR(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::LINE_SEPARATOR(state))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::TextElement(state))))))))))))
330 }
331 #[inline]
332 #[allow(non_snake_case, unused_variables)]
333 pub fn TildeRest(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
334 state.rule(Rule::TildeRest, |state| state.sequence(|state| self::Tilde(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::Tilde(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::Tilde(state))))))))))
335 }
336 #[inline]
337 #[allow(non_snake_case, unused_variables)]
338 pub fn Template(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
339 state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::HTMLSelfClose(state).or_else(|state| state.restore_on_err(|state| self::HTMLOpenClose(state)))))
340 }
341 #[inline]
342 #[allow(non_snake_case, unused_variables)]
343 pub fn HTMLOpenClose(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
344 state.rule(Rule::HTMLOpenClose, |state| state.sequence(|state| self::HTMLOpen(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.restore_on_err(|state| self::TextElement(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.restore_on_err(|state| self::TextElement(state))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::HTMLClose(state))))
345 }
346 #[inline]
347 #[allow(non_snake_case, unused_variables)]
348 pub fn HTMLOpen(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
349 state.rule(Rule::HTMLOpen, |state| state.sequence(|state| state.match_string("<").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.stack_push(|state| self::SYMBOL(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::key_value(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::key_value(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state)))))))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string(">"))))
350 }
351 #[inline]
352 #[allow(non_snake_case, unused_variables)]
353 pub fn HTMLClose(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
354 state.rule(Rule::HTMLClose, |state| state.sequence(|state| state.match_string("</").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::PEEK(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string(">"))))
355 }
356 #[inline]
357 #[allow(non_snake_case, unused_variables)]
358 pub fn HTMLSelfClose(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
359 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::HTMLSelfClose, |state| state.sequence(|state| state.match_string("<").and_then(|state| state.repeat(|state| self::PATTERN_WHITE_SPACE(state))).and_then(|state| self::SYMBOL(state)).and_then(|state| state.repeat(|state| state.sequence(|state| state.repeat(|state| self::PATTERN_WHITE_SPACE(state)).and_then(|state| self::key_value(state)).and_then(|state| state.repeat(|state| self::PATTERN_WHITE_SPACE(state)))))).and_then(|state| state.match_string("/>")))))
360 }
361 #[inline]
362 #[allow(non_snake_case, unused_variables)]
363 pub fn Command(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
364 state.sequence(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::CommandLine(state).or_else(|state| self::CommandBlock(state))))
365 }
366 #[inline]
367 #[allow(non_snake_case, unused_variables)]
368 pub fn CommandLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
369 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::CommandLine, |state| state.sequence(|state| self::Escape(state).and_then(|state| self::SYMBOL(state)).and_then(|state| state.repeat(|state| self::WHITE_SPACE(state))).and_then(|state| self::Colon(state)).and_then(|state| self::RestOfLine(state)))))
370 }
371 #[inline]
372 #[allow(non_snake_case, unused_variables)]
373 pub fn CommandBlock(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
374 state.atomic(::pest::Atomicity::NonAtomic, |state| state.rule(Rule::CommandBlock, |state| state.sequence(|state| self::Escape(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::call(state).or_else(|state| state.sequence(|state| self::SYMBOL(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| self::argument_literal(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]"))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| self::argument_literal(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]"))))))))))))))))
375 }
376 #[inline]
377 #[allow(non_snake_case, unused_variables)]
378 pub fn call(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
379 state.sequence(|state| self::SYMBOL(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::arguments(state)))
380 }
381 #[inline]
382 #[allow(non_snake_case, unused_variables)]
383 pub fn arguments(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
384 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::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))).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.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::key_value(state).or_else(|state| self::argument(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::key_value(state).or_else(|state| self::argument(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))))).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| state.sequence(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::key_value(state).or_else(|state| self::argument(state))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state))))))))))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string(")"))))))
385 }
386 #[inline]
387 #[allow(non_snake_case, unused_variables)]
388 pub fn argument_literal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
389 state.rule(Rule::argument_literal, |state| state.sequence(|state| state.optional(|state| state.sequence(|state| state.lookahead(false, |state| state.match_string("]")).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| state.match_string("]")).and_then(|state| super::hidden::skip(state)).and_then(|state| self::ANY(state))))))))))
390 }
391 #[inline]
392 #[allow(non_snake_case, unused_variables)]
393 pub fn argument(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
394 state.rule(Rule::argument, |state| state.sequence(|state| self::value(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::Comma(state)))))
395 }
396 #[inline]
397 #[allow(non_snake_case, unused_variables)]
398 pub fn key_value(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
399 state.rule(Rule::key_value, |state| state.sequence(|state| self::key(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(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.sequence(|state| state.optional(|state| self::WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::WHITE_SPACE(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| self::PATTERN_WHITE_SPACE(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::PATTERN_WHITE_SPACE(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.optional(|state| self::Comma(state)))))
400 }
401 #[inline]
402 #[allow(non_snake_case, unused_variables)]
403 pub fn key(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
404 state.rule(Rule::key, |state| self::Integer(state).or_else(|state| self::String(state)).or_else(|state| self::SYMBOL(state)))
405 }
406 #[inline]
407 #[allow(non_snake_case, unused_variables)]
408 pub fn value(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
409 state.rule(Rule::value, |state| self::Integer(state).or_else(|state| self::String(state)).or_else(|state| self::Keywords(state)).or_else(|state| self::call(state)).or_else(|state| self::SYMBOL(state)))
410 }
411 #[inline]
412 #[allow(non_snake_case, unused_variables)]
413 pub fn Number(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
414 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Number, |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))))))
415 }
416 #[inline]
417 #[allow(non_snake_case, unused_variables)]
418 pub fn Decimal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
419 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))))))
420 }
421 #[inline]
422 #[allow(non_snake_case, unused_variables)]
423 pub fn DecimalBad(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
424 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)))))))
425 }
426 #[inline]
427 #[allow(non_snake_case, unused_variables)]
428 pub fn Integer(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
429 state.rule(Rule::Integer, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("0").or_else(|state| state.sequence(|state| self::ASCII_NONZERO_DIGIT(state).and_then(|state| state.repeat(|state| self::ASCII_DIGIT(state)))))))
430 }
431 #[inline]
432 #[allow(non_snake_case, unused_variables)]
433 pub fn Sign(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
434 state.rule(Rule::Sign, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::Plus(state).or_else(|state| self::Minus(state))))
435 }
436 #[inline]
437 #[allow(non_snake_case, unused_variables)]
438 pub fn String(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
439 state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::String, |state| state.sequence(|state| self::S1(state).and_then(|state| state.repeat(|state| state.sequence(|state| self::Escape(state).and_then(|state| self::Escape(state).or_else(|state| self::S1(state)))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| self::S1(state)).and_then(|state| self::ANY(state)))))).and_then(|state| self::S1(state))).or_else(|state| state.sequence(|state| self::S2(state).and_then(|state| state.repeat(|state| state.sequence(|state| self::Escape(state).and_then(|state| self::Escape(state).or_else(|state| self::S2(state)))).or_else(|state| state.sequence(|state| state.lookahead(false, |state| self::S2(state)).and_then(|state| self::ANY(state)))))).and_then(|state| self::S2(state))))))
440 }
441 #[inline]
442 #[allow(non_snake_case, unused_variables)]
443 pub fn S1(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
444 state.match_string("'")
445 }
446 #[inline]
447 #[allow(non_snake_case, unused_variables)]
448 pub fn S2(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
449 state.match_string("\"")
450 }
451 #[inline]
452 #[allow(non_snake_case, unused_variables)]
453 pub fn SYMBOL(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
454 state.rule(Rule::SYMBOL, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::XID_START(state).and_then(|state| state.repeat(|state| self::XID_CONTINUE(state)))).or_else(|state| state.sequence(|state| self::Underline(state).and_then(|state| self::XID_CONTINUE(state)).and_then(|state| state.repeat(|state| self::XID_CONTINUE(state)))))))
455 }
456 #[inline]
457 #[allow(non_snake_case, unused_variables)]
458 pub fn Escaped(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
459 state.rule(Rule::Escaped, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::Escape(state).and_then(|state| self::ANY(state)))))
460 }
461 #[inline]
462 #[allow(non_snake_case, unused_variables)]
463 pub fn Keywords(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
464 state.rule(Rule::Keywords, |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"))))
465 }
466 #[inline]
467 #[allow(non_snake_case, unused_variables)]
468 pub fn LINE_SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
469 state.rule(Rule::LINE_SEPARATOR, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::NEWLINE(state)))
470 }
471 #[inline]
472 #[allow(non_snake_case, unused_variables)]
473 pub fn WHITE_SPACE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
474 state.rule(Rule::WHITE_SPACE, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::SPACE_SEPARATOR(state).or_else(|state| state.match_string("\t"))))
475 }
476 #[inline]
477 #[allow(non_snake_case, unused_variables)]
478 pub fn PATTERN_WHITE_SPACE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
479 state.rule(Rule::PATTERN_WHITE_SPACE, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::NEWLINE(state).or_else(|state| self::WHITE_SPACE(state))))
480 }
481 #[inline]
482 #[allow(non_snake_case, unused_variables)]
483 pub fn Escape(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
484 state.rule(Rule::Escape, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("\\")))
485 }
486 #[inline]
487 #[allow(non_snake_case, unused_variables)]
488 pub fn At(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
489 state.rule(Rule::At, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("@")))
490 }
491 #[inline]
492 #[allow(non_snake_case, unused_variables)]
493 pub fn Sharp(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
494 state.rule(Rule::Sharp, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("#")))
495 }
496 #[inline]
497 #[allow(non_snake_case, unused_variables)]
498 pub fn Underline(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
499 state.rule(Rule::Underline, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("_")))
500 }
501 #[inline]
502 #[allow(non_snake_case, unused_variables)]
503 pub fn Asterisk(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
504 state.rule(Rule::Asterisk, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("*")))
505 }
506 #[inline]
507 #[allow(non_snake_case, unused_variables)]
508 pub fn Comma(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
509 state.rule(Rule::Comma, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(",")))
510 }
511 #[inline]
512 #[allow(non_snake_case, unused_variables)]
513 pub fn Dot(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
514 state.rule(Rule::Dot, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(".")))
515 }
516 #[inline]
517 #[allow(non_snake_case, unused_variables)]
518 pub fn Set(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
519 state.rule(Rule::Set, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("=")))
520 }
521 #[inline]
522 #[allow(non_snake_case, unused_variables)]
523 pub fn Colon(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
524 state.rule(Rule::Colon, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(":")))
525 }
526 #[inline]
527 #[allow(non_snake_case, unused_variables)]
528 pub fn Vertical(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
529 state.rule(Rule::Vertical, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("|")))
530 }
531 #[inline]
532 #[allow(non_snake_case, unused_variables)]
533 pub fn Plus(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
534 state.rule(Rule::Plus, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("+")))
535 }
536 #[inline]
537 #[allow(non_snake_case, unused_variables)]
538 pub fn Minus(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
539 state.rule(Rule::Minus, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("-")))
540 }
541 #[inline]
542 #[allow(non_snake_case, unused_variables)]
543 pub fn QuoteMark(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
544 state.rule(Rule::QuoteMark, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string(">")))
545 }
546 #[inline]
547 #[allow(non_snake_case, unused_variables)]
548 pub fn Accent(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
549 state.rule(Rule::Accent, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("`")))
550 }
551 #[inline]
552 #[allow(non_snake_case, unused_variables)]
553 pub fn Dollar(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
554 state.rule(Rule::Dollar, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("$")))
555 }
556 #[inline]
557 #[allow(non_snake_case, unused_variables)]
558 pub fn Tilde(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
559 state.rule(Rule::Tilde, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("~")))
560 }
561 #[inline]
562 #[allow(dead_code, non_snake_case, unused_variables)]
563 pub fn ANY(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
564 state.skip(1)
565 }
566 #[inline]
567 #[allow(dead_code, non_snake_case, unused_variables)]
568 pub fn EOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
569 state.rule(Rule::EOI, |state| state.end_of_input())
570 }
571 #[inline]
572 #[allow(dead_code, non_snake_case, unused_variables)]
573 pub fn SOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
574 state.start_of_input()
575 }
576 #[inline]
577 #[allow(dead_code, non_snake_case, unused_variables)]
578 pub fn PEEK(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
579 state.stack_peek()
580 }
581 #[inline]
582 #[allow(dead_code, non_snake_case, unused_variables)]
583 pub fn POP(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
584 state.stack_pop()
585 }
586 #[inline]
587 #[allow(dead_code, non_snake_case, unused_variables)]
588 pub fn ASCII_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
589 state.match_range('0'..'9')
590 }
591 #[inline]
592 #[allow(dead_code, non_snake_case, unused_variables)]
593 pub fn ASCII_NONZERO_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
594 state.match_range('1'..'9')
595 }
596 #[inline]
597 #[allow(dead_code, non_snake_case, unused_variables)]
598 pub fn ASCII_ALPHA(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
599 state.match_range('a'..'z').or_else(|state| state.match_range('A'..'Z'))
600 }
601 #[inline]
602 #[allow(dead_code, non_snake_case, unused_variables)]
603 pub fn NEWLINE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
604 state.match_string("\n").or_else(|state| state.match_string("\r\n")).or_else(|state| state.match_string("\r"))
605 }
606 #[inline]
607 #[allow(dead_code, non_snake_case, unused_variables)]
608 fn XID_CONTINUE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
609 state.match_char_by(::pest::unicode::XID_CONTINUE)
610 }
611 #[inline]
612 #[allow(dead_code, non_snake_case, unused_variables)]
613 fn XID_START(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
614 state.match_char_by(::pest::unicode::XID_START)
615 }
616 #[inline]
617 #[allow(dead_code, non_snake_case, unused_variables)]
618 fn SPACE_SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
619 state.match_char_by(::pest::unicode::SPACE_SEPARATOR)
620 }
621 }
622 pub use self::visible::*;
623 }
624 ::pest::state(input, |state| match rule {
625 Rule::program => rules::program(state),
626 Rule::statement => rules::statement(state),
627 Rule::EmptyLine => rules::EmptyLine(state),
628 Rule::BlockEnd => rules::BlockEnd(state),
629 Rule::RestOfLine => rules::RestOfLine(state),
630 Rule::Header => rules::Header(state),
631 Rule::TextBlock => rules::TextBlock(state),
632 Rule::TextElement => rules::TextElement(state),
633 Rule::TextRest => rules::TextRest(state),
634 Rule::URL => rules::URL(state),
635 Rule::Code => rules::Code(state),
636 Rule::CodeAction => rules::CodeAction(state),
637 Rule::CodeLevel => rules::CodeLevel(state),
638 Rule::CodeText => rules::CodeText(state),
639 Rule::CodeMark => rules::CodeMark(state),
640 Rule::Table => rules::Table(state),
641 Rule::TableFirstLine => rules::TableFirstLine(state),
642 Rule::TableRestLine => rules::TableRestLine(state),
643 Rule::List => rules::List(state),
644 Rule::ListFirstLine => rules::ListFirstLine(state),
645 Rule::ListRestLine => rules::ListRestLine(state),
646 Rule::ListMark => rules::ListMark(state),
647 Rule::Checkmark => rules::Checkmark(state),
648 Rule::HorizontalRule => rules::HorizontalRule(state),
649 Rule::MathStatement => rules::MathStatement(state),
650 Rule::Math => rules::Math(state),
651 Rule::MathLevel => rules::MathLevel(state),
652 Rule::MathText => rules::MathText(state),
653 Rule::MathBlock => rules::MathBlock(state),
654 Rule::MathRest => rules::MathRest(state),
655 Rule::RawStatement => rules::RawStatement(state),
656 Rule::Raw => rules::Raw(state),
657 Rule::RawLevel => rules::RawLevel(state),
658 Rule::RawText => rules::RawText(state),
659 Rule::RawRest => rules::RawRest(state),
660 Rule::StyleStatement => rules::StyleStatement(state),
661 Rule::Style => rules::Style(state),
662 Rule::StyleLevel => rules::StyleLevel(state),
663 Rule::StyleText => rules::StyleText(state),
664 Rule::StyleRest => rules::StyleRest(state),
665 Rule::TildeStatement => rules::TildeStatement(state),
666 Rule::TildeLine => rules::TildeLine(state),
667 Rule::TildeLevel => rules::TildeLevel(state),
668 Rule::TildeText => rules::TildeText(state),
669 Rule::TildeRest => rules::TildeRest(state),
670 Rule::Template => rules::Template(state),
671 Rule::HTMLOpenClose => rules::HTMLOpenClose(state),
672 Rule::HTMLOpen => rules::HTMLOpen(state),
673 Rule::HTMLClose => rules::HTMLClose(state),
674 Rule::HTMLSelfClose => rules::HTMLSelfClose(state),
675 Rule::Command => rules::Command(state),
676 Rule::CommandLine => rules::CommandLine(state),
677 Rule::CommandBlock => rules::CommandBlock(state),
678 Rule::call => rules::call(state),
679 Rule::arguments => rules::arguments(state),
680 Rule::argument_literal => rules::argument_literal(state),
681 Rule::argument => rules::argument(state),
682 Rule::key_value => rules::key_value(state),
683 Rule::key => rules::key(state),
684 Rule::value => rules::value(state),
685 Rule::Number => rules::Number(state),
686 Rule::Decimal => rules::Decimal(state),
687 Rule::DecimalBad => rules::DecimalBad(state),
688 Rule::Integer => rules::Integer(state),
689 Rule::Sign => rules::Sign(state),
690 Rule::String => rules::String(state),
691 Rule::S1 => rules::S1(state),
692 Rule::S2 => rules::S2(state),
693 Rule::SYMBOL => rules::SYMBOL(state),
694 Rule::Escaped => rules::Escaped(state),
695 Rule::Keywords => rules::Keywords(state),
696 Rule::LINE_SEPARATOR => rules::LINE_SEPARATOR(state),
697 Rule::WHITE_SPACE => rules::WHITE_SPACE(state),
698 Rule::PATTERN_WHITE_SPACE => rules::PATTERN_WHITE_SPACE(state),
699 Rule::Escape => rules::Escape(state),
700 Rule::At => rules::At(state),
701 Rule::Sharp => rules::Sharp(state),
702 Rule::Underline => rules::Underline(state),
703 Rule::Asterisk => rules::Asterisk(state),
704 Rule::Comma => rules::Comma(state),
705 Rule::Dot => rules::Dot(state),
706 Rule::Set => rules::Set(state),
707 Rule::Colon => rules::Colon(state),
708 Rule::Vertical => rules::Vertical(state),
709 Rule::Plus => rules::Plus(state),
710 Rule::Minus => rules::Minus(state),
711 Rule::QuoteMark => rules::QuoteMark(state),
712 Rule::Accent => rules::Accent(state),
713 Rule::Dollar => rules::Dollar(state),
714 Rule::Tilde => rules::Tilde(state),
715 Rule::EOI => rules::EOI(state),
716 })
717 }
718}