Struct ParserState

pub struct ParserState<'a> {
    pub data: &'a [u8],
    pub current_scope: Vec<NameSeg>,
    pub method_signatures: Vec<MethodSignature>,
}

Input data plus context needed to disambiguate grammar

Fields

data: &'a [u8]

current_scope: Vec<NameSeg>

method_signatures: Vec<MethodSignature>

Implementations

impl<'a> ParserState<'a>

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

pub fn get_arg_count(&self, name: &NameString) -> Option<u8>

Get the argument count of the named method, if it is declared

pub fn in_scope<P, O, E>( self, new_scope: &NameString, parser: P, ) -> AMLParseResult<'a, O, E>

where P: Parser<ParserState<'a>, O, E>, E: AMLParseError<'a>,

Execute a parser in a new scope relative to the current scope, then restore the original scope.

Errors

Fails if the given scope is invalid when resolved against the current scope (because it falls outside the namespace root), or when the inner parser fails.

pub fn lift<P, O, E>( parser: P, ) -> impl FnMut(ParserState<'a>) -> AMLParseResult<'a, O, E>

where P: Parser<&'a [u8], O, E::From>, E: AMLParseError<'a>,

Wraps a byte-oriented parser to work with ParserState

Trait Implementations

impl AsBytes for ParserState<'_>

fn as_bytes(&self) -> &[u8]

Casts the input type to a byte slice

impl<'a> Clone for ParserState<'a>

fn clone(&self) -> ParserState<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for ParserState<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for ParserState<'a>

fn default() -> ParserState<'a>

Returns the “default value” for a type.

impl<'a> From<&'a [u8]> for ParserState<'a>

fn from(data: &'a [u8]) -> Self

Converts to this type from the input type.

impl<'a> InputIter for ParserState<'a>

type Item = <&'a [u8] as InputIter>::Item

The current input type is a sequence of that Item type.

type Iter = <&'a [u8] as InputIter>::Iter

An iterator over the input type, producing the item and its position for use with [Slice]. If we’re iterating over &str, the position corresponds to the byte index of the character

type IterElem = <&'a [u8] as InputIter>::IterElem

An iterator over the input type, producing the item

fn iter_indices(&self) -> Self::Iter

Returns an iterator over the elements and their byte offsets

fn iter_elements(&self) -> Self::IterElem

Returns an iterator over the elements

fn position<P: Fn(Self::Item) -> bool>(&self, pred: P) -> Option<usize>

Finds the byte position of the element

fn slice_index(&self, i: usize) -> Result<usize, Needed>

Get the byte offset from the element’s position in the stream

impl InputLength for ParserState<'_>

fn input_len(&self) -> usize

Calculates the input length, as indicated by its name, and the name of the trait itself

impl<'a> PartialEq for ParserState<'a>

fn eq(&self, other: &ParserState<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for ParserState<'a>

impl<'a> StructuralPartialEq for ParserState<'a>