pub struct JssParser;
#[allow(dead_code, non_camel_case_types)]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum Rule {
EOI,
program,
statement,
EmptyLine,
schema_statement,
define_statement,
_define,
property_statement,
_property,
DOT,
block,
attitude_statement,
key,
REQUIRED,
COLON,
SET,
data,
object,
object_item,
array,
Special,
Cite,
_number,
Float,
Integer,
Byte,
SignedNumber,
Decimal,
DecimalBad,
UNSIGNED,
Exponent,
Sign,
_string,
STRING_INLINE,
ESCAPED,
S1,
S2,
NS1,
NS2,
SYMBOL,
URL,
COMMENT,
WHITESPACE,
DOCUMENTATION,
LineComment,
MultiLineComment,
SEPARATOR,
}
#[allow(clippy::all)]
impl ::pest::Parser<Rule> for JssParser {
fn parse<'i>(rule: Rule, input: &'i str) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> {
mod rules {
pub mod hidden {
use super::super::Rule;
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn skip(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
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) }
}
}
pub mod visible {
use super::super::Rule;
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn program(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.sequence(|state| self::SOI(state).and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::statement(state).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::statement(state)))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| self::EOI(state)))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
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| self::DOCUMENTATION(state)).or_else(|state| self::schema_statement(state)).or_else(|state| self::property_statement(state)).or_else(|state| self::define_statement(state))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn EmptyLine(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
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)))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn schema_statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::schema_statement, |state| state.sequence(|state| state.match_string("schema").and_then(|state| super::hidden::skip(state)).and_then(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::COLON(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::block(state))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn define_statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::define_statement, |state| state.sequence(|state| self::_define(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::COLON(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::block(state))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn _define(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string("define").or_else(|state| state.match_string("def"))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn property_statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::property_statement, |state| state.sequence(|state| self::_property(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::SYMBOL(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::COLON(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::block(state))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn _property(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string("property").or_else(|state| state.match_string("properties")).or_else(|state| state.match_string("prop")).or_else(|state| self::DOT(state))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn DOT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string(".")
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn block(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::block, |state| state.sequence(|state| self::key(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::object(state))).or_else(|state| self::key(state)).or_else(|state| self::object(state)))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn attitude_statement(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::attitude_statement, |state| state.sequence(|state| self::key(state).and_then(|state| super::hidden::skip(state)).and_then(|state| self::SET(state)).and_then(|state| super::hidden::skip(state)).and_then(|state| self::data(state))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn key(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::key, |state| self::SYMBOL(state).or_else(|state| self::STRING_INLINE(state)))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn REQUIRED(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::REQUIRED, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("!")))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn COLON(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string(":")
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn SET(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string(":").or_else(|state| state.match_string("="))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn data(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::NonAtomic, |state| state.rule(Rule::data, |state| self::URL(state).or_else(|state| self::Special(state)).or_else(|state| self::_number(state)).or_else(|state| self::_string(state)).or_else(|state| self::array(state)).or_else(|state| self::object(state))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn object(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::object, |state| state.sequence(|state| state.match_string("{").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::object_item(state).or_else(|state| self::SEPARATOR(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::object_item(state).or_else(|state| self::SEPARATOR(state))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("}"))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn object_item(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
self::property_statement(state).or_else(|state| self::attitude_statement(state)).or_else(|state| self::DOCUMENTATION(state))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn array(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::array, |state| state.sequence(|state| state.match_string("[").and_then(|state| super::hidden::skip(state)).and_then(|state| state.sequence(|state| state.optional(|state| self::data(state).or_else(|state| self::SEPARATOR(state)).and_then(|state| state.repeat(|state| state.sequence(|state| super::hidden::skip(state).and_then(|state| self::data(state).or_else(|state| self::SEPARATOR(state))))))))).and_then(|state| super::hidden::skip(state)).and_then(|state| state.match_string("]"))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Special(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
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"))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Cite(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Cite, |state| state.sequence(|state| state.match_string("$").and_then(|state| state.match_string("namespace")))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn _number(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
self::Float(state).or_else(|state| self::Integer(state)).or_else(|state| self::Byte(state))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Float(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::Float, |state| state.atomic(::pest::Atomicity::Atomic, |state| self::Exponent(state).or_else(|state| self::SignedNumber(state))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Integer(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::Integer, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.optional(|state| self::Sign(state)).and_then(|state| self::UNSIGNED(state)))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Byte(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::Byte, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.match_string("0").and_then(|state| self::ASCII_ALPHA(state)).and_then(|state| self::ASCII_ALPHANUMERIC(state).or_else(|state| state.match_string("_")).or_else(|state| state.match_string("-"))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn SignedNumber(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
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::UNSIGNED(state))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Decimal(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::Decimal, |state| state.sequence(|state| self::UNSIGNED(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))))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn DecimalBad(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::DecimalBad, |state| state.sequence(|state| self::UNSIGNED(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)))))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn UNSIGNED(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::UNSIGNED, |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))))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Exponent(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
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))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn Sign(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::Sign, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("+").or_else(|state| state.match_string("-"))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn _string(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
self::STRING_INLINE(state)
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn STRING_INLINE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::CompoundAtomic, |state| state.rule(Rule::STRING_INLINE, |state| state.sequence(|state| self::S1(state).and_then(|state| state.repeat(|state| self::ESCAPED(state).or_else(|state| self::NS1(state)))).and_then(|state| self::S1(state))).or_else(|state| state.sequence(|state| self::S2(state).and_then(|state| state.repeat(|state| self::ESCAPED(state).or_else(|state| self::NS2(state)))).and_then(|state| self::S2(state))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn ESCAPED(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::ESCAPED, |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))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn S1(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string("'")
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn S2(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string("\"")
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn NS1(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::NS1, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.lookahead(false, |state| self::S1(state)).and_then(|state| self::ANY(state)))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn NS2(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::NS2, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.lookahead(false, |state| self::S2(state)).and_then(|state| self::ANY(state)))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn SYMBOL(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::SYMBOL, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| self::XID_START(state).or_else(|state| state.match_string("_")).or_else(|state| state.match_string("$")).and_then(|state| state.repeat(|state| self::XID_CONTINUE(state).or_else(|state| state.match_string("_")).or_else(|state| state.match_string("-")))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn URL(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::URL, |state| state.atomic(::pest::Atomicity::Atomic, |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.repeat(|state| self::XID_CONTINUE(state).or_else(|state| state.match_string("_")).or_else(|state| state.match_string("-")).or_else(|state| state.match_string("/")).or_else(|state| state.match_string(".")))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn COMMENT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::Atomic, |state| self::MultiLineComment(state).or_else(|state| self::LineComment(state)))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn WHITESPACE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.atomic(::pest::Atomicity::Atomic, |state| self::NEWLINE(state).or_else(|state| self::SPACE_SEPARATOR(state)).or_else(|state| state.match_string("\t")))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn DOCUMENTATION(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::DOCUMENTATION, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.match_string("///").and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state)).and_then(|state| self::ANY(state))))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn LineComment(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::LineComment, |state| state.atomic(::pest::Atomicity::Atomic, |state| state.sequence(|state| state.lookahead(false, |state| state.match_string("///")).and_then(|state| state.match_string("//")).and_then(|state| state.repeat(|state| state.sequence(|state| state.lookahead(false, |state| self::NEWLINE(state)).and_then(|state| self::ANY(state))))))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn MultiLineComment(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::MultiLineComment, |state| state.atomic(::pest::Atomicity::Atomic, |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("*/")))))
}
#[inline]
#[allow(non_snake_case, unused_variables)]
pub fn SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string(",").or_else(|state| state.match_string(";"))
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn ANY(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.skip(1)
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn EOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::EOI, |state| state.end_of_input())
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn SOI(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.start_of_input()
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn ASCII_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_range('0'..'9')
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn ASCII_HEX_DIGIT(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_range('0'..'9').or_else(|state| state.match_range('a'..'f')).or_else(|state| state.match_range('A'..'F'))
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn ASCII_ALPHA(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_range('a'..'z').or_else(|state| state.match_range('A'..'Z'))
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn ASCII_ALPHANUMERIC(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_range('a'..'z').or_else(|state| state.match_range('A'..'Z')).or_else(|state| state.match_range('0'..'9'))
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
pub fn NEWLINE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_string("\n").or_else(|state| state.match_string("\r\n")).or_else(|state| state.match_string("\r"))
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
fn XID_CONTINUE(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_char_by(::pest::unicode::XID_CONTINUE)
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
fn XID_START(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_char_by(::pest::unicode::XID_START)
}
#[inline]
#[allow(dead_code, non_snake_case, unused_variables)]
fn SPACE_SEPARATOR(state: Box<::pest::ParserState<Rule>>) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.match_char_by(::pest::unicode::SPACE_SEPARATOR)
}
}
pub use self::visible::*;
}
::pest::state(input, |state| match rule {
Rule::program => rules::program(state),
Rule::statement => rules::statement(state),
Rule::EmptyLine => rules::EmptyLine(state),
Rule::schema_statement => rules::schema_statement(state),
Rule::define_statement => rules::define_statement(state),
Rule::_define => rules::_define(state),
Rule::property_statement => rules::property_statement(state),
Rule::_property => rules::_property(state),
Rule::DOT => rules::DOT(state),
Rule::block => rules::block(state),
Rule::attitude_statement => rules::attitude_statement(state),
Rule::key => rules::key(state),
Rule::REQUIRED => rules::REQUIRED(state),
Rule::COLON => rules::COLON(state),
Rule::SET => rules::SET(state),
Rule::data => rules::data(state),
Rule::object => rules::object(state),
Rule::object_item => rules::object_item(state),
Rule::array => rules::array(state),
Rule::Special => rules::Special(state),
Rule::Cite => rules::Cite(state),
Rule::_number => rules::_number(state),
Rule::Float => rules::Float(state),
Rule::Integer => rules::Integer(state),
Rule::Byte => rules::Byte(state),
Rule::SignedNumber => rules::SignedNumber(state),
Rule::Decimal => rules::Decimal(state),
Rule::DecimalBad => rules::DecimalBad(state),
Rule::UNSIGNED => rules::UNSIGNED(state),
Rule::Exponent => rules::Exponent(state),
Rule::Sign => rules::Sign(state),
Rule::_string => rules::_string(state),
Rule::STRING_INLINE => rules::STRING_INLINE(state),
Rule::ESCAPED => rules::ESCAPED(state),
Rule::S1 => rules::S1(state),
Rule::S2 => rules::S2(state),
Rule::NS1 => rules::NS1(state),
Rule::NS2 => rules::NS2(state),
Rule::SYMBOL => rules::SYMBOL(state),
Rule::URL => rules::URL(state),
Rule::COMMENT => rules::COMMENT(state),
Rule::WHITESPACE => rules::WHITESPACE(state),
Rule::DOCUMENTATION => rules::DOCUMENTATION(state),
Rule::LineComment => rules::LineComment(state),
Rule::MultiLineComment => rules::MultiLineComment(state),
Rule::SEPARATOR => rules::SEPARATOR(state),
Rule::EOI => rules::EOI(state),
})
}
}