Struct StreamCharSpan

pub struct StreamCharSpan<P>
where
    P: PosnInCharStream,
{ /* private fields */ }

This provides a span between two byte offsets within a stream; the start and end have an associated position that might also ccurately provide line and column numbers

This can be used as within tokens for a lexer; if crate::LineColumn is used for the generic argument then the lexer will correctly track the line and column of the span of tokens, and parsers can correctly track real spans of the tokens, which allows for suitable formatting of errors etc within their context (see crate::FmtContext also).

Implementations

impl<P> StreamCharSpan<P>

where P: PosnInCharStream,

pub fn new(start: P, end: P) -> Self

Create a new StreamCharSpan

Examples found in repository

examples/simple.rs (line 74)

    pub fn parse_comment_line<L>(
        stream: &L,
        state: L::State,
        ch: char,
    ) -> LexerParseResult<P, Self, L::Error>
    where
        L: CharStream<P>,
        L: Lexer<Token = Self, State = P>,
    {
        match stream.do_while(state, ch, &|n, ch| {
            ((n < 2) && (ch == '/')) || ((n >= 2) && ch != '\n')
        }) {
            (state, Some((start, _n))) => {
                let span = StreamCharSpan::new(start, state);
                Ok(Some((state, SimpleToken::CommentLine(span))))
            }
            (_, None) => Ok(None),
        }
    }

    //fp parse_digits
    pub fn parse_digits<L>(
        stream: &L,
        state: L::State,
        ch: char,
    ) -> LexerParseResult<P, Self, L::Error>
    where
        L: CharStream<P>,
        L: Lexer<Token = Self, State = P>,
    {
        match stream.do_while(state, ch, &|_, ch| ch.is_ascii_digit()) {
            (state, Some((start, _n))) => {
                let span = StreamCharSpan::new(start, state);
                Ok(Some((state, SimpleToken::Digits(span))))
            }
            (_, None) => Ok(None),
        }
    }

    //fp parse_whitespace
    pub fn parse_whitespace<L>(
        stream: &L,
        state: L::State,
        ch: char,
    ) -> LexerParseResult<P, Self, L::Error>
    where
        L: CharStream<P>,
        L: Lexer<Token = Self, State = P>,
    {
        match stream.do_while(state, ch, &|_, ch| (ch == ' ' || ch == '\t')) {
            (state, Some((start, _))) => {
                let span = StreamCharSpan::new(start, state);
                Ok(Some((state, SimpleToken::Whitespace(span))))
            }
            (_, None) => Ok(None),
        }
    }

    //fp parse_id
    pub fn parse_id<L, F1, F2>(
        stream: &L,
        state: L::State,
        ch: char,
        is_id_start: F1,
        is_id: F2,
    ) -> LexerParseResult<P, Self, L::Error>
    where
        L: CharStream<P>,
        L: Lexer<Token = Self, State = P>,
        F1: Fn(char) -> bool,
        F2: Fn(char) -> bool,
    {
        match stream.do_while(state, ch, &|n, ch| {
            (n == 0 && is_id_start(ch)) || ((n > 0) && is_id(ch))
        }) {
            (state, Some((start, _))) => {
                let span = StreamCharSpan::new(start, state);
                Ok(Some((state, SimpleToken::Id(span))))
            }
            (_, None) => Ok(None),
        }
    }

pub fn new_at(posn: &P) -> Self

Create a new StreamCharSpan

pub fn end_at(self, posn: &P) -> Self

Create a new StreamCharSpan

pub fn start(&self) -> &P

Get the start of the span

pub fn end(&self) -> &P

Get the end of the span

pub fn byte_range(&self) -> Range<usize>

Get the range between the two positions of this StreamCharSpan

Trait Implementations

impl<P> Clone for StreamCharSpan<P>

where P: PosnInCharStream + Clone,

fn clone(&self) -> StreamCharSpan<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> Debug for StreamCharSpan<P>

where P: PosnInCharStream + Debug,

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

Formats the value using the given formatter.

impl<P> Copy for StreamCharSpan<P>

where P: PosnInCharStream + Copy,