Struct RdParser 

struct RdParser<'a> {
    input: &'a str,
    pos: usize,
    line: usize,
}

Stateful parser for Rd files.

The parser processes input character by character, tracking brace depth and recognizing Rd commands, comments, and escape sequences.

Fields

input: &'a str

pos: usize

line: usize

Implementations

impl<'a> RdParser<'a>

fn new(input: &'a str) -> Self

fn peek(&self) -> Option<char>

Peek at the current character without advancing.

fn peek_str(&self, n: usize) -> &'a str

Peek at the next n characters as a string slice (char-aware, not byte-aware).

fn advance(&mut self) -> Option<char>

Advance by one character and return it.

fn skip_spaces(&mut self)

Skip whitespace (but not newlines).

fn at_end(&self) -> bool

Check if we’re at end of input.

fn read_command_name(&mut self) -> String

Read a command name after \. Returns the command name (e.g., “name”, “title”).

fn read_brace_arg(&mut self) -> Result<String, RdError>

Read a brace-delimited argument {...}, handling nesting and Rd markup. Returns the content with markup stripped to plain text.

fn read_brace_arg_verbatim(&mut self) -> Result<String, RdError>

Read a brace-delimited argument in verbatim mode.

fn read_brace_arg_rcode(&mut self) -> Result<String, RdError>

Read a brace-delimited argument in R-code mode.

Like normal mode (Rd commands still expanded via \ + alpha → break), but tracks R string literals so { inside "..." or '...' doesn’t affect brace depth. % still acts as Rd comment. # comments still count braces (matching GNU R’s gramRd.y behavior — ## END} closes).

Used for \examples{} (RSECTIONHEADER) and \code{} (RCODEMACRO).

fn read_brace_arg_inner(&mut self, verbatim: bool) -> Result<String, RdError>

fn read_brace_arg_ex( &mut self, verbatim: bool, rlike: bool, ) -> Result<String, RdError>

Core brace-delimited argument reader.

verbatim: no Rd command expansion, % is literal. rlike: track R string literals (don’t count braces inside strings).

fn handle_inline_command( &mut self, cmd: &str, out: &mut String, ) -> Result<(), RdError>

Handle an inline Rd command encountered inside a brace group. Strips the markup and appends plain-text content to out.

fn skip_bracket_arg(&mut self)

Skip a […] optional argument.

fn skip_comment_line(&mut self)

Skip a % comment line (from % to end of line).

fn skip_to_eol(&mut self)

Skip to end of line (for preprocessor directives).

fn is_at_line_start(&self, text_so_far: &str) -> bool

Check if we’re at the start of a line (nothing but whitespace before the current position on this line).

fn is_preprocessor_directive(&self) -> bool

Check if the current position starts a preprocessor directive (#ifdef, #ifndef, #endif).

fn parse_toplevel(&mut self, doc: &mut RdDoc) -> Result<(), RdError>

Parse the top-level structure of an Rd file.

fn parse_toplevel_command( &mut self, cmd: &str, doc: &mut RdDoc, ) -> Result<(), RdError>

Parse a top-level Rd command and store its content in the doc.

fn parse_arguments(&mut self, doc: &mut RdDoc) -> Result<(), RdError>

Parse the \arguments{...} section, extracting \item{name}{desc} pairs.