Trait FmtContext 

pub trait FmtContext<P> {
    // Required methods
    fn line_length(&self, line: usize) -> usize;
    fn fmt_line(&self, f: &mut dyn Write, line: usize) -> Result;

    // Provided methods
    fn fmt_context_single_line(
        &self,
        f: &mut dyn Write,
        start: &P,
        num_cols: usize,
    ) -> Result
       where P: UserPosn { ... }
    fn fmt_context_multiple_lines(
        &self,
        f: &mut dyn Write,
        start: &P,
        end: &P,
    ) -> Result
       where P: UserPosn { ... }
    fn fmt_context(&self, fmt: &mut dyn Write, start: &P, end: &P) -> Result
       where P: UserPosn { ... }
}

This trait is provided by types that wish to support context for (e.g.) error messages

It requires the type to have the ability to map from a line number to a position within the file/stream/text of the type, and to provide the length of any specific line nummber.e

With those supplied methods, the trait provides the ‘fmt_context’ method, which outputs to a formatter (which can be an &mut String even) the lines of the text ahead of a provided span of start and end positions within the stream.

Currently the format of the context is fixed - the number of lines ahead is fixed a a maximum of four, the lines are always numbered with aa line number of up to 4 digits, and so on.

Required Methods

fn line_length(&self, line: usize) -> usize

Return the length of the specified line

fn fmt_line(&self, f: &mut dyn Write, line: usize) -> Result

Format the line of text (potentially with coloring and so on).

This formatting must preserve the columnn numbers of characters if context markers are to line up correctly

Provided Methods

fn fmt_context_single_line( &self, f: &mut dyn Write, start: &P, num_cols: usize, ) -> Result

where P: UserPosn,

Format a line of text with highlight on certain columns

fn fmt_context_multiple_lines( &self, f: &mut dyn Write, start: &P, end: &P, ) -> Result

where P: UserPosn,

Format multiple lines of text, highlighting certain lines

fn fmt_context(&self, fmt: &mut dyn Write, start: &P, end: &P) -> Result

where P: UserPosn,

Format text with highlighting between start and end

This is the main method used by clients of the trait

Examples found in repository

examples/calc.rs (line 171)

fn main() -> Result<(), String> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        return Err(format!("Usage: {} <expression>", args[0]));
    }
    let args_as_string = args[1..].join(" ");
    let c = CalcTokenParser::new();
    let l = LexerOfString::default().set_text(args_as_string);
    let ts = l.lexer();

    // let ts = TextStream::new(&args_as_string);

    println!("Parsing");
    let tokens = c.iter(&ts);
    for t in tokens {
        let t = {
            match t {
                Err(e) => {
                    println!();
                    let mut s = String::new();
                    l.fmt_context(&mut s, &e.pos, &e.pos).unwrap();
                    eprintln!("{}", s);
                    return Err(format!("{}", e));
                }
                Ok(t) => t,
            }
        };
        print!("{}", t);
    }
    println!();
    println!("Text parsed okay");
    Ok(())
}

examples/simple.rs (line 225)

fn main() -> Result<(), String> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        return Err(format!("Usage: {} <expression>", args[0]));
    }
    let args_as_string = args[1..].join(" ");

    let mut parsers = ParserVec::new();
    parsers.add_parser(|a, b, c| LexToken::parse_whitespace(a, b, c));
    parsers.add_parser(|a, b, c| LexToken::parse_comment_line(a, b, c));
    parsers.add_parser(|a, b, c| LexToken::parse_digits(a, b, c));
    parsers.add_parser(|a, b, c| LexToken::parse_char(a, b, c));

    let l = LexerOfString::default().set_text(args_as_string);
    let ts = l.lexer();
    let tokens = ts.iter(&parsers.parsers);

    println!("Parsing");
    for t in tokens {
        let t = {
            match t {
                Err(e) => {
                    println!();
                    let mut s = String::new();
                    l.fmt_context(&mut s, &e.pos, &e.pos).unwrap();
                    eprintln!("{}", s);
                    return Err(format!("{}", e));
                }
                Ok(t) => t,
            }
        };
        println!("{:?}", t);
    }
    println!();
    println!("Text parsed okay");
    Ok(())
}

Implementors

impl<P, T, E> FmtContext<P> for LexerOfString<P, T, E>

where P: PosnInCharStream, E: LexerError<P>,