Struct yaml_peg::parser::Parser

pub struct Parser<'a> {
    pub pos: usize,
    pub eaten: usize,
    // some fields omitted
}

A PEG parser with YAML grammar, support UTF-8 characters.

A simple example for parsing YAML only:

use yaml_peg::{parser::Parser, node};
let n = Parser::new(b"true").parse().unwrap();
assert_eq!(n, vec![node!(true)]);

For matching partial grammar, each methods are the sub-parser. The methods have some behaviers:

• They will move the current cursor if matched.
• Returned value:
  • Result<(), ()> represents the sub-parser can be matched and mismatched.
  • PError represents the sub-parser can be totally breaked when mismatched.
• Use ? to match a condition.
• Use Result::unwrap_or_default to match an optional condition.
• Method Parser::forward is used to move on.
• Method Parser::text is used to get the matched string.
• Method Parser::backward is used to get back if mismatched.

Fields

pos: usize

Current position.

eaten: usize

Read position.

Implementations

impl Parser<'_>

The low level grammar implementation for YAML.

These sub-parser returns Result<R, ()>, and calling Parser::backward if mismatched.

pub fn bound(&mut self) -> Result<(), ()>

Match invisible boundaries and keep the gaps. (must matched once)

pub fn complex_mapping(&mut self) -> Result<(), ()>

Match complex mapping indicator (?).

pub fn int(&mut self) -> Result<String, ()>

Match integer.

pub fn float(&mut self) -> Result<String, ()>

Match float.

pub fn sci_float(&mut self) -> Result<String, ()>

Match float with scientific notation.

pub fn nan(&mut self) -> Result<(), ()>

Match NaN.

pub fn inf(&mut self) -> Result<bool, ()>

Match inf, return true if the value is positive.

pub fn string_quoted(&mut self, sym: u8, ignore: &[u8]) -> Result<String, ()>

Match quoted string.

pub fn string_plain(
    &mut self,
    level: usize,
    use_sep: bool
) -> Result<String, ()>

Match plain string.

pub fn string_flow(&mut self, level: usize, use_sep: bool) -> Result<String, ()>

Match flow string and return the content.

pub fn string_literal(&mut self, level: usize) -> Result<String, ()>

Match literal string.

pub fn string_folded(&mut self, level: usize) -> Result<String, ()>

Match folded string.

pub fn chomp(&mut self) -> impl Fn(String) -> String

Match chomping option.

pub fn string_wrapped(
    &mut self,
    level: usize,
    sep: u8,
    leading: bool
) -> Result<String, ()>

Match wrapped string.

pub fn escape(doc: &str) -> String

String escaping, return a new string.

pub fn identifier(&mut self) -> Result<(), ()>

Match valid YAML identifier.

pub fn ty(&mut self) -> Result<String, ()>

Match type assertion.

pub fn anchor(&mut self) -> Result<String, ()>

Match anchor definition.

pub fn anchor_use(&mut self) -> Result<String, ()>

Match anchor used.

pub fn ws(&mut self, opt: TakeOpt) -> Result<(), ()>

Match any invisible characters except newline.

pub fn nl(&mut self) -> Result<(), ()>

Match newline characters.

pub fn inv(&mut self, opt: TakeOpt) -> Result<(), ()>

Match any invisible characters.

pub fn unind(&mut self, level: usize) -> Result<bool, ()>

Match indent with previous level.

Return true if downgrading indent is allowed.

pub fn gap(&mut self) -> Result<usize, ()>

Match any optional invisible characters between two lines.

pub fn comment(&mut self) -> Result<(), ()>

Match comment.

impl<'a> Parser<'a>

The implementation of string pointer.

pub fn new(doc: &'a [u8]) -> Self

Create a PEG parser with the string.

pub fn food(&self) -> &'a [u8]

Show the right hand side string after the current cursor.

pub fn text(&mut self) -> String

Get the text from the eaten cursor to the current position.

impl Parser<'_>

The low level grammar implementation.

These sub-parser returns Result<(), ()>, and calling Parser::backward if mismatched.

pub fn indent(self, indent: usize) -> Self

Builder method for setting indent.

pub fn pos(self, pos: usize) -> Self

Set the starting point if character boundary is valid.

pub fn indicator(&self) -> u64

Get the indicator.

pub fn err<R>(&self, msg: &str) -> Result<R, PError>

A short function to raise error.

pub fn consume(&mut self)

Consume and move the pointer.

pub fn forward(&mut self)

Consume the eaten part.

pub fn backward(&mut self)

Move the current position back.

pub fn back(&mut self, n: usize)

Move back current cursor.

pub fn sym(&mut self, s: u8) -> Result<(), ()>

Match symbol.

pub fn seq(&mut self, s: &[u8]) -> Result<(), ()>

Match sequence.

pub fn take_while<F>(&mut self, f: F, opt: TakeOpt) -> Result<(), ()> where
    F: Fn(&u8) -> bool, 

Match until the condition failed.

The argument opt matches different terminate requirement.

pub fn context<F, R>(&mut self, f: F) -> R where
    F: Fn(&mut Self) -> R, 

A wrapper for saving local checkpoint.

pub fn is_in<'b>(s: &'b [u8]) -> impl Fn(&u8) -> bool + 'b

A SET detector.

pub fn not_in<'b>(s: &'b [u8]) -> impl Fn(&u8) -> bool + 'b

A NOT detector.

pub fn ind(&mut self, level: usize) -> Result<(), ()>

Match indent.

impl Parser<'_>

The basic implementation.

These sub-parser returns PError, and failed immediately for PError::Terminate. Additionally, they should eat the string by themself.

pub fn parse(&mut self) -> Result<Array, PError>

YAML entry point, return entire doc if exist.

pub fn doc(&mut self) -> Result<Node, PError>

Match one doc block.

pub fn doc_end(&mut self) -> bool

Match doc end.

pub fn scalar(
    &mut self,
    level: usize,
    nest: bool,
    use_sep: bool
) -> Result<Node, PError>

Match scalar.

pub fn scalar_flow(
    &mut self,
    level: usize,
    use_sep: bool
) -> Result<Node, PError>

Match flow scalar.

pub fn scalar_term(
    &mut self,
    level: usize,
    use_sep: bool
) -> Result<Yaml, PError>

Match flow scalar terminal.

pub fn array_flow(&mut self, level: usize) -> Result<Yaml, PError>

Match flow array.

pub fn map_flow(&mut self, level: usize) -> Result<Yaml, PError>

Match flow map.

pub fn array(&mut self, level: usize, nest: bool) -> Result<Yaml, PError>

Match array.

pub fn map(
    &mut self,
    level: usize,
    nest: bool,
    use_sep: bool
) -> Result<Yaml, PError>

Match map.