aboutsummaryrefslogtreecommitdiff
path: root/src/makefile/target.rs
blob: eb181cdb7017925a980d7759e476637c445df4f1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
use std::cell::Cell;
use std::fmt;
use std::fs::metadata;
use std::time::SystemTime;

use crate::makefile::command_line::CommandLine;

use super::Makefile;

#[derive(PartialEq, Eq, Clone, Debug)]
pub(crate) struct Target {
    pub(crate) name: String,
    pub(crate) prerequisites: Vec<String>,
    pub(crate) commands: Vec<CommandLine>,
    pub(crate) already_updated: Cell<bool>,
}

impl Target {
    fn modified_time(&self) -> Option<SystemTime> {
        metadata(&self.name)
            .and_then(|metadata| metadata.modified())
            .ok()
    }

    pub(crate) fn newer_than(&self, other: &Self) -> Option<bool> {
        let self_updated = self.already_updated.get();
        let other_updated = other.already_updated.get();
        Some(match (self.modified_time(), other.modified_time()) {
            (Some(self_mtime), Some(other_mtime)) => self_mtime >= other_mtime,
            // per POSIX: "If the target does not exist after the target has been
            // successfully made up-to-date, the target shall be treated as being
            // newer than any target for which it is a prerequisite."
            (None, _) if self_updated && other.prerequisites.contains(&self.name) => true,
            (_, None) if other_updated && self.prerequisites.contains(&other.name) => false,
            _ => return None,
        })
    }

    fn is_up_to_date(&self, file: &Makefile) -> bool {
        if self.already_updated.get() {
            return true;
        }
        let exists = metadata(&self.name).is_ok();
        let newer_than_all_dependencies = self.prerequisites.iter().all(|t| {
            self.newer_than(&file.get_target(t).borrow())
                .unwrap_or(false)
        });
        exists && newer_than_all_dependencies
    }

    pub(crate) fn update(&self, file: &Makefile) {
        for prereq in &self.prerequisites {
            file.update_target(prereq);
        }
        if !self.is_up_to_date(file) {
            self.execute_commands(file);
        }
        self.already_updated.set(true);
    }

    fn execute_commands(&self, file: &Makefile) {
        for command in &self.commands {
            command.execute(file, self);
        }
    }
}

impl fmt::Display for Target {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let prereqs = self.prerequisites.join(" ");
        writeln!(f, "{}: {}", &self.name, prereqs)?;
        for command in &self.commands {
            writeln!(f, "\t{}", command)?;
        }
        Ok(())
    }
}