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
|
// file : build2/cxx/guess -*- C++ -*-
// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
// license : MIT; see accompanying LICENSE file
#ifndef BUILD2_CXX_GUESS
#define BUILD2_CXX_GUESS
#include <build2/types>
#include <build2/utility>
namespace build2
{
namespace cxx
{
// C++ compiler id consisting of a type and optional variant. If the
// variant is not empty, then the id is spelled out as 'type-variant',
// similar to target triplets (this also means that the type cannot
// contain '-').
//
// Currently recognized compilers and their ids:
//
// gcc GCC g++
// clang Vanilla Clang clang++
// clang-apple Apple Clang clang++ and the g++ "alias"
// icc Intel icpc
// msvc Microsoft cl.exe
//
struct compiler_id
{
std::string type;
std::string variant;
bool
empty () const {return type.empty ();}
std::string
string () const {return variant.empty () ? type : type + "-" + variant;}
};
inline ostream&
operator<< (ostream& os, const compiler_id& id)
{
return os << id.string ();
}
// C++ compiler version. Here we map the various compiler version formats
// to something that resembles the MAJOR.MINOR.PATCH-BUILD form of the
// Semantic Versioning. While the MAJOR.MINOR part is relatively
// straightforward, PATCH may be empty and BUILD can contain pretty much
// anything (including spaces).
//
// gcc A.B.C[ ...] {A, B, C, ...}
// clang A.B.C[( |-)...] {A, B, C, ...}
// clang-apple A.B[.C] ... {A, B, C, ...}
// icc A.B[.C.D] ... {A, B, C, D ...}
// msvc A.B.C[.D] {A, B, C, D}
//
// Note that the clang-apple version is a custom Apple version and does
// not correspond to the vanilla clang version.
//
struct compiler_version
{
std::string string;
// Currently all the compilers that we support have numeric MAJOR,
// MINOR, and PATCH components and it makes sense to represent them as
// integers for easy comparison. If we meet a compiler for which this
// doesn't hold, then we will probably just set these to 0 and let the
// user deal with the string representation.
//
uint64_t major;
uint64_t minor;
uint64_t patch;
std::string build;
};
// C++ compiler information.
//
// The signature is normally the -v/--version line that was used to guess
// the compiler id and its version.
//
// The checksum is used to detect compiler changes. It is calculated in a
// compiler-specific manner (usually the output of -v/--version) and is
// not bulletproof (e.g., it most likely won't detect that the underlying
// assembler or linker has changed). However, it should detect most
// common cases, such as an upgrade to a new version or a configuration
// change.
//
// The target is the compiler's traget architecture triplet. Note that
// unlike all the preceding fields, this one takes into account the
// compile options (e.g., -m32).
//
struct compiler_info
{
compiler_id id;
compiler_version version;
string signature;
string checksum;
string target;
};
compiler_info
guess (const path& cxx, const strings* coptions);
}
}
#endif // BUILD2_CXX_GUESS
|
