aboutsummaryrefslogtreecommitdiff
path: root/src/makefile
diff options
context:
space:
mode:
Diffstat (limited to 'src/makefile')
-rw-r--r--src/makefile/conditional.rs164
-rw-r--r--src/makefile/mod.rs54
-rw-r--r--src/makefile/token.rs21
3 files changed, 239 insertions, 0 deletions
diff --git a/src/makefile/conditional.rs b/src/makefile/conditional.rs
new file mode 100644
index 0000000..f9d2d60
--- /dev/null
+++ b/src/makefile/conditional.rs
@@ -0,0 +1,164 @@
+use super::token::TokenString;
+
+pub(crate) enum ConditionalLine {
+ /// spelled "ifeq"
+ IfEqual(TokenString, TokenString),
+ /// spelled "ifneq"
+ IfNotEqual(TokenString, TokenString),
+ /// spelled "ifdef"
+ IfDefined(String),
+ /// spelled "ifndef"
+ IfNotDefined(String),
+ /// spelled "else"
+ Else,
+ /// spelled "else condition"
+ ElseIf(Box<ConditionalLine>),
+ /// spelled "endif"
+ EndIf,
+}
+
+pub(crate) enum ConditionalState {
+ /// we saw a conditional, the condition was true, we're executing now
+ /// and if we hit an else we will start SkippingUntilEndIf
+ Executing,
+ /// we saw a conditional, the condition was false, we're ignoring now
+ /// and if we hit an else we'll start executing
+ /// (or if it's an else if we'll check the condition)
+ SkippingUntilElseOrEndIf,
+ /// we saw a conditional, the condition was true, we executed, and now we hit an else
+ /// so we don't need to stop and evaluate new conditions, because we straight up do
+ /// not care
+ SkippingUntilEndIf,
+}
+
+impl ConditionalState {
+ pub(crate) const fn skipping(&self) -> bool {
+ match self {
+ Self::Executing => false,
+ Self::SkippingUntilElseOrEndIf | Self::SkippingUntilEndIf => true,
+ }
+ }
+}
+
+pub(crate) enum ConditionalStateAction {
+ Push(ConditionalState),
+ Replace(ConditionalState),
+ Pop,
+}
+
+impl ConditionalStateAction {
+ pub(crate) fn apply_to(self, stack: &mut Vec<ConditionalState>) {
+ match self {
+ Self::Push(state) => stack.push(state),
+ Self::Replace(state) => match stack.last_mut() {
+ Some(x) => *x = state,
+ None => panic!("applying Replace on an empty condition stack"),
+ },
+ Self::Pop => {
+ stack.pop();
+ }
+ }
+ }
+}
+
+fn decode_condition_args(line_body: &str) -> Option<(TokenString, TokenString)> {
+ let tokens: TokenString = line_body.parse().ok()?;
+ let (mut arg1, mut arg2) = if tokens.starts_with("(") && tokens.ends_with(")") {
+ let mut tokens = tokens;
+ tokens.strip_prefix("(");
+ tokens.strip_suffix(")");
+ tokens.split_once(',')?
+ } else {
+ // TODO see if i really need to implement potentially-mixed-quoted args
+ return None;
+ };
+ arg1.trim_end();
+ arg2.trim_start();
+ Some((arg1, arg2))
+}
+
+impl ConditionalLine {
+ pub(crate) fn from(line: &str, expand_macro: impl Fn(&TokenString) -> String) -> Option<Self> {
+ if let Some(line) = line.strip_prefix("ifeq ") {
+ let (arg1, arg2) = decode_condition_args(line)?;
+ Some(Self::IfEqual(arg1, arg2))
+ } else if let Some(line) = line.strip_prefix("ifneq ") {
+ let (arg1, arg2) = decode_condition_args(line)?;
+ Some(Self::IfNotEqual(arg1, arg2))
+ } else if let Some(line) = line.strip_prefix("ifdef ") {
+ Some(Self::IfDefined(expand_macro(&line.parse().ok()?)))
+ } else if let Some(line) = line.strip_prefix("ifndef ") {
+ Some(Self::IfNotDefined(expand_macro(&line.parse().ok()?)))
+ } else if line == "else" {
+ Some(Self::Else)
+ } else if let Some(line) = line.strip_prefix("else ") {
+ let sub_condition = Self::from(line, expand_macro)?;
+ Some(Self::ElseIf(Box::new(sub_condition)))
+ } else if line == "endif" {
+ Some(Self::EndIf)
+ } else {
+ None
+ }
+ }
+
+ pub(crate) fn action(
+ &self,
+ current_state: Option<&ConditionalState>,
+ is_macro_defined: impl Fn(&str) -> bool,
+ expand_macro: impl Fn(&TokenString) -> String,
+ ) -> ConditionalStateAction {
+ use ConditionalState as State;
+ use ConditionalStateAction as Action;
+ match self {
+ Self::IfEqual(arg1, arg2) => {
+ let arg1 = expand_macro(arg1);
+ let arg2 = expand_macro(arg2);
+ if arg1 == arg2 {
+ Action::Push(State::Executing)
+ } else {
+ Action::Push(State::SkippingUntilElseOrEndIf)
+ }
+ }
+ Self::IfNotEqual(arg1, arg2) => {
+ let arg1 = expand_macro(arg1);
+ let arg2 = expand_macro(arg2);
+ if arg1 == arg2 {
+ Action::Push(State::SkippingUntilElseOrEndIf)
+ } else {
+ Action::Push(State::Executing)
+ }
+ }
+ Self::IfDefined(name) => {
+ if is_macro_defined(name) {
+ Action::Push(State::Executing)
+ } else {
+ Action::Push(State::SkippingUntilElseOrEndIf)
+ }
+ }
+ Self::IfNotDefined(name) => {
+ if is_macro_defined(name) {
+ Action::Push(State::SkippingUntilElseOrEndIf)
+ } else {
+ Action::Push(State::Executing)
+ }
+ }
+ Self::Else => Action::Replace(match current_state {
+ Some(State::Executing) | Some(State::SkippingUntilEndIf) => {
+ State::SkippingUntilEndIf
+ }
+ Some(State::SkippingUntilElseOrEndIf) => State::Executing,
+ None => panic!("got an Else but not in a conditional"),
+ }),
+ Self::ElseIf(inner_condition) => match current_state {
+ Some(State::Executing) | Some(State::SkippingUntilEndIf) => {
+ Action::Replace(State::SkippingUntilEndIf)
+ }
+ Some(State::SkippingUntilElseOrEndIf) => {
+ inner_condition.action(current_state, is_macro_defined, expand_macro)
+ }
+ None => panic!("got an ElseIf but not in a conditional"),
+ },
+ Self::EndIf => Action::Pop,
+ }
+ }
+}
diff --git a/src/makefile/mod.rs b/src/makefile/mod.rs
index 2f73c70..0d4cded 100644
--- a/src/makefile/mod.rs
+++ b/src/makefile/mod.rs
@@ -13,11 +13,13 @@ use regex::Regex;
use crate::args::Args;
mod command_line;
+mod conditional;
mod inference_rules;
mod target;
mod token;
use command_line::CommandLine;
+use conditional::{ConditionalLine, ConditionalState};
use inference_rules::InferenceRule;
use target::Target;
use token::{tokenize, Token, TokenString};
@@ -151,6 +153,7 @@ impl<'a> Makefile<'a> {
pub(crate) fn and_read(&mut self, source: impl BufRead) {
let mut lines_iter = source.lines().enumerate().peekable();
+ let mut conditional_stack: Vec<ConditionalState> = vec![];
while let Some((line_number, line)) = lines_iter.next() {
// TODO handle I/O errors at all
let mut line = line.expect("failed to read line of makefile!");
@@ -170,6 +173,14 @@ impl<'a> Makefile<'a> {
}
let line = COMMENT.replace(&line, "").into_owned();
+ // skip lines if we need to
+ if conditional_stack
+ .last()
+ .map_or(false, ConditionalState::skipping)
+ {
+ continue;
+ }
+
// handle include lines
if let Some(line) = line.strip_prefix("include ") {
// remove extra leading space
@@ -181,6 +192,14 @@ impl<'a> Makefile<'a> {
for field in fields {
self.and_read_file(field);
}
+ } else if let Some(line) = ConditionalLine::from(&line, |t| self.expand_macros(t, None))
+ {
+ line.action(
+ conditional_stack.last(),
+ |name| self.macros.contains_key(name),
+ |t| self.expand_macros(t, None),
+ )
+ .apply_to(&mut conditional_stack);
} else if line.trim().is_empty() {
// handle blank lines
continue;
@@ -728,3 +747,38 @@ fn builtin_targets() -> Vec<Target> {
already_updated: Cell::new(false),
}]
}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ use std::io::Cursor;
+
+ fn empty_makefile(args: &Args) -> Makefile {
+ Makefile {
+ inference_rules: vec![],
+ macros: HashMap::new(),
+ targets: RefCell::new(HashMap::new()),
+ first_non_special_target: None,
+ args,
+ }
+ }
+
+ #[test]
+ fn basic_conditionals() {
+ let file = "
+ifeq (1,1)
+worked = yes
+else ifeq (2,2)
+worked = no
+endif
+ ";
+ let args = Args::empty();
+ let mut makefile = empty_makefile(&args);
+ makefile.and_read(Cursor::new(file));
+ assert_eq!(
+ makefile.expand_macros(&"$(worked)".parse().unwrap(), None),
+ "yes"
+ );
+ }
+}
diff --git a/src/makefile/token.rs b/src/makefile/token.rs
index 811f30f..86c442b 100644
--- a/src/makefile/token.rs
+++ b/src/makefile/token.rs
@@ -47,6 +47,13 @@ impl TokenString {
None
}
+ pub(crate) fn starts_with(&self, pattern: &str) -> bool {
+ match self.0.first() {
+ Some(Token::Text(t)) => t.starts_with(pattern),
+ _ => false,
+ }
+ }
+
pub(crate) fn ends_with(&self, pattern: &str) -> bool {
match self.0.last() {
Some(Token::Text(t)) => t.ends_with(pattern),
@@ -54,6 +61,14 @@ impl TokenString {
}
}
+ pub(crate) fn strip_prefix(&mut self, suffix: &str) {
+ if let Some(Token::Text(t)) = self.0.first_mut() {
+ if let Some(x) = t.strip_prefix(suffix) {
+ *t = x.into()
+ }
+ }
+ }
+
pub(crate) fn strip_suffix(&mut self, suffix: &str) {
if let Some(Token::Text(t)) = self.0.last_mut() {
if let Some(x) = t.strip_suffix(suffix) {
@@ -71,6 +86,12 @@ impl TokenString {
*t = t.trim_start().into();
}
}
+
+ pub(crate) fn trim_end(&mut self) {
+ if let Some(Token::Text(t)) = self.0.last_mut() {
+ *t = t.trim_end().into();
+ }
+ }
}
impl fmt::Display for TokenString {