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
|
#!/usr/bin/python3 -tt
# Copyright 2012 Jussi Pakkanen
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import subprocess, os.path
class EnvironmentException(Exception):
def __init(self, text):
Exception.__init__(self, text)
def detect_c_compiler(execmd):
exelist = execmd.split()
p = subprocess.Popen(exelist + ['--version'], stdout=subprocess.PIPE)
(out, err) = p.communicate()
out = out.decode()
if (out.startswith('cc ') or out.startswith('gcc')) and \
'Free Software Foundation' in out:
return GnuCCompiler(exelist)
raise EnvironmentException('Unknown compiler "' + execmd + '"')
class CCompiler():
def __init__(self, exelist):
if type(exelist) == type(''):
self.exelist = [exelist]
elif type(exelist) == type([]):
self.exelist = exelist
else:
raise TypeError('Unknown argument to CCompiler')
def get_exelist(self):
return self.exelist
def get_compile_only_flags(self):
return ['-c']
def get_output_flags(self):
return ['-o']
def can_compile(self, filename):
suffix = filename.split('.')[-1]
if suffix == 'c' or suffix == 'h':
return True
return False
def name_string(self):
return ' '.join(self.exelist)
def sanity_check(self, work_dir):
source_name = os.path.join(work_dir, 'sanitycheck.c')
binary_name = os.path.join(work_dir, 'sanitycheck')
ofile = open(source_name, 'w')
ofile.write('int main(int argc, char **argv) { return 0; }\n')
ofile.close()
pc = subprocess.Popen(self.exelist + [source_name, '-o', binary_name])
pc.wait()
if pc.returncode != 0:
raise RuntimeError('Compiler %s can not compile programs.' % self.name_string())
pe = subprocess.Popen(binary_name)
pe.wait()
if pe.returncode != 0:
raise RuntimeError('Executables created by compiler %s are not runnable.' % self.name_string())
class GnuCCompiler(CCompiler):
std_warn_flags = ['-Wall', '-Winvalid-pch']
std_opt_flags = ['-O2']
def __init__(self, exelist):
CCompiler.__init__(self, exelist)
def get_std_warn_flags(self):
return GnuCCompiler.std_warn_flags
def get_std_opt_flags(self):
return GnuCCompiler.std_opt_flags
def shell_quote(cmdlist):
return ["'" + x + "'" for x in cmdlist]
def test_cmd_line_building():
src_file = 'file.c'
dst_file = 'file.o'
gnuc = detect_c_compiler('/usr/bin/cc')
cmds = gnuc.get_exelist()
cmds += gnuc.get_std_warn_flags()
cmds += gnuc.get_compile_only_flags()
cmds.append(src_file)
cmds += gnuc.get_output_flags()
cmds.append(dst_file)
cmd_line = ' '.join(shell_quote(cmds))
print(cmd_line)
class Environment():
def __init__(self, source_dir, build_dir):
self.source_dir = source_dir
self.build_dir = build_dir
self.default_c = ['cc']
self.default_cxx = ['c++']
self.exe_suffix = ''
self.shared_lib_suffix = 'so'
self.shared_lib_prefix = 'lib'
self.static_lib_suffix = 'a'
self.static_lib_prefix = 'lib'
self.object_suffix = 'o'
def get_c_compiler(self):
evar = 'CC'
if evar in os.environ:
return os.environ[evar].split()
return self.default_c
def get_cxx_compiler(self):
evar = 'CXX'
if evar in os.environ:
return os.environ[evar].split()
return self.default_cxx
def get_source_dir(self):
return self.source_dir
def get_build_dir(self):
return self.build_dir
def get_exe_suffix(self):
return self.exe_suffix
def get_shared_lib_prefix(self):
return self.shared_lib_prefix
def get_shared_lib_suffix(self):
return self.shared_lib_suffix
def get_static_lib_prefix(self):
return self.static_lib_prefix
def get_static_lib_suffix(self):
return self.static_lib_suffix
def get_object_suffix(self):
return self.object_suffix
if __name__ == '__main__':
test_cmd_line_building()
|
