From bc5038e6c344803bce76add47b13ceaa61a5bde3 Mon Sep 17 00:00:00 2001 From: Melody Horn Date: Sun, 28 Mar 2021 14:57:03 -0600 Subject: almost implement all functions --- src/makefile/functions.rs | 285 ++++++++++++++++++++++++++++++++++++++++-- src/makefile/macro.rs | 189 ++++++++++++++++++++++++++++ src/makefile/mod.rs | 306 +++++++++++++++++++--------------------------- src/makefile/pattern.rs | 49 ++++++++ src/makefile/token.rs | 7 ++ 5 files changed, 647 insertions(+), 189 deletions(-) create mode 100644 src/makefile/macro.rs create mode 100644 src/makefile/pattern.rs (limited to 'src/makefile') diff --git a/src/makefile/functions.rs b/src/makefile/functions.rs index bc39886..b9a6a6d 100644 --- a/src/makefile/functions.rs +++ b/src/makefile/functions.rs @@ -1,26 +1,160 @@ +use std::env; +use std::path::Path; + +use super::pattern::r#match; +use super::r#macro::{MacroSet, MacroSource}; use super::token::TokenString; -pub(crate) fn call(name: &str, args: &[TokenString]) -> TokenString { +pub(crate) struct FunctionCall {} + +fn filter(macros: &MacroSet, patterns: &TokenString, text: &TokenString) -> String { + let patterns = macros.expand(patterns); + let patterns = patterns.split_whitespace().collect::>(); + let text = macros.expand(&text); + let text = text.split_whitespace(); + let mut result_pieces = vec![]; + for word in text { + if patterns + .iter() + .any(|pattern| r#match(pattern, word).is_some()) + { + result_pieces.push(word); + } + } + result_pieces.join(" ") +} + +pub(crate) fn call(name: &str, args: &[TokenString], macros: &MacroSet) -> String { match name { // Text Functions - "filter" => todo!(), - "filter-out" => todo!(), - "sort" => todo!(), + "filter" => { + assert_eq!(args.len(), 2); + filter(macros, &args[0], &args[1]) + } + "filter-out" => { + assert_eq!(args.len(), 2); + let patterns = macros.expand(&args[0]); + let patterns = patterns.split_whitespace().collect::>(); + let text = macros.expand(&args[1]); + let text = text.split_whitespace(); + let mut result_pieces = vec![]; + for word in text { + if patterns + .iter() + .all(|pattern| r#match(pattern, word).is_none()) + { + result_pieces.push(word); + } + } + result_pieces.join(" ") + } + "sort" => { + assert_eq!(args.len(), 1); + let words = macros.expand(&args[0]); + let mut words = words.split_whitespace().collect::>(); + words.sort(); + words.dedup(); + words.join(" ") + } // File Name Functions - "notdir" => todo!(), - "basename" => todo!(), - "addprefix" => todo!(), - "wildcard" => todo!(), + "notdir" => { + assert_eq!(args.len(), 1); + let words = macros.expand(&args[0]); + let words = words + .split_whitespace() + .map(|word| { + Path::new(word) + .file_name() + .and_then(|filename| filename.to_str()) + .unwrap_or("") + }) + .collect::>(); + words.join(" ") + } + "basename" => { + assert_eq!(args.len(), 1); + let words = macros.expand(&args[0]); + let words = words + .split_whitespace() + .map(|word| { + Path::new(word) + .with_extension("") + .to_str() + .map_or_else(String::new, ToString::to_string) + }) + .collect::>(); + words.join(" ") + } + "addprefix" => { + assert_eq!(args.len(), 2); + let prefix = macros.expand(&args[0]); + let targets = macros.expand(&args[1]); + let results = targets + .split_whitespace() + .map(|t| format!("{}{}", prefix, t)) + .collect::>(); + results.join(" ") + } + "wildcard" => { + assert_eq!(args.len(), 1); + let pattern = macros.expand(&args[0]); + let home_dir = env::var("HOME") + .ok() + .or(dirs::home_dir().and_then(|p| p.to_str().map(String::from))); + let pattern = if let Some(home_dir) = home_dir { + pattern.replace('~', &home_dir) + } else { + pattern + }; + let results = glob::glob(&pattern) + .expect("invalid glob pattern!") + .filter_map(|path| path.ok()) + .map(|path| path.to_str().map(ToString::to_string).unwrap_or_default()) + .collect::>(); + results.join(" ") + } // foreach - "foreach" => todo!(), + "foreach" => { + assert_eq!(args.len(), 3); + let var = macros.expand(&args[0]); + let list = macros.expand(&args[1]); + let text = &args[2]; + let words = list.split_whitespace(); + + let mut macros = macros.clone(); + let results = words + .map(|word| { + macros.set(var.clone(), MacroSource::File, TokenString::text(word)); + macros.expand(text) + }) + .collect::>(); + results.join(" ") + } // call - "call" => todo!(), + "call" => { + assert!(args.len() > 0); + let args = args + .iter() + .map(|arg| macros.expand(arg)) + .collect::>(); + let function = args[0].clone(); + + let mut macros = macros.clone(); + for (i, x) in args.into_iter().enumerate() { + macros.set(i.to_string(), MacroSource::File, TokenString::text(x)); + } + macros.expand(&TokenString::r#macro(function)) + } // eval - "eval" => todo!(), + "eval" => { + assert_eq!(args.len(), 1); + let arg = macros.expand(&args[0]); + todo!() + } // shell "shell" => todo!(), @@ -29,3 +163,132 @@ pub(crate) fn call(name: &str, args: &[TokenString]) -> TokenString { _ => panic!("function not implemented: {}", name), } } + +#[cfg(test)] +mod test { + use super::*; + + fn call(name: &str, args: &[TokenString], macros: &MacroSet) -> String { + super::call(name, args, macros, lookup_fail) + } + + macro_rules! call { + ($func:literal $($arg:literal),+) => { + call($func, &[$(TokenString::text($arg)),+], &MacroSet::new()) + }; + ($func:ident $($arg:literal),+) => { + call(stringify!($func), &[$(TokenString::text($arg)),+], &MacroSet::new()) + }; + } + + #[test] + fn filter() { + let result = call!(filter "word", "this contains a word inside it"); + assert_eq!(result, "word"); + + let result = call!(filter "%.c %.s", "foo.c bar.c baz.s ugh.h"); + assert_eq!(result, "foo.c bar.c baz.s"); + } + + #[test] + fn filter_out() { + let result = call!("filter-out" "main1.o main2.o", "main1.o foo.o main2.o bar.o"); + assert_eq!(result, "foo.o bar.o"); + } + + #[test] + fn sort() { + let result = call!(sort "foo bar lose foo"); + assert_eq!(result, "bar foo lose"); + } + + #[test] + fn notdir() { + let result = call!(notdir "src/foo.c hacks"); + assert_eq!(result, "foo.c hacks"); + } + + #[test] + fn basename() { + let result = call!(basename "src/foo.c src-1.0/bar hacks"); + assert_eq!(result, "src/foo src-1.0/bar hacks"); + } + + #[test] + fn addprefix() { + let result = call!(addprefix "src/", "foo bar"); + assert_eq!(result, "src/foo src/bar"); + } + + #[test] + fn wildcard() { + use std::env::{set_current_dir, set_var}; + use std::fs::write; + use std::path::MAIN_SEPARATOR; + + let tempdir = tempfile::tempdir().unwrap(); + + write(tempdir.path().join("foo.c"), "").unwrap(); + write(tempdir.path().join("bar.h"), "").unwrap(); + write(tempdir.path().join("baz.txt"), "").unwrap(); + write(tempdir.path().join("acab.c"), "ACAB").unwrap(); + write(tempdir.path().join("based.txt"), "☭").unwrap(); + + set_current_dir(tempdir.path()).unwrap(); + set_var("HOME", tempdir.path().to_str().unwrap()); + let sort = |x: String| call("sort", &[TokenString::text(&x)], &MacroSet::new()); + assert_eq!(sort(call!(wildcard "*.c")), "acab.c foo.c"); + assert_eq!( + sort(call!(wildcard "~/ba?.*")), + format!( + "{0}{1}bar.h {0}{1}baz.txt", + tempdir.path().to_str().unwrap(), + MAIN_SEPARATOR + ) + ); + } + + #[test] + fn foreach() { + let mut macros = MacroSet::new(); + macros.set( + "test".to_string(), + MacroSource::File, + "worked for $(item).".parse().unwrap(), + ); + assert_eq!( + call( + "foreach", + &[ + TokenString::text("item"), + TokenString::text("a b c d"), + TokenString::r#macro("test") + ], + ¯os, + ), + "worked for a. worked for b. worked for c. worked for d." + ); + } + + #[test] + fn call_test() { + let mut macros = MacroSet::new(); + macros.set( + "reverse".to_string(), + MacroSource::File, + "$(2) $(1)".parse().unwrap(), + ); + assert_eq!( + call( + "call", + &[ + TokenString::text("reverse"), + TokenString::text("a"), + TokenString::text("b") + ], + ¯os, + ), + "b a" + ); + } +} diff --git a/src/makefile/macro.rs b/src/makefile/macro.rs new file mode 100644 index 0000000..139903f --- /dev/null +++ b/src/makefile/macro.rs @@ -0,0 +1,189 @@ +use std::cell::RefCell; +use std::collections::HashMap; +use std::env; +use std::fmt; +use std::rc::{Rc, Weak}; + +use regex::Regex; + +use super::functions; +use super::token::{Token, TokenString}; + +#[derive(Debug, Clone)] +pub(crate) enum MacroSource { + File, + CommandLineOrMakeflags, + Environment, + Builtin, +} + +pub(crate) trait LookupInternal: for<'a> Fn(&'a str) -> String {} + +impl Fn(&'a str) -> String> LookupInternal for F {} + +fn lookup_fail(_: &str) -> String { + panic!("internal variables not available!"); +} + +#[derive(Clone)] +pub(crate) struct MacroSet { + data: HashMap, + lookup_internal: RefCell>, +} + +impl MacroSet { + pub(crate) fn new() -> Self { + let lookup_fail: Rc = Rc::new(lookup_fail); + Self { + data: HashMap::new(), + lookup_internal: RefCell::new(Rc::downgrade(&lookup_fail)), + } + } + + pub(crate) fn lookup(&self, lookup: Weak) { + self.lookup_internal.replace(lookup); + } + + pub(crate) fn add_builtins(&mut self) { + for (k, v) in builtins() { + self.data.insert(k.into(), (MacroSource::Builtin, v)); + } + } + + pub(crate) fn add_env(&mut self) { + for (k, v) in env::vars() { + if k != "MAKEFLAGS" && k != "SHELL" { + self.data + .insert(k, (MacroSource::Environment, TokenString::text(v))); + } + } + } + + pub(crate) fn set(&mut self, name: String, source: MacroSource, text: TokenString) { + self.data.insert(name, (source, text)); + } + + pub(crate) fn is_defined(&self, name: &str) -> bool { + self.data.contains_key(name) + } + + pub(crate) fn get(&self, name: &str) -> Option<&(MacroSource, TokenString)> { + self.data.get(name) + } + + // `remove` is fine, but I think for "remove-and-return" `pop` is better + pub(crate) fn pop(&mut self, name: &str) -> Option<(MacroSource, TokenString)> { + self.data.remove(name) + } + + pub(crate) fn expand(&self, text: &TokenString) -> String { + let mut result = String::new(); + for token in text.tokens() { + match token { + Token::Text(t) => result.push_str(t), + Token::MacroExpansion { name, replacement } => { + let internal_macro_names = &['@', '?', '<', '*'][..]; + let internal_macro_suffices = &['D', 'F'][..]; + let just_internal = name.len() == 1 && name.starts_with(internal_macro_names); + let suffixed_internal = name.len() == 2 + && name.starts_with(internal_macro_names) + && name.ends_with(internal_macro_suffices); + let macro_value = if just_internal || suffixed_internal { + let lookup_internal = self.lookup_internal.borrow(); + let lookup_internal = match lookup_internal.upgrade() { + Some(f) => f, + None => Rc::new(lookup_fail), + }; + lookup_internal(name) + } else { + self.data + .get(name) + .map_or_else(String::new, |(_, macro_value)| self.expand(macro_value)) + }; + let macro_value = match replacement { + Some((subst1, subst2)) => { + let subst1 = self.expand(subst1); + let subst1_suffix = regex::escape(&subst1); + let subst1_suffix = + Regex::new(&format!(r"{}\b", subst1_suffix)).unwrap(); + let subst2 = self.expand(subst2); + subst1_suffix.replace_all(¯o_value, subst2).to_string() + } + None => macro_value, + }; + result.push_str(¯o_value); + } + Token::FunctionCall { name, args } => { + result.push_str(&functions::call(name, args, &self)); + } + } + } + result + } +} + +impl fmt::Debug for MacroSet { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{:?}", &self.data) + } +} + +impl fmt::Display for MacroSet { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let pieces = self + .data + .iter() + .map(|(k, (_, v))| format!("{}={}", k, v)) + .collect::>(); + write!(f, "{}", pieces.join("\n")) + } +} + +fn builtins() -> Vec<(&'static str, TokenString)> { + // Fuck it, might as well. + macro_rules! handle { + ($value:ident) => { + stringify!($value) + }; + ($value:literal) => { + $value + }; + } + macro_rules! make { + ($($name:ident=$value:tt)+) => {vec![$( + (stringify!($name), handle!($value).parse().unwrap()) + ),+]}; + } + + make![ + MAKE=makers + AR=ar + YACC=yacc + YFLAGS="" + LEX=lex + LFLAGS="" + LDFLAGS="" + + AS=as + CC=cc + CXX="g++" + CPP="$(CC) -E" + FC=f77 + PC=pc + CO=co + GET=get + LINT=lint + MAKEINFO=makeinfo + TEX=tex + TEXI2DVI=texi2dvi + WEAVE=weave + CWEAVE=cweave + TANGLE=tangle + CTANGLE=ctangle + RM="rm -f" + + ARFLAGS="rv" + CFLAGS="" + FFLAGS="" + ] +} diff --git a/src/makefile/mod.rs b/src/makefile/mod.rs index 1fc8303..7610197 100644 --- a/src/makefile/mod.rs +++ b/src/makefile/mod.rs @@ -7,21 +7,23 @@ use std::io::{BufRead, BufReader, Error as IoError}; use std::path::Path; use std::rc::Rc; +use crate::args::Args; use lazy_static::lazy_static; use regex::Regex; -use crate::args::Args; - mod command_line; mod conditional; mod functions; mod inference_rules; +mod r#macro; +mod pattern; mod target; mod token; use command_line::CommandLine; use conditional::{ConditionalLine, ConditionalState}; use inference_rules::InferenceRule; +use r#macro::{LookupInternal, MacroSet, MacroSource}; use target::Target; use token::{tokenize, Token, TokenString}; @@ -58,13 +60,6 @@ impl LineType { } } -enum MacroSource { - File, - CommandLineOrMakeflags, - Environment, - Builtin, -} - fn inference_match<'a>( targets: &[&'a str], prerequisites: &[String], @@ -91,7 +86,7 @@ fn inference_match<'a>( pub(crate) struct Makefile<'a> { inference_rules: Vec, - macros: HashMap, + macros: MacroSet, targets: RefCell>>>, pub(crate) first_non_special_target: Option, args: &'a Args, @@ -101,15 +96,13 @@ pub(crate) struct Makefile<'a> { impl<'a> Makefile<'a> { pub(crate) fn new(args: &'a Args) -> Self { let mut inference_rules = vec![]; - let mut macros = HashMap::new(); + let mut macros = MacroSet::new(); let mut targets = HashMap::new(); let first_non_special_target = None; if !args.no_builtin_rules { inference_rules.extend(builtin_inference_rules()); - for (k, v) in builtin_macros() { - macros.insert(k.into(), (MacroSource::Builtin, v)); - } + macros.add_builtins(); targets.extend( builtin_targets() .into_iter() @@ -117,20 +110,14 @@ impl<'a> Makefile<'a> { ); } - for (k, v) in env::vars() { - if k != "MAKEFLAGS" && k != "SHELL" { - macros.insert(k, (MacroSource::Environment, TokenString::text(v))); - } - } + macros.add_env(); for r#macro in args.macros() { if let [name, value] = *r#macro.splitn(2, '=').collect::>() { - macros.insert( + macros.set( name.into(), - ( - MacroSource::CommandLineOrMakeflags, - TokenString::text(value), - ), + MacroSource::CommandLineOrMakeflags, + TokenString::text(value), ); } } @@ -197,7 +184,7 @@ impl<'a> Makefile<'a> { { line.action( conditional_stack.last(), - |name| self.macros.contains_key(name), + |name| self.macros.is_defined(name), |t| self.expand_macros(t, None), ) .apply_to(&mut conditional_stack); @@ -375,7 +362,7 @@ impl<'a> Makefile<'a> { _ => {} } - let value = match self.macros.remove(name) { + let value = match self.macros.pop(name) { Some((_, mut old_value)) if append => { // TODO eagerly expand if appending to eagerly-expanded macro old_value.extend(TokenString::text(" ")); @@ -384,7 +371,7 @@ impl<'a> Makefile<'a> { } _ => value, }; - self.macros.insert(name.into(), (MacroSource::File, value)); + self.macros.set(name.into(), MacroSource::File, value); } fn special_target_has_prereq(&self, target: &str, name: &str) -> bool { @@ -501,104 +488,75 @@ impl<'a> Makefile<'a> { } fn expand_macros(&self, text: &TokenString, target: Option<&Target>) -> String { - let mut result = String::new(); - for token in text.tokens() { - match token { - Token::Text(t) => result.push_str(t), - Token::MacroExpansion { name, replacement } => { - let internal_macro_names = &['@', '?', '<', '*'][..]; - let internal_macro_suffices = &['D', 'F'][..]; - let just_internal = name.len() == 1 && name.starts_with(internal_macro_names); - let suffixed_internal = name.len() == 2 - && name.starts_with(internal_macro_names) - && name.ends_with(internal_macro_suffices); - let macro_value = if just_internal || suffixed_internal { - let target = target.expect("internal macro but no current target!"); - let macro_pieces = if name.starts_with('@') { - // The $@ shall evaluate to the full target name of the - // current target. - vec![target.name.clone()] - } else if name.starts_with('?') { - // The $? macro shall evaluate to the list of prerequisites - // that are newer than the current target. - target - .prerequisites - .iter() - .filter(|prereq| { - self.get_target(prereq) - .borrow() - .newer_than(target) - .unwrap_or(false) - }) - .cloned() - .collect() - } else if name.starts_with('<') { - // In an inference rule, the $< macro shall evaluate to the - // filename whose existence allowed the inference rule to be - // chosen for the target. In the .DEFAULT rule, the $< macro - // shall evaluate to the current target name. - target.prerequisites.clone() - } else if name.starts_with('*') { - // The $* macro shall evaluate to the current target name with - // its suffix deleted. - vec![Path::new(name).with_extension("").to_string_lossy().into()] - } else { - unreachable!() - }; + let target = target.cloned(); + let lookup_internal = move |name: &str| { + let target = target + .as_ref() + .expect("internal macro but no current target!"); + let macro_pieces = if name.starts_with('@') { + // The $@ shall evaluate to the full target name of the + // current target. + vec![target.name.clone()] + } else if name.starts_with('?') { + // The $? macro shall evaluate to the list of prerequisites + // that are newer than the current target. + target + .prerequisites + .iter() + .filter(|prereq| { + self.get_target(prereq) + .borrow() + .newer_than(&target) + .unwrap_or(false) + }) + .cloned() + .collect() + } else if name.starts_with('<') { + // In an inference rule, the $< macro shall evaluate to the + // filename whose existence allowed the inference rule to be + // chosen for the target. In the .DEFAULT rule, the $< macro + // shall evaluate to the current target name. + target.prerequisites.clone() + } else if name.starts_with('*') { + // The $* macro shall evaluate to the current target name with + // its suffix deleted. + vec![Path::new(name).with_extension("").to_string_lossy().into()] + } else { + unreachable!() + }; - let macro_pieces = if name.ends_with('D') { - macro_pieces - .into_iter() - .map(|x| { - Path::new(&x) - .parent() - .expect("no parent") - .to_string_lossy() - .into() - }) - .collect() - } else if name.ends_with('F') { - macro_pieces - .into_iter() - .map(|x| { - Path::new(&x) - .file_name() - .expect("no filename") - .to_string_lossy() - .into() - }) - .collect() - } else { - macro_pieces - }; + let macro_pieces = if name.ends_with('D') { + macro_pieces + .into_iter() + .map(|x| { + Path::new(&x) + .parent() + .expect("no parent") + .to_string_lossy() + .into() + }) + .collect() + } else if name.ends_with('F') { + macro_pieces + .into_iter() + .map(|x| { + Path::new(&x) + .file_name() + .expect("no filename") + .to_string_lossy() + .into() + }) + .collect() + } else { + macro_pieces + }; - macro_pieces.join(" ") - } else { - self.macros - .get(name) - .map_or_else(String::new, |(_, macro_value)| { - self.expand_macros(macro_value, target) - }) - }; - let macro_value = match replacement { - Some((subst1, subst2)) => { - let subst1 = self.expand_macros(subst1, target); - let subst1_suffix = regex::escape(&subst1); - let subst1_suffix = - Regex::new(&format!(r"{}\b", subst1_suffix)).unwrap(); - let subst2 = self.expand_macros(subst2, target); - subst1_suffix.replace_all(¯o_value, subst2).to_string() - } - None => macro_value, - }; - result.push_str(¯o_value); - } - Token::FunctionCall { name, args } => { - result.push_str(&self.expand_macros(&functions::call(name, args), None)); - } - } - } - result + macro_pieces.join(" ") + }; + + let lookup_internal: Rc = Rc::new(lookup_internal); + self.macros.lookup(Rc::downgrade(&lookup_internal)); + self.macros.expand(text) } } @@ -614,9 +572,7 @@ impl fmt::Display for Makefile<'_> { writeln!(f)?; header(f, "Macros")?; - for (k, (_, v)) in &self.macros { - writeln!(f, "{}={}", k, v)?; - } + writeln!(f, "{}", &self.macros)?; writeln!(f)?; header(f, "Targets")?; @@ -691,54 +647,6 @@ fn builtin_inference_rules() -> Vec { "rm -f $*.o" } } -fn builtin_macros() -> Vec<(&'static str, TokenString)> { - // Fuck it, might as well. - macro_rules! handle { - ($value:ident) => { - stringify!($value) - }; - ($value:literal) => { - $value - }; - } - macro_rules! make { - ($($name:ident=$value:tt)+) => {vec![$( - (stringify!($name), handle!($value).parse().unwrap()) - ),+]}; - } - - make![ - MAKE=makers - AR=ar - YACC=yacc - YFLAGS="" - LEX=lex - LFLAGS="" - LDFLAGS="" - - AS=as - CC=cc - CXX="g++" - CPP="$(CC) -E" - FC=f77 - PC=pc - CO=co - GET=get - LINT=lint - MAKEINFO=makeinfo - TEX=tex - TEXI2DVI=texi2dvi - WEAVE=weave - CWEAVE=cweave - TANGLE=tangle - CTANGLE=ctangle - RM="rm -f" - - ARFLAGS="rv" - CFLAGS="" - FFLAGS="" - ] -} fn builtin_targets() -> Vec { // even i'm not going to do that just for this vec![Target { @@ -754,14 +662,14 @@ fn builtin_targets() -> Vec { #[cfg(test)] mod test { - use super::*; - use std::io::Cursor; + use super::*; + fn empty_makefile(args: &Args) -> Makefile { Makefile { inference_rules: vec![], - macros: HashMap::new(), + macros: MacroSet::new(), targets: RefCell::new(HashMap::new()), first_non_special_target: None, args, @@ -781,8 +689,50 @@ endif let mut makefile = empty_makefile(&args); makefile.and_read(Cursor::new(file)); assert_eq!( - makefile.expand_macros(&"$(worked)".parse().unwrap(), None), + makefile.expand_macros(&TokenString::r#macro("worked"), None), "yes" ); } + + #[test] + #[ignore = "I still haven't implemented `eval` or `define` or %-based macro substitution."] + fn eval() { + // This, for the record, is a terrible misfeature. + // If you need this, you probably shouldn't be using Make. + // But a lot of people are using this and still use Make anyway, so here we go, + // I guess. + + let file = " +PROGRAMS = server client + +server_OBJS = server.o server_priv.o server_access.o +server_LIBS = priv protocol + +client_OBJS = client.o client_api.o client_mem.o +client_LIBS = protocol + +# Everything after this is generic + +.PHONY: all +all: $(PROGRAMS) + +define PROGRAM_template = + $(1): $$($(1)_OBJS) $$($(1)_LIBS:%=-l%) + ALL_OBJS += $$($(1)_OBJS) +endef + +$(foreach prog,$(PROGRAMS),$(eval $(call PROGRAM_template,$(prog)))) + +$(PROGRAMS): + $(LINK.o) $^ $(LDLIBS) -o $@ + +clean: + rm -f $(ALL_OBJS) $(PROGRAMS) + "; + + let args = Args::empty(); + let mut makefile = empty_makefile(&args); + makefile.and_read(Cursor::new(file)); + assert!(makefile.targets.borrow().contains_key("server")) + } } diff --git a/src/makefile/pattern.rs b/src/makefile/pattern.rs new file mode 100644 index 0000000..733721e --- /dev/null +++ b/src/makefile/pattern.rs @@ -0,0 +1,49 @@ +use regex::{Captures, Regex}; + +fn compile_pattern(pattern: &str) -> Regex { + let mut result = String::new(); + for c in pattern.chars() { + match c { + // This is a nightmare, because we're escaping for regex syntax before we put + // things into result. + + // We don't end with a backslash, so this is an unescaped wildcard. + '%' if !result.ends_with(r"\\") => { + result.push_str(r"(\w*)"); + } + + // We end with two backslashes, so this is an escaped backslash and then an + // unescaped wildcard. + '%' if result.ends_with(r"\\\\") => { + result = result.strip_suffix(r"\\\\").unwrap().to_string(); + result.push_str(r"\\(\w*)"); + } + + // We end with one backslash, so this is an escaped wildcard. + '%' if result.ends_with(r"\\") => { + result = result.strip_suffix(r"\\").unwrap().to_string(); + result.push('%'); + } + _ => result.push_str(®ex::escape(&c.to_string())), + } + } + Regex::new(&result).expect("built invalid regex!") +} + +pub(crate) fn r#match<'a>(pattern: &str, text: &'a str) -> Option> { + compile_pattern(pattern).captures(text) +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn pattern_backslashes() { + let test_case = compile_pattern(r"the\%weird\\%pattern\\"); + assert_eq!(test_case.to_string(), r"the%weird\\(\w*)pattern\\\\"); + + let hell = compile_pattern(r"\\\\%"); + assert_eq!(hell.to_string(), r"\\\\\\(\w*)"); + } +} diff --git a/src/makefile/token.rs b/src/makefile/token.rs index eca40ed..8b21f06 100644 --- a/src/makefile/token.rs +++ b/src/makefile/token.rs @@ -19,6 +19,13 @@ impl TokenString { Self(vec![Token::Text(text.into())]) } + pub(crate) fn r#macro(name: impl Into) -> Self { + Self(vec![Token::MacroExpansion { + name: name.into(), + replacement: None, + }]) + } + pub(crate) fn tokens(&self) -> impl Iterator { self.0.iter() } -- cgit v1.2.3