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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
Help('''
Type 'scons' to build and run all the available test cases.
It will automatically detect your platform and C compiler and
build appropriately.
You can modify the behaviour using following options:
BUILDDIR Directory to build into (default "build")
CC Name of C compiler
CXX Name of C++ compiler
CCFLAGS Flags to pass to the C compiler
CXXFLAGS Flags to pass to the C++ compiler
LINK Name of linker (usually same as CC)
LINKFLAGS Flags to pass to linker
LINKLIBS Flags to pass to linker after object files
PROTOC Path to protoc binary
PROTOCFLAGS Arguments to pass protoc
NODEFARGS Do not add the default CCFLAGS
NOVALGRIND Do not use valgrind for memory checks
For example, for a clang build, use:
scons CC=clang CXX=clang++
''')
import os
import platform
env = Environment(ENV = os.environ)
# Allow giving environment flags on command line.
list_vars = ['CCFLAGS', 'CXXFLAGS', 'LINKFLAGS', 'LINKLIBS', 'PROTOCFLAGS']
for var,val in ARGUMENTS.items():
if var in list_vars:
env.Append(**{var: val})
else:
env.Replace(**{var: val})
env.SetDefault(BUILDDIR = "build")
env.SConsignFile(env['BUILDDIR'] + "/sconsign")
env.Replace(CONFIGUREDIR = env['BUILDDIR'] + "/config")
# If a cross compilation platform is given, apply the environment settings
# from site_scons/platforms/X/X.py
if ARGUMENTS.get('PLATFORM'):
platform_func = platforms.get(ARGUMENTS.get('PLATFORM'))
if not platform_func:
print("Supported platforms: " + str(platforms.keys()))
raise Exception("Unsupported platform: " + ARGUMENTS.get('PLATFORM'))
else:
platform_func(env)
# Load nanopb generator build rules from site_scons/site_tools/nanopb.py
env.Tool("nanopb")
# Limit memory usage. This is to catch problems like issue #338
try:
import resource
soft, hard = resource.getrlimit(resourse.RLIMIT_AS)
resource.setrlimit(resource.RLIMIT_AS, (100*1024*1024, hard))
except:
pass
# On Mac OS X, gcc is usually alias for clang.
# To avoid problem with default options, use clang directly.
if platform.system() == "Darwin" and 'CC' not in ARGUMENTS:
env.Replace(CC = "clang", CXX = "clang++")
# Add the builders defined in site_init.py
add_nanopb_builders(env)
# Path to the files shared by tests, and to the nanopb core.
env.Append(CPPPATH = ["#../", "$COMMON"])
# Path for finding nanopb.proto
env.Append(PROTOCPATH = '#../generator')
# Check the compilation environment, unless we are just cleaning up.
if not env.GetOption('clean'):
def check_ccflags(context, flags, linkflags = ''):
'''Check if given CCFLAGS are supported'''
context.Message('Checking support for CCFLAGS="%s" LINKFLAGS="%s"... ' % (flags, linkflags))
oldflags = context.env['CCFLAGS']
oldlinkflags = context.env['LINKFLAGS']
context.env.Append(CCFLAGS = flags)
context.env.Append(LINKFLAGS = linkflags)
result = context.TryLink("int main() {return 0;}", '.c')
context.env.Replace(CCFLAGS = oldflags)
context.env.Replace(LINKFLAGS = oldlinkflags)
context.Result(result)
return result
def check_protocversion(context):
context.Display("Checking protoc version... ")
status, output = context.TryAction('$PROTOC --version > $TARGET')
if status:
context.Result(str(output.strip()))
return str(output.strip())
else:
context.Display("error: %s\n" % output.strip())
context.did_show_result = 1
context.Result("unknown, assuming 3.6.1")
return "3.6.1"
conf = Configure(env, custom_tests =
{'CheckCCFLAGS': check_ccflags,
'CheckProtocVersion': check_protocversion})
# If the platform doesn't support C99, use our own header file instead.
stdbool = conf.CheckCHeader('stdbool.h')
stdint = conf.CheckCHeader('stdint.h')
stddef = conf.CheckCHeader('stddef.h')
string = conf.CheckCHeader('string.h')
stdlib = conf.CheckCHeader('stdlib.h')
limits = conf.CheckCHeader('limits.h')
if not stdbool or not stdint or not stddef or not string or not limits:
conf.env.Append(CPPDEFINES = {'PB_SYSTEM_HEADER': '\\"pb_syshdr.h\\"'})
conf.env.Append(CPPPATH = "#../extra")
conf.env.Append(SYSHDR = '\\"pb_syshdr.h\\"')
if stdbool: conf.env.Append(CPPDEFINES = {'HAVE_STDBOOL_H': 1})
if stdint: conf.env.Append(CPPDEFINES = {'HAVE_STDINT_H': 1})
if stddef: conf.env.Append(CPPDEFINES = {'HAVE_STDDEF_H': 1})
if string: conf.env.Append(CPPDEFINES = {'HAVE_STRING_H': 1})
if stdlib: conf.env.Append(CPPDEFINES = {'HAVE_STDLIB_H': 1})
if limits: conf.env.Append(CPPDEFINES = {'HAVE_LIMITS_H': 1})
# Some platforms need libm for isnan()
if conf.CheckCCFLAGS('', linkflags = '-lm'):
conf.env.Append(LINKFLAGS = '-lm')
# Check protoc version
conf.env['PROTOC_VERSION'] = conf.CheckProtocVersion()
# Initialize compiler arguments with defaults, unless overridden on
# command line.
if not env.get('NODEFARGS'):
# Check if libmudflap is available (only with GCC)
if 'gcc' in env['CC']:
if conf.CheckLib('mudflap'):
conf.env.Append(CCFLAGS = '-fmudflap')
conf.env.Append(LINKFLAGS = '-fmudflap')
# Check if we can use extra strict warning flags (only with GCC)
extra = '-Wcast-qual -Wlogical-op -Wconversion'
extra += ' -fstrict-aliasing -Wstrict-aliasing=1'
extra += ' -Wmissing-prototypes -Wmissing-declarations -Wredundant-decls'
extra += ' -Wstack-protector '
if 'gcc' in env['CC']:
if conf.CheckCCFLAGS(extra):
conf.env.Append(CORECFLAGS = extra)
# Check if we can use undefined behaviour sanitizer (only with clang)
# TODO: Fuzz test triggers the bool sanitizer, figure out whether to
# modify the fuzz test or to keep ignoring the check.
extra = '-fsanitize=undefined,integer -fno-sanitize-recover=undefined,integer '
if 'clang' in env['CC']:
if conf.CheckCCFLAGS(extra, linkflags = extra):
conf.env.Append(CORECFLAGS = extra)
conf.env.Append(LINKFLAGS = extra)
# End the config stuff
env = conf.Finish()
if not env.get('NODEFARGS'):
# Initialize the CCFLAGS according to the compiler
if 'gcc' in env['CC']:
# GNU Compiler Collection
# Debug info, warnings as errors
env.Append(CFLAGS = '-g -Wall -Werror ')
env.Append(CORECFLAGS = '-Wextra ')
# Pedantic ANSI C. On AVR this doesn't work because we use large
# enums in some of the tests.
if env.get("EMBEDDED") != "AVR":
env.Append(CFLAGS = '-ansi ')
env.Append(CORECFLAGS = '-pedantic ')
# Profiling and coverage
if not env.get("EMBEDDED"):
env.Append(CFLAGS = '-fprofile-arcs -ftest-coverage ')
env.Append(LINKFLAGS = '-g --coverage')
# We currently need uint64_t anyway, even though ANSI C90 otherwise..
env.Append(CFLAGS = '-Wno-long-long')
elif 'clang' in env['CC']:
# CLang
env.Append(CFLAGS = '-ansi -g -Wall -Werror')
env.Append(CORECFLAGS = ' -Wextra -Wcast-qual -Wconversion')
elif 'cl' in env['CC']:
# Microsoft Visual C++
# Debug info on, warning level 2 for tests, warnings as errors
env.Append(CFLAGS = '/Zi /W2 /WX')
env.Append(LINKFLAGS = '/DEBUG')
# More strict checks on the nanopb core
env.Append(CORECFLAGS = '/W4')
# Enable C11 standard
env.Append(CFLAGS = ' /std:c11 ')
# Disable warning about sizeof(union{}) construct that is used in
# message size macros, in e.g. multiple_files testcase. The C construct
# itself is valid, but quite rare, which causes Visual C++ to give a warning
# about it.
env.Append(CFLAGS = '/wd4116')
elif 'tcc' in env['CC']:
# Tiny C Compiler
env.Append(CFLAGS = '-Wall -Werror -g')
if 'clang' in env['CXX']:
env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers')
elif 'g++' in env['CXX'] or 'gcc' in env['CXX']:
env.Append(CXXFLAGS = '-g -Wall -Werror -Wextra -Wno-missing-field-initializers -std=gnu++11')
elif 'cl' in env['CXX']:
env.Append(CXXFLAGS = '/Zi /W2 /WX /wd4116 /wd4127')
env.SetDefault(CORECFLAGS = '')
if not env.get("EMBEDDED") and not env.get("NOVALGRIND"):
valgrind = env.WhereIs('valgrind')
if valgrind:
env.SetDefault(VALGRIND = valgrind)
# Make it possible to add commands to the end of linker line
env.SetDefault(LINKLIBS = '')
env.Replace(LINKCOM = env['LINKCOM'] + " $LINKLIBS")
# Place build files under separate folder
import os.path
env['VARIANT_DIR'] = env['BUILDDIR']
env['BUILD'] = '#' + env['VARIANT_DIR']
env['COMMON'] = '#' + env['VARIANT_DIR'] + '/common'
# Include common/SConscript first to make sure its exports are available
# to other SConscripts.
SConscript("common/SConscript", exports = 'env', variant_dir = env['VARIANT_DIR'] + '/common')
# Now include the SConscript files from all subdirectories
for subdir in Glob('*/SConscript') + Glob('regression/*/SConscript'):
if str(subdir).startswith("common/"): continue
if str(subdir).startswith("common\\"): continue
SConscript(subdir, exports = 'env', variant_dir = env['VARIANT_DIR'] + '/' + os.path.dirname(str(subdir)))
|
