pagedmov/shed
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added 'map', 'pop', 'push', 'fpop', 'fpush', and 'rotate' builtins

Browse Source
This commit is contained in:
pagedmov
2026-02-27 20:37:58 -05:00
parent ab2ce36af4
commit 0c40f17b60
10 changed files with 734 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
Cargo.lock generated
View File

@@ -236,6 +236,12 @@ version = "1.70.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
[[package]]
name = "itoa"
version = "1.0.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
[[package]]
name = "jiff"
version = "0.2.20"
@@ -399,6 +405,15 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "serde"
version = "1.0.228"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
dependencies = [
"serde_core",
]
[[package]]
name = "serde_core"
version = "1.0.228"
@@ -419,6 +434,19 @@ dependencies = [
"syn",
]
[[package]]
name = "serde_json"
version = "1.0.149"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
dependencies = [
"itoa",
"memchr",
"serde",
"serde_core",
"zmij",
]
[[package]]
name = "shed"
version = "0.3.0"
@@ -432,6 +460,7 @@ dependencies = [
"nix",
"pretty_assertions",
"regex",
"serde_json",
"tempfile",
"unicode-segmentation",
"unicode-width",
@@ -616,3 +645,9 @@ name = "yansi"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
[[package]]
name = "zmij"
version = "1.0.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

1
Cargo.toml
View File

@@ -17,6 +17,7 @@ glob = "0.3.2"
log = "0.4.29"
nix = { version = "0.29.0", features = ["uio", "term", "user", "hostname", "fs", "default", "signal", "process", "event", "ioctl", "poll"] }
regex = "1.11.1"
serde_json = "1.0.149"
unicode-segmentation = "1.12.0"
unicode-width = "0.2.0"
vte = "0.15"

188
src/builtin/arrops.rs Normal file
View File

@@ -0,0 +1,188 @@
use crate::{
getopt::{Opt, OptSpec, get_opts_from_tokens}, jobs::JobBldr, libsh::error::{ShErr, ShErrKind, ShResult}, parse::{NdRule, Node}, prelude::*, procio::{IoStack, borrow_fd}, state::{self, VarFlags, VarKind, write_vars}
};
use super::setup_builtin;
fn arr_op_optspec() -> Vec<OptSpec> {
vec![
OptSpec {
opt: Opt::Short('c'),
takes_arg: true
},
OptSpec {
opt: Opt::Short('r'),
takes_arg: false
},
OptSpec {
opt: Opt::Short('v'),
takes_arg: true
}
]
}
pub struct ArrOpOpts {
count: usize,
reverse: bool,
var: Option<String>,
}
impl Default for ArrOpOpts {
fn default() -> Self {
Self {
count: 1,
reverse: false,
var: None,
}
}
}
#[derive(Clone, Copy)]
enum End { Front, Back }
fn arr_pop_inner(node: Node, io_stack: &mut IoStack, job: &mut JobBldr, end: End) -> ShResult<()> {
let NdRule::Command {
assignments: _,
argv,
} = node.class
else {
unreachable!()
};
let (argv, opts) = get_opts_from_tokens(argv, &arr_op_optspec())?;
let arr_op_opts = get_arr_op_opts(opts)?;
let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
let stdout = borrow_fd(STDOUT_FILENO);
let mut status = 0;
for (arg,_) in argv {
for _ in 0..arr_op_opts.count {
let pop = |arr: &mut std::collections::VecDeque<String>| match end {
End::Front => arr.pop_front(),
End::Back => arr.pop_back(),
};
let Some(popped) = write_vars(|v| v.get_arr_mut(&arg).ok().and_then(pop)) else {
status = 1;
break;
};
status = 0;
if let Some(ref var) = arr_op_opts.var {
write_vars(|v| v.set_var(var, VarKind::Str(popped), VarFlags::NONE))?;
} else {
write(stdout, popped.as_bytes())?;
write(stdout, b"\n")?;
}
}
}
state::set_status(status);
Ok(())
}
fn arr_push_inner(node: Node, io_stack: &mut IoStack, job: &mut JobBldr, end: End) -> ShResult<()> {
let NdRule::Command {
assignments: _,
argv,
} = node.class
else {
unreachable!()
};
let (argv, opts) = get_opts_from_tokens(argv, &arr_op_optspec())?;
let _arr_op_opts = get_arr_op_opts(opts)?;
let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
let mut argv = argv.into_iter();
let Some((name, _)) = argv.next() else {
return Err(ShErr::simple(ShErrKind::ExecFail, "push: missing array name".to_string()));
};
for (val, _) in argv {
let push_val = val.clone();
if let Err(e) = write_vars(|v| v.get_arr_mut(&name).map(|arr| match end {
End::Front => arr.push_front(push_val),
End::Back => arr.push_back(push_val),
})) {
state::set_status(1);
return Err(e);
};
}
state::set_status(0);
Ok(())
}
pub fn arr_pop(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
arr_pop_inner(node, io_stack, job, End::Back)
}
pub fn arr_fpop(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
arr_pop_inner(node, io_stack, job, End::Front)
}
pub fn arr_push(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
arr_push_inner(node, io_stack, job, End::Back)
}
pub fn arr_fpush(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
arr_push_inner(node, io_stack, job, End::Front)
}
pub fn arr_rotate(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
let NdRule::Command {
assignments: _,
argv,
} = node.class
else {
unreachable!()
};
let (argv, opts) = get_opts_from_tokens(argv, &arr_op_optspec())?;
let arr_op_opts = get_arr_op_opts(opts)?;
let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
for (arg, _) in argv {
write_vars(|v| -> ShResult<()> {
let arr = v.get_arr_mut(&arg)?;
if arr_op_opts.reverse {
arr.rotate_right(arr_op_opts.count.min(arr.len()));
} else {
arr.rotate_left(arr_op_opts.count.min(arr.len()));
}
Ok(())
})?;
}
state::set_status(0);
Ok(())
}
pub fn get_arr_op_opts(opts: Vec<Opt>) -> ShResult<ArrOpOpts> {
let mut arr_op_opts = ArrOpOpts::default();
for opt in opts {
match opt {
Opt::ShortWithArg('c', count) => {
arr_op_opts.count = count.parse::<usize>().map_err(|_| {
ShErr::simple(ShErrKind::ParseErr, format!("invalid count: {}", count))
})?;
}
Opt::Short('c') => {
return Err(ShErr::simple(ShErrKind::ParseErr, "missing count for -c".to_string()));
}
Opt::Short('r') => {
arr_op_opts.reverse = true;
}
Opt::ShortWithArg('v', var) => {
arr_op_opts.var = Some(var);
}
Opt::Short('v') => {
return Err(ShErr::simple(ShErrKind::ParseErr, "missing variable name for -v".to_string()));
}
_ => {
return Err(ShErr::simple(ShErrKind::ParseErr, format!("invalid option: {}", opt)));
}
}
}
Ok(arr_op_opts)
}

369
src/builtin/map.rs Normal file
View File

@@ -0,0 +1,369 @@
use std::collections::HashMap;
use bitflags::bitflags;
use nix::{libc::STDOUT_FILENO, unistd::write};
use serde_json::{Map, Value};
use crate::{
getopt::{Opt, OptSpec, get_opts_from_tokens}, jobs::JobBldr, libsh::error::{ShErr, ShErrKind, ShResult}, parse::{NdRule, Node, lex::{split_all_unescaped, split_at_unescaped}}, procio::{IoStack, borrow_fd}, state::{self, read_vars, write_vars}
};
#[derive(Debug, Clone)]
pub enum MapNode {
Leaf(String),
Array(Vec<MapNode>),
Branch(HashMap<String, MapNode>),
}
impl Default for MapNode {
fn default() -> Self {
Self::Branch(HashMap::new())
}
}
impl From<MapNode> for serde_json::Value {
fn from(val: MapNode) -> Self {
match val {
MapNode::Branch(map) => {
let val_map = map.into_iter()
.map(|(k,v)| {
(k,v.into())
})
.collect::<Map<String,Value>>();
Value::Object(val_map)
}
MapNode::Array(nodes) => {
let arr = nodes
.into_iter()
.map(|node| node.into())
.collect();
Value::Array(arr)
}
MapNode::Leaf(leaf) => {
Value::String(leaf)
}
}
}
}
impl From<Value> for MapNode {
fn from(value: Value) -> Self {
match value {
Value::Object(map) => {
let node_map = map.into_iter()
.map(|(k,v)| {
(k, v.into())
})
.collect::<HashMap<String, MapNode>>();
MapNode::Branch(node_map)
}
Value::Array(arr) => {
let nodes = arr
.into_iter()
.map(|v| v.into())
.collect();
MapNode::Array(nodes)
}
Value::String(s) => MapNode::Leaf(s),
v => MapNode::Leaf(v.to_string())
}
}
}
impl MapNode {
fn get(&self, path: &[String]) -> Option<&MapNode> {
match path {
[] => Some(self),
[key, rest @ ..] => match self {
MapNode::Leaf(_) => None,
MapNode::Array(map_nodes) => {
let idx: usize = key.parse().ok()?;
map_nodes.get(idx)?.get(rest)
}
MapNode::Branch(map) => map.get(key)?.get(rest)
}
}
}
fn set(&mut self, path: &[String], value: MapNode) {
match path {
[] => *self = value,
[key, rest @ ..] => {
if matches!(self, MapNode::Leaf(_)) {
// promote leaf to branch if we still have path left to traverse
*self = Self::default();
}
match self {
MapNode::Branch(map) => {
let child = map
.entry(key.to_string())
.or_insert_with(Self::default);
child.set(rest, value);
}
MapNode::Array(map_nodes) => {
let idx: usize = key.parse().expect("expected array index");
if idx >= map_nodes.len() {
map_nodes.resize(idx + 1, Self::default());
}
map_nodes[idx].set(rest, value);
}
_ => unreachable!()
}
}
}
}
fn remove(&mut self, path: &[String]) -> Option<MapNode> {
match path {
[] => None,
[key] => match self {
MapNode::Branch(map) => map.remove(key),
MapNode::Array(nodes) => {
let idx: usize = key.parse().ok()?;
if idx >= nodes.len() {
return None;
}
Some(nodes.remove(idx))
}
_ => None
}
[key, rest @ ..] => match self {
MapNode::Branch(map) => map.get_mut(key)?.remove(rest),
MapNode::Array(nodes) => {
let idx: usize = key.parse().ok()?;
if idx >= nodes.len() {
return None;
}
nodes[idx].remove(rest)
}
_ => None
}
}
}
fn keys(&self) -> Vec<String> {
match self {
MapNode::Branch(map) => map.keys().map(|k| k.to_string()).collect(),
MapNode::Array(nodes) => nodes.iter().filter_map(|n| n.display(false, false).ok()).collect(),
MapNode::Leaf(s) => vec![s.clone()],
}
}
fn display(&self, json: bool, pretty: bool) -> ShResult<String> {
if json || matches!(self, MapNode::Branch(_)) {
let val: Value = self.clone().into();
if pretty {
match serde_json::to_string_pretty(&val) {
Ok(s) => Ok(s),
Err(e) => Err(ShErr::simple(
ShErrKind::InternalErr,
format!("failed to serialize map: {e}")
))
}
} else {
match serde_json::to_string(&val) {
Ok(s) => Ok(s),
Err(e) => Err(ShErr::simple(
ShErrKind::InternalErr,
format!("failed to serialize map: {e}")
))
}
}
} else {
match self {
MapNode::Leaf(leaf) => Ok(leaf.clone()),
MapNode::Array(nodes) => {
let mut s = String::new();
for node in nodes {
let display = node.display(json, pretty)?;
if matches!(node, MapNode::Branch(_)) {
s.push_str(&format!("'{}'", display));
} else {
s.push_str(&node.display(json, pretty)?);
}
s.push('\n');
}
Ok(s.trim_end_matches('\n').to_string())
}
_ => unreachable!()
}
}
}
}
use super::setup_builtin;
fn map_opts_spec() -> [OptSpec; 5] {
[
OptSpec {
opt: Opt::Short('r'),
takes_arg: false
},
OptSpec {
opt: Opt::Short('j'),
takes_arg: false
},
OptSpec {
opt: Opt::Short('k'),
takes_arg: false
},
OptSpec {
opt: Opt::Long("pretty".into()),
takes_arg: false
},
OptSpec {
opt: Opt::Short('l'),
takes_arg: false
},
]
}
#[derive(Debug, Clone, Copy)]
pub struct MapOpts {
flags: MapFlags,
}
bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct MapFlags: u32 {
const REMOVE = 0b000001;
const KEYS = 0b000010;
const JSON = 0b000100;
const LOCAL = 0b001000;
const PRETTY = 0b010000;
}
}
pub fn map(node: Node, io_stack: &mut IoStack, job: &mut JobBldr) -> ShResult<()> {
let NdRule::Command {
assignments: _,
argv,
} = node.class
else {
unreachable!()
};
let (argv, opts) = get_opts_from_tokens(argv, &map_opts_spec())?;
let map_opts = get_map_opts(opts);
let (argv, _guard) = setup_builtin(argv, job, Some((io_stack, node.redirs)))?;
for (arg,_) in argv {
if let Some((lhs,rhs)) = split_at_unescaped(&arg, "=") {
let path = split_all_unescaped(&lhs, ".");
let Some(name) = path.first() else {
return Err(ShErr::simple(
ShErrKind::InternalErr,
format!("invalid map path: {}", lhs)
));
};
let is_json = map_opts.flags.contains(MapFlags::JSON);
let found = write_vars(|v| {
if let Some(map) = v.get_map_mut(name) {
if is_json {
if let Ok(parsed) = serde_json::from_str::<Value>(&rhs) {
map.set(&path[1..], parsed.into());
} else {
map.set(&path[1..], MapNode::Leaf(rhs.clone()));
}
} else {
map.set(&path[1..], MapNode::Leaf(rhs.clone()));
}
true
} else {
false
}
});
if !found {
let mut new = MapNode::default();
if is_json && let Ok(parsed) = serde_json::from_str::<Value>(&rhs) {
let node: MapNode = parsed.into();
new.set(&path[1..], node);
} else {
new.set(&path[1..], MapNode::Leaf(rhs));
}
write_vars(|v| v.set_map(name, new, map_opts.flags.contains(MapFlags::LOCAL)));
}
} else {
let path = split_all_unescaped(&arg, ".");
let Some(name) = path.first() else {
return Err(ShErr::simple(
ShErrKind::InternalErr,
format!("invalid map path: {}", &arg)
));
};
if map_opts.flags.contains(MapFlags::REMOVE) {
write_vars(|v| {
if path.len() == 1 {
v.remove_map(name);
} else {
let Some(map) = v.get_map_mut(name) else {
return Err(ShErr::simple(
ShErrKind::ExecFail,
format!("map not found: {}", name)
));
};
map.remove(&path[1..]);
}
Ok(())
})?;
continue;
}
let json = map_opts.flags.contains(MapFlags::JSON);
let pretty = map_opts.flags.contains(MapFlags::PRETTY);
let keys = map_opts.flags.contains(MapFlags::KEYS);
let has_map = read_vars(|v| v.get_map(name).is_some());
if !has_map {
return Err(ShErr::simple(
ShErrKind::ExecFail,
format!("map not found: {}", name)
));
}
let Some(output) = read_vars(|v| {
v.get_map(name)
.and_then(|map| map.get(&path[1..])
.and_then(|n| {
if keys {
Some(n.keys().join(" "))
} else {
n.display(json, pretty).ok()
}
}))
}) else {
state::set_status(1);
continue;
};
let stdout = borrow_fd(STDOUT_FILENO);
write(stdout, output.as_bytes())?;
write(stdout, b"\n")?;
}
}
state::set_status(0);
Ok(())
}
pub fn get_map_opts(opts: Vec<Opt>) -> MapOpts {
let mut map_opts = MapOpts {
flags: MapFlags::empty()
};
for opt in opts {
match opt {
Opt::Short('r') => map_opts.flags |= MapFlags::REMOVE,
Opt::Short('j') => map_opts.flags |= MapFlags::JSON,
Opt::Short('k') => map_opts.flags |= MapFlags::KEYS,
Opt::Short('l') => map_opts.flags |= MapFlags::LOCAL,
Opt::Long(ref s) if s == "pretty" => map_opts.flags |= MapFlags::PRETTY,
_ => unreachable!()
}
}
map_opts
}

6
src/builtin/mod.rs
View File

@@ -30,12 +30,14 @@ pub mod test; // [[ ]] thing
pub mod trap;
pub mod varcmds;
pub mod zoltraak;
pub mod map;
pub mod arrops;
pub const BUILTINS: [&str; 35] = [
pub const BUILTINS: [&str; 41] = [
"echo", "cd", "read", "export", "local", "pwd", "source", "shift", "jobs", "fg", "bg", "disown",
"alias", "unalias", "return", "break", "continue", "exit", "zoltraak", "shopt", "builtin",
"command", "trap", "pushd", "popd", "dirs", "exec", "eval", "true", "false", ":", "readonly",
"unset", "complete", "compgen",
"unset", "complete", "compgen", "map", "pop", "fpop", "push", "fpush", "rotate"
];
/// Sets up a builtin command

24
src/parse/execute.rs
View File

@@ -5,23 +5,7 @@ use std::{
use crate::{
builtin::{
alias::{alias, unalias},
cd::cd,
complete::{compgen_builtin, complete_builtin},
dirstack::{dirs, popd, pushd},
echo::echo,
eval, exec,
flowctl::flowctl,
jobctl::{JobBehavior, continue_job, disown, jobs},
pwd::pwd,
read::read_builtin,
shift::shift,
shopt::shopt,
source::source,
test::double_bracket_test,
trap::{TrapTarget, trap},
varcmds::{export, local, readonly, unset},
zoltraak::zoltraak,
alias::{alias, unalias}, arrops::{arr_pop, arr_fpop, arr_push, arr_fpush, arr_rotate}, cd::cd, complete::{compgen_builtin, complete_builtin}, dirstack::{dirs, popd, pushd}, echo::echo, eval, exec, flowctl::flowctl, jobctl::{JobBehavior, continue_job, disown, jobs}, map, pwd::pwd, read::read_builtin, shift::shift, shopt::shopt, source::source, test::double_bracket_test, trap::{TrapTarget, trap}, varcmds::{export, local, readonly, unset}, zoltraak::zoltraak
},
expand::{expand_aliases, glob_to_regex},
jobs::{ChildProc, JobStack, dispatch_job},
@@ -817,6 +801,12 @@ impl Dispatcher {
"unset" => unset(cmd, io_stack_mut, curr_job_mut),
"complete" => complete_builtin(cmd, io_stack_mut, curr_job_mut),
"compgen" => compgen_builtin(cmd, io_stack_mut, curr_job_mut),
"map" => map::map(cmd, io_stack_mut, curr_job_mut),
"pop" => arr_pop(cmd, io_stack_mut, curr_job_mut),
"fpop" => arr_fpop(cmd, io_stack_mut, curr_job_mut),
"push" => arr_push(cmd, io_stack_mut, curr_job_mut),
"fpush" => arr_fpush(cmd, io_stack_mut, curr_job_mut),
"rotate" => arr_rotate(cmd, io_stack_mut, curr_job_mut),
"true" | ":" => {
state::set_status(0);
Ok(())

29
src/parse/lex.rs
View File

@@ -912,6 +912,35 @@ pub fn ends_with_unescaped(slice: &str, pat: &str) -> bool {
slice.ends_with(pat) && !pos_is_escaped(slice, slice.len() - pat.len())
}
pub fn split_all_unescaped(slice: &str, pat: &str) -> Vec<String> {
let mut cursor = 0;
let mut splits = vec![];
while let Some(split) = split_at_unescaped(&slice[cursor..], pat) {
cursor += split.0.len() + pat.len();
splits.push(split.0);
}
if let Some(remaining) = slice.get(cursor..) {
splits.push(remaining.to_string());
}
splits
}
pub fn split_at_unescaped(slice: &str, pat: &str) -> Option<(String,String)> {
let mut window_start = 0;
let mut window_end = pat.len();
if window_end > slice.len() {
return None;
}
while window_end <= slice.len() {
if &slice[window_start..window_end] == pat && !pos_is_escaped(slice, window_start) {
return Some((slice[..window_start].to_string(), slice[window_end..].to_string()));
}
window_start += 1;
window_end += 1;
}
None
}
pub fn pos_is_escaped(slice: &str, pos: usize) -> bool {
let bytes = slice.as_bytes();
let mut escaped = false;

4
src/parse/mod.rs
View File

@@ -955,6 +955,7 @@ impl ParseStream {
};
case_blocks.push(case_node);
self.catch_separator(&mut node_tks);
if self.check_keyword("esac") {
node_tks.push(self.next_tk().unwrap());
self.assert_separator(&mut node_tks)?;
@@ -1057,6 +1058,7 @@ impl ParseStream {
}
}
self.catch_separator(&mut node_tks);
if !self.check_keyword("fi") || !self.next_tk_is_some() {
self.panic_mode(&mut node_tks);
return Err(parse_err_full(
@@ -1139,6 +1141,7 @@ impl ParseStream {
body.push(node)
}
self.catch_separator(&mut node_tks);
if !self.check_keyword("done") || !self.next_tk_is_some() {
self.panic_mode(&mut node_tks);
return Err(parse_err_full(
@@ -1210,6 +1213,7 @@ impl ParseStream {
));
};
self.catch_separator(&mut node_tks);
if !self.check_keyword("done") || !self.next_tk_is_some() {
self.panic_mode(&mut node_tks);
return Err(parse_err_full(

12
src/readline/linebuf.rs
View File

@@ -1947,13 +1947,23 @@ impl LineBuf {
return;
};
let mut level: usize = 0;
let mut last_keyword: Option<String> = None;
for tk in tokens {
if tk.flags.contains(TkFlags::KEYWORD) {
match tk.as_str() {
"then" | "do" | "in" => level += 1,
"in" => {
if last_keyword.as_deref() == Some("case") {
level += 1;
} else {
// 'in' is also used in for loops, but we already increment level on 'do' for those
// so we just skip it here
}
}
"then" | "do" => level += 1,
"done" | "fi" | "esac" => level = level.saturating_sub(1),
_ => { /* Continue */ }
}
last_keyword = Some(tk.to_string());
} else if tk.class == TkRule::BraceGrpStart {
level += 1;
} else if tk.class == TkRule::BraceGrpEnd {

110
src/state.rs
View File

@@ -11,7 +11,7 @@ use std::{
use nix::unistd::{User, gethostname, getppid};
use crate::{
builtin::{BUILTINS, trap::TrapTarget},
builtin::{BUILTINS, map::MapNode, trap::TrapTarget},
exec_input,
jobs::JobTab,
libsh::{
@@ -257,11 +257,7 @@ impl ScopeStack {
{
match var.kind() {
VarKind::Arr(items) => {
let mut item_vec = items.clone().into_iter().collect::<Vec<(usize, String)>>();
item_vec.sort_by_key(|(idx, _)| *idx); // sort by index
return Ok(item_vec.into_iter().map(|(_, s)| s).collect());
return Ok(items.iter().cloned().collect());
}
_ => {
return Err(ShErr::simple(
@@ -277,6 +273,25 @@ impl ScopeStack {
format!("Variable '{}' not found", var_name),
))
}
pub fn get_arr_mut(&mut self, var_name: &str) -> ShResult<&mut VecDeque<String>> {
for scope in self.scopes.iter_mut().rev() {
if scope.var_exists(var_name)
&& let Some(var) = scope.vars_mut().get_mut(var_name)
{
match var.kind_mut() {
VarKind::Arr(items) => return Ok(items),
_ => return Err(ShErr::simple(
ShErrKind::ExecFail,
format!("Variable '{}' is not an array", var_name),
)),
}
}
}
Err(ShErr::simple(
ShErrKind::ExecFail,
format!("Variable '{}' not found", var_name),
))
}
pub fn index_var(&self, var_name: &str, idx: ArrIndex) -> ShResult<String> {
for scope in self.scopes.iter().rev() {
if scope.var_exists(var_name)
@@ -304,7 +319,7 @@ impl ScopeStack {
}
};
if let Some(item) = items.get(&idx) {
if let Some(item) = items.get(idx) {
return Ok(item.clone());
} else {
return Err(ShErr::simple(
@@ -324,6 +339,38 @@ impl ScopeStack {
}
Ok("".into())
}
pub fn remove_map(&mut self, map_name: &str) -> Option<MapNode> {
for scope in self.scopes.iter_mut().rev() {
if scope.get_map(map_name).is_some() {
return scope.remove_map(map_name);
}
}
None
}
pub fn get_map(&self, map_name: &str) -> Option<&MapNode> {
for scope in self.scopes.iter().rev() {
if let Some(map) = scope.get_map(map_name) {
return Some(map)
}
}
None
}
pub fn get_map_mut(&mut self, map_name: &str) -> Option<&mut MapNode> {
for scope in self.scopes.iter_mut().rev() {
if let Some(map) = scope.get_map_mut(map_name) {
return Some(map)
}
}
None
}
pub fn set_map(&mut self, map_name: &str, map: MapNode, local: bool) {
if local
&& let Some(scope) = self.scopes.last_mut() {
scope.set_map(map_name, map);
} else if let Some(scope) = self.scopes.first_mut() {
scope.set_map(map_name, map);
}
}
pub fn try_get_var(&self, var_name: &str) -> Option<String> {
// This version of get_var() is mainly used internally
// so that we have access to Option methods
@@ -588,18 +635,11 @@ impl FromStr for ArrIndex {
}
}
pub fn hashmap_to_vec(map: HashMap<usize, String>) -> Vec<String> {
let mut items = map.into_iter().collect::<Vec<(usize, String)>>();
items.sort_by_key(|(idx, _)| *idx);
items.into_iter().map(|(_, i)| i).collect()
}
#[derive(Clone, Debug)]
pub enum VarKind {
Str(String),
Int(i32),
Arr(HashMap<usize, String>),
Arr(VecDeque<String>),
AssocArr(Vec<(String, String)>),
}
@@ -614,7 +654,7 @@ impl VarKind {
}
let raw = raw[1..raw.len() - 1].to_string();
let tokens: HashMap<usize, String> = LexStream::new(Arc::new(raw), LexFlags::empty())
let tokens: VecDeque<String> = LexStream::new(Arc::new(raw), LexFlags::empty())
.map(|tk| tk.and_then(|tk| tk.expand()).map(|tk| tk.get_words()))
.try_fold(vec![], |mut acc, wrds| {
match wrds {
@@ -624,16 +664,13 @@ impl VarKind {
Ok(acc)
})?
.into_iter()
.enumerate()
.collect();
Ok(Self::Arr(tokens))
}
pub fn arr_from_vec(vec: Vec<String>) -> Self {
let tokens: HashMap<usize, String> = vec.into_iter().enumerate().collect();
Self::Arr(tokens)
Self::Arr(VecDeque::from(vec))
}
}
@@ -643,7 +680,6 @@ impl Display for VarKind {
VarKind::Str(s) => write!(f, "{s}"),
VarKind::Int(i) => write!(f, "{i}"),
VarKind::Arr(items) => {
let items = hashmap_to_vec(items.clone());
let mut item_iter = items.iter().peekable();
while let Some(item) = item_iter.next() {
write!(f, "{item}")?;
@@ -702,8 +738,9 @@ impl Display for Var {
pub struct VarTab {
vars: HashMap<String, Var>,
params: HashMap<ShellParam, String>,
sh_argv: VecDeque<String>, /* Using a VecDeque makes the implementation of `shift`
* straightforward */
sh_argv: VecDeque<String>, /* Using a VecDeque makes the implementation of `shift` straightforward */
maps: HashMap<String, MapNode>
}
impl VarTab {
@@ -715,6 +752,7 @@ impl VarTab {
vars,
params,
sh_argv: VecDeque::new(),
maps: HashMap::new(),
};
var_tab.init_sh_argv();
var_tab
@@ -833,6 +871,24 @@ impl VarTab {
self.update_arg_params();
arg
}
pub fn set_map(&mut self, map_name: &str, map: MapNode) {
self.maps.insert(map_name.to_string(), map);
}
pub fn remove_map(&mut self, map_name: &str) -> Option<MapNode> {
self.maps.remove(map_name)
}
pub fn get_map(&self, map_name: &str) -> Option<&MapNode> {
self.maps.get(map_name)
}
pub fn get_map_mut(&mut self, map_name: &str) -> Option<&mut MapNode> {
self.maps.get_mut(map_name)
}
pub fn maps(&self) -> &HashMap<String, MapNode> {
&self.maps
}
pub fn maps_mut(&mut self) -> &mut HashMap<String, MapNode> {
&mut self.maps
}
pub fn vars(&self) -> &HashMap<String, Var> {
&self.vars
}
@@ -906,7 +962,10 @@ impl VarTab {
}
};
items.insert(idx, val);
if idx >= items.len() {
items.resize(idx + 1, String::new());
}
items[idx] = val;
return Ok(());
}
_ => {
@@ -945,6 +1004,9 @@ impl VarTab {
}
Ok(())
}
pub fn map_exists(&self, map_name: &str) -> bool {
self.maps.contains_key(map_name)
}
pub fn var_exists(&self, var_name: &str) -> bool {
if let Ok(param) = var_name.parse::<ShellParam>() {
return self.params.contains_key(&param);