This commit is contained in:
Noah Swerhun 2023-12-02 17:30:57 -06:00
parent 07846d0635
commit 7c5ee2e70a

View file

@ -1,220 +0,0 @@
use std::io;
fn recurse_through_c_files(dir: &str) -> io::Result<()> {
let dir = std::fs::read_dir(dir)?;
for file in dir {
let file = file?;
let file_path = file.path();
if file.path().is_dir() {
recurse_through_c_files(file_path.to_str()
.expect("filepath should be converted to string slice"))?;
}
let ext = file_path.extension()
.and_then(|v| v.to_str())
.unwrap_or_else(|| "");
if ext != "c" {
continue;
}
println!("{:?}", file.path().with_extension("o").file_name().expect("files should have names"));
todo!()
}
<<<<<<< Updated upstream
Ok(())
=======
fn contains_objdir_def(&self) -> bool {
let re = Regex::new(r"\s+OBJDIR = ").unwrap();
re.is_match(&(self.prologue)) || re.is_match(&(self.epilogue))
}
fn write_new_generated_content(&self, generated_content: String) -> std::io::Result<()> {
let content = [&self.prologue, START_KEY, &generated_content, END_KEY, &self.epilogue].concat();
fs::write(&self.path, &content)?;
Ok(())
}
}
fn join_build_rule_vec(vector: &Vec<BuildRule>, seperator: &str) -> String{
let mut ret = String::new();
for (i, rule) in vector.iter().enumerate() {
if i != 0 {
ret.push_str(seperator);
}
ret.push_str(&rule.to_string());
}
ret
}
impl ToString for RuleList {
fn to_string(&self) -> String {
let targets = join_build_rule_vec(&self.get_target_rules(), "");
let objects = join_build_rule_vec(&self.get_object_rules(), "");
let directories = join_build_rule_vec(&self.get_directory_rules(), "");
let conveniences = join_build_rule_vec(&self.get_convenience_rules(), "");
[targets, objects, directories, conveniences].concat()
}
}
impl RuleList {
fn new() -> RuleList{
RuleList(vec![])
}
fn recursively_gen_objects(&mut self, proj_dir_path: &str) -> std::io::Result<()>{
let files = fs::read_dir(proj_dir_path)?;
for file in files {
let file = file?;
let is_dir = file.metadata()?.is_dir();
// ignore hidden files
if file_is_hidden(&file) {
continue;
}
let path = file.path();
if is_dir {
self.recursively_gen_objects(path.to_str().unwrap())?;
} else {
match path.extension() {
Some(v) => {
let v = v.to_str().unwrap();
if v != "c" {
continue;
}
let path = path.to_str().unwrap();
self.0.push(BuildRuleKind::Object(BuildRule::new_from_c_file(path)));
},
None => {
continue;
},
}
}
}
Ok(())
}
fn get_obj_targets(&self) -> Vec<String>{
let mut ret: Vec<String> = Vec::new();
for rule in &self.0 {
match rule {
BuildRuleKind::Object(r) => ret.push(r.target.clone()),
_ => break,
}
}
ret
}
fn add_target_rule(&mut self) {
let mut objects = self.get_obj_targets();
let target_comm = String::from(
format!("$(CC) $(LDFLAGS) -o $(BUILDDIR)/$(TARGET) {} $(LDLIBS)", objects.join(" "))
);
objects.push(String::from("| $(OBJDIR) $(BUILDDIR)"));
let prereqs = objects;
self.0.push(BuildRuleKind::Target(BuildRule {
target: String::from("$(BUILDDIR)/$(TARGET)"),
prerequisites: prereqs,
recipe_commands: vec![target_comm],
}))
}
fn add_directory_rule(&mut self, dir: &str) {
self.0.push(BuildRuleKind::Directory(BuildRule {
target: dir.to_string(),
prerequisites: vec![],
recipe_commands: vec![format!("mkdir -p {dir}").to_string()]
}));
}
fn add_clean_rule(&mut self) {
self.0.push(BuildRuleKind::Convenience(BuildRule {
target: String::from(".PHONY: clean\nclean"),
prerequisites: vec![],
recipe_commands: vec![String::from("rm -r $(OBJDIR)"), String::from("rm -r $(BUILDDIR)")]
}));
}
fn add_run_rule(&mut self) {
self.0.push(BuildRuleKind::Convenience(BuildRule {
target: String::from(".PHONY: run\nrun"),
prerequisites: vec![String::from("$(BUILDDIR)/$(TARGET)")],
recipe_commands: vec![String::from("./$(BUILDDIR)/$(TARGET) $(args)")]
}));
}
fn get_target_rules(&self) -> Vec<BuildRule> {
let mut ret: Vec<BuildRule> = Vec::new();
for rule in &self.0 {
match rule {
BuildRuleKind::Target(r) => ret.push(r.clone()),
_ => continue,
}
}
ret
}
fn get_object_rules(&self) -> Vec<BuildRule> {
let mut ret: Vec<BuildRule> = Vec::new();
for rule in &self.0 {
match rule {
BuildRuleKind::Object(r) => ret.push(r.clone()),
_ => continue,
}
}
ret
}
fn get_directory_rules(&self) -> Vec<BuildRule> {
let mut ret: Vec<BuildRule> = Vec::new();
for rule in &self.0 {
match rule {
BuildRuleKind::Directory(r) => ret.push(r.clone()),
_ => continue,
}
}
ret
}
fn get_convenience_rules(&self) -> Vec<BuildRule> {
let mut ret: Vec<BuildRule> = Vec::new();
for rule in &self.0 {
match rule {
BuildRuleKind::Convenience(r) => ret.push(r.clone()),
_ => continue,
}
}
ret
}
}
fn file_is_hidden(file: &DirEntry) -> bool{
let file_name = file.file_name();
let str_name = file_name.to_str().unwrap();
let first_char = str_name.chars().nth(0).unwrap();
if first_char == '.' {
true
} else {
false
}
>>>>>>> Stashed changes
}
fn main() {
recurse_through_c_files(".").unwrap_or_else(|e| {
panic!("error: could not recurse through directory: {e}");
});
}