Struct cpclib_asm::parser::Z80Span

pub struct Z80Span(_);

Implementations

impl Z80Span

pub fn as_str(&self) -> &str

impl Z80Span

pub fn new_extra(src: &str, ctx: &ParserContext) -> Self

pub fn context(&self) -> &ParserContext

impl Z80Span

pub fn state(&self) -> &ParsingState

Methods from Deref<Target = LocatedSpan<&'static str, &'static ParserContext>>

pub fn location_offset(&self) -> usize

The offset represents the position of the fragment relatively to the input of the parser. It starts at offset 0.

pub fn location_line(&self) -> u32

The line number of the fragment relatively to the input of the parser. It starts at line 1.

pub fn fragment(&self) -> &T

The fragment that is spanned. The fragment represents a part of the input of the parser.

pub fn get_line_beginning(&self) -> &[u8]

Return the line that contains this LocatedSpan.

The get_column and get_utf8_column functions returns indexes that corresponds to the line returned by this function.

Note that if this LocatedSpan ends before the end of the original data, the result of calling get_line_beginning() will not include any data from after the LocatedSpan.

let program = LocatedSpan::new(
    "Hello World!\
    \nThis is a multi-line input\
    \nthat ends after this line.\n");
let multi = program.find_substring("multi").unwrap();

assert_eq!(
    program.slice(multi..).get_line_beginning(),
    "This is a multi-line input".as_bytes(),
);

pub fn get_column(&self) -> usize

Return the column index, assuming 1 byte = 1 column.

Use it for ascii text, or use get_utf8_column for UTF8.

Example of use

let span = LocatedSpan::new("foobar");

assert_eq!(span.slice(3..).get_column(), 4);

pub fn get_utf8_column(&self) -> usize

Return the column index for UTF8 text. Return value is unspecified for non-utf8 text.

This version uses bytecount’s hyper algorithm to count characters. This is much faster for long lines, but is non-negligibly slower for short slices (below around 100 bytes). This is also sped up significantly more depending on architecture and enabling the simd feature gates. If you expect primarily short lines, you may get a noticeable speedup in parsing by using naive_get_utf8_column instead. Benchmark your specific use case!

Example of use

let span = LocatedSpan::new("メカジキ");
let indexOf3dKanji = span.find_substring("ジ").unwrap();

assert_eq!(span.slice(indexOf3dKanji..).get_column(), 7);
assert_eq!(span.slice(indexOf3dKanji..).get_utf8_column(), 3);

pub fn naive_get_utf8_column(&self) -> usize

Return the column index for UTF8 text. Return value is unspecified for non-utf8 text.

A simpler implementation of get_utf8_column that may be faster on shorter lines. If benchmarking shows that this is faster, you can use it instead of get_utf8_column. Prefer defaulting to get_utf8_column unless this legitimately is a performance bottleneck.

Example of use

let span = LocatedSpan::new("メカジキ");
let indexOf3dKanji = span.find_substring("ジ").unwrap();

assert_eq!(span.slice(indexOf3dKanji..).get_column(), 7);
assert_eq!(span.slice(indexOf3dKanji..).naive_get_utf8_column(), 3);

Trait Implementations

impl AsRef<LocatedSpan<&'static str, &'static ParserContext>> for Z80Span

fn as_ref(&self) -> &LocatedSpan<&'static str, &'static ParserContext>

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<str> for Z80Span

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<str> for Z80Span

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl Clone for Z80Span

fn clone(&self) -> Z80Span

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Compare<&'static str> for Z80Span

fn compare(&self, t: &'static str) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, t: &'static str) -> CompareResult

Compares self to another value for equality independently of the case.

impl ContextError<Z80Span> for Z80ParserError

fn add_context(input: Z80Span, ctx: &'static str, other: Self) -> Self

Creates a new error from an input position, a static string and an existing error. This is used mainly in the [context] combinator, to add user friendly information to errors when backtracking through a parse tree

impl Debug for Z80Span

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

Formats the value using the given formatter.

impl Deref for Z80Span

type Target = LocatedSpan<&'static str, &'static ParserContext>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Z80Span

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Display for Z80Span

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

Formats the value using the given formatter.

impl<'src, 'ctx, U> FindSubstring<U> for Z80Spanwhere &'src str: FindSubstring<U>,

fn find_substring(&self, substr: U) -> Option<usize>

Returns the byte position of the substring if it is found

impl InputIter for Z80Span

type Item = <LocatedSpan<&'static str, &'static ParserContext> as InputIter>::Item

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

type Iter = <LocatedSpan<&'static str, &'static ParserContext> 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 = <LocatedSpan<&'static str, &'static ParserContext> 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>(&self, predicate: P) -> Option<usize>where P: Fn(Self::Item) -> bool,

Finds the byte position of the element

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

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

impl InputLength for Z80Span

fn input_len(&self) -> usize

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

impl InputTake for Z80Span

fn take(&self, count: usize) -> Self

Returns a slice of count bytes. panics if count > length

fn take_split(&self, count: usize) -> (Self, Self)

Split the stream at the count byte offset. panics if count > length

impl InputTakeAtPosition for Z80Span

type Item = <LocatedSpan<&'static str, &'static ParserContext> as InputIter>::Item

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

fn split_at_position<P, E: ParseError<Self>>( &self, predicate: P ) -> IResult<Self, Self, E>where P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1<P, E: ParseError<Self>>( &self, predicate: P, e: ErrorKind ) -> IResult<Self, Self, E>where P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

fn split_at_position_complete<P, E: ParseError<Self>>( &self, predicate: P ) -> IResult<Self, Self, E>where P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1_complete<P, E: ParseError<Self>>( &self, predicate: P, e: ErrorKind ) -> IResult<Self, Self, E>where P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

impl<'a> Into<LocatedSpan<&'a str, ()>> for Z80Span

fn into(self) -> LocatedSpan<&'a str>

Converts this type into the (usually inferred) input type.

impl Into<SmolStr> for &Z80Span

fn into(self) -> SmolStr

Converts this type into the (usually inferred) input type.

impl Into<SmolStr> for Z80Span

fn into(self) -> SmolStr

Converts this type into the (usually inferred) input type.

impl Into<Source> for &Z80Span

fn into(self) -> Source

Converts this type into the (usually inferred) input type.

impl Offset for Z80Span

fn offset(&self, second: &Self) -> usize

Offset between the first byte of self and the first byte of the argument

impl ParseError<Z80Span> for Z80ParserError

fn from_error_kind(input: Z80Span, kind: ErrorKind) -> Self

Creates an error from the input position and an [ErrorKind]

fn from_char(input: Z80Span, c: char) -> Self

Creates an error from an input position and an expected character

fn append(input: Z80Span, kind: ErrorKind, other: Self) -> Self

Combines an existing error with a new one created from the input position and an [ErrorKind]. This is useful when backtracking through a parse tree, accumulating error context on the way

fn or(self, other: Self) -> Self

Combines two existing errors. This function is used to compare errors generated in various branches of alt.

impl PartialEq<Z80Span> for Z80Span

fn eq(&self, other: &Z80Span) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Slice<Range<usize>> for Z80Span

fn slice(&self, range: Range<usize>) -> Self

Slices self according to the range argument

impl Slice<RangeFrom<usize>> for Z80Span

fn slice(&self, range: RangeFrom<usize>) -> Self

Slices self according to the range argument

impl Slice<RangeTo<usize>> for Z80Span

fn slice(&self, range: RangeTo<usize>) -> Self

Slices self according to the range argument

impl Eq for Z80Span

impl StructuralEq for Z80Span

impl StructuralPartialEq for Z80Span