aboutsummaryrefslogtreecommitdiff
path: root/build2/functions-filesystem.cxx
blob: d9e74b7a50fef71834bcd3d9e067886282ebf68d (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
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
// file      : build2/functions-filesystem.cxx -*- C++ -*-
// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
// license   : MIT; see accompanying LICENSE file

#include <libbutl/filesystem.hxx>

#include <build2/function.hxx>
#include <build2/variable.hxx>

using namespace std;

namespace build2
{
  // Return paths of filesystem entries that match the pattern. See
  // path_search() overloads (below) for details.
  //
  static names
  path_search (const path& pattern, const optional<dir_path>& start)
  {
    names r;
    auto add = [&r] (path&& p, const std::string&, bool interm) -> bool
    {
      // Canonicalizing paths seems to be the right thing to do. Otherwise, we
      // can end up with different separators in the same path on Windows.
      //
      if (!interm)
        r.emplace_back (
          value_traits<path>::reverse (move (p.canonicalize ())));

      return true;
    };

    // Print paths "as is" in the diagnostics.
    //
    try
    {
      if (pattern.absolute ())
        path_search (pattern, add);
      else
      {
        // An absolute start directory must be specified for the relative
        // pattern.
        //
        if (!start || start->relative ())
        {
          diag_record dr (fail);

          if (!start)
            dr << "start directory is not specified";
          else
            dr << "start directory '" << start->representation ()
               << "' is relative";

          dr << info << "pattern '" << pattern.representation ()
             << "' is relative";
        }

        path_search (pattern, add, *start);
      }
    }
    catch (const system_error& e)
    {
      diag_record d (fail);
      d << "unable to scan";

      // If the pattern is absolute, then the start directory is not used, and
      // so printing it would be misleading.
      //
      if (start && pattern.relative ())
        d << " '" << start->representation () << "'";

      d << ": " << e
        << info << "pattern: '" << pattern.representation () << "'";
    }

    return r;
  }

  using butl::path_match;

  // Return true if a path for a filesystem entry matches the pattern. See
  // path_match() overloads (below) for details.
  //
  static bool
  path_match (const path& pattern,
              const path& entry,
              const optional<dir_path>& start)
  {
    // If pattern and entry are both either absolute or relative and
    // non-empty, and the first pattern component is not a self-matching
    // wildcard, then ignore the start directory.
    //
    bool rel (pattern.relative () == entry.relative () &&
              !pattern.empty () && !entry.empty ());

    bool self (!pattern.empty () &&
               (*pattern.begin ()).find ("***") != string::npos);

    if (rel && !self)
      return path_match (pattern, entry);

    // The start directory must be specified and be absolute.
    //
    if (!start || start->relative ())
    {
      diag_record dr (fail);

      // Print paths "as is".
      //
      if (!start)
        dr << "start directory is not specified";
      else
        dr << "start directory path '" << start->representation ()
           << "' is relative";

      dr << info << "pattern: '" << pattern.representation () << "'"
         << info << "entry: '" << entry.representation () << "'";
    }

    return path_match (pattern, entry, *start);
  }

  void
  filesystem_functions ()
  {
    function_family f ("filesystem");

    // path_search
    //
    // Return filesystem paths that match the pattern. If the pattern is an
    // absolute path, then the start directory is ignored (if present).
    // Otherwise, the start directory must be specified and be absolute.
    //
    f["path_search"] = [](path pattern, optional<dir_path> start)
    {
      return path_search (pattern, start);
    };

    f["path_search"] = [](path pattern, names start)
    {
      return path_search (pattern, convert<dir_path> (move (start)));
    };

    f["path_search"] = [](names pattern, optional<dir_path> start)
    {
      return path_search (convert<path> (move (pattern)), start);
    };

    f["path_search"] = [](names pattern, names start)
    {
      return path_search (convert<path>     (move (pattern)),
                          convert<dir_path> (move (start)));
    };

    // path_match
    //
    // Match a filesystem entry name against a name pattern (both are strings),
    // or a filesystem entry path against a path pattern. For the latter case
    // the start directory may also be required (see below). The semantics of
    // the pattern and name/entry arguments is determined according to the
    // following rules:
    //
    // - The arguments must be of the string or path types, or be untyped.
    //
    // - If one of the arguments is typed, then the other one must be of the
    //   same type or be untyped. In the later case, an untyped argument is
    //   converted to the type of the other argument.
    //
    // - If both arguments are untyped and the start directory is specified,
    //   then the arguments are converted to the path type.
    //
    // - If both arguments are untyped and the start directory is not
    //   specified, then, if one of the arguments is syntactically a path (the
    //   value contains a directory separator), convert them to the path type,
    //   otherwise to the string type (match as names).
    //
    // If pattern and entry paths are both either absolute or relative and
    // non-empty, and the first pattern component is not a self-matching
    // wildcard (doesn't contain ***), then the start directory is not
    // required, and is ignored if specified. Otherwise, the start directory
    // must be specified and be an absolute path.
    //
    // Name matching.
    //
    f["path_match"] = [](string pattern, string name)
    {
      return path_match (pattern, name);
    };

    f["path_match"] = [](string pattern, names name)
    {
      return path_match (pattern, convert<string> (move (name)));
    };

    f["path_match"] = [](names pattern, string name)
    {
      return path_match (convert<string> (move (pattern)), name);
    };

    // Path matching.
    //
    //                   path      path      *
    //
    f["path_match"] = [](path pat, path ent, optional<dir_path> start)
    {
      return path_match (pat, ent, start);
    };

    f["path_match"] = [](path pat, path ent, names start)
    {
      return path_match (pat, ent, convert<dir_path> (move (start)));
    };

    //                   path      untyped    *
    //
    f["path_match"] = [](path pat, names ent, optional<dir_path> start)
    {
      return path_match (pat, convert<path> (move (ent)), start);
    };

    f["path_match"] = [](path pat, names ent, names start)
    {
      return path_match (pat,
                         convert<path> (move (ent)),
                         convert<dir_path> (move (start)));
    };

    //                   untyped    path      *
    //
    f["path_match"] = [](names pat, path ent, optional<dir_path> start)
    {
      return path_match (convert<path> (move (pat)), ent, start);
    };

    f["path_match"] = [](names pat, path ent, names start)
    {
      return path_match (convert<path> (move (pat)),
                         ent,
                         convert<dir_path> (move (start)));
    };

    // The semantics depends on the presence of the start directory or the
    // first two argument syntactic representation.
    //
    //                   untyped    untyped    *
    //
    f["path_match"] = [](names pat, names ent, optional<dir_path> start)
    {
      auto path_arg = [] (const names& a) -> bool
      {
        return a.size () == 1 &&
        (a[0].directory () ||
         a[0].value.find_first_of (path::traits::directory_separators) !=
         string::npos);
      };

      return start || path_arg (pat) || path_arg (ent)
        ? path_match (convert<path> (move (pat)),   // Match as paths.
                      convert<path> (move (ent)),
                      start)
        : path_match (convert<string> (move (pat)), // Match as names.
                      convert<string> (move (ent)));
    };

    f["path_match"] = [](names pat, names ent, names start)
    {
      // Match as paths.
      //
      return path_match (convert<path> (move (pat)),
                         convert<path> (move (ent)),
                         convert<dir_path> (move (start)));
    };
  }
}