Struct Scanner 

pub struct Scanner<'a> { /* private fields */ }

A PostScript scanner that parses Objects from a byte stream.

Implementations

impl<'a> Scanner<'a>

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

Create a new scanner over the given bytes of a PostScript program.

Examples found in repository

examples/tokenize.rs (line 27)

fn main() {
    let path = match env::args().nth(1) {
        Some(p) => p,
        None => {
            eprintln!("Usage: tokenize <file>");
            process::exit(1);
        }
    };

    let data = match fs::read(&path) {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error reading {path}: {e}");
            process::exit(1);
        }
    };

    let mut scanner = Scanner::new(&data);

    while !scanner.at_end() {
        match scanner.parse_object() {
            Ok(object) => {
                print_object(&object);
                println!();
            }
            Err(e) => eprintln!("Error: {e}"),
        }
    }
}

pub fn at_end(&mut self) -> bool

Returns true if there are no more objects to parse.

Examples found in repository

examples/tokenize.rs (line 29)

fn main() {
    let path = match env::args().nth(1) {
        Some(p) => p,
        None => {
            eprintln!("Usage: tokenize <file>");
            process::exit(1);
        }
    };

    let data = match fs::read(&path) {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error reading {path}: {e}");
            process::exit(1);
        }
    };

    let mut scanner = Scanner::new(&data);

    while !scanner.at_end() {
        match scanner.parse_object() {
            Ok(object) => {
                print_object(&object);
                println!();
            }
            Err(e) => eprintln!("Error: {e}"),
        }
    }
}

fn print_object(object: &Object<'_>) {
    match object {
        Object::Number(Number::Integer(n)) => print!("Integer({n})"),
        Object::Number(Number::Real(n)) => print!("Real({n})"),
        Object::Name(name) => {
            let kind = if name.is_literal() {
                "literal"
            } else {
                "executable"
            };
            let text = name.as_str().unwrap_or("<non-ascii name>");
            print!("Name({text}, {kind})");
        }
        Object::String(s) => {
            let decoded = s.decode().unwrap_or_else(|_| Vec::new());
            print!("String({})", String::from_utf8_lossy(&decoded));
        }
        Object::Array(arr) => {
            print!("[");
            let mut inner = arr.objects();
            let mut first = true;
            while !inner.at_end() {
                if !first {
                    print!(" ");
                }
                first = false;
                match inner.parse_object() {
                    Ok(obj) => print_object(&obj),
                    Err(e) => print!("Error({e})"),
                }
            }
            print!("]");
        }
    }
}

pub fn parse_object(&mut self) -> Result<Object<'a>>

Parse the next object.

Examples found in repository

examples/tokenize.rs (line 30)

fn main() {
    let path = match env::args().nth(1) {
        Some(p) => p,
        None => {
            eprintln!("Usage: tokenize <file>");
            process::exit(1);
        }
    };

    let data = match fs::read(&path) {
        Ok(d) => d,
        Err(e) => {
            eprintln!("Error reading {path}: {e}");
            process::exit(1);
        }
    };

    let mut scanner = Scanner::new(&data);

    while !scanner.at_end() {
        match scanner.parse_object() {
            Ok(object) => {
                print_object(&object);
                println!();
            }
            Err(e) => eprintln!("Error: {e}"),
        }
    }
}

fn print_object(object: &Object<'_>) {
    match object {
        Object::Number(Number::Integer(n)) => print!("Integer({n})"),
        Object::Number(Number::Real(n)) => print!("Real({n})"),
        Object::Name(name) => {
            let kind = if name.is_literal() {
                "literal"
            } else {
                "executable"
            };
            let text = name.as_str().unwrap_or("<non-ascii name>");
            print!("Name({text}, {kind})");
        }
        Object::String(s) => {
            let decoded = s.decode().unwrap_or_else(|_| Vec::new());
            print!("String({})", String::from_utf8_lossy(&decoded));
        }
        Object::Array(arr) => {
            print!("[");
            let mut inner = arr.objects();
            let mut first = true;
            while !inner.at_end() {
                if !first {
                    print!(" ");
                }
                first = false;
                match inner.parse_object() {
                    Ok(obj) => print_object(&obj),
                    Err(e) => print!("Error({e})"),
                }
            }
            print!("]");
        }
    }
}

pub fn parse_number(&mut self) -> Result<Number>

Parse the next object as a Number.

pub fn parse_name(&mut self) -> Result<Name<'a>>

Parse the next object as a Name.

pub fn parse_string(&mut self) -> Result<String<'a>>

Parse the next object as a String.

pub fn parse_array(&mut self) -> Result<Array<'a>>

Parse the next object as an Array.