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
|
// 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;
};
// 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
|
