sim_codec_algol/

parse.rs

//! Parsing root for the Algol codec, aggregating its `tokenize`, `state`,
//! `origin`, and `rewrite` submodules and exposing the `decode_algol_located`
//! decode entry points built on top of the Pratt parser.

use std::sync::Arc;

mod origin;
mod rewrite;
mod state;
mod tokenize;

use crate::pratt::{PrattParser, default_pratt_table};
use sim_codec::{DecodeBudget, DecodeLimits};
use sim_kernel::{Expr, LocatedExpr, PrattTable, Result};
use sim_shape::{PrattShape, Shape, ShapeExprParser};

pub use state::ParseCx;
pub use tokenize::{SpannedToken, tokenize_algol_spanned, tokenize_algol_spanned_with_budget};

pub(crate) use sim_codec_pratt::raw_number_tag;

/// Decodes Algol source into a [`LocatedExpr`], attaching span and trivia
/// origin so source layout round-trips.
///
/// Uses [`crate::default_pratt_table`] and a default decode budget; call
/// [`decode_algol_located_with_budget`] to supply an explicit budget. The
/// default [`DecodeLimits::max_input_bytes`] ceiling is applied to `source`
/// before parsing, so this convenience entry point is bounded even when called
/// directly. Raw number literals are carried as a tagged extension form and
/// lowered to concrete number domains later by the runtime decoder.
pub fn decode_algol_located(
    codec: sim_kernel::CodecId,
    source_id: impl Into<String>,
    source: &str,
) -> Result<LocatedExpr> {
    let mut budget = DecodeBudget::new(DecodeLimits::default());
    budget.check_input_bytes(codec, source.len())?;
    decode_algol_located_with_budget(codec, source_id, source, &mut budget)
}

/// Decodes Algol source into a [`LocatedExpr`] under an explicit decode
/// `budget`.
///
/// The budget bounds token count, nesting depth, and string/trivia sizes so a
/// hostile input cannot exhaust resources. Otherwise behaves like
/// [`decode_algol_located`].
pub fn decode_algol_located_with_budget(
    codec: sim_kernel::CodecId,
    source_id: impl Into<String>,
    source: &str,
    budget: &mut DecodeBudget,
) -> Result<LocatedExpr> {
    let parser = PrattParser::new(default_pratt_table());
    let source_id = sim_kernel::SourceId(source_id.into());
    let mut tree =
        parser.parse_text_tree_with_budget(codec, source_id.0.clone(), source, budget)?;
    tree.origin = Some(origin::origin_from_algol_source(codec, source_id, source)?);
    Ok(tree.located())
}

/// Parses Algol `source` into a bare [`Expr`] using a caller-supplied operator
/// `table`, lowering raw number literals through `cx`.
///
/// This is the entry point the `Shape` engine uses to parse infix grammar with
/// a custom operator table rather than [`crate::default_pratt_table`]. It
/// applies the default [`DecodeLimits::max_input_bytes`] ceiling to `source`
/// before parsing; call [`parse_algol_expr_with_table_and_budget`] to honor a
/// caller-supplied budget. Number literals are lowered lossily: a literal no
/// number domain accepts is left as the tagged raw form rather than raising an
/// error.
///
/// # Examples
///
/// ```
/// use sim_codec_algol::{default_pratt_table, parse_algol_expr_with_table};
/// use sim_kernel::Expr;
/// use sim_test_support::{core_cx, register_f64_number_domain};
///
/// let mut cx = core_cx();
/// register_f64_number_domain(&mut cx);
/// let expr = parse_algol_expr_with_table(&mut cx, default_pratt_table(), "1 + 2 * 3").unwrap();
/// assert!(matches!(expr, Expr::Infix { .. }));
/// ```
pub fn parse_algol_expr_with_table(
    cx: &mut sim_kernel::Cx,
    table: PrattTable,
    source: &str,
) -> Result<Expr> {
    let mut budget = DecodeBudget::new(DecodeLimits::default());
    budget.check_input_bytes(sim_kernel::CodecId(0), source.len())?;
    parse_algol_expr_with_table_and_budget(cx, table, source, &mut budget)
}

/// Parses Algol `source` into a bare [`Expr`] under an explicit decode `budget`,
/// using a caller-supplied operator `table`.
///
/// Identical to [`parse_algol_expr_with_table`] but honors caller limits rather
/// than hardcoding [`DecodeLimits::default`], so a Shape grammar driven from a
/// limited runtime context bounds the same way the runtime decode path does.
pub fn parse_algol_expr_with_table_and_budget(
    cx: &mut sim_kernel::Cx,
    table: PrattTable,
    source: &str,
    budget: &mut DecodeBudget,
) -> Result<Expr> {
    let mut tree = PrattParser::new(table).parse_text_tree_with_budget(
        sim_kernel::CodecId(0),
        "<shape>",
        source,
        budget,
    )?;
    rewrite::rewrite_number_domains_tree_lossy(cx, &mut tree)?;
    Ok(tree.expr)
}

/// [`ShapeExprParser`] adapter that parses string input with an Algol
/// [`PrattTable`].
///
/// This lets callers build a [`PrattShape`] over the real Algol parser instead
/// of carrying a local test-only adapter. The parser returns the raw Pratt
/// expression tree; number-domain lowering belongs to codec decode paths that
/// have a runtime context.
pub struct AlgolShapeParser {
    table: PrattTable,
}

impl AlgolShapeParser {
    /// Build an adapter backed by `table`.
    pub fn new(table: PrattTable) -> Self {
        Self { table }
    }

    /// Return the Pratt table used by this adapter.
    pub fn table(&self) -> &PrattTable {
        &self.table
    }
}

impl ShapeExprParser for AlgolShapeParser {
    fn label(&self) -> &str {
        "algol-pratt"
    }

    fn parse_expr(&self, source: &str) -> Result<Expr> {
        Ok(PrattParser::new(self.table.clone())
            .parse_text_tree(sim_kernel::CodecId(0), "<shape>", source)?
            .expr)
    }
}

/// Build a [`PrattShape`] that parses string expressions through the Algol
/// Pratt parser before matching `inner`.
pub fn algol_pratt_shape(table: PrattTable, inner: Arc<dyn Shape>) -> PrattShape {
    PrattShape::new(Arc::new(AlgolShapeParser::new(table)), inner)
}