shellsim 0.1.7__tar.gz → 0.1.9__tar.gz

{shellsim-0.1.7 → shellsim-0.1.9}/Cargo.lock

@@ -330,7 +330,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.7"
+version = "0.1.9"
 dependencies = [
  "base64",
  "crc32fast",

{shellsim-0.1.7 → shellsim-0.1.9}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shellsim"
-version = "0.1.7"
+version = "0.1.9"
 edition = "2021"
 description = "In-process BusyBox-like environment for RL rollouts and agent tests"
 license = "Apache-2.0"

{shellsim-0.1.7 → shellsim-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.7
+Version: 0.1.9
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS :: MacOS X
@@ -160,8 +160,10 @@ printf '%s\n' \
 
 CPU is deterministic fuel, memory is modeled working set, disk is current virtual-filesystem
 usage, and output bounds materialized stdout and stderr. The defaults are 10,000,000 CPU units,
-64 MiB memory, 64 MiB disk, and 4 MiB output. Costs are stable and intentionally approximate.
-Exhaustion is observable and never falls back to an ambient host implementation.
+64 MiB memory, 64 MiB disk, and 4 MiB output. Costs use simple, stable approximations intended to
+be correct within an order of magnitude. They bound runaway work and make runs comparable; they
+do not model allocator layouts or instruction timing exactly. Exhaustion is observable and never
+falls back to an ambient host implementation.
 
 For internals and contribution workflow, see [implementation](docs/implementation.md),
 [Python](docs/python.md), and [CONTRIBUTING.md](CONTRIBUTING.md).

{shellsim-0.1.7 → shellsim-0.1.9}/README.md

@@ -137,8 +137,10 @@ printf '%s\n' \
 
 CPU is deterministic fuel, memory is modeled working set, disk is current virtual-filesystem
 usage, and output bounds materialized stdout and stderr. The defaults are 10,000,000 CPU units,
-64 MiB memory, 64 MiB disk, and 4 MiB output. Costs are stable and intentionally approximate.
-Exhaustion is observable and never falls back to an ambient host implementation.
+64 MiB memory, 64 MiB disk, and 4 MiB output. Costs use simple, stable approximations intended to
+be correct within an order of magnitude. They bound runaway work and make runs comparable; they
+do not model allocator layouts or instruction timing exactly. Exhaustion is observable and never
+falls back to an ambient host implementation.
 
 For internals and contribution workflow, see [implementation](docs/implementation.md),
 [Python](docs/python.md), and [CONTRIBUTING.md](CONTRIBUTING.md).

{shellsim-0.1.7 → shellsim-0.1.9}/python/native/Cargo.lock

@@ -406,7 +406,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim"
-version = "0.1.7"
+version = "0.1.9"
 dependencies = [
  "base64",
  "crc32fast",
@@ -427,7 +427,7 @@ dependencies = [
 
 [[package]]
 name = "shellsim-python-bindings"
-version = "0.1.7"
+version = "0.1.9"
 dependencies = [
  "pyo3",
  "serde",

{shellsim-0.1.7 → shellsim-0.1.9}/python/native/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "shellsim-python-bindings"
-version = "0.1.7"
+version = "0.1.9"
 edition = "2021"
 description = "Python bindings for shellsim"
 license = "Apache-2.0"

{shellsim-0.1.7 → shellsim-0.1.9}/src/commands/builtins.rs

@@ -50,7 +50,7 @@ pub fn register(m: &mut HashMap<&'static str, CommandSpec>) {
     reg_resumable(m, &["command"], Trust::Real, cmd_command, start_command);
     reg(m, &["alias"], Trust::Partial, cmd_alias);
     reg(m, &["unalias"], Trust::Real, cmd_unalias);
-    reg_unsupported(m, &["getopts"]);
+    reg(m, &["getopts"], Trust::Real, cmd_getopts);
     reg(m, &["let"], Trust::Real, cmd_let);
     reg(m, &["mapfile", "readarray"], Trust::Real, cmd_mapfile);
     reg(m, &["pushd"], Trust::Real, cmd_pushd);
@@ -1259,6 +1259,125 @@ fn cmd_shift(interp: &mut CommandContext<'_>, args: &[String], _io: &mut Io) ->
     0
 }
 
+fn cmd_getopts(interp: &mut CommandContext<'_>, args: &[String], io: &mut Io) -> i32 {
+    if args.len() < 2 {
+        ewln(io.err, "getopts: usage: getopts optstring name [arg ...]");
+        return 2;
+    }
+    let optstring = &args[0];
+    let name = &args[1];
+    let operands = if args.len() > 2 {
+        args[2..].to_vec()
+    } else {
+        interp.positional.clone()
+    };
+    let visible_optind = interp
+        .get_var("OPTIND")
+        .and_then(|value| value.parse::<usize>().ok())
+        .filter(|value| *value > 0)
+        .unwrap_or(1);
+    if visible_optind != interp.getopts.optind {
+        interp.getopts.optind = visible_optind;
+        interp.getopts.offset = 1;
+    }
+
+    let argument_index = interp.getopts.optind - 1;
+    let Some(argument) = operands.get(argument_index) else {
+        set_getopts_optind(interp);
+        return 1;
+    };
+    if argument == "--" {
+        interp.getopts.optind += 1;
+        interp.getopts.offset = 1;
+        set_getopts_optind(interp);
+        return 1;
+    }
+    let option_characters = argument.chars().collect::<Vec<_>>();
+    if !argument.starts_with('-')
+        || argument == "-"
+        || interp.getopts.offset >= option_characters.len()
+    {
+        set_getopts_optind(interp);
+        return 1;
+    }
+
+    let option = option_characters[interp.getopts.offset];
+    let silent = optstring.starts_with(':');
+    let specification = optstring
+        .trim_start_matches(':')
+        .chars()
+        .collect::<Vec<_>>();
+    let Some(specification_index) = specification
+        .iter()
+        .position(|candidate| *candidate == option)
+    else {
+        advance_getopts(interp, option_characters.len());
+        if silent {
+            interp.set_var("OPTARG", option.to_string());
+        } else {
+            interp.vars.remove("OPTARG");
+        }
+        interp.set_var(name, "?");
+        set_getopts_optind(interp);
+        if !silent {
+            ewln(io.err, &format!("getopts: illegal option -- {option}"));
+        }
+        return 0;
+    };
+    let requires_argument = specification.get(specification_index + 1) == Some(&':');
+    if !requires_argument {
+        advance_getopts(interp, option_characters.len());
+        interp.vars.remove("OPTARG");
+        interp.set_var(name, option.to_string());
+        set_getopts_optind(interp);
+        return 0;
+    }
+
+    let inline = option_characters[interp.getopts.offset + 1..]
+        .iter()
+        .collect::<String>();
+    let option_argument = if !inline.is_empty() {
+        interp.getopts.optind += 1;
+        inline
+    } else if let Some(value) = operands.get(argument_index + 1) {
+        interp.getopts.optind += 2;
+        value.clone()
+    } else {
+        interp.getopts.optind += 1;
+        interp.getopts.offset = 1;
+        set_getopts_optind(interp);
+        interp.set_var(name, if silent { ":" } else { "?" });
+        if silent {
+            interp.set_var("OPTARG", option.to_string());
+        } else {
+            interp.vars.remove("OPTARG");
+            ewln(
+                io.err,
+                &format!("getopts: option requires an argument -- {option}"),
+            );
+        }
+        return 0;
+    };
+    interp.getopts.offset = 1;
+    interp.set_var("OPTARG", option_argument);
+    interp.set_var(name, option.to_string());
+    set_getopts_optind(interp);
+    0
+}
+
+fn advance_getopts(interp: &mut CommandContext<'_>, argument_length: usize) {
+    interp.getopts.offset += 1;
+    if interp.getopts.offset >= argument_length {
+        interp.getopts.optind += 1;
+        interp.getopts.offset = 1;
+    }
+}
+
+fn set_getopts_optind(interp: &mut CommandContext<'_>) {
+    let value = interp.getopts.optind.to_string();
+    interp.vars.insert("OPTIND".to_string(), value);
+}
+
 fn cmd_test(interp: &mut CommandContext<'_>, args: &[String], io: &mut Io) -> i32 {
     eval_test_cmd(interp, "test", args, io)
 }

{shellsim-0.1.7 → shellsim-0.1.9}/src/interp.rs

@@ -24,6 +24,13 @@ pub enum ArrayVal {
     Assoc(BTreeMap<String, String>),
 }
 
+/// Cursor retained between calls to the `getopts` shell builtin.
+#[derive(Clone, Debug)]
+pub(crate) struct GetoptsState {
+    pub(crate) optind: usize,
+    pub(crate) offset: usize,
+}
+
 /// A simulated background job started with `&`.
 ///
 /// Its process continuation is owned separately by [`ProcessStates`]. This shell-facing record
@@ -144,6 +151,7 @@ pub struct ProcessState {
     random_state: Cell<u32>,
     /// positional parameters `$1 $2 ... $@`
     pub positional: Vec<String>,
+    pub(crate) getopts: GetoptsState,
     /// `set -e` / `set -u` / `set -x`
     pub opt_errexit: bool,
     pub opt_nounset: bool,
@@ -316,6 +324,7 @@ impl ProcessState {
             last_status: self.last_status,
             random_state: Cell::new(self.random_state.get()),
             positional: self.positional.clone(),
+            getopts: self.getopts.clone(),
             opt_errexit: self.opt_errexit,
             opt_nounset: self.opt_nounset,
             opt_xtrace: self.opt_xtrace,
@@ -550,6 +559,10 @@ impl Environment {
                 last_status: 0,
                 random_state: Cell::new(1),
                 positional: Vec::new(),
+                getopts: GetoptsState {
+                    optind: 1,
+                    offset: 1,
+                },
                 opt_errexit: false,
                 opt_nounset: false,
                 opt_xtrace: false,
@@ -1457,6 +1470,14 @@ impl Environment {
         if name == "PWD" {
             self.cwd = val.clone();
         }
+        if name == "OPTIND" {
+            self.getopts.optind = val
+                .parse::<usize>()
+                .ok()
+                .filter(|value| *value > 0)
+                .unwrap_or(1);
+            self.getopts.offset = 1;
+        }
         // A plain scalar assignment to an array name in bash sets element 0; we instead treat it
         // as a fresh scalar (drop the array) — the common case in our scripts and lower-risk.
         self.arrays.remove(name);

{shellsim-0.1.7 → shellsim-0.1.9}/src/python/ast.rs

@@ -173,14 +173,13 @@ pub enum ExpressionKind {
         value: Box<Expression>,
         clauses: Vec<ComprehensionClause>,
     },
-    /// The VM deliberately materializes this as a list for now.  This gives
-    /// generator expressions an ordinary iterable and isolated comprehension
-    /// scope while keeping the bounded-resource contract simple and explicit.
+    /// A lazy comprehension evaluated in its own generator frame.
     GeneratorExpression {
         element: Box<Expression>,
         clauses: Vec<ComprehensionClause>,
     },
     Yield(Option<Box<Expression>>),
+    YieldFrom(Box<Expression>),
     Attribute {
         value: Box<Expression>,
         name: String,

{shellsim-0.1.7 → shellsim-0.1.9}/src/python/compiler.rs

@@ -936,10 +936,7 @@ impl Compiler {
                 self.emit_dict_comprehension(*key, *value, clauses, span);
             }
             ExpressionKind::GeneratorExpression { element, clauses } => {
-                // The first implementation intentionally materializes generator expressions.
-                // It is still a separate function scope (like CPython's generator frame), and
-                // all iteration remains metered by the ordinary bytecode loop.
-                self.emit_comprehension(ComprehensionKind::List, *element, clauses, span);
+                self.emit_generator_expression(*element, clauses, span);
             }
             ExpressionKind::Yield(value) => {
                 if !self.in_function {
@@ -947,11 +944,6 @@ impl Compiler {
                         Operation::RuntimeError("'yield' outside function".into()),
                         span,
                     );
-                } else if let Some(region) = self.protected_regions.last() {
-                    self.emit(
-                        Operation::RuntimeError(format!("yield is not supported inside a {region} cleanup region; suspending here would lose exception or context-manager state")),
-                        span,
-                    );
                 } else {
                     if let Some(value) = value {
                         self.expression(*value);
@@ -961,6 +953,24 @@ impl Compiler {
                     self.emit(Operation::Yield, span);
                 }
             }
+            ExpressionKind::YieldFrom(value) => {
+                if !self.in_function {
+                    self.emit(
+                        Operation::RuntimeError("'yield from' outside function".into()),
+                        span,
+                    );
+                } else {
+                    self.expression(*value);
+                    self.emit(Operation::GetIterator, span);
+                    let next = self.emit(Operation::ForIterator(usize::MAX), span);
+                    self.emit(Operation::Yield, span);
+                    self.emit(Operation::PopTop, span);
+                    self.emit(Operation::Jump(next), span);
+                    let exhausted = self.instructions.len();
+                    self.patch_jump(next, exhausted);
+                    self.emit(Operation::LoadConstant(Constant::None), span);
+                }
+            }
             ExpressionKind::Attribute { value, name } => {
                 self.expression(*value);
                 self.emit(Operation::LoadAttribute(name), span);
@@ -1216,6 +1226,46 @@ impl Compiler {
         );
     }
 
+    fn emit_generator_expression(
+        &mut self,
+        element: Expression,
+        clauses: Vec<ComprehensionClause>,
+        span: Span,
+    ) {
+        let named_expression = self.comprehension_named_expression_context();
+        let mut nested = Compiler {
+            instructions: Vec::new(),
+            loops: Vec::new(),
+            finalizers: Vec::new(),
+            protected_regions: Vec::new(),
+            in_function: true,
+            globals: HashSet::new(),
+            nonlocals: HashSet::new(),
+            named_expression,
+            is_class_scope: false,
+            structural_depth: self.structural_depth,
+        };
+        nested.emit_generator_comprehension_body(&clauses, 0, &element, span);
+        nested.emit(Operation::LoadConstant(Constant::None), span);
+        nested.emit(Operation::Return, span);
+        self.emit(
+            Operation::MakeFunction {
+                name: "<genexpr>".into(),
+                code: nested.finish(Vec::new()),
+                defaults: 0,
+            },
+            span,
+        );
+        self.emit(
+            Operation::Call {
+                positional: 0,
+                keywords: Vec::new(),
+                starred: Vec::new(),
+            },
+            span,
+        );
+    }
+
     fn emit_dict_comprehension(
         &mut self,
         key: Expression,
@@ -1307,6 +1357,35 @@ impl Compiler {
         self.patch_jump(next, exhausted);
     }
 
+    fn emit_generator_comprehension_body(
+        &mut self,
+        clauses: &[ComprehensionClause],
+        index: usize,
+        element: &Expression,
+        span: Span,
+    ) {
+        let clause = &clauses[index];
+        self.expression(clause.iterable.clone());
+        self.emit(Operation::GetIterator, span);
+        let next = self.emit(Operation::ForIterator(usize::MAX), span);
+        self.store_target(clause.target.clone(), span);
+        for condition in &clause.conditions {
+            self.expression(condition.clone());
+            let skip = self.emit(Operation::PopJumpIfFalse(usize::MAX), span);
+            self.patch_jump(skip, next);
+        }
+        if index + 1 < clauses.len() {
+            self.emit_generator_comprehension_body(clauses, index + 1, element, span);
+        } else {
+            self.expression(element.clone());
+            self.emit(Operation::Yield, span);
+            self.emit(Operation::PopTop, span);
+        }
+        self.emit(Operation::Jump(next), span);
+        let exhausted = self.instructions.len();
+        self.patch_jump(next, exhausted);
+    }
+
     fn emit_dict_comprehension_body(
         &mut self,
         clauses: &[ComprehensionClause],