Struct shfunc_table 

pub struct shfunc_table { /* private fields */ }

Shell function hash table $shfunctab shell function table. Port of the shfunctab HashTable Src/hashtable.c builds — printshfuncnode / freeshfuncnode (Src/builtin.c) hang off the same shape. Faithful port of C’s HashTable shfunctab (Src/zsh.h, declared mod_export HashTable shfunctab). Stores Box<shfunc> so that raw *mut shfunc handed to C-style call sites stays stable across map rehashes — mirrors C’s HashNode semantics where the table owns the heap allocation and hands out pointers. Owned-value accessors (add, get, get_mut) coexist with C-faithful pointer accessors (addnode, getnode) so both the Rust-idiomatic bytecode function-def path (fusevm_bridge.rs:8378) and the C-style bin_functions port (builtin.rs:3689+) write to the same canonical table.

Implementations

impl shfunc_table

pub fn new() -> Self

new — shfunctab = newhashtable(7, "shfunctab", NULL) (Src/hashtable.c:814). The initial bucket count is part of the observable scan order, so it must be C’s 7 and grow only through expandhashtable’s x4 rule.

pub fn snapshot(&self) -> Arc<shfunc_table>

snapshot — clone the whole bucket array for subshell save/restore. Used by subshell_begin to capture the parent’s function set before the subshell body runs, so subshell_end can restore it (matches C fork-copy semantics at Src/exec.c::entersubsh).

This clones the TABLE, not a HashMap of its entries: the scan order is part of the state (Src/Modules/parameter.c:480-481 walks shfunctab->nodes[i] directly), and rebuilding a bucket array from an unordered map would reshuffle ${(k)functions} after every ( … ) / $( … ).

pub fn restore(&mut self, snap: Arc<shfunc_table>)

restore — replace the internal table with a saved snapshot. Called by subshell_end after the subshell body completes. Takes the Arc-shared snapshot stored in SubshellSnapshot; unwraps in place when uniquely owned (the common case), else clones out of the shared handle.

pub fn reserve(&mut self, _additional: usize)

Formerly pre-sized the backing HashMap. C has no such call and CANNOT have one: hsize only ever moves through expandhashtable’s x4 steps (Src/hashtable.c:466), and the bucket count is what hasher(nam) % hsize — hence the whole scan order — is computed against. Pre-sizing to the batch size would put every name in a different bucket than zsh does. Kept as a no-op so the compinit call site (which is a Rust-only optimisation) still compiles.

pub fn add(&mut self, func: shfunc) -> Option<shfunc>

add — addhashnode2 (Src/hashtable.c:168) with the displaced node handed back to the caller instead of freenoded.

pub fn get(&self, name: &str) -> Option<&shfunc>

get — gethashnode (Src/hashtable.c:231): DISABLED nodes read as absent.

pub fn get_including_disabled(&self, name: &str) -> Option<&shfunc>

get_including_disabled — gethashnode2 (Src/hashtable.c:255).

pub fn get_mut(&mut self, name: &str) -> Option<&mut shfunc>

get_mut — see implementation.

pub fn remove(&mut self, name: &str) -> Option<shfunc>

remove — removehashnode (Src/hashtable.c:275).

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

contains_key — see implementation.

pub fn addnode(&mut self, shf: *mut shfunc)

Port of C’s HashTable.addnode GSU function pointer (Src/zsh.h:281+). Takes a *mut shfunc (typedef Shfunc) previously obtained via Box::into_raw — reclaims ownership into the table by name. After this call, the caller’s shf pointer is INVALIDATED in the Rust ownership sense; subsequent reads must go through getnode(name) to get a fresh pointer. In practice, C code re-uses the same shf pointer because the Box stays at the same heap address — we keep that semantic by boxing-on-heap. Replaces any prior entry with the same name (matching C addnode’s overwrite-and-free-old behavior).

pub fn getnode(&self, name: &str) -> *mut shfunc

Port of C’s HashTable.getnode GSU. Returns the raw Shfunc pointer (typedef *mut shfunc) or null if missing or disabled. Pointer stays valid as long as the underlying Box<shfunc> lives in the table (i.e. until remove/addnode-overwrite).

pub fn getnode2(&self, name: &str) -> *mut shfunc

Port of C’s HashTable.getnode2 GSU — same as getnode but returns disabled nodes too. Used by unhash/enable -f paths.

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

disable — see implementation.

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

enable — see implementation.

pub fn len(&self) -> usize

len — see implementation.

pub fn is_empty(&self) -> bool

is_empty — see implementation.

pub fn iter(&self) -> impl Iterator<Item = (&String, &shfunc)>

iter — see implementation.

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

iter_sorted — see implementation.

pub fn clear(&mut self)

clear — emptyhashtable (Src/hashtable.c:517): frees every node but keeps the bucket count.

Trait Implementations

impl Clone for shfunc_table

fn clone(&self) -> shfunc_table

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for shfunc_table

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for shfunc_table

fn default() -> Self

Returns the “default value” for a type.