128 lines
3.7 KiB
Rust
128 lines
3.7 KiB
Rust
use shellenv::jobs::JobCmdFlags;
|
|
|
|
use crate::prelude::*;
|
|
|
|
pub fn continue_job(node: Node, shenv: &mut ShEnv, fg: bool) -> ShResult<()> {
|
|
let blame = node.span();
|
|
let cmd = if fg { "fg" } else { "bg" };
|
|
let rule = node.into_rule();
|
|
if let NdRule::Command { argv, redirs } = rule {
|
|
let mut argv_s = argv.drop_first().as_strings(shenv).into_iter();
|
|
|
|
if read_jobs(|j| j.get_fg().is_some()) {
|
|
return Err(
|
|
ShErr::full(
|
|
ShErrKind::InternalErr,
|
|
format!("Somehow called {} with an existing foreground job",cmd),
|
|
blame
|
|
)
|
|
)
|
|
}
|
|
|
|
let curr_job_id = if let Some(id) = read_jobs(|j| j.curr_job()) {
|
|
id
|
|
} else {
|
|
return Err(ShErr::full(ShErrKind::ExecFail, "No jobs found".into(), blame))
|
|
};
|
|
|
|
let tabid = match argv_s.next() {
|
|
Some(arg) => parse_job_id(&arg, blame.clone())?,
|
|
None => curr_job_id
|
|
};
|
|
|
|
let mut job = write_jobs(|j| {
|
|
let id = JobID::TableID(tabid);
|
|
let query_result = j.query(id.clone());
|
|
if query_result.is_some() {
|
|
Ok(j.remove_job(id.clone()).unwrap())
|
|
} else {
|
|
Err(ShErr::full(ShErrKind::ExecFail, format!("Job id `{}' not found", tabid), blame))
|
|
}
|
|
})?;
|
|
|
|
job.killpg(Signal::SIGCONT)?;
|
|
|
|
if fg {
|
|
write_jobs(|j| j.new_fg(job))?;
|
|
} else {
|
|
let job_order = read_jobs(|j| j.order().to_vec());
|
|
write(borrow_fd(1), job.display(&job_order, JobCmdFlags::PIDS).as_bytes())?;
|
|
write_jobs(|j| j.insert_job(job, true))?;
|
|
}
|
|
shenv.set_code(0);
|
|
} else { unreachable!() }
|
|
Ok(())
|
|
}
|
|
|
|
fn parse_job_id(arg: &str, blame: Span) -> ShResult<usize> {
|
|
if arg.starts_with('%') {
|
|
let arg = arg.strip_prefix('%').unwrap();
|
|
if arg.chars().all(|ch| ch.is_ascii_digit()) {
|
|
Ok(arg.parse::<usize>().unwrap())
|
|
} else {
|
|
let result = write_jobs(|j| {
|
|
let query_result = j.query(JobID::Command(arg.into()));
|
|
query_result.map(|job| job.tabid().unwrap())
|
|
});
|
|
match result {
|
|
Some(id) => Ok(id),
|
|
None => Err(ShErr::full(ShErrKind::InternalErr,"Found a job but no table id in parse_job_id()".into(),blame))
|
|
}
|
|
}
|
|
} else if arg.chars().all(|ch| ch.is_ascii_digit()) {
|
|
let result = write_jobs(|j| {
|
|
let pgid_query_result = j.query(JobID::Pgid(Pid::from_raw(arg.parse::<i32>().unwrap())));
|
|
if let Some(job) = pgid_query_result {
|
|
return Some(job.tabid().unwrap())
|
|
}
|
|
|
|
if arg.parse::<i32>().unwrap() > 0 {
|
|
let table_id_query_result = j.query(JobID::TableID(arg.parse::<usize>().unwrap()));
|
|
return table_id_query_result.map(|job| job.tabid().unwrap());
|
|
}
|
|
|
|
None
|
|
});
|
|
|
|
match result {
|
|
Some(id) => Ok(id),
|
|
None => Err(ShErr::full(ShErrKind::InternalErr,"Found a job but no table id in parse_job_id()".into(),blame))
|
|
}
|
|
} else {
|
|
Err(ShErr::full(ShErrKind::SyntaxErr,format!("Invalid fd arg: {}", arg),blame))
|
|
}
|
|
}
|
|
|
|
pub fn jobs(node: Node, shenv: &mut ShEnv) -> ShResult<()> {
|
|
let rule = node.into_rule();
|
|
if let NdRule::Command { argv, redirs } = rule {
|
|
let mut argv = argv.drop_first().into_iter();
|
|
|
|
let mut flags = JobCmdFlags::empty();
|
|
while let Some(arg) = argv.next() {
|
|
let arg_s = arg.to_string();
|
|
let mut chars = arg_s.chars().peekable();
|
|
if chars.peek().is_none_or(|ch| *ch != '-') {
|
|
return Err(ShErr::full(ShErrKind::SyntaxErr, "Invalid flag in jobs call".into(), arg.span().clone()))
|
|
}
|
|
chars.next();
|
|
while let Some(ch) = chars.next() {
|
|
let flag = match ch {
|
|
'l' => JobCmdFlags::LONG,
|
|
'p' => JobCmdFlags::PIDS,
|
|
'n' => JobCmdFlags::NEW_ONLY,
|
|
'r' => JobCmdFlags::RUNNING,
|
|
's' => JobCmdFlags::STOPPED,
|
|
_ => return Err(ShErr::full(ShErrKind::SyntaxErr, "Invalid flag in jobs call".into(), arg.span().clone()))
|
|
|
|
};
|
|
flags |= flag
|
|
}
|
|
}
|
|
read_jobs(|j| j.print_jobs(flags))?;
|
|
shenv.set_code(0);
|
|
} else { unreachable!() }
|
|
|
|
Ok(())
|
|
}
|