Struct ParserConfig

pub struct ParserConfig {
    pub parse_expressions: bool,
    pub language: Language,
}

Configuration for IR generation and expression parsing

This controls how the parser converts syntax to IR, particularly how it handles expressions.

Learning: Configuration Pattern

Rather than using global state or command-line flags, we pass configuration explicitly. This makes the code:

• Testable: Easy to test with different configs
• Composable: Multiple parsers with different configs
• Thread-safe: No global mutable state

Example

use roup::ir::{ParserConfig, Language};

// Default: parse expressions
let default_config = ParserConfig::default();
assert!(default_config.parse_expressions);

// Custom: disable expression parsing
let string_only = ParserConfig {
    parse_expressions: false,
    language: Language::C,
};

Fields

parse_expressions: bool

Whether to attempt parsing expressions into structured form

• true (default): Parse expressions, fall back to string on failure
• false: Keep all expressions as raw strings

language: Language

Source language (affects expression parsing rules)

Different languages have different expression syntax:

• C/C++: arr[i], *ptr, x->y
• Fortran: arr(i), different operators

Implementations

impl ParserConfig

pub const fn new(parse_expressions: bool, language: Language) -> Self

Create a new configuration

pub const fn string_only(language: Language) -> Self

Create config that keeps all expressions as strings

pub const fn with_parsing(language: Language) -> Self

Create config that parses expressions

Trait Implementations

impl Clone for ParserConfig

fn clone(&self) -> ParserConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParserConfig

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

Formats the value using the given formatter.

impl Default for ParserConfig

fn default() -> Self

Default: parse expressions, unknown language

impl PartialEq for ParserConfig

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for ParserConfig

impl Eq for ParserConfig

impl StructuralPartialEq for ParserConfig