implement define blocks

1 files changed, 58 insertions, 6 deletions

diff --git a/src/makefile/mod.rs b/src/makefile/mod.rs
index f4f0853..fb92a01 100644
--- a/src/makefile/mod.rs
+++ b/src/makefile/mod.rs
@@ -42,6 +42,10 @@ enum LineType {
 
 impl LineType {
     fn of(line_tokens: &TokenString) -> Self {
+        #[cfg(feature = "full")]
+        if line_tokens.starts_with("define ") {
+            return Self::Macro;
+        }
         for token in line_tokens.tokens() {
             if let Token::Text(text) = token {
                 let colon_idx = text.find(':');
@@ -242,7 +246,9 @@ impl<'a> Makefile<'a> {
 
                 match line_type {
                     LineType::Rule => self.read_rule(&line_tokens, line_number, &mut lines_iter)?,
-                    LineType::Macro => self.read_macro(&line_tokens, line_number)?,
+                    LineType::Macro => {
+                        self.read_macro(line_tokens, line_number, &mut lines_iter)?
+                    }
                     LineType::Unknown => {
                         if !line_tokens.is_empty() {
                             bail!(
@@ -377,10 +383,37 @@ impl<'a> Makefile<'a> {
         Ok(())
     }
 
-    fn read_macro(&mut self, line_tokens: &TokenString, line_number: usize) -> Result<()> {
-        let (name, mut value) = line_tokens
-            .split_once('=')
-            .ok_or_else(|| eyre!("read_rule couldn't find a ':' on line {}", line_number))?;
+    fn read_macro(
+        &mut self,
+        mut line_tokens: TokenString,
+        line_number: usize,
+        lines_iter: &mut Peekable<impl Iterator<Item = (usize, Result<String>)>>,
+    ) -> Result<()> {
+        let (name, mut value) = if cfg!(feature = "full") && line_tokens.starts_with("define ") {
+            line_tokens.strip_prefix("define ");
+            if line_tokens.ends_with("=") {
+                line_tokens.strip_suffix("=");
+                line_tokens.trim_end();
+            }
+            let mut value = TokenString::from(vec![]);
+            for (_, line) in lines_iter {
+                let line = line?;
+                if line == "endef" {
+                    break;
+                }
+                dbg!(&value, &line);
+                if !value.is_empty() {
+                    value.extend(TokenString::text("\n"));
+                }
+                value.extend(line.parse()?);
+                dbg!(&value);
+            }
+            (line_tokens, value)
+        } else {
+            line_tokens
+                .split_once('=')
+                .ok_or_else(|| eyre!("read_rule couldn't find a ':' on line {}", line_number))?
+        };
         let name = self.expand_macros(&name, None)?;
         // GNUisms are annoying, but popular
         let mut expand_value = false;
@@ -762,8 +795,27 @@ endif
         Ok(())
     }
 
+    #[cfg(feature = "full")]
+    #[test]
+    fn define_syntax() -> R {
+        let file = "
+define foo =
+bar
+baz
+endef
+        ";
+        let args = Args::empty();
+        let mut makefile = empty_makefile(&args);
+        makefile.and_read(Cursor::new(file))?;
+        assert_eq!(
+            makefile.expand_macros(&TokenString::r#macro("foo"), None)?,
+            "bar\nbaz"
+        );
+        Ok(())
+    }
+
     #[test]
-    #[ignore = "I still haven't implemented `eval` or `define` or %-based macro substitution."]
+    #[ignore = "I still haven't implemented `eval` or %-based macro substitution."]
     fn eval() -> R {
         // This, for the record, is a terrible misfeature.
         // If you need this, you probably shouldn't be using Make.