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
|
// file : libbuild2/module.hxx -*- C++ -*-
// copyright : Copyright (c) 2014-2019 Code Synthesis Ltd
// license : MIT; see accompanying LICENSE file
#ifndef LIBBUILD2_MODULE_HXX
#define LIBBUILD2_MODULE_HXX
#include <map>
#include <libbuild2/types.hxx>
#include <libbuild2/utility.hxx>
#include <libbuild2/variable.hxx>
#include <libbuild2/diagnostics.hxx>
#include <libbuild2/export.hxx>
namespace build2
{
class scope;
class location;
class module_base
{
public:
virtual
~module_base () = default;
};
// Return true if the module should be initialized first (the order of
// initialization within each group is unspecified).
//
using module_boot_function =
bool (scope& root,
const location&,
unique_ptr<module_base>&);
// Return false if the module configuration (normally based on the default
// values) was unsuccessful but this is not (yet) an error. One example
// would be the optional use of a module. Or a module might remain
// unconfigured for as long as it is actually not used (e.g., install,
// dist). The return value is used to set the <module>.configured variable.
//
using module_init_function =
bool (scope& root,
scope& base,
const location&,
unique_ptr<module_base>&,
bool first, // First time for this project.
bool optional, // Loaded with using? (optional module).
const variable_map& hints); // Configuration hints (see below).
struct module_functions
{
module_boot_function* boot;
module_init_function* init;
};
// The register() function will be written in C++ and will be called from
// C++ but we need to suppress name mangling to be able to use dlsym() and
// equivalent.
//
extern "C"
using module_register_function = module_functions ();
// Loaded modules state.
//
struct module_state
{
bool boot; // True if the module boot'ed but not yet init'ed.
bool first; // True if the boot'ed module must be init'ed first.
module_init_function* init;
unique_ptr<module_base> module;
const location loc; // Boot location.
};
struct loaded_module_map: std::map<string, module_state>
{
template <typename T>
T*
lookup (const string& name) const
{
auto i (find (name));
return i != end ()
? static_cast<T*> (i->second.module.get ())
: nullptr;
}
};
// Load and boot the specified module.
//
LIBBUILD2_SYMEXPORT void
boot_module (scope& root, const string& name, const location&);
// Load (if not already loaded) and initialize the specified module. Used
// by the parser but also by some modules to load prerequisite modules.
// Return true if the module was both successfully loaded and configured
// (false can only be returned if optional).
//
// The config_hints variable map can be used to pass configuration hints
// from one module to another. For example, the cxx modude may pass the
// target platform (which was extracted from the C++ compiler) to the bin
// module (which may not always be able to extract the same information from
// its tools).
//
LIBBUILD2_SYMEXPORT bool
load_module (scope& root,
scope& base,
const string& name,
const location&,
bool optional = false,
const variable_map& config_hints = variable_map ());
// Builtin modules.
//
using available_module_map = std::map<string, module_functions>;
LIBBUILD2_SYMEXPORT extern available_module_map builtin_modules;
}
#endif // LIBBUILD2_MODULE_HXX
|
