zsh::exec

Struct ShellExecutor

pub struct ShellExecutor {Show 57 fields
    pub scriptname: Option<String>,
    pub scriptfilename: Option<String>,
    pub loop_signal: Option<LoopSignal>,
    pub subshell_snapshots: Vec<SubshellSnapshot>,
    pub inline_env_stack: Vec<Vec<(String, Option<String>, Option<String>)>>,
    pub current_command_glob_failed: Cell<bool>,
    pub jobs: JobTable,
    pub fpath: Vec<PathBuf>,
    pub zwc_cache: HashMap<PathBuf, ZwcFile>,
    pub history: Option<HistoryEngine>,
    pub session_histnum: i64,
    pub traps: HashMap<String, String>,
    pub completions: HashMap<String, CompSpec>,
    pub comp_matches: Vec<CompMatch>,
    pub comp_groups: Vec<CompGroup>,
    pub comp_state: CompState,
    pub zstyles: Vec<zstyle_entry>,
    pub comp_words: Vec<String>,
    pub comp_current: i32,
    pub comp_prefix: String,
    pub comp_suffix: String,
    pub comp_iprefix: String,
    pub comp_isuffix: String,
    pub local_scope_depth: usize,
    pub pending_underscore: Option<String>,
    pub in_dq_context: u32,
    pub in_scalar_assign: u32,
    pub session_history_ids: Vec<i64>,
    pub open_fds: HashMap<i32, File>,
    pub next_fd: i32,
    pub profiling_enabled: bool,
    pub compsys_cache: Option<CompsysCache>,
    pub compinit_pending: Option<(Receiver<CompInitBgResult>, Instant)>,
    pub plugin_cache: Option<PluginCache>,
    pub deferred_compdefs: Vec<Vec<String>>,
    pub returning: Option<i32>,
    pub breaking: i32,
    pub continuing: i32,
    pub zsh_compat: bool,
    pub bash_compat: bool,
    pub posix_mode: bool,
    pub worker_pool: Arc<WorkerPool>,
    pub intercepts: Vec<Intercept>,
    pub async_jobs: HashMap<u32, Receiver<(i32, String)>>,
    pub next_async_id: u32,
    pub defer_stack: Vec<Vec<String>>,
    pub redirect_scope_stack: Vec<Vec<(i32, i32)>>,
    pub redirect_failed: bool,
    pub pending_stdin: Option<String>,
    pub functions_compiled: HashMap<String, Chunk>,
    pub function_source: HashMap<String, String>,
    pub function_line_base: HashMap<String, i64>,
    pub function_def_file: HashMap<String, Option<String>>,
    pub prompt_funcstack: Vec<(String, i64, Option<String>)>,
    pub tied_scalar_to_array: HashMap<String, (String, String)>,
    pub tied_array_to_scalar: HashMap<String, (String, String)>,
    pub buffer_stack: Vec<String>,
    /* private fields */
}

Expand description

Top-level shell executor state. Port of the file-static globals + Estate chain Src/exec.c uses — execlist() (line 1349) drives every list, with execpline() (line 1668), execpline2() (line 1991), execsimple() (line 1290), and the per-WC_* execfuncs[] table (line 268) feeding off it. The Rust port collapses everything into one ShellExecutor so we don’t need thread-local globals.

Fields§

§scriptname: Option<String>

Mirrors C zsh’s file-static scriptname (Src/init.c). Used by PS4’s %N and the scriptname:line: … prefix on error messages. Inside a function, MUTATES to the function name (Src/exec.c:5903 scriptname = dupstring(name)). Init sets this in -c mode to the binary basename per init.c:479; when sourcing a file via source/bin_dot, it becomes the resolved file path; otherwise it falls back through $0 → $ZSH_ARGZERO.

§scriptfilename: Option<String>

Mirrors C zsh’s scriptfilename global (Src/init.c). Tracks the FILE BEING READ (vs scriptname which tracks the active function name during a call). Used by PS4’s %x and certain error-message prefixes that want the file location, NOT the function name.

At -c-mode init, scriptname == scriptfilename == “zsh” (Src/init.c:479). When entering a function, ONLY scriptname updates (exec.c:5903); scriptfilename stays at the outer file path, so %x inside a function still shows the file the function was called from.

§loop_signal: Option<LoopSignal>

Set by break/continue keywords when no enclosing loop in the current chunk’s patch lists. Outer-loop builtins (BUILTIN_RUN_SELECT) observe + clear this after each body run.

§subshell_snapshots: Vec<SubshellSnapshot>

Stack of subshell-state snapshots. Each (…) subshell pushes a copy of variables/arrays/assoc_arrays at entry and pops/restores at exit. Without this, (x=inner; …); echo $x shows inner instead of the outer-scope value.

§inline_env_stack: Vec<Vec<(String, Option<String>, Option<String>)>>

Stack of inline-assignment scopes — X=foo Y=bar cmd pushes a frame at the start, the assigns run inside it, and cmd returns into END_INLINE_ENV which restores both shell-vars and process-env to the pre-frame state. Each frame holds (name, prev_var, prev_env) per assigned name. zsh’s equivalent is the parser-level “addvar” list executed under addvars() (Src/exec.c) right before the command exec.

§current_command_glob_failed: Cell<bool>

Set by expand_glob’s no-match arm when nomatch is on (zsh default) — instructs the simple-command dispatcher to skip executing the current command, set last_status=1, and continue to the next command in the script. zsh’s bin_simple uses the errflag global for the same role: error printed, command suppressed, script continues. Without this we were calling process::exit(1) deep inside expand_glob, killing the whole shell on any unmatched glob even with multi-statement input. Cell because the no-match site only has a &self borrow.

§jobs: JobTable§fpath: Vec<PathBuf>§zwc_cache: HashMap<PathBuf, ZwcFile>§history: Option<HistoryEngine>§session_histnum: i64

Session-relative history line counter. Starts at 0; incremented when an interactive command is recorded. Used by %h/%! in prompt expansion (zsh’s “current history line number”), distinct from the persistent disk history total.

§traps: HashMap<String, String>§completions: HashMap<String, CompSpec>§comp_matches: Vec<CompMatch>§comp_groups: Vec<CompGroup>§comp_state: CompState§zstyles: Vec<zstyle_entry>§comp_words: Vec<String>§comp_current: i32§comp_prefix: String§comp_suffix: String§comp_iprefix: String§comp_isuffix: String§local_scope_depth: usize

Current function scope depth for local tracking.

§pending_underscore: Option<String>

Last arg of the currently-running command, deferred into $_ when the next command dispatches. zsh: $_ reflects the LAST command’s last arg, so echo hi; echo $_ prints hi (not the _ arg of echo $_ itself). Promoted in pop_args and host.exec before the command’s args are read.

§in_dq_context: u32

True while expanding inside a double-quoted context. Set by BUILTIN_EXPAND_TEXT mode 1 around expand_string calls. Used by parameter-flag application to suppress array-only flags ((o)/(O)/(n)/(i)/(M)/(u)) — zsh’s behaviour: those flags only fire in array context.

§in_scalar_assign: u32

True (>0) while expanding the RHS of a scalar assignment. Direct port of zsh’s PREFORK_SINGLE bit set by Src/exec.c::addvars line 2546 (prefork(vl, isstr ? (PREFORK_SINGLE|PREFORK_ASSIGN) : PREFORK_ASSIGN, ...)). Subst_port’s paramsubst reads this via ssub and suppresses (f) / (s:STR:) / (0) / (z) split flags per Src/subst.c:1759 + 3902, so y="${(f)x}" preserves x’s original separator (newlines) instead of re-joining with IFS-first-char (space).

§session_history_ids: Vec<i64>

IDs of history entries explicitly added during this session via print -s. fc -l uses this to scope listings to just the script-added entries (matches zsh’s -c semantics where session history is the only thing visible to the script).

§open_fds: HashMap<i32, File>§next_fd: i32§profiling_enabled: bool§compsys_cache: Option<CompsysCache>§compinit_pending: Option<(Receiver<CompInitBgResult>, Instant)>§plugin_cache: Option<PluginCache>§deferred_compdefs: Vec<Vec<String>>§returning: Option<i32>§breaking: i32§continuing: i32§zsh_compat: bool

zsh compatibility mode - use .zcompdump, fpath scanning, etc. Also serves as the --zsh parity-test flag: caches off, daemon off, plugin_cache replay off so every source re-runs the file fresh per Src/builtin.c:6080-6123 bin_dot semantics.

§bash_compat: bool

bash compatibility mode (--bash). Same parity-mode semantics as zsh_compat (caches/daemon/replay off) plus bash-specific behavior tweaks where bash 5.x diverges from zsh — e.g. BASH_VERSION / BASH_REMATCH exposed, [[ =~ ]] populates match indices the bash way, mapfile/readarray as builtins.

§posix_mode: bool

POSIX sh strict mode — no SQLite, no worker pool, no zsh extensions

§worker_pool: Arc<WorkerPool>

Worker thread pool for background tasks (compinit, process subs, etc.)

§intercepts: Vec<Intercept>

AOP intercept table: command/function name → advice chain. Glob patterns supported (e.g. “git ”, “”).

§async_jobs: HashMap<u32, Receiver<(i32, String)>>

Async job handles: id → receiver for (status, stdout)

§next_async_id: u32

Next async job ID

§defer_stack: Vec<Vec<String>>

Defer stack: commands to run on scope exit (LIFO).

§redirect_scope_stack: Vec<Vec<(i32, i32)>>

Per-scope saved-fd stacks for Op::WithRedirectsBegin/End. Each entry is a Vec of (fd, saved_dup_fd) pairs taken from dup(fd) before the redirect was applied; with_redirects_end dup2s them back and closes.

§redirect_failed: bool

Set by host_apply_redirect when a redirect target couldn’t be opened (permission denied, no such directory, etc). The next builtin/command checks this at entry and short-circuits with status 1 instead of running. Mirrors zsh’s “command skip” on redirect failure.

§pending_stdin: Option<String>

Stdin content set by Op::HereDoc(idx) / Op::HereString for the next command/builtin in this VM. Consumed (and cleared) by the next command.

§functions_compiled: HashMap<String, Chunk>

Compiled function bodies — name → fusevm::Chunk. Populated by BUILTIN_REGISTER_FUNCTION (from FunctionDef lowering) and lazily by ZshrsHost::call_function when only an AST exists in self.functions (autoloaded, sourced, etc.). Op::CallFunction dispatches through here.

§function_source: HashMap<String, String>

Canonical source text for functions. Populated by autoload paths (the raw file/cache body), runtime FuncDef compile (the parsed source span), and unfunction removal. Used by introspection (whence, which, typeset -f) instead of reconstructing from a ShellCommand AST. When a function is in functions_compiled but not here, introspection falls back to text::getpermtext(self.functions[name]).

§function_line_base: HashMap<String, i64>

first_body_line - 1 per compiled function — matches inner ZshCompiler::lineno_offset / zsh funcstack->flineno combined with relative $LINENO for Src/prompt.c:909 %I.

§function_def_file: HashMap<String, Option<String>>

scriptfilename when BUILTIN_REGISTER_COMPILED_FN ran — %x inside a function (prompt.c:931-934) reads funcstack->filename.

§prompt_funcstack: Vec<(String, i64, Option<String>)>

Innermost-last stack of active compiled-call frames for prompt %I / %x.

§tied_scalar_to_array: HashMap<String, (String, String)>

Scalar→(array, sep) tie table set up by typeset -T VAR var [SEP]. Used by BUILTIN_SET_VAR to split the assigned scalar on sep and mirror it into array.

§tied_array_to_scalar: HashMap<String, (String, String)>

Array→(scalar, sep) reverse-tie table. Used by BUILTIN_SET_ARRAY to join the array elements with sep and mirror to the scalar side.

§buffer_stack: Vec<String>

ZLE buffer stack — port of bufstack (zsh/Src/builtin.c:4567, LinkList bufstack). print -z (builtin.c:5039-5045) pushes joined args onto it; read -z and getln (builtin.c:6769-6770) pop the top entry as the input source. zsh treats this as a stack shared between the buffer/zle subsystem and the read path.

Struct ShellExecutor Copy item path

Fields§

Implementations§

impl ShellExecutor

pub fn drain_compinit_bg(&mut self)

impl ShellExecutor

pub fn host_apply_redirect(&mut self, fd: u8, op_byte: u8, target: &str)

pub fn host_redirect_scope_begin(&mut self, _count: u8)

pub fn host_redirect_scope_end(&mut self)

pub fn host_set_pending_stdin(&mut self, content: String)

pub fn host_exec_external(&mut self, args: &[String]) -> i32

impl ShellExecutor

pub fn set_scalar(&mut self, name: String, value: String)

pub fn pparams(&self) -> Vec<String>

pub fn set_pparams(&mut self, params: Vec<String>)

pub fn param_flags(&self, name: &str) -> i32

pub fn is_integer_param(&self, name: &str) -> bool

pub fn is_float_param(&self, name: &str) -> bool

pub fn is_lowercase_param(&self, name: &str) -> bool

pub fn is_uppercase_param(&self, name: &str) -> bool

pub fn is_readonly_param(&self, name: &str) -> bool

pub fn last_status(&self) -> i32

pub fn set_last_status(&mut self, status: i32)

pub fn set_array(&mut self, name: String, value: Vec<String>)

pub fn set_assoc(&mut self, name: String, value: IndexMap<String, String>)

pub fn scalar(&self, name: &str) -> Option<String>

pub fn array(&self, name: &str) -> Option<Vec<String>>

pub fn assoc(&self, name: &str) -> Option<IndexMap<String, String>>

pub fn has_scalar(&self, name: &str) -> bool

pub fn has_array(&self, name: &str) -> bool

pub fn has_assoc(&self, name: &str) -> bool

pub fn unset_assoc(&mut self, name: &str)

pub fn alias(&self, name: &str) -> Option<String>

pub fn global_alias(&self, name: &str) -> Option<String>

pub fn suffix_alias(&self, name: &str) -> Option<String>

pub fn set_alias(&mut self, name: String, value: String)

pub fn set_global_alias(&mut self, name: String, value: String)

pub fn set_suffix_alias(&mut self, name: String, value: String)

pub fn unset_alias(&mut self, name: &str)

pub fn unset_suffix_alias(&mut self, name: &str)

pub fn alias_entries(&self) -> Vec<(String, String)>

pub fn global_alias_entries(&self) -> Vec<(String, String)>

pub fn suffix_alias_entries(&self) -> Vec<(String, String)>

pub fn unset_array(&mut self, name: &str)

pub fn unset_scalar(&mut self, name: &str)

pub fn new() -> Self

pub fn add_fpath(&mut self, path: PathBuf)

pub fn execute_script_file(&mut self, file_path: &str) -> Result<i32, String>

pub fn exec_wordcode(&mut self) -> i32

pub fn exec_list_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_sublist_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_pline_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_cmd_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_for_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_select_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_case_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_if_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_while_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_repeat_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_funcdef_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_subsh_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_cursh_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_timed_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_cond_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_arith_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_try_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn exec_simple_wordcode(&mut self, buf: &[u32], pc: usize) -> (i32, usize)

pub fn execute_script_zsh_pipeline( &mut self, script: &str, ) -> Result<i32, String>

pub fn execute_script(&mut self, script: &str) -> Result<i32, String>

pub fn function_exists(&self, name: &str) -> bool

pub fn function_definition_text(&self, name: &str) -> Option<String>

pub fn remove_function(&mut self, name: &str) -> bool

pub fn function_names(&self) -> Vec<String>

pub fn dispatch_function_call( &mut self, name: &str, args: &[String], ) -> Option<i32>

pub fn run_command_substitution(&mut self, cmd_str: &str) -> String

impl ShellExecutor

pub fn zfork(&mut self, flags: ForkFlags) -> Result<ForkResult>

pub fn zexecve(&self, cmd: &str, args: &[String]) -> !

pub fn entersubsh(&mut self, flags: SubshellFlags)

impl ShellExecutor

Struct ShellExecutor

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<F, W, T, D> Deserialize<With<T, W>, D> for F
where W: DeserializeWith<F, T, D>, D: Fallible + ?Sized, F: ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,