shellsim 0.1.5__tar.gz → 0.1.8__tar.gz

{shellsim-0.1.5 → shellsim-0.1.8}/Cargo.lock

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

{shellsim-0.1.5 → shellsim-0.1.8}/Cargo.toml

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

{shellsim-0.1.5 → shellsim-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shellsim
-Version: 0.1.5
+Version: 0.1.8
 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.5 → shellsim-0.1.8}/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.5 → shellsim-0.1.8}/python/native/Cargo.lock

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

{shellsim-0.1.5 → shellsim-0.1.8}/python/native/Cargo.toml

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

{shellsim-0.1.5 → shellsim-0.1.8}/python/shellsim/_cli.py

@@ -148,7 +148,10 @@ def _interactive(environment: Environment, stdin: Any, stdout: Any, stderr: Any)
 def main(arguments: Optional[Sequence[str]] = None) -> int:
     """Run the package CLI and return the simulated or usage exit status."""
 
-    options = _parser().parse_args(sys.argv[1:] if arguments is None else arguments)
+    parsed_arguments = list(sys.argv[1:] if arguments is None else arguments)
+    if parsed_arguments[-1:] == ["--"]:
+        parsed_arguments.pop()
+    options = _parser().parse_args(parsed_arguments)
     environment, preparation_status = _prepare_environment(options, sys.stdout, sys.stderr)
     if environment is None:
         return preparation_status

{shellsim-0.1.5 → shellsim-0.1.8}/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.5 → shellsim-0.1.8}/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.5 → shellsim-0.1.8}/src/python/heap.rs

@@ -48,6 +48,10 @@ impl SymbolId {
     pub(super) const fn index(self) -> usize {
         self.0 as usize
     }
+
+    pub(super) fn from_index(index: usize) -> Option<Self> {
+        u32::try_from(index).ok().map(Self)
+    }
 }
 
 /// Runtime-local identity for one append-only instance storage layout.
@@ -386,6 +390,43 @@ impl Heap {
         self.symbol_ids.get(name).copied()
     }
 
+    /// Resolve a symbol identity back to its interpreter-owned name.
+    pub fn symbol_name(&self, symbol: SymbolId) -> Option<&str> {
+        self.symbol_names.get(symbol.index()).map(AsRef::as_ref)
+    }
+
+    /// Snapshot the names stored directly on an instance in either attribute representation.
+    pub fn instance_attribute_names(&self, id: ObjectId) -> Result<Vec<String>, String> {
+        let object = self
+            .objects
+            .get(id.0)
+            .and_then(Option::as_ref)
+            .ok_or("invalid object reference")?;
+        let Object::Instance { attributes, .. } = &object.payload else {
+            return Err("object does not have instance attributes".into());
+        };
+        match attributes {
+            InstanceAttributes::Shaped { shape, values } => (0..values.len())
+                .map(|slot| {
+                    let symbol = self
+                        .shape_attribute_at(*shape, slot)
+                        .ok_or("invalid instance shape slot")?;
+                    self.symbol_name(symbol)
+                        .map(str::to_string)
+                        .ok_or_else(|| "invalid instance attribute symbol".into())
+                })
+                .collect(),
+            InstanceAttributes::Dictionary(values) => values
+                .keys()
+                .map(|symbol| {
+                    self.symbol_name(*symbol)
+                        .map(str::to_string)
+                        .ok_or_else(|| "invalid instance attribute symbol".into())
+                })
+                .collect(),
+        }
+    }
+
     /// Intern one identifier, charging its process-lifetime storage before mutation.
     pub fn intern_symbol(
         &mut self,

{shellsim-0.1.5 → shellsim-0.1.8}/src/python/object_model.rs

@@ -883,6 +883,7 @@ fn install_builtin_slots(types: &mut [PyType]) {
     slots.add = Some(intrinsic(super::stdlib::core::slot_string_add));
     slots.multiply = Some(intrinsic(super::stdlib::core::slot_string_multiply));
     slots.reflected_multiply = Some(intrinsic(super::stdlib::core::slot_string_multiply));
+    slots.remainder = Some(intrinsic(super::stdlib::core::slot_string_remainder));
 
     let slots = &mut types[BuiltinType::Bytes as usize].slots;
     slots.length = Some(unary(super::stdlib::core::slot_bytes_length));

{shellsim-0.1.5 → shellsim-0.1.8}/src/python/stdlib/bisect.rs

@@ -8,32 +8,67 @@ use std::cmp::Ordering;
 
 use super::super::native::PyValue as Value;
 use super::super::native::{
-    CallArgs, FunctionDef, ModuleDef, PyError, PyResult, PyRuntime, PySequence, PyValueCast,
+    CallArgs, FunctionDef, ModuleDef, PyError, PyList, PyResult, PyRuntime, PySequence, PyValueCast,
 };
 
 pub(super) static MODULE: ModuleDef = ModuleDef {
     name: "bisect",
-    functions: &[FunctionDef {
-        module: "bisect",
-        name: "bisect_left",
-        call: native_bisect_left,
-    }],
+    functions: &[
+        FunctionDef {
+            module: "bisect",
+            name: "bisect_left",
+            call: native_bisect_left,
+        },
+        FunctionDef {
+            module: "bisect",
+            name: "bisect_right",
+            call: native_bisect_right,
+        },
+        FunctionDef {
+            module: "bisect",
+            name: "bisect",
+            call: native_bisect_right,
+        },
+        FunctionDef {
+            module: "bisect",
+            name: "insort_left",
+            call: native_insort_left,
+        },
+        FunctionDef {
+            module: "bisect",
+            name: "insort_right",
+            call: native_insort_right,
+        },
+        FunctionDef {
+            module: "bisect",
+            name: "insort",
+            call: native_insort_right,
+        },
+    ],
     values: &[],
 };
 
 fn native_bisect_left(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
-    args.expect_positional("bisect_left", 2, 2)?;
-    args.reject_keywords("bisect_left")?;
+    native_bisect(runtime, args, false)
+}
+
+fn native_bisect_right(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_bisect(runtime, args, true)
+}
+
+fn native_bisect(runtime: &mut dyn PyRuntime, args: CallArgs, right: bool) -> PyResult {
+    args.expect_positional("bisect", 2, 4)?;
+    args.reject_keywords("bisect")?;
     let values = args.positional()[0]
         .cast::<PySequence>(runtime)?
         .items(runtime)?;
     let needle = &args.positional()[1];
-    let mut low = 0usize;
-    let mut high = values.len();
+    let (mut low, mut high) = bisect_bounds(runtime, &args, values.len())?;
     while low < high {
         runtime.charge_cpu(1)?;
         let middle = low + (high - low) / 2;
-        if runtime.compare(&values[middle], needle)? == Ordering::Less {
+        let ordering = runtime.compare(&values[middle], needle)?;
+        if ordering == Ordering::Less || (right && ordering == Ordering::Equal) {
             low = middle + 1;
         } else {
             high = middle;
@@ -44,6 +79,69 @@ fn native_bisect_left(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
         .map_err(|_| PyError::overflow_error("bisect result exceeds bounded integer range"))
 }
 
+fn bisect_bounds(
+    runtime: &dyn PyRuntime,
+    args: &CallArgs,
+    length: usize,
+) -> PyResult<(usize, usize)> {
+    let low = args
+        .positional()
+        .get(2)
+        .map(|value| {
+            runtime
+                .int_value(value)
+                .ok_or_else(|| PyError::type_error("lo must be an integer"))
+                .and_then(|value| {
+                    usize::try_from(value)
+                        .map_err(|_| PyError::value_error("lo must be non-negative"))
+                })
+        })
+        .transpose()?
+        .unwrap_or(0);
+    let high = args
+        .positional()
+        .get(3)
+        .map(|value| {
+            runtime
+                .int_value(value)
+                .ok_or_else(|| PyError::type_error("hi must be an integer"))
+                .and_then(|value| {
+                    usize::try_from(value)
+                        .map_err(|_| PyError::value_error("hi must be non-negative"))
+                })
+        })
+        .transpose()?
+        .unwrap_or(length);
+    if high > length {
+        return Err(PyError::value_error("hi exceeds sequence length"));
+    }
+    Ok((low, high))
+}
+
+fn native_insort_left(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_insort(runtime, args, false)
+}
+
+fn native_insort_right(runtime: &mut dyn PyRuntime, args: CallArgs) -> PyResult {
+    native_insort(runtime, args, true)
+}
+
+fn native_insort(runtime: &mut dyn PyRuntime, args: CallArgs, right: bool) -> PyResult {
+    let list = args
+        .positional()
+        .first()
+        .copied()
+        .ok_or_else(|| PyError::type_error("insort expected a list and a value"))?
+        .cast::<PyList>(runtime)?;
+    let index_value = native_bisect(runtime, args.clone(), right)?;
+    let index = runtime
+        .int_value(&index_value)
+        .and_then(|index| usize::try_from(index).ok())
+        .ok_or_else(|| PyError::runtime_error("bisect returned an invalid index"))?;
+    runtime.list_insert(list, index, args.positional()[1])?;
+    Ok(Value::None)
+}
+
 /// Errors for an explicitly bounded search.
 #[cfg(test)]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]