Struct ParseOptions 

#[non_exhaustive]
pub struct ParseOptions {
    pub default_width: Option<Width>,
    pub existing_symbols_only: bool,
}

Options for Context::parse.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

default_width: Option<Width>

Width for symbols and literals whose width cannot be inferred. None makes such an expression an error.

existing_symbols_only: bool

Only resolve symbols that already exist in the context (never create new ones).

Implementations

impl ParseOptions

pub fn width(w: Width) -> Self

Options with a default width.

Examples found in repository

examples/valeria_rule_audit.rs (line 26)

fn main() {
    let strategy = if std::env::args().any(|a| a == "--deobfuscate") {
        Strategy::deobfuscate()
    } else {
        Strategy::standard()
    };
    let engine = Engine::builder()
        .builtin()
        .strategy(strategy)
        .build()
        .unwrap();
    let mut invalid = false;
    for line in io::stdin().lock().lines() {
        let line = line.unwrap();
        let fields: Vec<_> = line.split('\t').collect();
        if fields.len() != 4 {
            panic!("expected id/width/input/reference");
        }
        let mut cx = Context::new();
        let options = ParseOptions::width(Width::new(fields[1].parse().unwrap()).unwrap());
        let result = (|| -> Result<_, Box<dyn std::error::Error>> {
            let input = cx.parse(fields[2], &options)?;
            let reference = cx.parse(fields[3], &options)?;
            let before = cx.tree_size(input)?;
            if !agrees(&mut cx, &[input, reference])? {
                return Ok((
                    "invalid-reference",
                    before,
                    before,
                    cx.tree_size(reference)?,
                    cx.display(input).to_string().replace(['\n', '\t'], " "),
                    cx.display(reference).to_string().replace(['\n', '\t'], " "),
                ));
            }
            let output = engine.simplify(&mut cx, input)?.expr;
            let want = engine.simplify(&mut cx, reference)?.expr;
            let after = cx.tree_size(output)?;
            let target = cx.tree_size(want)?;
            let status = if !agrees(&mut cx, &[input, reference, output, want])? {
                "invalid-output"
            } else if output == want {
                "covered"
            } else if after > target {
                "gap"
            } else {
                "different-form"
            };
            Ok((
                status,
                before,
                after,
                target,
                cx.display(output).to_string().replace(['\n', '\t'], " "),
                cx.display(want).to_string().replace(['\n', '\t'], " "),
            ))
        })();
        match result {
            Ok((status, before, after, target, output, want)) => {
                invalid |= status.starts_with("invalid-");
                println!(
                    "{}\t{}\t{status}\t{before}\t{after}\t{target}\t{output}\t{want}",
                    fields[0], fields[1]
                );
            }
            Err(error) => {
                invalid = true;
                println!(
                    "{}\t{}\terror\t{}",
                    fields[0],
                    fields[1],
                    error.to_string().replace(['\n', '\t'], " ")
                );
            }
        }
    }
    if invalid {
        std::process::exit(1);
    }
}

pub fn with_existing_symbols_only(self, yes: bool) -> Self

Sets existing_symbols_only.

Trait Implementations

impl Clone for ParseOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseOptions

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

Formats the value using the given formatter.

impl Default for ParseOptions

fn default() -> Self

Returns the “default value” for a type.