build/rule.cxx


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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

// file      : build/rule.cxx -*- C++ -*-
// copyright : Copyright (c) 2014-2015 Code Synthesis Tools CC
// license   : MIT; see accompanying LICENSE file

#include <build/rule>

#include <utility>  // move()

#include <build/diagnostics>

using namespace std;

namespace build
{
  rule_map rules;

  // default_path_rule
  //
  void* default_path_rule::
  match (target& t, const string&) const
  {
    // @@ TODO:
    //
    // - need to assign path somehow. Get (potentially several)
    //   extensions from target type? Maybe target type should
    //   generate a list of potential paths that we can try here.
    //   What if none of them exist, which one do we use? Should
    //   there be a default extension, perhaps configurable via
    //   a variable?
    //

    path_target& pt (dynamic_cast<path_target&> (t));

    if (pt.path ().empty ())
    {
      path p (t.directory / path (pt.name));

      // @@ TMP: derive file name by appending target name as an extension?
      //
      const string& e (pt.ext != nullptr ? *pt.ext : pt.type ().name);

      if (!e.empty ())
      {
        p += '.';
        p += e;
      }

      pt.path (move (p));
    }

    return pt.mtime () != timestamp_nonexistent ? &t : nullptr;
  }

  recipe default_path_rule::
  select (target&, void*) const
  {
    return &update;
  }

  target_state default_path_rule::
  update (target& t)
  {
    // Make sure the target is not older than any of its prerequisites.
    //
    path_target& pt (dynamic_cast<path_target&> (t));
    timestamp mt (pt.mtime ());

    for (const prerequisite& p: t.prerequisites)
    {
      const target& pt (*p.target); // Should be resolved at this stage.

      // If this is an mtime-based target, then simply compare timestamps.
      //
      if (auto mtp = dynamic_cast<const mtime_target*> (&pt))
      {
        if (mt < mtp->mtime ())
        {
          error << "no rule to update target " << t <<
            info << "prerequisite " << pt << " is ahead of " << t
                << " by " << (mtp->mtime () - mt);

          return target_state::failed;
        }
      }
      else
      {
        // Otherwise we assume the prerequisite is newer if it was updated.
        //
        if (pt.state () == target_state::updated)
        {
          error << "no rule to update target " << t <<
            info << "prerequisite " << pt << " is ahead of " << t
                << " because it was updated";

          return target_state::failed;
        }
      }
    }

    return target_state::uptodate;
  }
}