aboutsummaryrefslogtreecommitdiff
path: root/build2/context
blob: e2732dbe33c73fa4bd8fdafb588233bf83afeefb (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
// file      : build2/context -*- C++ -*-
// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
// license   : MIT; see accompanying LICENSE file

#ifndef BUILD2_CONTEXT
#define BUILD2_CONTEXT

#include <string>
#include <ostream>
#include <cstdint> // uint64_t

#include <butl/filesystem>

#include <build2/types>
#include <build2/utility>
#include <build2/operation>

namespace build2
{
  class scope;
  class file;

  extern dir_path work;
  extern dir_path home;

  extern string_pool extension_pool;
  extern string_pool project_name_pool;

  // Current action (meta/operation).
  //
  extern const meta_operation_info* current_mif;
  extern const operation_info* current_inner_oif;
  extern const operation_info* current_outer_oif;

  extern execution_mode current_mode;

  // Total number of dependency relationships in the current action.
  // Together with the target::dependents count it is incremented
  // during the rule search & match phase and is decremented during
  // execution with the expectation of it reaching 0. Used as a sanity
  // check.
  //
  extern std::uint64_t dependency_count;

  // Reset the dependency state. In particular, this removes all the
  // targets, scopes, and variable names.
  //
  void
  reset ();

  // The dual interface wrapper for the {mk,rm}{file,dir}() functions
  // below that allows you to use it as a true/false return or a more
  // detailed enum from <butl/filesystem>
  //
  template <typename T>
  struct fs_status
  {
    T v;
    fs_status (T v): v (v) {};
    operator T () const {return v;}
    explicit operator bool () const {return v == T::success;}
  };

  // Create the directory and print the standard diagnostics. Note that
  // this implementation is not suitable if it is expected that the
  // directory will exist in the majority of case and performance is
  // important. See the fsdir{} rule for details.
  //
  fs_status<butl::mkdir_status>
  mkdir (const dir_path&);

  fs_status<butl::mkdir_status>
  mkdir_p (const dir_path&);

  // Remove the file and print the standard diagnostics. The second
  // argument is only used in diagnostics, to print the target name.
  // Passing the path for target will result in the relative path
  // being printed.
  //
  template <typename T>
  fs_status<butl::rmfile_status>
  rmfile (const path&, const T& target);

  inline fs_status<butl::rmfile_status>
  rmfile (const path& f) {return rmfile (f, f);}

  // Similar to rmfile() but for directories.
  //
  template <typename T>
  fs_status<butl::rmdir_status>
  rmdir (const dir_path&, const T& target);

  inline fs_status<butl::rmdir_status>
  rmdir (const dir_path& d) {return rmdir (d, d);}

  // Note that this function returns not_empty if we try to remove
  // a working directory.
  //
  fs_status<butl::rmdir_status>
  rmdir_r (const dir_path&);

  // Return the src/out directory corresponding to the given out/src. The
  // passed directory should be a sub-directory of out/src_root.
  //
  dir_path
  src_out (const dir_path& out, scope&);

  dir_path
  src_out (const dir_path& out,
           const dir_path& out_root, const dir_path& src_root);

  dir_path
  out_src (const dir_path& src, scope&);

  dir_path
  out_src (const dir_path& src,
           const dir_path& out_root, const dir_path& src_root);

  // If possible and beneficial, translate an absolute, normalized path
  // into relative to the relative_base directory, which is normally
  // work. Note that if the passed path is the same as relative_base,
  // then this function returns empty path.
  //
  template <typename K>
  basic_path<char, K>
  relative (const basic_path<char, K>&);

  // By default this points to work. Setting this to something else
  // should only be done in tightly controlled, non-parallel
  // situations (see dump). If base is empty, then relative()
  // returns the original path.
  //
  extern const dir_path* relative_base;

  // In addition to calling relative(), this function also uses shorter
  // notations such as '~/'.
  //
  std::string
  diag_relative (const path&);

  // As above but also adds trailing '/'. If the path is the same as
  // base, returns "./" if current is true and empty string otherwise.
  //
  std::string
  diag_relative (const dir_path&, bool current = true);

  // Action phrases, e.g., "configure update exe{foo}", "updating exe{foo}",
  // and "updating exe{foo} is configured". Use like this:
  //
  // info << "while " << diag_doing (a, t);
  //
  class target;

  struct diag_phrase
  {
    const action& a;
    const target& t;
    void (*f) (ostream&, const action&, const target&);
  };

  inline ostream&
  operator<< (ostream& os, const diag_phrase& p)
  {
    p.f (os, p.a, p.t);
    return os;
  }

  void
  diag_do (ostream&, const action&, const target&);

  inline diag_phrase
  diag_do (const action& a, const target& t)
  {
    return diag_phrase {a, t, &diag_do};
  }

  void
  diag_doing (ostream&, const action&, const target&);

  inline diag_phrase
  diag_doing (const action& a, const target& t)
  {
    return diag_phrase {a, t, &diag_doing};
  }

  void
  diag_done (ostream&, const action&, const target&);

  inline diag_phrase
  diag_done (const action& a, const target& t)
  {
    return diag_phrase {a, t, &diag_done};
  }
}

#include <build2/context.txx>

#endif // BUILD2_CONTEXT