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
|
// file : libbuild2/cc/target.hxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#ifndef LIBBUILD2_CC_TARGET_HXX
#define LIBBUILD2_CC_TARGET_HXX
#include <libbuild2/types.hxx>
#include <libbuild2/utility.hxx>
#include <libbuild2/target.hxx>
#include <libbuild2/cc/export.hxx>
namespace build2
{
namespace cc
{
// This is an abstract base target for all c-common header/source files.
// We use this arrangement during rule matching to detect "unknown" (to
// this rule) source/header files that it cannot handle but should not
// ignore either. For example, a C link rule that sees a C++ source file.
//
class LIBBUILD2_CC_SYMEXPORT cc: public file
{
public:
cc (context& c, dir_path d, dir_path o, string n)
: file (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
// There is hardly a c-family compilation without a C header inclusion.
// As a result, this target type is registered for any c-family module.
//
class LIBBUILD2_CC_SYMEXPORT h: public cc
{
public:
h (context& c, dir_path d, dir_path o, string n)
: cc (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
// This one we define in cc but the target type is only registered by the
// c module. This way we can implement rule chaining without jumping
// through too many hoops (like resolving target type dynamically) but
// also without relaxing things too much (i.e., the user still won't be
// able to refer to c{} without loading the c module).
//
class LIBBUILD2_CC_SYMEXPORT c: public cc
{
public:
c (context& ctx, dir_path d, dir_path o, string n)
: cc (ctx, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
// Objective-C source file (the same rationale for having it here as for
// c{} above).
//
class LIBBUILD2_CC_SYMEXPORT m: public cc
{
public:
m (context& c, dir_path d, dir_path o, string n)
: cc (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
// Assembler with C preprocessor source file (the same rationale for
// having it here as for c{} above).
//
class LIBBUILD2_CC_SYMEXPORT S: public cc
{
public:
S (context& c, dir_path d, dir_path o, string n)
: cc (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
// This is an abstract base target for deriving additional targets that
// can be #include'd in C translation units (the same rationale for having
// it here as for c{} above). In particular, only such targets will be
// considered to reverse-lookup extensions to target types (see
// dyndep_rule::map_extension() for background).
//
class LIBBUILD2_CC_SYMEXPORT c_inc: public cc
{
public:
c_inc (context& c, dir_path d, dir_path o, string n)
: cc (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
// pkg-config file targets.
//
class LIBBUILD2_CC_SYMEXPORT pc: public file // .pc (common)
{
public:
pc (context& c, dir_path d, dir_path o, string n)
: file (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
class LIBBUILD2_CC_SYMEXPORT pca: public pc // .static.pc
{
public:
pca (context& c, dir_path d, dir_path o, string n)
: pc (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
class LIBBUILD2_CC_SYMEXPORT pcs: public pc // .shared.pc
{
public:
pcs (context& c, dir_path d, dir_path o, string n)
: pc (c, move (d), move (o), move (n))
{
dynamic_type = &static_type;
}
public:
static const target_type static_type;
};
}
}
#endif // LIBBUILD2_CC_TARGET_HXX
|
