snail-lang 0.7.2__tar.gz → 0.7.4__tar.gz

{snail_lang-0.7.2 → snail_lang-0.7.4}/Cargo.lock

@@ -312,25 +312,25 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "snail-ast"
-version = "0.7.2"
+version = "0.7.4"
 
 [[package]]
 name = "snail-error"
-version = "0.7.2"
+version = "0.7.4"
 dependencies = [
  "snail-ast",
 ]
 
 [[package]]
 name = "snail-lower"
-version = "0.7.2"
+version = "0.7.4"
 dependencies = [
  "snail-python",
 ]
 
 [[package]]
 name = "snail-parser"
-version = "0.7.2"
+version = "0.7.4"
 dependencies = [
  "pest",
  "pest_derive",
@@ -340,7 +340,7 @@ dependencies = [
 
 [[package]]
 name = "snail-python"
-version = "0.7.2"
+version = "0.7.4"
 dependencies = [
  "pyo3",
  "snail-ast",

{snail_lang-0.7.2 → snail_lang-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.7.2
+Version: 0.7.4
 Requires-Dist: astunparse>=1.6.3 ; python_full_version < '3.9'
 Requires-Dist: jmespath>=1.0.1
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
@@ -121,6 +121,35 @@ snail --map --begin "print('start')" --end "print('done')" "print($src)" *.txt
 | `$e` | Exception object in `expr:fallback?` |
 | `$env` | Environment map (wrapper around `os.environ`) |
 
+### Begin/End Blocks
+
+Regular Snail programs can include `BEGIN { ... }` and `END { ... }` blocks for
+setup and teardown. These blocks can also be supplied via CLI flags (`-b`/`--begin`,
+`-e`/`--end`) in all modes. CLI BEGIN blocks run before in-file BEGIN blocks; CLI
+END blocks run after in-file END blocks.
+BEGIN/END blocks are regular Snail blocks, so awk/map-only `$` variables are not
+available inside them.
+
+```snail
+print("running")
+BEGIN { print("start") }
+END { print("done") }
+```
+
+In regular mode, my main use case for this feature is passing unexported
+variables
+
+```bash
+my_bashvar=123
+snail -b x=$my_bashvar 'int(x) + 1'
+```
+
+This is roughly the same as using $env to access an exported variable.
+
+```bash
+my_bashvar=123 snail 'int($env.my_bashvar) + 1'
+```
+
 ### Compact Error Handling
 
 The `?` operator makes error handling terse yet expressive:
@@ -249,6 +278,13 @@ result = js('{{"foo": 12}}') | $[foo]
 names = js('{{"name": "Ada"}}\n{{"name": "Lin"}}') | $[[*].name]
 ```
 
+Snail rewrites JMESPath queries in `$[query]` so that double-quoted segments are
+treated as string literals. This lets you write
+`$[items[?ifname=="eth0"].ifname]` inside a single-quoted shell command. If you
+need JMESPath quoted identifiers (for keys like `"foo-bar"`), escape the quotes
+in the query (for example, `$[\"foo-bar\"]`). JSON literal backticks
+(`` `...` ``) are left unchanged.
+
 ### Full Python Interoperability
 
 Snail compiles to Python AST—import any Python module, use any library, in any
@@ -327,3 +363,16 @@ make test
 make install
 ```
 
+### Arch Linux (PKGBUILD)
+
+An Arch package build file is available at `extras/arch/PKGBUILD`.
+
+```bash
+mkdir -p /tmp/snail-pkg
+cp extras/arch/PKGBUILD /tmp/snail-pkg/
+cd /tmp/snail-pkg
+
+# Update pkgver and sha256sums as needed, then build and install
+makepkg -si
+```
+

{snail_lang-0.7.2 → snail_lang-0.7.4}/README.md

@@ -108,6 +108,35 @@ snail --map --begin "print('start')" --end "print('done')" "print($src)" *.txt
 | `$e` | Exception object in `expr:fallback?` |
 | `$env` | Environment map (wrapper around `os.environ`) |
 
+### Begin/End Blocks
+
+Regular Snail programs can include `BEGIN { ... }` and `END { ... }` blocks for
+setup and teardown. These blocks can also be supplied via CLI flags (`-b`/`--begin`,
+`-e`/`--end`) in all modes. CLI BEGIN blocks run before in-file BEGIN blocks; CLI
+END blocks run after in-file END blocks.
+BEGIN/END blocks are regular Snail blocks, so awk/map-only `$` variables are not
+available inside them.
+
+```snail
+print("running")
+BEGIN { print("start") }
+END { print("done") }
+```
+
+In regular mode, my main use case for this feature is passing unexported
+variables
+
+```bash
+my_bashvar=123
+snail -b x=$my_bashvar 'int(x) + 1'
+```
+
+This is roughly the same as using $env to access an exported variable.
+
+```bash
+my_bashvar=123 snail 'int($env.my_bashvar) + 1'
+```
+
 ### Compact Error Handling
 
 The `?` operator makes error handling terse yet expressive:
@@ -236,6 +265,13 @@ result = js('{{"foo": 12}}') | $[foo]
 names = js('{{"name": "Ada"}}\n{{"name": "Lin"}}') | $[[*].name]
 ```
 
+Snail rewrites JMESPath queries in `$[query]` so that double-quoted segments are
+treated as string literals. This lets you write
+`$[items[?ifname=="eth0"].ifname]` inside a single-quoted shell command. If you
+need JMESPath quoted identifiers (for keys like `"foo-bar"`), escape the quotes
+in the query (for example, `$[\"foo-bar\"]`). JSON literal backticks
+(`` `...` ``) are left unchanged.
+
 ### Full Python Interoperability
 
 Snail compiles to Python AST—import any Python module, use any library, in any
@@ -313,3 +349,16 @@ cd snail
 make test
 make install
 ```
+
+### Arch Linux (PKGBUILD)
+
+An Arch package build file is available at `extras/arch/PKGBUILD`.
+
+```bash
+mkdir -p /tmp/snail-pkg
+cp extras/arch/PKGBUILD /tmp/snail-pkg/
+cd /tmp/snail-pkg
+
+# Update pkgver and sha256sums as needed, then build and install
+makepkg -si
+```

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-ast/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-ast"
-version = "0.7.2"
+version = "0.7.4"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-error"
-version = "0.7.2"
+version = "0.7.4"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-parser"
-version = "0.7.2"
+version = "0.7.4"
 edition = "2024"
 readme = "README.md"
 

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-parser/src/lib.rs

@@ -12,7 +12,7 @@ mod string;
 mod util;
 
 use awk::parse_awk_rule;
-use stmt::{parse_block, parse_stmt, parse_stmt_list};
+use stmt::{parse_block, parse_stmt};
 use util::{error_with_span, full_span, parse_error_from_pest, span_from_offset, span_from_pair};
 
 #[derive(Parser)]
@@ -20,8 +20,16 @@ use util::{error_with_span, full_span, parse_error_from_pest, span_from_offset,
 pub struct SnailParser;
 
 pub type MapProgramWithBeginEnd = (Program, Vec<Vec<Stmt>>, Vec<Vec<Stmt>>);
+pub type ProgramWithBeginEnd = (Program, Vec<Vec<Stmt>>, Vec<Vec<Stmt>>);
 
 pub fn parse_program(source: &str) -> Result<Program, ParseError> {
+    let (program, _, _) = parse_program_with_begin_end(source)?;
+    Ok(program)
+}
+
+/// Parses a regular Snail program with in-file BEGIN/END blocks.
+/// BEGIN/END blocks are parsed as regular Snail statement blocks (no map/awk vars).
+pub fn parse_program_with_begin_end(source: &str) -> Result<ProgramWithBeginEnd, ParseError> {
     let mut pairs = SnailParser::parse(Rule::program, source)
         .map_err(|err| parse_error_from_pest(err, source))?;
     let pair = pairs
@@ -29,14 +37,51 @@ pub fn parse_program(source: &str) -> Result<Program, ParseError> {
         .ok_or_else(|| ParseError::new("missing program root"))?;
     let span = full_span(source);
     let mut stmts = Vec::new();
+    let mut begin_blocks = Vec::new();
+    let mut end_blocks = Vec::new();
+    let mut entries = Vec::new();
+
     for inner in pair.into_inner() {
-        if inner.as_rule() == Rule::stmt_list {
-            stmts = parse_stmt_list(inner, source)?;
+        if inner.as_rule() == Rule::program_entry_list {
+            for entry in inner.into_inner() {
+                if entry.as_rule() != Rule::program_entry {
+                    continue;
+                }
+                let entry_span = span_from_pair(&entry, source);
+                let mut entry_inner = entry.into_inner();
+                let entry_pair = entry_inner.next().ok_or_else(|| {
+                    error_with_span("missing program entry", entry_span.clone(), source)
+                })?;
+                match entry_pair.as_rule() {
+                    Rule::program_begin => {
+                        let block = parse_begin_end_block(entry_pair, source, "BEGIN")?;
+                        if !block.is_empty() {
+                            begin_blocks.push(block);
+                        }
+                        entries.push((entry_span, ProgramEntryKind::BeginEnd));
+                    }
+                    Rule::program_end => {
+                        let block = parse_begin_end_block(entry_pair, source, "END")?;
+                        if !block.is_empty() {
+                            end_blocks.push(block);
+                        }
+                        entries.push((entry_span, ProgramEntryKind::BeginEnd));
+                    }
+                    _ => {
+                        let stmt = parse_stmt(entry_pair, source)?;
+                        entries.push((entry_span, program_entry_kind_for_stmt(&stmt)));
+                        stmts.push(stmt);
+                    }
+                }
+            }
         }
     }
+
+    validate_program_entry_separators(&entries, source)?;
+
     let program = Program { stmts, span };
     validate_no_awk_syntax(&program, source)?;
-    Ok(program)
+    Ok((program, begin_blocks, end_blocks))
 }
 
 pub fn parse_awk_program(source: &str) -> Result<AwkProgram, ParseError> {
@@ -210,6 +255,46 @@ fn parse_begin_end_block(
     Ok(block)
 }
 
+#[derive(Clone, Copy)]
+enum ProgramEntryKind {
+    BeginEnd,
+    Simple,
+    Compound,
+}
+
+fn program_entry_kind_for_stmt(stmt: &Stmt) -> ProgramEntryKind {
+    match stmt {
+        Stmt::If { .. }
+        | Stmt::While { .. }
+        | Stmt::For { .. }
+        | Stmt::Def { .. }
+        | Stmt::Class { .. }
+        | Stmt::Try { .. }
+        | Stmt::With { .. } => ProgramEntryKind::Compound,
+        _ => ProgramEntryKind::Simple,
+    }
+}
+
+fn validate_program_entry_separators(
+    entries: &[(SourceSpan, ProgramEntryKind)],
+    source: &str,
+) -> Result<(), ParseError> {
+    for window in entries.windows(2) {
+        let (prev_span, prev_kind) = &window[0];
+        let (next_span, _) = &window[1];
+        let gap = &source[prev_span.end.offset..next_span.start.offset];
+        let has_sep = gap.contains('\n') || gap.contains(';');
+        if !has_sep && matches!(prev_kind, ProgramEntryKind::Simple) {
+            return Err(error_with_span(
+                "expected statement separator",
+                span_from_offset(next_span.start.offset, next_span.start.offset, source),
+                source,
+            ));
+        }
+    }
+    Ok(())
+}
+
 #[derive(Clone, Copy)]
 enum MapEntryKind {
     BeginEnd,

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-parser/src/snail.pest

@@ -1,8 +1,15 @@
 // Top-level program entry points
-program = { SOI ~ stmt_sep* ~ stmt_list? ~ stmt_sep* ~ EOI }
+program = { SOI ~ stmt_sep* ~ program_entry_list? ~ stmt_sep* ~ EOI }
 awk_program = { SOI ~ stmt_sep* ~ awk_entry_list? ~ stmt_sep* ~ EOI }
 map_program = { SOI ~ stmt_sep* ~ map_entry_list? ~ stmt_sep* ~ EOI }
 
+// Regular mode: program with optional BEGIN/END blocks
+program_entry_list = { program_entry ~ (stmt_sep* ~ program_entry)* ~ stmt_sep* }
+program_entry = { program_begin_end | stmt }
+program_begin_end = _{ program_begin | program_end }
+program_begin = { "BEGIN" ~ block }
+program_end = { "END" ~ block }
+
 // AWK mode: pattern-action rules
 awk_entry_list = { awk_entry ~ (stmt_sep* ~ awk_entry)* ~ stmt_sep* }
 awk_entry = _{ awk_begin | awk_end | awk_rule }

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-parser/tests/errors.rs

@@ -3,7 +3,7 @@ mod common;
 use common::*;
 use snail_parser::{
     parse_awk_program, parse_awk_program_with_begin_end, parse_map_program_with_begin_end,
-    parse_program,
+    parse_program, parse_program_with_begin_end,
 };
 
 #[test]
@@ -203,6 +203,29 @@ fn parser_rejects_invalid_parameter_syntax() {
     assert!(err.span.is_some());
 }
 
+// ========== Regular Mode BEGIN/END Parser Tests ==========
+
+#[test]
+fn program_begin_end_parsed_as_blocks() {
+    let (program, begin_blocks, end_blocks) =
+        parse_program_with_begin_end("BEGIN { print(1) }\nprint(2)\nEND { print(3) }")
+            .expect("should parse");
+    assert_eq!(program.stmts.len(), 1);
+    assert_eq!(begin_blocks.len(), 1);
+    assert_eq!(end_blocks.len(), 1);
+}
+
+#[test]
+fn program_begin_end_rejects_awk_map_vars() {
+    let err =
+        parse_program_with_begin_end("BEGIN { print($0) }").expect_err("should reject awk vars");
+    assert!(err.to_string().contains("$0"));
+
+    let err =
+        parse_program_with_begin_end("BEGIN { print($src) }").expect_err("should reject map vars");
+    assert!(err.to_string().contains("$src"));
+}
+
 // ========== AWK Mode Parser Tests ==========
 
 #[test]

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snail-python"
-version = "0.7.2"
+version = "0.7.4"
 edition.workspace = true
 build = "build.rs"
 

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-python/src/compiler.rs

@@ -1,13 +1,13 @@
 use crate::lower::{
     lower_awk_program_with_auto_print, lower_map_program_with_begin_end,
-    lower_program_with_auto_print,
+    lower_program_with_begin_end,
 };
 use pyo3::prelude::*;
 use snail_ast::{CompileMode, Stmt};
 use snail_error::{ParseError, SnailError};
 use snail_parser::{
     parse_awk_program, parse_awk_program_with_begin_end, parse_map_program_with_begin_end,
-    parse_program,
+    parse_program, parse_program_with_begin_end,
 };
 
 type BlockList = Vec<Vec<Stmt>>;
@@ -21,8 +21,14 @@ pub fn compile_snail_source_with_auto_print(
 ) -> Result<PyObject, SnailError> {
     match mode {
         CompileMode::Snail => {
-            let program = parse_program(source)?;
-            let module = lower_program_with_auto_print(py, &program, auto_print_last)?;
+            let (program, begin_blocks, end_blocks) = parse_program_with_begin_end(source)?;
+            let module = lower_program_with_begin_end(
+                py,
+                &program,
+                &begin_blocks,
+                &end_blocks,
+                auto_print_last,
+            )?;
             Ok(module)
         }
         CompileMode::Awk => {
@@ -44,6 +50,21 @@ pub fn compile_snail_source_with_auto_print(
     }
 }
 
+pub fn compile_snail_source_with_begin_end(
+    py: Python<'_>,
+    main_source: &str,
+    begin_sources: &[&str],
+    end_sources: &[&str],
+    auto_print_last: bool,
+) -> Result<PyObject, SnailError> {
+    let (program, begin_blocks, end_blocks) = parse_program_with_begin_end(main_source)?;
+    let begin_blocks = merge_cli_begin_blocks(begin_sources, begin_blocks)?;
+    let end_blocks = merge_cli_end_blocks(end_sources, end_blocks)?;
+    let module =
+        lower_program_with_begin_end(py, &program, &begin_blocks, &end_blocks, auto_print_last)?;
+    Ok(module)
+}
+
 pub fn compile_awk_source_with_begin_end(
     py: Python<'_>,
     main_source: &str,

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-python/src/lib.rs

@@ -8,12 +8,15 @@ mod profiling;
 pub use lower::{
     lower_awk_program, lower_awk_program_with_auto_print, lower_map_program,
     lower_map_program_with_auto_print, lower_map_program_with_begin_end, lower_program,
-    lower_program_with_auto_print,
+    lower_program_with_auto_print, lower_program_with_begin_end,
 };
 pub use pyo3::prelude::{PyObject, Python};
 
-use compiler::{compile_awk_source_with_begin_end, compile_map_source_with_begin_end};
-use compiler::{compile_snail_source_with_auto_print, merge_map_cli_blocks};
+use compiler::{
+    compile_awk_source_with_begin_end, compile_map_source_with_begin_end,
+    compile_snail_source_with_auto_print, compile_snail_source_with_begin_end,
+    merge_map_cli_blocks,
+};
 use linecache::{display_filename, register_linecache, strip_display_prefix};
 use profiling::{log_profile, profile_enabled};
 use pyo3::Bound;
@@ -24,7 +27,7 @@ use snail_ast::CompileMode;
 use snail_error::{ParseError, format_snail_error};
 use snail_parser::{
     parse_awk_program, parse_awk_program_with_begin_end, parse_map_program_with_begin_end,
-    parse_program,
+    parse_program_with_begin_end,
 };
 use std::time::Instant;
 
@@ -66,7 +69,7 @@ fn compile_source(
     let total_start = Instant::now();
     let compile_start = Instant::now();
 
-    // If mode is awk/map and we have begin/end code, use the specialized function
+    // If we have begin/end code, use the specialized function
     let module = if !begin_code.is_empty() || !end_code.is_empty() {
         let begin_refs: Vec<&str> = begin_code.iter().map(|s| s.as_str()).collect();
         let end_refs: Vec<&str> = end_code.iter().map(|s| s.as_str()).collect();
@@ -79,8 +82,10 @@ fn compile_source(
                 compile_map_source_with_begin_end(py, source, &begin_refs, &end_refs, auto_print)
                     .map_err(|err| PySyntaxError::new_err(format_snail_error(&err, filename)))?
             }
-            _ => compile_snail_source_with_auto_print(py, source, mode, auto_print)
-                .map_err(|err| PySyntaxError::new_err(format_snail_error(&err, filename)))?,
+            CompileMode::Snail => {
+                compile_snail_source_with_begin_end(py, source, &begin_refs, &end_refs, auto_print)
+                    .map_err(|err| PySyntaxError::new_err(format_snail_error(&err, filename)))?
+            }
         }
     } else {
         compile_snail_source_with_auto_print(py, source, mode, auto_print)
@@ -277,6 +282,14 @@ struct MapAst {
     end_blocks: Vec<Vec<snail_ast::Stmt>>,
 }
 
+#[allow(dead_code)]
+#[derive(Debug)]
+struct SnailAst {
+    program: snail_ast::Program,
+    begin_blocks: Vec<Vec<snail_ast::Stmt>>,
+    end_blocks: Vec<Vec<snail_ast::Stmt>>,
+}
+
 #[pyfunction(name = "parse_ast")]
 #[pyo3(signature = (source, *, mode = "snail", filename = "<snail>", begin_code = Vec::new(), end_code = Vec::new()))]
 fn parse_ast_py(
@@ -289,9 +302,24 @@ fn parse_ast_py(
     let err_to_syntax =
         |err: ParseError| PySyntaxError::new_err(format_snail_error(&err.into(), filename));
     match parse_mode(mode)? {
-        CompileMode::Snail => parse_program(source)
-            .map(|program| format!("{:#?}", program))
-            .map_err(err_to_syntax),
+        CompileMode::Snail => {
+            let (program, begin_blocks, end_blocks) =
+                parse_program_with_begin_end(source).map_err(err_to_syntax)?;
+            let (begin_blocks, end_blocks) =
+                merge_map_cli_blocks(&begin_code, &end_code, begin_blocks, end_blocks)
+                    .map_err(err_to_syntax)?;
+
+            if begin_blocks.is_empty() && end_blocks.is_empty() {
+                return Ok(format!("{:#?}", program));
+            }
+
+            let snail_ast = SnailAst {
+                program,
+                begin_blocks,
+                end_blocks,
+            };
+            Ok(format!("{:#?}", snail_ast))
+        }
         CompileMode::Awk => {
             let program = if begin_code.is_empty() && end_code.is_empty() {
                 parse_awk_program(source).map_err(err_to_syntax)?
@@ -328,7 +356,7 @@ fn parse_ast_py(
 #[pyo3(signature = (source, *, mode = "snail", filename = "<snail>"))]
 fn parse_py(source: &str, mode: &str, filename: &str) -> PyResult<()> {
     match parse_mode(mode)? {
-        CompileMode::Snail => parse_program(source)
+        CompileMode::Snail => parse_program_with_begin_end(source)
             .map(|_| ())
             .map_err(|err| PySyntaxError::new_err(format_snail_error(&err.into(), filename))),
         CompileMode::Awk => parse_awk_program(source)

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-python/src/lower/mod.rs

@@ -15,5 +15,5 @@ pub use map::{
 };
 pub use program::{
     lower_awk_program, lower_awk_program_with_auto_print, lower_program,
-    lower_program_with_auto_print,
+    lower_program_with_auto_print, lower_program_with_begin_end,
 };

{snail_lang-0.7.2 → snail_lang-0.7.4}/crates/snail-python/src/lower/program.rs

@@ -8,7 +8,9 @@ use super::desugar::LambdaHoister;
 use super::helpers::{assign_name, name_expr, number_expr, string_expr};
 use super::py_ast::{AstBuilder, py_err_to_lower};
 use super::stmt::lower_block_with_auto_print;
-use super::validate::{validate_yield_usage_awk, validate_yield_usage_program};
+use super::validate::{
+    validate_yield_usage_awk, validate_yield_usage_blocks, validate_yield_usage_program,
+};
 
 pub fn lower_program(py: Python<'_>, program: &Program) -> Result<PyObject, LowerError> {
     lower_program_with_auto_print(py, program, false)
@@ -18,14 +20,50 @@ pub fn lower_program_with_auto_print(
     py: Python<'_>,
     program: &Program,
     auto_print_last: bool,
+) -> Result<PyObject, LowerError> {
+    lower_program_with_begin_end(py, program, &[], &[], auto_print_last)
+}
+
+pub fn lower_program_with_begin_end(
+    py: Python<'_>,
+    program: &Program,
+    begin_blocks: &[Vec<Stmt>],
+    end_blocks: &[Vec<Stmt>],
+    auto_print_last: bool,
 ) -> Result<PyObject, LowerError> {
     let mut hoister = LambdaHoister::new();
+    let begin_blocks: Vec<Vec<Stmt>> = begin_blocks
+        .iter()
+        .map(|block| hoister.desugar_block(block))
+        .collect();
     let program = hoister.desugar_program(program);
+    let end_blocks: Vec<Vec<Stmt>> = end_blocks
+        .iter()
+        .map(|block| hoister.desugar_block(block))
+        .collect();
     validate_yield_usage_program(&program)?;
+    validate_yield_usage_blocks(&begin_blocks)?;
+    validate_yield_usage_blocks(&end_blocks)?;
     let builder = AstBuilder::new(py).map_err(py_err_to_lower)?;
-    let body =
-        lower_block_with_auto_print(&builder, &program.stmts, auto_print_last, &program.span)?;
-    builder.module(body, &program.span).map_err(py_err_to_lower)
+    let span = program.span.clone();
+    let mut body = Vec::new();
+
+    for block in begin_blocks {
+        let lowered =
+            lower_block_with_auto_print(&builder, block.as_slice(), auto_print_last, &span)?;
+        body.extend(lowered);
+    }
+
+    let main_body = lower_block_with_auto_print(&builder, &program.stmts, auto_print_last, &span)?;
+    body.extend(main_body);
+
+    for block in end_blocks {
+        let lowered =
+            lower_block_with_auto_print(&builder, block.as_slice(), auto_print_last, &span)?;
+        body.extend(lowered);
+    }
+
+    builder.module(body, &span).map_err(py_err_to_lower)
 }
 
 pub fn lower_awk_program(py: Python<'_>, program: &AwkProgram) -> Result<PyObject, LowerError> {

{snail_lang-0.7.2 → snail_lang-0.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "snail-lang"
-version = "0.7.2"
+version = "0.7.4"
 description = "Snail programming language interpreter"
 readme = "README.md"
 requires-python = ">=3.8"

{snail_lang-0.7.2 → snail_lang-0.7.4}/python/snail/cli.py

@@ -6,10 +6,7 @@ from typing import Optional
 
 from . import __build_info__, compile_ast, exec
 
-_USAGE = (
-    "snail [options] -f <file> [args]...\n"
-    "       snail [options] <code> [args]..."
-)
+_USAGE = "snail [options] -f <file> [args]...\n       snail [options] <code> [args]..."
 _DESCRIPTION = "Snail programming language interpreter"
 _BOOLEAN_FLAGS = frozenset("amPIvh")
 _VALUE_FLAGS = frozenset("fbe")
@@ -119,11 +116,11 @@ def _print_help(file=None) -> None:
     print("  -a, --awk               awk mode", file=file)
     print("  -m, --map               map mode (process files one at a time)", file=file)
     print(
-        "  -b, --begin <code>       begin block code (awk/map mode, repeatable)",
+        "  -b, --begin <code>       begin block code (repeatable)",
         file=file,
     )
     print(
-        "  -e, --end <code>         end block code (awk/map mode, repeatable)",
+        "  -e, --end <code>         end block code (repeatable)",
         file=file,
     )
     print(
@@ -131,7 +128,9 @@ def _print_help(file=None) -> None:
         file=file,
     )
     print("  -I, --no-auto-import    disable auto-imports", file=file)
-    print("  --debug                 parse and compile, then print, do not run", file=file)
+    print(
+        "  --debug                 parse and compile, then print, do not run", file=file
+    )
     print("  --debug-snail-ast       parse and print Snail AST, do not run", file=file)
     print("  --debug-python-ast      parse and print Python AST, do not run", file=file)
     print("  -v, --version           show version and exit", file=file)
@@ -170,9 +169,7 @@ def _expand_short_options(argv: list[str]) -> list[str]:
                     expanded.append(f"-{flag}")
                     pos += 1
                     continue
-                if all(
-                    ch in _BOOLEAN_FLAGS or ch in _VALUE_FLAGS for ch in remainder
-                ):
+                if all(ch in _BOOLEAN_FLAGS or ch in _VALUE_FLAGS for ch in remainder):
                     raise ValueError(
                         f"option -{flag} requires an argument and must be last in a "
                         "combined flag group"
@@ -290,9 +287,7 @@ def _get_version() -> str:
 
 def _format_python_runtime() -> str:
     version = (
-        f"{sys.version_info.major}."
-        f"{sys.version_info.minor}."
-        f"{sys.version_info.micro}"
+        f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
     )
     executable = sys.executable or "<unknown>"
     if executable != "<unknown>":
@@ -325,14 +320,6 @@ def main(argv: Optional[list[str]] = None) -> int:
         print("error: --awk and --map cannot be used together", file=sys.stderr)
         return 2
 
-    # Validate -b/--begin and -e/--end only with --awk or --map mode
-    if (namespace.begin_code or namespace.end_code) and not (namespace.awk or namespace.map):
-        print(
-            "error: -b/--begin and -e/--end options require --awk or --map mode",
-            file=sys.stderr,
-        )
-        return 2
-
     mode = "map" if namespace.map else ("awk" if namespace.awk else "snail")
 
     if namespace.file:

snail_lang-0.7.4/python/snail/runtime/structured_accessor.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import json as _json
+import os as _os
+import sys as _sys
+
+
+def _append_transpiled_char(out: list[str], ch: str) -> None:
+    if ch == "'":
+        out.append("\\")
+        out.append("'")
+        return
+    if ch == "\\":
+        out.append("\\")
+        out.append("\\")
+        return
+    out.append(ch)
+
+
+def _transpile_jmespath_query(query: str) -> str:
+    out: list[str] = []
+    state = "normal"
+    i = 0
+    while i < len(query):
+        ch = query[i]
+        if state == "normal":
+            if ch == "\\" and i + 1 < len(query) and query[i + 1] == '"':
+                out.append('"')
+                i += 2
+                continue
+            if ch == "'":
+                state = "single"
+                out.append(ch)
+                i += 1
+                continue
+            if ch == "`":
+                state = "backtick"
+                out.append(ch)
+                i += 1
+                continue
+            if ch == '"':
+                state = "double"
+                out.append("'")
+                i += 1
+                continue
+            out.append(ch)
+            i += 1
+            continue
+
+        if state == "single":
+            out.append(ch)
+            if ch == "\\" and i + 1 < len(query):
+                out.append(query[i + 1])
+                i += 2
+                continue
+            if ch == "'":
+                state = "normal"
+            i += 1
+            continue
+
+        if state == "backtick":
+            out.append(ch)
+            if ch == "\\" and i + 1 < len(query):
+                out.append(query[i + 1])
+                i += 2
+                continue
+            if ch == "`":
+                state = "normal"
+            i += 1
+            continue
+
+        if state == "double":
+            if ch == '"':
+                out.append("'")
+                state = "normal"
+                i += 1
+                continue
+            if ch == "\\" and i + 1 < len(query):
+                nxt = query[i + 1]
+                if nxt == '"':
+                    _append_transpiled_char(out, '"')
+                    i += 2
+                    continue
+                if nxt == "\\":
+                    _append_transpiled_char(out, "\\")
+                    i += 2
+                    continue
+                _append_transpiled_char(out, "\\")
+                i += 1
+                continue
+            _append_transpiled_char(out, ch)
+            i += 1
+
+    return "".join(out)
+
+
+def __snail_jmespath_query(query: str):
+    """Create a callable that applies JMESPath query.
+
+    Used by the $[query] syntax which lowers to __snail_jmespath_query(query).
+    """
+
+    import jmespath as _jmespath
+
+    transpiled = _transpile_jmespath_query(query)
+
+    def apply(data):
+        return _jmespath.search(transpiled, data)
+
+    return apply
+
+
+def _parse_jsonl(content: str):
+    lines = [line for line in content.splitlines() if line.strip()]
+    if not lines:
+        return []
+
+    items = []
+    for line in lines:
+        try:
+            items.append(_json.loads(line))
+        except _json.JSONDecodeError as exc:
+            raise _json.JSONDecodeError(
+                f"Invalid JSONL line: {exc.msg}",
+                line,
+                exc.pos,
+            ) from exc
+    return items
+
+
+def js(input_data=None):
+    """Parse JSON from various input sources.
+
+    Returns the parsed Python object (dict, list, etc.) directly.
+    If called with no arguments, reads from stdin.
+    """
+    if input_data is None:
+        input_data = _sys.stdin
+
+    if isinstance(input_data, str):
+        try:
+            return _json.loads(input_data)
+        except _json.JSONDecodeError:
+            if _os.path.exists(input_data):
+                with open(input_data, "r", encoding="utf-8") as handle:
+                    content = handle.read()
+                try:
+                    return _json.loads(content)
+                except _json.JSONDecodeError:
+                    return _parse_jsonl(content)
+            else:
+                return _parse_jsonl(input_data)
+    elif hasattr(input_data, "read"):
+        content = input_data.read()
+        if isinstance(content, bytes):
+            content = content.decode("utf-8")
+        try:
+            return _json.loads(content)
+        except _json.JSONDecodeError:
+            return _parse_jsonl(content)
+    elif isinstance(input_data, (dict, list, int, float, bool)) or input_data is None:
+        return input_data
+    else:
+        raise TypeError(
+            f"js() input must be JSON-compatible, got {type(input_data).__name__}"
+        )

snail_lang-0.7.2/python/snail/runtime/structured_accessor.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import json as _json
-import os as _os
-import sys as _sys
-
-def __snail_jmespath_query(query: str):
-    """Create a callable that applies JMESPath query.
-
-    Used by the $[query] syntax which lowers to __snail_jmespath_query(query).
-    """
-
-    import jmespath as _jmespath
-
-    def apply(data):
-        return _jmespath.search(query, data)
-
-    return apply
-
-
-def _parse_jsonl(content: str):
-    lines = [line for line in content.splitlines() if line.strip()]
-    if not lines:
-        return []
-
-    items = []
-    for line in lines:
-        try:
-            items.append(_json.loads(line))
-        except _json.JSONDecodeError as exc:
-            raise _json.JSONDecodeError(
-                f"Invalid JSONL line: {exc.msg}",
-                line,
-                exc.pos,
-            ) from exc
-    return items
-
-
-def js(input_data=None):
-    """Parse JSON from various input sources.
-
-    Returns the parsed Python object (dict, list, etc.) directly.
-    If called with no arguments, reads from stdin.
-    """
-    if input_data is None:
-        input_data = _sys.stdin
-
-    if isinstance(input_data, str):
-        try:
-            return _json.loads(input_data)
-        except _json.JSONDecodeError:
-            if _os.path.exists(input_data):
-                with open(input_data, "r", encoding="utf-8") as handle:
-                    content = handle.read()
-                try:
-                    return _json.loads(content)
-                except _json.JSONDecodeError:
-                    return _parse_jsonl(content)
-            else:
-                return _parse_jsonl(input_data)
-    elif hasattr(input_data, "read"):
-        content = input_data.read()
-        if isinstance(content, bytes):
-            content = content.decode("utf-8")
-        try:
-            return _json.loads(content)
-        except _json.JSONDecodeError:
-            return _parse_jsonl(content)
-    elif isinstance(input_data, (dict, list, int, float, bool)) or input_data is None:
-        return input_data
-    else:
-        raise TypeError(
-            f"js() input must be JSON-compatible, got {type(input_data).__name__}"
-        )