use std::path::Path;
mod scan;
pub(crate) use scan::program_opaque_reason;
use scan::{effective_command_name, opaque_dispatch_reason};
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum ItemOutcome {
Assign(String),
Clear,
Undetermined(&'static str),
Ignore,
}
pub(crate) fn walk_item(
item: &brush_parser::ast::CompoundListItem,
home: &Path,
nb_dir: &mut Option<String>,
) -> ItemOutcome {
use brush_parser::ast::SeparatorOperator;
let brush_parser::ast::CompoundListItem(andor, sep) = item;
if matches!(sep, SeparatorOperator::Async) {
return if mentions_nb_dir(&format!("{andor:?}")) {
ItemOutcome::Undetermined("backgrounded command")
} else {
ItemOutcome::Ignore
};
}
if !andor.additional.is_empty() {
return if mentions_nb_dir(&format!("{andor:?}")) {
ItemOutcome::Undetermined("conditional command")
} else {
ItemOutcome::Ignore
};
}
let pipe = &andor.first;
if pipe.timed.is_some() || pipe.bang || pipe.seq.len() != 1 {
return if mentions_nb_dir(&format!("{pipe:?}")) {
ItemOutcome::Undetermined("conditional command")
} else {
ItemOutcome::Ignore
};
}
match &pipe.seq[0] {
brush_parser::ast::Command::Simple(command) => {
walk_simple(command, home, nb_dir)
},
other => {
if mentions_nb_dir(&format!("{other:?}")) {
ItemOutcome::Undetermined("compound command")
} else {
ItemOutcome::Ignore
}
},
}
}
fn scan_side_effects(
command: &brush_parser::ast::SimpleCommand,
home: &Path,
nb_dir: &mut Option<String>,
) -> Option<&'static str> {
use brush_parser::ast::CommandPrefixOrSuffixItem as Item;
let parts = command
.prefix
.as_ref()
.map(|prefix| prefix.0.as_slice())
.unwrap_or(&[])
.iter()
.chain(
command
.suffix
.as_ref()
.map(|suffix| suffix.0.as_slice())
.unwrap_or(&[]),
);
for item in parts {
if let Item::AssignmentWord(assignment, _) = item
&& let AssignOutcome::Undetermined(reason) =
classify_assignment(assignment, home, nb_dir)
{
return Some(reason);
}
}
None
}
fn walk_simple(
command: &brush_parser::ast::SimpleCommand,
home: &Path,
nb_dir: &mut Option<String>,
) -> ItemOutcome {
use brush_parser::ast::CommandPrefixOrSuffixItem as Item;
if let Some(reason) = opaque_dispatch_reason(command, home, nb_dir, false)
{
return ItemOutcome::Undetermined(reason);
}
let effective =
effective_command_name(command, home, nb_dir).ok().flatten();
let transient = command.word_or_name.is_some()
&& !effective.as_deref().is_some_and(is_declaration_builtin)
&& command.prefix.as_ref().is_some_and(|prefix| {
prefix.0.iter().any(|item| {
matches!(item,
Item::AssignmentWord(assignment, _)
if is_nb_dir(&assignment.name))
})
});
if transient {
if let Some(reason) = scan_side_effects(command, home, nb_dir) {
return ItemOutcome::Undetermined(reason);
}
return ItemOutcome::Ignore;
}
match &command.word_or_name {
None => {
let mut outcome = ItemOutcome::Ignore;
if let Some(prefix) = &command.prefix {
for item in &prefix.0 {
match item {
Item::IoRedirect(_) => {},
Item::AssignmentWord(assignment, _) => {
match classify_assignment(assignment, home, nb_dir)
{
AssignOutcome::Value(value) => {
*nb_dir = Some(value.clone());
outcome = ItemOutcome::Assign(value);
},
AssignOutcome::Undetermined(reason) => {
return ItemOutcome::Undetermined(reason);
},
AssignOutcome::Unrelated => {},
}
},
_ => {
return ItemOutcome::Undetermined(
"unsupported assignment form",
);
},
}
}
}
if let Some(suffix) = &command.suffix {
for item in &suffix.0 {
match item {
Item::IoRedirect(_) => {},
Item::AssignmentWord(assignment, _) => {
match classify_assignment(assignment, home, nb_dir)
{
AssignOutcome::Value(value) => {
*nb_dir = Some(value.clone());
outcome = ItemOutcome::Assign(value);
},
AssignOutcome::Undetermined(reason) => {
return ItemOutcome::Undetermined(reason);
},
AssignOutcome::Unrelated => {},
}
},
_ => {
return ItemOutcome::Undetermined(
"unsupported assignment form",
);
},
}
}
}
outcome
},
Some(_) if effective.as_deref() == Some("export") => {
let mut outcome = ItemOutcome::Ignore;
let mut pending: Option<String> = None;
let mut bare_word = false;
if let Some(suffix) = &command.suffix {
for item in &suffix.0 {
match item {
Item::IoRedirect(_) => {},
Item::AssignmentWord(assignment, _) => {
if is_nb_dir(&assignment.name) {
match classify_assignment(
assignment, home, nb_dir,
) {
AssignOutcome::Value(value) => {
pending = Some(value.clone());
outcome = ItemOutcome::Assign(value);
},
AssignOutcome::Undetermined(reason) => {
return ItemOutcome::Undetermined(
reason,
);
},
AssignOutcome::Unrelated => {},
}
} else {
match classify_assignment(
assignment, home, nb_dir,
) {
AssignOutcome::Value(_) => {},
AssignOutcome::Undetermined(reason) => {
return ItemOutcome::Undetermined(
reason,
);
},
AssignOutcome::Unrelated => {},
}
}
},
Item::Word(word) if word.value == "NB_DIR" => {
bare_word = true;
},
Item::Word(word) if mentions_nb_dir(&word.value) => {
return ItemOutcome::Undetermined(
"unsupported export form",
);
},
Item::Word(_) => {},
_ => {
return ItemOutcome::Undetermined(
"unsupported export form",
);
},
}
}
}
let transient = match collect_transient_prefix(
command,
home,
nb_dir,
"unsupported export form",
) {
Ok(transient) => transient,
Err(reason) => return ItemOutcome::Undetermined(reason),
};
if let Some(value) = pending {
*nb_dir = Some(value);
} else if bare_word && let Some(value) = transient {
*nb_dir = Some(value.clone());
outcome = ItemOutcome::Assign(value);
}
outcome
},
Some(_) if effective.as_deref() == Some("readonly") => {
if let Some(suffix) = &command.suffix {
for item in &suffix.0 {
match item {
Item::AssignmentWord(assignment, _)
if is_nb_dir(&assignment.name) =>
{
return ItemOutcome::Undetermined(
"readonly NB_DIR is not modeled",
);
},
Item::Word(word)
if word.value == "NB_DIR"
|| !is_demonstrably_literal(&word.value) =>
{
return ItemOutcome::Undetermined(
"readonly NB_DIR is not modeled",
);
},
_ => {},
}
}
}
if let Some(reason) = scan_side_effects(command, home, nb_dir) {
return ItemOutcome::Undetermined(reason);
}
ItemOutcome::Ignore
},
Some(_) if effective.as_deref() == Some("unset") => {
let mut clearing = false;
if let Some(suffix) = &command.suffix {
for item in &suffix.0 {
match item {
Item::IoRedirect(_) => {},
Item::Word(word)
if word.value == "NB_DIR"
|| word.value == "-v"
|| word.value == "--" =>
{
if word.value == "NB_DIR" {
clearing = true;
}
},
_ => {
return ItemOutcome::Undetermined(
"unsupported unset form",
);
},
}
}
}
if clearing {
*nb_dir = None;
ItemOutcome::Clear
} else {
ItemOutcome::Ignore
}
},
Some(name) if name.value == "source" || name.value == "." => {
ItemOutcome::Undetermined("sourced file may set NB_DIR")
},
Some(_) => {
if let Some(reason) = scan_side_effects(command, home, nb_dir) {
return ItemOutcome::Undetermined(reason);
}
if assigns_nb_dir(command) {
return ItemOutcome::Undetermined(
"unsupported NB_DIR assignment",
);
}
if words_mention_nb_dir(command) {
ItemOutcome::Undetermined("unsupported NB_DIR use")
} else {
ItemOutcome::Ignore
}
},
}
}
fn assigns_nb_dir(command: &brush_parser::ast::SimpleCommand) -> bool {
use brush_parser::ast::CommandPrefixOrSuffixItem as Item;
let mut parts = command
.prefix
.as_ref()
.map(|prefix| prefix.0.as_slice())
.unwrap_or(&[])
.iter()
.chain(
command
.suffix
.as_ref()
.map(|suffix| suffix.0.as_slice())
.unwrap_or(&[]),
);
parts.any(|item| {
matches!(item,
Item::AssignmentWord(assignment, _)
if mentions_nb_dir(&assignment.name.to_string()))
})
}
fn words_mention_nb_dir(command: &brush_parser::ast::SimpleCommand) -> bool {
use brush_parser::ast::CommandPrefixOrSuffixItem as Item;
if command
.word_or_name
.as_ref()
.is_some_and(|word| mentions_nb_dir(&word.value))
{
return true;
}
let mut parts = command
.prefix
.as_ref()
.map(|prefix| prefix.0.as_slice())
.unwrap_or(&[])
.iter()
.chain(
command
.suffix
.as_ref()
.map(|suffix| suffix.0.as_slice())
.unwrap_or(&[]),
);
parts.any(|item| {
matches!(item, Item::Word(word) if mentions_nb_dir(&word.value))
})
}
fn is_declaration_builtin(name: &str) -> bool {
matches!(name, "export" | "readonly")
}
fn collect_transient_prefix(
command: &brush_parser::ast::SimpleCommand,
home: &Path,
nb_dir: &mut Option<String>,
form: &'static str,
) -> Result<Option<String>, &'static str> {
use brush_parser::ast::CommandPrefixOrSuffixItem as Item;
let mut transient = None;
if let Some(prefix) = &command.prefix {
for item in &prefix.0 {
match item {
Item::IoRedirect(_) => {},
Item::AssignmentWord(assignment, _) => {
match classify_assignment(assignment, home, nb_dir) {
AssignOutcome::Value(value) => {
if is_nb_dir(&assignment.name) {
transient = Some(value);
}
},
AssignOutcome::Undetermined(reason) => {
return Err(reason);
},
AssignOutcome::Unrelated => {},
}
},
_ => return Err(form),
}
}
}
Ok(transient)
}
fn is_nb_dir(name: &brush_parser::ast::AssignmentName) -> bool {
matches!(name,
brush_parser::ast::AssignmentName::VariableName(name)
if name == "NB_DIR")
}
fn is_demonstrably_literal(word: &str) -> bool {
let identifier = word
.bytes()
.next()
.is_some_and(|byte| byte.is_ascii_alphabetic() || byte == b'_')
&& word
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || byte == b'_');
let flag = word.len() > 1
&& word.starts_with('-')
&& word[1..]
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || byte == b'-');
identifier || flag
}
enum AssignOutcome {
Value(String),
Undetermined(&'static str),
Unrelated,
}
fn classify_assignment(
assignment: &brush_parser::ast::Assignment,
home: &Path,
nb_dir: &mut Option<String>,
) -> AssignOutcome {
if !is_nb_dir(&assignment.name) {
if mentions_nb_dir(&assignment.name.to_string()) {
return AssignOutcome::Undetermined(
"unsupported NB_DIR assignment",
);
}
if mentions_nb_dir(&format!("{:?}", assignment.value)) {
match &assignment.value {
brush_parser::ast::AssignmentValue::Scalar(word) => {
match eval_word(word, home, nb_dir) {
Ok(_) => AssignOutcome::Unrelated,
Err(reason) => AssignOutcome::Undetermined(reason),
}
},
brush_parser::ast::AssignmentValue::Array(_) => {
AssignOutcome::Undetermined("array assignment")
},
}
} else {
AssignOutcome::Unrelated
}
} else if assignment.append {
AssignOutcome::Undetermined("append assignment")
} else {
match &assignment.value {
brush_parser::ast::AssignmentValue::Scalar(word) => {
match eval_word(word, home, nb_dir) {
Ok(value) => AssignOutcome::Value(value),
Err(reason) => AssignOutcome::Undetermined(reason),
}
},
brush_parser::ast::AssignmentValue::Array(_) => {
AssignOutcome::Undetermined("array assignment")
},
}
}
}
fn eval_word(
word: &brush_parser::ast::Word,
home: &Path,
nb_dir: &mut Option<String>,
) -> Result<String, &'static str> {
let pieces = brush_parser::word::parse(
&word.value,
&brush_parser::ParserOptions::default(),
)
.map_err(|_| "unparseable value")?;
eval_pieces(&pieces, home, nb_dir, false)
}
fn eval_pieces(
pieces: &[brush_parser::word::WordPieceWithSource],
home: &Path,
nb_dir: &mut Option<String>,
quoted: bool,
) -> Result<String, &'static str> {
use brush_parser::word::WordPiece;
let mut out = String::new();
let mut first = true;
for piece in pieces {
match &piece.piece {
WordPiece::Text(text) => out.push_str(text),
WordPiece::SingleQuotedText(text) => out.push_str(text),
WordPiece::DoubleQuotedSequence(inner) => {
out.push_str(&eval_pieces(inner, home, nb_dir, true)?);
},
WordPiece::GettextDoubleQuotedSequence(_) => {
return Err("gettext quoting");
},
WordPiece::AnsiCQuotedText(_) => {
return Err("ansi-c quoting");
},
WordPiece::TildeExpansion(tilde) => {
use brush_parser::word::TildeExpr;
match tilde {
TildeExpr::Home if first && !quoted => {
out.push_str(&home.to_string_lossy());
},
TildeExpr::Home => {
out.push('~');
},
_ => return Err("tilde expansion"),
}
},
WordPiece::ParameterExpansion(expansion) => {
out.push_str(&eval_parameter(
expansion, home, nb_dir, quoted,
)?);
},
WordPiece::CommandSubstitution(_)
| WordPiece::BackquotedCommandSubstitution(_)
| WordPiece::ArithmeticExpression(_) => {
return Err("command substitution");
},
WordPiece::EscapeSequence(escaped) => {
let rest = escaped.strip_prefix('\\').unwrap_or(escaped);
if quoted {
match rest {
"$" | "`" | "\"" | "\\" => out.push_str(rest),
"\n" => {},
_ => out.push_str(escaped),
}
} else if rest == "\n" {
} else {
out.push_str(rest);
}
},
}
first = false;
}
Ok(out)
}
fn eval_parameter(
expansion: &brush_parser::word::ParameterExpr,
home: &Path,
nb_dir: &mut Option<String>,
quoted: bool,
) -> Result<String, &'static str> {
use brush_parser::word::{Parameter, ParameterExpr, ParameterTestType};
let is_missing = |test: &ParameterTestType| match test {
ParameterTestType::UnsetOrNull => {
nb_dir.as_deref().is_none_or(|v| v.is_empty())
},
ParameterTestType::Unset => nb_dir.is_none(),
};
match expansion {
ParameterExpr::Parameter {
parameter: Parameter::Named(name),
indirect: false,
} if name == "HOME" => Ok(home.to_string_lossy().into_owned()),
ParameterExpr::Parameter {
parameter: Parameter::Named(name),
indirect: false,
} if name == "NB_DIR" => Ok(nb_dir.clone().unwrap_or_default()),
ParameterExpr::UseDefaultValues {
parameter: Parameter::Named(name),
indirect: false,
test_type,
default_value,
} if name == "NB_DIR" => {
if is_missing(test_type) {
eval_default_word(default_value, home, nb_dir, quoted)
} else {
Ok(nb_dir.clone().unwrap_or_default())
}
},
ParameterExpr::AssignDefaultValues {
parameter: Parameter::Named(name),
indirect: false,
test_type,
default_value,
} if name == "NB_DIR" => {
if is_missing(test_type) {
let value =
eval_default_word(default_value, home, nb_dir, quoted)?;
*nb_dir = Some(value.clone());
Ok(value)
} else {
Ok(nb_dir.clone().unwrap_or_default())
}
},
ParameterExpr::UseAlternativeValue {
parameter: Parameter::Named(name),
indirect: false,
test_type,
alternative_value,
} if name == "NB_DIR" => {
let present = match test_type {
ParameterTestType::UnsetOrNull => {
nb_dir.as_deref().is_some_and(|v| !v.is_empty())
},
ParameterTestType::Unset => nb_dir.is_some(),
};
if present {
eval_default_word(alternative_value, home, nb_dir, quoted)
} else {
Ok(String::new())
}
},
_ => Err("non-HOME expansion"),
}
}
fn eval_default_word(
raw: &Option<String>,
home: &Path,
nb_dir: &mut Option<String>,
quoted: bool,
) -> Result<String, &'static str> {
match raw {
None => Ok(String::new()),
Some(text) => {
let pieces = brush_parser::word::parse(
text,
&brush_parser::ParserOptions::default(),
)
.map_err(|_| "unparseable default")?;
if quoted && default_has_nested_quoting(&pieces) {
return Err("nested quoting in double-quoted default");
}
eval_pieces(pieces.as_slice(), home, nb_dir, quoted)
},
}
}
fn default_has_nested_quoting(
pieces: &[brush_parser::word::WordPieceWithSource],
) -> bool {
use brush_parser::word::WordPiece;
pieces.iter().any(|piece| {
matches!(
piece.piece,
WordPiece::SingleQuotedText(_)
| WordPiece::AnsiCQuotedText(_)
| WordPiece::GettextDoubleQuotedSequence(_)
| WordPiece::DoubleQuotedSequence(_)
)
})
}
fn mentions_nb_dir(code: &str) -> bool {
let mut start = 0;
while let Some(index) = code[start..].find("NB_DIR") {
let index = start + index;
let before = code[..index].chars().next_back();
let after = code[index + "NB_DIR".len()..].chars().next();
let boundary = |c: Option<char>| {
c.is_none_or(|c| !(c.is_ascii_alphanumeric() || c == '_'))
};
if boundary(before) && boundary(after) {
return true;
}
start = index + 1;
}
false
}