Struct yaml_peg::parser::Parser

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

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

A simple example for parsing YAML only:

use yaml_peg::{node, parser::Parser};

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 behaviors:

• They will move the current cursor if matched.
• Returned value:
  • Result<(), PError> 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.

anchors: AnchorBase<R>

A visitor of anchors.

Implementations

impl<'a, R: Repr> Parser<'a, R>

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<R: Repr> Parser<'_, R>

The low level grammar implementation.

These sub-parser returns Result<(), PError>, 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<Ret>(&self, msg: &'static str) -> Result<Ret, 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<(), PError>

Match symbol.

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

Match symbol from a set.

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

Match sequence.

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

Match until the condition failed.

The argument opt matches different terminate requirement.

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

A wrapper for saving checkpoint locally.

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

A SET detector.

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

A NOT detector.

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

Match indent.

impl<R: Repr> Parser<'_, R>

The implementation of the directives.

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

Match directives.

impl<R: Repr> Parser<'_, R>

The low level grammar implementation for YAML.

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

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

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

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

Match complex mapping indicator (?).

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

Match integer.

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

Match float.

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

Match float with scientific notation.

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

Match NaN.

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

Match inf, return true if the value is positive.

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

Match quoted string.

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

Match plain string.

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

Match flow string and return the content.

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

Match literal string.

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

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, PError>

Match wrapped string.

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

String escaping, return a new string.

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

Match valid YAML identifier.

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

Match tags.

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

Match anchor definition.

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

Match anchor used.

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

Match any invisible characters except newline.

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

Match newline characters.

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

Match any invisible characters.

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

Match indent with previous level.

Return true if downgrading indent is allowed.

pub fn gap(&mut self, cmt: bool) -> Result<usize, PError>

Match any optional invisible characters between two lines.

Set cmt to true to ignore comments at the line end.

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

Match comment.

impl<R: Repr> Parser<'_, R>

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<R>, PError>

YAML entry point, return entire doc if exist.

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

Match one doc block.

pub fn doc_end(&mut self) -> bool

Match doc end.

pub fn scalar(
    &mut self,
    level: usize,
    nest: bool,
    inner: bool
) -> Result<NodeBase<R>, PError>

Match scalar.

pub fn scalar_flow(
    &mut self,
    level: usize,
    inner: bool
) -> Result<NodeBase<R>, PError>

Match flow scalar.

pub fn scalar_term(
    &mut self,
    level: usize,
    inner: bool
) -> Result<YamlBase<R>, PError>

Match flow scalar terminal.

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

Match flow array.

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

Match flow map.

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

Match array.

pub fn map(
    &mut self,
    level: usize,
    nest: bool,
    inner: bool
) -> Result<YamlBase<R>, PError>

Match map.