( )⚙ D7581 rust-configparser: regenerate parser.rs

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7581

rust-configparser: regenerate parser.rs
AbandonedPublic

Authored by indygreg on Dec 7 2019, 5:56 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

I couldn't get generate_parser.py to work without modification
because my version of cargo-expand didn't accept a --release
argument. I assume --release isn't supported in the newest version
of this tool.

Once I did get it to run, the auto-generated file wasn't formatted
at all and was literally just a wall of unreadable tokens. It appears
we were disabling rustfmt as part of generating the file. So I
removed that and got a working generation of parser.rs!

The changes to parser.rs reflect the new auto-generated content.

I also snuck in the addition of a rustfmt::skip attribute. This
is needed to avoid rustfmt complaining about the content of this
file.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Dec 7 2019, 5:56 PM
indygreg abandoned this revision.Dec 7 2019, 10:04 PM

The autogenerated parser.rs and its Python script to generate it have been removed in the latest version of this series.

Revision Contents
Changeset List

Diff 18542

rust/hg-core/src/configparser/generate_parser.py

os.mkdir(os.path.join(tmp_root, "src")) os.mkdir(os.path.join(tmp_root, "src"))
with open(os.path.join(tmp_root, "src", "spec.pest"), "wb") as f: with open(os.path.join(tmp_root, "src", "spec.pest"), "wb") as f:
f.write(pest) f.write(pest)
# Create a minimal project which is used to expand ConfigParser # Create a minimal project which is used to expand ConfigParser
with open(os.path.join(tmp_root, "src", "lib.rs"), "w") as f: with open(os.path.join(tmp_root, "src", "lib.rs"), "w") as f:
f.write( f.write(
""" """
use pest_derive::*;
#[derive(Parser)] #[derive(Parser)]
#[grammar = "spec.pest"] #[grammar = "spec.pest"]
pub(crate) struct ConfigParser; pub(crate) struct ConfigParser;
""" """
) )
# Run cargo-expand # Run cargo-expand
env = os.environ.copy() env = os.environ.copy()
env["RUSTFMT"] = "false"
expanded = subprocess.check_output( expanded = subprocess.check_output(
["cargo-expand", "--release"], env=env, cwd=tmp_root ["cargo-expand"], env=env, cwd=tmp_root
) )
expanded = expanded.decode("utf-8") expanded = expanded.decode("utf-8")
# Keep only interesting parts # Keep only interesting parts
rule_struct = re.search( rule_struct = re.search(
"^pub enum Rule [^}]*^\}", expanded, re.S + re.M "^pub enum Rule [^}]*^\}", expanded, re.S + re.M
).group(0) ).group(0)
parser_impl = re.search( parser_impl = re.search(
"^impl ::pest::Parser<Rule> for ConfigParser .*^\}", "^impl ::pest::Parser<Rule> for ConfigParser .*^\}",
expanded, expanded,
re.S + re.M, re.S + re.M,
).group(0) ).group(0)
code = f""" code = f"""
#[allow(dead_code, non_camel_case_types)] #[allow(dead_code, non_camel_case_types)]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)] #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
{rule_struct} {rule_struct}
pub(crate) struct ConfigParser; pub(crate) struct ConfigParser;
#[rustfmt::skip]
{parser_impl} {parser_impl}
""" """
return code return code
def write_generated_parser(): def write_generated_parser():
spec_pest_path = os.path.join( spec_pest_path = os.path.join(

rust/hg-core/src/configparser/parser.rs

// Copyright 2018 Facebook, Inc.
//
// This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version.
// Generated by generate_parser.py. Do not edit manually. Instead, edit // Generated by generate_parser.py. Do not edit manually. Instead, edit
// spec.pest, then run generate_parser.py (require cargo-expand). // spec.pest, then run generate_parser.py (require cargo-expand).
// //
// This file should really be just 3 lines: // This file should really be just 3 lines:
// //
// #[derive(Parser)] // #[derive(Parser)]
// #[grammar = "spec.pest"] // #[grammar = "spec.pest"]
include, include,
unset, unset,
compound, compound,
file, file,
} }
pub(crate) struct ConfigParser; pub(crate) struct ConfigParser;
#[rustfmt::skip]
impl ::pest::Parser<Rule> for ConfigParser { impl ::pest::Parser<Rule> for ConfigParser {
fn parse<'i>(rule: Rule, input: &'i str) fn parse<'i>(
-> rule: Rule,
::std::result::Result<::pest::iterators::Pairs<'i, Rule>, input: &'i str,
::pest::error::Error<Rule>> { ) -> ::std::result::Result<::pest::iterators::Pairs<'i, Rule>, ::pest::error::Error<Rule>> {
mod rules { mod rules {
pub mod hidden { pub mod hidden {
use super::super::Rule; use super::super::Rule;
#[inline] #[inline]
#[allow(dead_code, non_snake_case, unused_variables)] #[allow(dead_code, non_snake_case, unused_variables)]
pub fn skip(state: Box<::pest::ParserState<Rule>>) pub fn skip(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
Ok(state) Ok(state)
} }
} }
pub mod visible { pub mod visible {
use super::super::Rule; use super::super::Rule;
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn new_line(state: Box<::pest::ParserState<Rule>>) pub fn new_line(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::new_line, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::new_line, |state| {
{ state
state.match_string("\n").or_else(|state| .match_string("\n")
{ .or_else(|state| state.match_string("\r\n"))
state.match_string("\r\n")
})
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn space(state: Box<::pest::ParserState<Rule>>) pub fn space(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::space, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::space, |state| {
{ state
state.match_string(" ").or_else(|state| .match_string(" ")
{ .or_else(|state| state.match_string("\t"))
state.match_string("\t")
})
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn comment_start(state: Box<::pest::ParserState<Rule>>) pub fn comment_start(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::comment_start, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::comment_start, |state| {
{ state
state.match_string("#").or_else(|state| .match_string("#")
{ .or_else(|state| state.match_string(";"))
state.match_string(";")
})
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn line(state: Box<::pest::ParserState<Rule>>) pub fn line(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::line, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::line, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| {
state.atomic(::pest::Atomicity::Atomic, state.repeat(|state| {
|state| state.sequence(|state| {
{ state
state.repeat(|state| .lookahead(false, |state| self::new_line(state))
{ .and_then(|state| self::ANY(state))
state.sequence(|state|
{
state.lookahead(false,
|state|
{
self::new_line(state)
}).and_then(|state|
{
self::ANY(state)
})
}) })
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn value(state: Box<::pest::ParserState<Rule>>) pub fn value(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.atomic(::pest::Atomicity::CompoundAtomic, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.atomic(::pest::Atomicity::CompoundAtomic, |state| {
{ state.rule(Rule::value, |state| {
state.rule(Rule::value, state.sequence(|state| {
|state| self::line(state).and_then(|state| {
{ state.repeat(|state| {
state.sequence(|state| state.sequence(|state| {
{ self::new_line(state)
self::line(state).and_then(|state| .and_then(|state| {
{ state.sequence(|state| {
state.repeat(|state| self::space(state).and_then(|state| {
{ state.repeat(|state| self::space(state))
state.sequence(|state|
{
self::new_line(state).and_then(|state|
{
state.sequence(|state|
{
self::space(state).and_then(|state|
{
state.repeat(|state|
{
self::space(state)
})
}) })
}) })
}).and_then(|state|
{
self::line(state)
}) })
.and_then(|state| self::line(state))
}) })
}) })
}) })
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn equal_sign(state: Box<::pest::ParserState<Rule>>) pub fn equal_sign(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::equal_sign, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::equal_sign, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| {
state.atomic(::pest::Atomicity::Atomic, state.sequence(|state| {
|state| state
{ .match_string("=")
state.sequence(|state| .and_then(|state| state.repeat(|state| self::space(state)))
{
state.match_string("=").and_then(|state|
{
state.repeat(|state|
{
self::space(state)
})
})
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn config_name(state: Box<::pest::ParserState<Rule>>) pub fn config_name(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::config_name, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::config_name, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| {
state.atomic(::pest::Atomicity::Atomic, state.sequence(|state| {
|state| state
{ .lookahead(false, |state| {
state.sequence(|state| state
{ .match_string("[")
state.lookahead(false, .or_else(|state| state.match_string("="))
|state| .or_else(|state| state.match_string("%"))
{ .or_else(|state| self::space(state))
state.match_string("[").or_else(|state| .or_else(|state| self::comment_start(state))
{ .or_else(|state| self::new_line(state))
state.match_string("=")
}).or_else(|state|
{
state.match_string("%")
}).or_else(|state|
{
self::space(state)
}).or_else(|state|
{
self::comment_start(state)
}).or_else(|state|
{
self::new_line(state)
})
}).and_then(|state|
{
self::ANY(state)
}).and_then(|state|
{
state.repeat(|state|
{
state.sequence(|state|
{
state.lookahead(false,
|state|
{
state.match_string("=").or_else(|state|
{
self::new_line(state)
}) })
}).and_then(|state| .and_then(|state| self::ANY(state))
{ .and_then(|state| {
self::ANY(state) state.repeat(|state| {
state.sequence(|state| {
state
.lookahead(false, |state| {
state
.match_string("=")
.or_else(|state| self::new_line(state))
}) })
.and_then(|state| self::ANY(state))
}) })
}) })
}) })
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn config_item(state: Box<::pest::ParserState<Rule>>) pub fn config_item(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.atomic(::pest::Atomicity::CompoundAtomic, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.atomic(::pest::Atomicity::CompoundAtomic, |state| {
{ state.rule(Rule::config_item, |state| {
state.rule(Rule::config_item, state.sequence(|state| {
|state| self::config_name(state)
{ .and_then(|state| self::equal_sign(state))
state.sequence(|state| .and_then(|state| self::value(state))
{
self::config_name(state).and_then(|state|
{
self::equal_sign(state)
}).and_then(|state|
{
self::value(state)
})
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn left_bracket(state: Box<::pest::ParserState<Rule>>) pub fn left_bracket(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::left_bracket, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::left_bracket, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("["))
state.atomic(::pest::Atomicity::Atomic,
|state|
{
state.match_string("[")
})
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn right_bracket(state: Box<::pest::ParserState<Rule>>) pub fn right_bracket(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::right_bracket, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::right_bracket, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| state.match_string("]"))
state.atomic(::pest::Atomicity::Atomic,
|state|
{
state.match_string("]")
})
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn section_name(state: Box<::pest::ParserState<Rule>>) pub fn section_name(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::section_name, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::section_name, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| {
state.atomic(::pest::Atomicity::Atomic, state.sequence(|state| {
|state| state
{ .sequence(|state| {
state.sequence(|state| state
{ .lookahead(false, |state| {
state.sequence(|state| state
{ .match_string("]")
state.lookahead(false, .or_else(|state| self::new_line(state))
|state|
{
state.match_string("]").or_else(|state|
{
self::new_line(state)
}) })
}).and_then(|state| .and_then(|state| self::ANY(state))
{
self::ANY(state)
})
}).and_then(|state|
{
state.repeat(|state|
{
state.sequence(|state|
{
state.lookahead(false,
|state|
{
state.match_string("]").or_else(|state|
{
self::new_line(state)
}) })
}).and_then(|state| .and_then(|state| {
{ state.repeat(|state| {
self::ANY(state) state.sequence(|state| {
state
.lookahead(false, |state| {
state
.match_string("]")
.or_else(|state| self::new_line(state))
}) })
.and_then(|state| self::ANY(state))
}) })
}) })
}) })
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn section(state: Box<::pest::ParserState<Rule>>) pub fn section(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.atomic(::pest::Atomicity::CompoundAtomic, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.atomic(::pest::Atomicity::CompoundAtomic, |state| {
{ state.rule(Rule::section, |state| {
state.rule(Rule::section, state.sequence(|state| {
|state| self::left_bracket(state)
{ .and_then(|state| self::section_name(state))
state.sequence(|state| .and_then(|state| self::right_bracket(state))
{ .and_then(|state| state.repeat(|state| self::space(state)))
self::left_bracket(state).and_then(|state|
{
self::section_name(state)
}).and_then(|state|
{
self::right_bracket(state)
}).and_then(|state|
{
state.repeat(|state|
{
self::space(state)
})
})
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn comment_line(state: Box<::pest::ParserState<Rule>>) pub fn comment_line(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::comment_line, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::comment_line, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| {
state.atomic(::pest::Atomicity::Atomic, state.sequence(|state| {
|state| self::comment_start(state).and_then(|state| self::line(state))
{
state.sequence(|state|
{
self::comment_start(state).and_then(|state|
{
self::line(state)
})
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn blank_line(state: Box<::pest::ParserState<Rule>>) pub fn blank_line(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::blank_line, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.rule(Rule::blank_line, |state| {
{ state.atomic(::pest::Atomicity::Atomic, |state| {
state.atomic(::pest::Atomicity::Atomic, state.repeat(|state| self::space(state))
|state|
{
state.repeat(|state|
{
self::space(state)
})
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn directive(state: Box<::pest::ParserState<Rule>>) pub fn directive(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.atomic(::pest::Atomicity::CompoundAtomic, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.atomic(::pest::Atomicity::CompoundAtomic, |state| {
{ state.rule(Rule::directive, |state| {
state.rule(Rule::directive, state.sequence(|state| {
|state| state.match_string("%").and_then(|state| {
{ self::include(state).or_else(|state| self::unset(state))
state.sequence(|state|
{
state.match_string("%").and_then(|state|
{
self::include(state).or_else(|state|
{
self::unset(state)
})
}) })
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn include(state: Box<::pest::ParserState<Rule>>) pub fn include(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.atomic(::pest::Atomicity::CompoundAtomic, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.atomic(::pest::Atomicity::CompoundAtomic, |state| {
{ state.rule(Rule::include, |state| {
state.rule(Rule::include, state.sequence(|state| {
|state| state
{ .match_string("include")
state.sequence(|state| .and_then(|state| {
{ state.sequence(|state| {
state.match_string("include").and_then(|state| self::space(state).and_then(|state| {
{ state.repeat(|state| self::space(state))
state.sequence(|state|
{
self::space(state).and_then(|state|
{
state.repeat(|state|
{
self::space(state)
}) })
}) })
}) })
}).and_then(|state| .and_then(|state| self::line(state))
{
self::line(state)
})
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn unset(state: Box<::pest::ParserState<Rule>>) pub fn unset(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.atomic(::pest::Atomicity::CompoundAtomic, ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
|state| state.atomic(::pest::Atomicity::CompoundAtomic, |state| {
{ state.rule(Rule::unset, |state| {
state.rule(Rule::unset, state.sequence(|state| {
|state| state
{ .match_string("unset")
state.sequence(|state| .and_then(|state| {
{ state.sequence(|state| {
state.match_string("unset").and_then(|state| self::space(state).and_then(|state| {
{ state.repeat(|state| self::space(state))
state.sequence(|state|
{
self::space(state).and_then(|state|
{
state.repeat(|state|
{
self::space(state)
})
}) })
}) })
}).and_then(|state|
{
self::config_name(state)
}).and_then(|state|
{
state.repeat(|state|
{
self::space(state)
})
}) })
.and_then(|state| self::config_name(state))
.and_then(|state| state.repeat(|state| self::space(state)))
}) })
}) })
}) })
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn compound(state: Box<::pest::ParserState<Rule>>) pub fn compound(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
self::config_item(state).or_else(|state| ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
{ self::config_item(state)
self::section(state) .or_else(|state| self::section(state))
}).or_else(|state| .or_else(|state| self::comment_line(state))
{ .or_else(|state| self::directive(state))
self::comment_line(state) .or_else(|state| self::blank_line(state))
}).or_else(|state|
{
self::directive(state)
}).or_else(|state|
{
self::blank_line(state)
})
} }
#[inline] #[inline]
#[allow(non_snake_case, unused_variables)] #[allow(non_snake_case, unused_variables)]
pub fn file(state: Box<::pest::ParserState<Rule>>) pub fn file(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.sequence(|state| ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
{ state.sequence(|state| {
self::SOI(state).and_then(|state| self::SOI(state)
{ .and_then(|state| super::hidden::skip(state))
super::hidden::skip(state) .and_then(|state| self::compound(state))
}).and_then(|state| .and_then(|state| super::hidden::skip(state))
{ .and_then(|state| {
self::compound(state) state.sequence(|state| {
}).and_then(|state| state.optional(|state| {
{ state
super::hidden::skip(state) .sequence(|state| {
}).and_then(|state| self::new_line(state)
{ .and_then(|state| super::hidden::skip(state))
state.sequence(|state| .and_then(|state| self::compound(state))
{
state.optional(|state|
{
state.sequence(|state|
{
self::new_line(state).and_then(|state|
{
super::hidden::skip(state)
}).and_then(|state|
{
self::compound(state)
}) })
}).and_then(|state| .and_then(|state| {
{ state.repeat(|state| {
state.repeat(|state| state.sequence(|state| {
{ super::hidden::skip(state).and_then(
state.sequence(|state| |state| {
{ state.sequence(|state| {
super::hidden::skip(state).and_then(|state| self::new_line(state)
{ .and_then(|state| {
state.sequence(|state| super::hidden::skip(
{ state,
self::new_line(state).and_then(|state| )
{
super::hidden::skip(state)
}).and_then(|state|
{
self::compound(state)
}) })
.and_then(|state| {
self::compound(state)
}) })
}) })
},
)
}) })
}) })
}) })
}) })
}) })
}).and_then(|state|
{
super::hidden::skip(state)
}).and_then(|state|
{
self::EOI(state)
}) })
.and_then(|state| super::hidden::skip(state))
.and_then(|state| self::EOI(state))
}) })
} }
#[inline] #[inline]
#[allow(dead_code, non_snake_case, unused_variables)] #[allow(dead_code, non_snake_case, unused_variables)]
pub fn SOI(state: Box<::pest::ParserState<Rule>>) pub fn ANY(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.start_of_input() ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.skip(1)
} }
#[inline] #[inline]
#[allow(dead_code, non_snake_case, unused_variables)] #[allow(dead_code, non_snake_case, unused_variables)]
pub fn EOI(state: Box<::pest::ParserState<Rule>>) pub fn SOI(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.rule(Rule::EOI, |state| state.end_of_input()) ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.start_of_input()
} }
#[inline] #[inline]
#[allow(dead_code, non_snake_case, unused_variables)] #[allow(dead_code, non_snake_case, unused_variables)]
pub fn ANY(state: Box<::pest::ParserState<Rule>>) pub fn EOI(
-> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> { state: Box<::pest::ParserState<Rule>>,
state.skip(1) ) -> ::pest::ParseResult<Box<::pest::ParserState<Rule>>> {
state.rule(Rule::EOI, |state| state.end_of_input())
} }
} }
pub use self::visible::*; pub use self::visible::*;
} }
::pest::state(input, ::pest::state(input, |state| match rule {
|state|
{
match rule {
Rule::new_line => rules::new_line(state), Rule::new_line => rules::new_line(state),
Rule::space => rules::space(state), Rule::space => rules::space(state),
Rule::comment_start => Rule::comment_start => rules::comment_start(state),
rules::comment_start(state),
Rule::line => rules::line(state), Rule::line => rules::line(state),
Rule::value => rules::value(state), Rule::value => rules::value(state),
Rule::equal_sign => Rule::equal_sign => rules::equal_sign(state),
rules::equal_sign(state), Rule::config_name => rules::config_name(state),
Rule::config_name => Rule::config_item => rules::config_item(state),
rules::config_name(state), Rule::left_bracket => rules::left_bracket(state),
Rule::config_item => Rule::right_bracket => rules::right_bracket(state),
rules::config_item(state), Rule::section_name => rules::section_name(state),
Rule::left_bracket =>
rules::left_bracket(state),
Rule::right_bracket =>
rules::right_bracket(state),
Rule::section_name =>
rules::section_name(state),
Rule::section => rules::section(state), Rule::section => rules::section(state),
Rule::comment_line => Rule::comment_line => rules::comment_line(state),
rules::comment_line(state), Rule::blank_line => rules::blank_line(state),
Rule::blank_line =>
rules::blank_line(state),
Rule::directive => rules::directive(state), Rule::directive => rules::directive(state),
Rule::include => rules::include(state), Rule::include => rules::include(state),
Rule::unset => rules::unset(state), Rule::unset => rules::unset(state),
Rule::compound => rules::compound(state), Rule::compound => rules::compound(state),
Rule::file => rules::file(state), Rule::file => rules::file(state),
Rule::EOI => rules::EOI(state), Rule::EOI => rules::EOI(state),
}
}) })
} }
} }
rust/hg-core/src/configparser/generate_parser.py