76 lines
2.9 KiB
Rust
76 lines
2.9 KiB
Rust
use super::*;
|
|
|
|
use super::ignore::Ignore;
|
|
use super::preprocessed::Preprocessed;
|
|
|
|
/// A TokenStream is a specialized [Iterator] which produces [Tokens](Token)
|
|
pub trait TokenStream<'text>: Iterator<Item = Token<'text>> + std::fmt::Debug {
|
|
/// Gets this stream's [Context]
|
|
fn context(&self) -> Context;
|
|
|
|
/// Creates an iterator that skips [Type::Space] in the input
|
|
fn ignore(&'text mut self, variant: Type) -> Ignore<'text, Self>
|
|
where Self: Sized {
|
|
Ignore::new(variant, self)
|
|
}
|
|
|
|
/// Creates a [TokenStream] that performs live substitution of the input
|
|
fn preprocessed(&'text mut self) -> Preprocessed<'text, Self>
|
|
where Self: Sized {
|
|
Preprocessed::new(self)
|
|
}
|
|
|
|
/// Returns the next [Token] without advancing
|
|
fn peek(&mut self) -> Self::Item;
|
|
|
|
/// Returns the next [Token] if it is of the expected [Type], without advancing
|
|
fn peek_expect(&mut self, expected: Type) -> Result<Self::Item, Error>;
|
|
|
|
/// Consumes and returns a [Token] if it is the expected [Type]
|
|
///
|
|
/// Otherwise, does not consume a [Token]
|
|
fn expect(&mut self, expected: Type) -> Result<Self::Item, Error>;
|
|
|
|
/// Ignores a [Token] of the expected [Type], propegating errors.
|
|
fn require(&mut self, expected: Type) -> Result<(), Error> { self.expect(expected).map(|_| ()) }
|
|
|
|
/// Ignores a [Token] of the expected [Type], discarding errors.
|
|
fn allow(&mut self, expected: Type) { let _ = self.expect(expected); }
|
|
|
|
/// Runs a function on each
|
|
fn any_of<T, U>(&mut self, f: fn(&mut Self, Type) -> Result<U, Error>, expected: T) -> Result<U, Error>
|
|
where T: AsRef<[Type]> {
|
|
for &expected in expected.as_ref() {
|
|
match f(self, expected).map_err(|e| e.bare()) {
|
|
Ok(t) => return Ok(t),
|
|
Err(Error::UnexpectedToken { .. }) => continue,
|
|
Err(e) => return Err(e.context(self.context())),
|
|
}
|
|
}
|
|
Err(Error::expected(expected, self.peek()).context(self.context()))
|
|
}
|
|
|
|
/// Returns the next [Token] if it is of the expected [Types](Type), without advancing
|
|
fn peek_expect_any_of<T>(&mut self, expected: T) -> Result<Self::Item, Error>
|
|
where T: AsRef<[Type]> {
|
|
self.any_of(Self::peek_expect, expected)
|
|
}
|
|
/// Consumes and returns a [Token] if it matches any of the expected [Types](Type)
|
|
///
|
|
/// Otherwise, does not consume a [Token]
|
|
fn expect_any_of<T>(&mut self, expected: T) -> Result<Self::Item, Error>
|
|
where T: AsRef<[Type]> {
|
|
self.any_of(Self::expect, expected)
|
|
}
|
|
/// Ignores a [Token] of any expected [Type], discarding errors.
|
|
fn allow_any_of<T>(&mut self, expected: T)
|
|
where T: AsRef<[Type]> {
|
|
let _ = self.expect_any_of(expected);
|
|
}
|
|
/// Ignores a [Token] of any expected [Type], propegating errors.
|
|
fn require_any_of<T>(&mut self, expected: T) -> Result<(), Error>
|
|
where T: AsRef<[Type]> {
|
|
self.any_of(Self::require, expected)
|
|
}
|
|
}
|