snail-lang 0.7.3__tar.gz → 0.7.5__tar.gz

{snail_lang-0.7.3 → snail_lang-0.7.5}/Cargo.lock

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

{snail_lang-0.7.3 → snail_lang-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snail-lang
-Version: 0.7.3
+Version: 0.7.5
 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
@@ -287,7 +323,7 @@ Documentation is WIP
 
 ## 🔌 Editor Support
 
-Vim/Neovim plugin with syntax highlighting, formatting, and run commands:
+Vim/Neovim plugin with Tree-sitter-based highlighting (Neovim), formatting, and run commands:
 
 ```vim
 Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }
@@ -340,4 +376,3 @@ cd /tmp/snail-pkg
 makepkg -si
 ```
 
-

{snail_lang-0.7.3 → snail_lang-0.7.5}/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
@@ -274,7 +310,7 @@ Documentation is WIP
 
 ## 🔌 Editor Support
 
-Vim/Neovim plugin with syntax highlighting, formatting, and run commands:
+Vim/Neovim plugin with Tree-sitter-based highlighting (Neovim), formatting, and run commands:
 
 ```vim
 Plug 'sudonym1/snail', { 'rtp': 'extras/vim' }
@@ -326,4 +362,3 @@ cd /tmp/snail-pkg
 # Update pkgver and sha256sums as needed, then build and install
 makepkg -si
 ```
-

{snail_lang-0.7.3 → snail_lang-0.7.5}/crates/snail-ast/Cargo.toml

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

{snail_lang-0.7.3 → snail_lang-0.7.5}/crates/snail-error/Cargo.toml

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

{snail_lang-0.7.3 → snail_lang-0.7.5}/crates/snail-parser/Cargo.toml

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

{snail_lang-0.7.3 → snail_lang-0.7.5}/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.3 → snail_lang-0.7.5}/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.3 → snail_lang-0.7.5}/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.3 → snail_lang-0.7.5}/crates/snail-python/Cargo.toml

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

{snail_lang-0.7.3 → snail_lang-0.7.5}/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.3 → snail_lang-0.7.5}/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)
@@ -107,6 +112,8 @@ fn prepare_globals<'py>(
     filename: &str,
     argv: &[String],
     auto_import: bool,
+    awk_field_separators: Option<String>,
+    awk_include_whitespace: Option<bool>,
 ) -> PyResult<Bound<'py, PyAny>> {
     let runtime = py.import_bound("snail.runtime")?;
 
@@ -126,6 +133,16 @@ fn prepare_globals<'py>(
     sys.setattr("argv", PyList::new_bound(py, argv))?;
 
     runtime.call_method1("install_helpers", (&globals,))?;
+    let separators = awk_field_separators
+        .as_deref()
+        .filter(|value| !value.is_empty());
+    let separators_value = match separators {
+        Some(separators) => separators.into_py(py),
+        None => py.None().into_py(py),
+    };
+    globals.set_item("__snail_awk_field_separators", separators_value)?;
+    let include_whitespace = awk_include_whitespace.unwrap_or(separators.is_none());
+    globals.set_item("__snail_awk_include_whitespace", include_whitespace)?;
 
     Ok(globals)
 }
@@ -196,7 +213,7 @@ fn compile_ast_py(
 }
 
 #[pyfunction(name = "exec")]
-#[pyo3(signature = (source, *, argv = Vec::new(), mode = "snail", auto_print = true, auto_import = true, filename = "<snail>", begin_code = Vec::new(), end_code = Vec::new()))]
+#[pyo3(signature = (source, *, argv = Vec::new(), mode = "snail", auto_print = true, auto_import = true, filename = "<snail>", begin_code = Vec::new(), end_code = Vec::new(), field_separators = None, include_whitespace = None))]
 #[allow(clippy::too_many_arguments)]
 fn exec_py(
     py: Python<'_>,
@@ -208,6 +225,8 @@ fn exec_py(
     filename: &str,
     begin_code: Vec<String>,
     end_code: Vec<String>,
+    field_separators: Option<String>,
+    include_whitespace: Option<bool>,
 ) -> PyResult<i32> {
     let profile = profile_enabled();
     let total_start = Instant::now();
@@ -236,7 +255,14 @@ fn exec_py(
         log_profile("py_compile", compile_start.elapsed());
     }
     let globals_start = Instant::now();
-    let globals = prepare_globals(py, strip_display_prefix(filename), &argv, auto_import)?;
+    let globals = prepare_globals(
+        py,
+        strip_display_prefix(filename),
+        &argv,
+        auto_import,
+        field_separators,
+        include_whitespace,
+    )?;
     if profile {
         log_profile("prepare_globals", globals_start.elapsed());
     }
@@ -277,6 +303,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 +323,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 +377,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.3 → snail_lang-0.7.5}/crates/snail-python/src/lower/awk.rs

@@ -270,23 +270,36 @@ pub(crate) fn lower_awk_line_loop_with_auto_print(
         .call_node(
             "Call",
             vec![
-                builder
-                    .call_node(
-                        "Attribute",
-                        vec![
-                            name_expr(
-                                builder,
-                                SNAIL_AWK_LINE_PYVAR,
-                                span,
-                                builder.load_ctx().map_err(py_err_to_lower)?,
-                            )?,
-                            "split".to_string().into_py(builder.py()),
+                name_expr(
+                    builder,
+                    SNAIL_AWK_SPLIT_HELPER,
+                    span,
+                    builder.load_ctx().map_err(py_err_to_lower)?,
+                )?,
+                PyList::new_bound(
+                    builder.py(),
+                    vec![
+                        name_expr(
+                            builder,
+                            SNAIL_AWK_LINE_PYVAR,
+                            span,
                             builder.load_ctx().map_err(py_err_to_lower)?,
-                        ],
-                        span,
-                    )
-                    .map_err(py_err_to_lower)?,
-                PyList::empty_bound(builder.py()).into_py(builder.py()),
+                        )?,
+                        name_expr(
+                            builder,
+                            SNAIL_AWK_FIELD_SEPARATORS_PYVAR,
+                            span,
+                            builder.load_ctx().map_err(py_err_to_lower)?,
+                        )?,
+                        name_expr(
+                            builder,
+                            SNAIL_AWK_INCLUDE_WHITESPACE_PYVAR,
+                            span,
+                            builder.load_ctx().map_err(py_err_to_lower)?,
+                        )?,
+                    ],
+                )
+                .into_py(builder.py()),
                 PyList::empty_bound(builder.py()).into_py(builder.py()),
             ],
             span,

{snail_lang-0.7.3 → snail_lang-0.7.5}/crates/snail-python/src/lower/constants.rs

@@ -13,6 +13,7 @@ pub const SNAIL_INCR_ATTR: &str = "__snail_incr_attr";
 pub const SNAIL_INCR_INDEX: &str = "__snail_incr_index";
 pub const SNAIL_AUG_ATTR: &str = "__snail_aug_attr";
 pub const SNAIL_AUG_INDEX: &str = "__snail_aug_index";
+pub(crate) const SNAIL_AWK_SPLIT_HELPER: &str = "__snail_awk_split";
 pub(crate) const SNAIL_LET_VALUE: &str = "__snail_let_value";
 pub(crate) const SNAIL_LET_OK: &str = "__snail_let_ok";
 pub(crate) const SNAIL_LET_KEEP: &str = "__snail_let_keep";
@@ -28,6 +29,8 @@ pub(crate) const SNAIL_AWK_MATCH: &str = "$m";
 pub(crate) const SNAIL_AWK_FIELDS: &str = "$f";
 pub(crate) const SNAIL_AWK_LINE_PYVAR: &str = "__snail_line";
 pub(crate) const SNAIL_AWK_FIELDS_PYVAR: &str = "__snail_fields";
+pub(crate) const SNAIL_AWK_FIELD_SEPARATORS_PYVAR: &str = "__snail_awk_field_separators";
+pub(crate) const SNAIL_AWK_INCLUDE_WHITESPACE_PYVAR: &str = "__snail_awk_include_whitespace";
 pub(crate) const SNAIL_AWK_NR_PYVAR: &str = "__snail_nr_user";
 pub(crate) const SNAIL_AWK_FNR_PYVAR: &str = "__snail_fnr_user";
 pub(crate) const SNAIL_AWK_PATH_PYVAR: &str = "__snail_path_user";