Struct rustc_ast_pretty::pp::Printer

pub struct Printer {
    out: String,
    buf_max_len: usize,
    margin: isize,
    space: isize,
    left: usize,
    right: usize,
    buf: Vec<BufEntry>,
    left_total: isize,
    right_total: isize,
    scan_stack: VecDeque<usize>,
    print_stack: Vec<PrintStackElem>,
    pending_indentation: isize,
}

Fields

out: String

buf_max_len: usize

margin: isize

Width of lines we’re constrained to

space: isize

Number of spaces left on line

left: usize

Index of left side of input stream

right: usize

Index of right side of input stream

buf: Vec<BufEntry>

Ring-buffer of tokens and calculated sizes

left_total: isize

Running size of stream “…left”

right_total: isize

Running size of stream “…right”

scan_stack: VecDeque<usize>

Pseudo-stack, really a ring too. Holds the primary-ring-buffers index of the Begin that started the current block, possibly with the most recent Break after that Begin (if there is any) on top of it. Stuff is flushed off the bottom as it becomes irrelevant due to the primary ring-buffer advancing.

print_stack: Vec<PrintStackElem>

Stack of blocks-in-progress being flushed by print

pending_indentation: isize

Buffered indentation to avoid writing trailing whitespace

Implementations

impl Printer

pub fn word_space<W: Into<Cow<'static, str>>>(&mut self, w: W)

pub fn popen(&mut self)

pub fn pclose(&mut self)

pub fn hardbreak_if_not_bol(&mut self)

pub fn space_if_not_bol(&mut self)

pub fn nbsp(&mut self)

pub fn word_nbsp<S: Into<Cow<'static, str>>>(&mut self, w: S)

impl Printer

pub fn last_token(&self) -> Token

pub fn replace_last_token(&mut self, t: Token)

Be very careful with this!

fn scan_eof(&mut self)

fn scan_begin(&mut self, b: BeginToken)

fn scan_end(&mut self)

fn scan_break(&mut self, b: BreakToken)

fn scan_string(&mut self, s: Cow<'static, str>)

fn check_stream(&mut self)

fn scan_push(&mut self, entry: BufEntry)

fn scan_pop(&mut self) -> usize

fn scan_top(&self) -> usize

fn scan_pop_bottom(&mut self) -> usize

fn advance_right(&mut self)

fn advance_left(&mut self)

fn check_stack(&mut self, k: usize)

fn print_newline(&mut self, amount: isize)

fn indent(&mut self, amount: isize)

fn get_top(&self) -> PrintStackElem

fn print_begin(&mut self, b: BeginToken, l: isize)

fn print_end(&mut self)

fn print_break(&mut self, b: BreakToken, l: isize)

fn print_string(&mut self, s: Cow<'static, str>)

fn print(&mut self, token: Token, l: isize)

pub fn rbox(&mut self, indent: usize, b: Breaks)

“raw box”

pub fn ibox(&mut self, indent: usize)

Inconsistent breaking box

pub fn cbox(&mut self, indent: usize)

Consistent breaking box

pub fn break_offset(&mut self, n: usize, off: isize)

pub fn end(&mut self)

pub fn eof(self) -> String

pub fn word<S: Into<Cow<'static, str>>>(&mut self, wrd: S)

fn spaces(&mut self, n: usize)

pub(crate) fn zerobreak(&mut self)

pub fn space(&mut self)

pub fn hardbreak(&mut self)

pub fn is_beginning_of_line(&self) -> bool

pub fn hardbreak_tok_offset(off: isize) -> Token

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference’s “Type Layout” chapter for details on type layout guarantees.

Size: 168 bytes