add (& somewhat test!) GNUful conditionals

1 files changed, 164 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,
+        }
+    }
+}