1 | #!/usr/bin/env python |
||
2 | # |
||
3 | # iuwandbox.py |
||
4 | # |
||
5 | # Copyright (C) 2014-2020, Takazumi Shirayanagi |
||
6 | # This software is released under the new BSD License, |
||
7 | # see LICENSE |
||
8 | # |
||
9 | |||
10 | import os |
||
11 | import sys |
||
12 | import re |
||
13 | import codecs |
||
14 | |||
15 | from argparse import ArgumentParser |
||
16 | from argparse import SUPPRESS |
||
17 | from wandbox import Wandbox |
||
18 | |||
19 | IUTEST_FUSED_SRC = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../fused-src/iutest.min.hpp')) |
||
20 | IUTEST_WANDBOX_FUSED_SRC = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../fused-src/iutest.wandbox.min.hpp')) |
||
21 | IUTEST_WANDBOX_FUSED_CLANG_SRC = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../fused-src/iutest.wandbox.min.clang.hpp')) |
||
22 | IUTEST_WANDBOX_FUSED_GCC_SRC = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../fused-src/iutest.wandbox.min.gcc.hpp')) |
||
23 | IUTEST_INCLUDE_PATH = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../include')) |
||
24 | IUTEST_INCLUDE_REGEX = re.compile(r'^\s*#\s*include\s*".*(iutest|iutest_switch)\.hpp"') |
||
25 | EXPAND_INCLUDE_REGEX = re.compile(r'^\s*#\s*include\s*"(.*?)"') |
||
26 | IUTEST_INCG_REGEX = re.compile(r'\s*#\s*define[/\s]*(INCG_IRIS_\S*)\s*') |
||
27 | |||
28 | iutest_src_map = { |
||
29 | 'wandbox': { |
||
30 | 'any': IUTEST_WANDBOX_FUSED_SRC, |
||
31 | 'clang': IUTEST_WANDBOX_FUSED_CLANG_SRC, |
||
32 | 'gcc': IUTEST_WANDBOX_FUSED_GCC_SRC, |
||
33 | }, |
||
34 | 'min': { |
||
35 | 'any': IUTEST_FUSED_SRC, |
||
36 | } |
||
37 | } |
||
38 | |||
39 | iutest_incg_list = [] |
||
40 | workaround = True |
||
41 | api_retries = 3 |
||
42 | api_retry_wait = 60 |
||
43 | fused_src = 'wandbox' |
||
44 | |||
45 | |||
46 | # command line option |
||
47 | def parse_command_line(): |
||
48 | global api_retries |
||
49 | global api_retry_wait |
||
50 | global fused_src |
||
51 | |||
52 | parser = ArgumentParser() |
||
53 | parser.add_argument( |
||
54 | '-v', |
||
55 | '--version', |
||
56 | action='version', |
||
57 | version=u'%(prog)s version 8.0' |
||
58 | ) |
||
59 | parser.add_argument( |
||
60 | '--list-compiler', |
||
61 | '--list_compiler', |
||
62 | action='store_true', |
||
63 | help='listup compiler.' |
||
64 | ) |
||
65 | parser.add_argument( |
||
66 | '--list-options', |
||
67 | '--list_options', |
||
68 | metavar='COMPILER', |
||
69 | help='listup compiler options.' |
||
70 | ) |
||
71 | parser.add_argument( |
||
72 | '-c', |
||
73 | '--compiler', |
||
74 | default='gcc-head', |
||
75 | help='compiler select. default: %(default)s' |
||
76 | ) |
||
77 | parser.add_argument( |
||
78 | '-x', |
||
79 | '--options', |
||
80 | help='used options for a compiler.' |
||
81 | ) |
||
82 | parser.add_argument( |
||
83 | '--default', |
||
84 | action='store_true', |
||
85 | help='--default option is deprecated. default options are always set.' |
||
86 | ) |
||
87 | parser.add_argument( |
||
88 | '--no-default', |
||
89 | action='store_true', |
||
90 | help='no set default options.' |
||
91 | ) |
||
92 | parser.add_argument( |
||
93 | '--std', |
||
94 | metavar='VERSION', |
||
95 | help='set --std options.' |
||
96 | ) |
||
97 | parser.add_argument( |
||
98 | '--boost', |
||
99 | metavar='VERSION', |
||
100 | help='set boost options version X.XX or nothing.' |
||
101 | ) |
||
102 | parser.add_argument( |
||
103 | '--optimize', |
||
104 | action='store_true', |
||
105 | help='use optimization.' |
||
106 | ) |
||
107 | parser.add_argument( |
||
108 | '--cpp-verbose', |
||
109 | action='store_true', |
||
110 | help='use cpp-verbose.' |
||
111 | ) |
||
112 | parser.add_argument( |
||
113 | '--sprout', |
||
114 | action='store_true', |
||
115 | help='use sprout.' |
||
116 | ) |
||
117 | parser.add_argument( |
||
118 | '--msgpack', |
||
119 | action='store_true', |
||
120 | help='use msgpack.' |
||
121 | ) |
||
122 | parser.add_argument( |
||
123 | '--stdin', |
||
124 | help='set stdin.' |
||
125 | ) |
||
126 | parser.add_argument( |
||
127 | '-f', |
||
128 | '--compiler-option-raw', |
||
129 | '--compiler_option_raw', |
||
130 | metavar='OPTIONS', |
||
131 | action='append', |
||
132 | default=['-D__WANDBOX__'], |
||
133 | help='compile-time any additional options.' |
||
134 | ) |
||
135 | parser.add_argument( |
||
136 | '-r', |
||
137 | '--runtime-option-raw', |
||
138 | '--runtime_option_raw', |
||
139 | metavar='OPTIONS', |
||
140 | action='append', |
||
141 | help='runtime-time any additional options.' |
||
142 | ) |
||
143 | parser.add_argument( |
||
144 | '-s', |
||
145 | '--save', |
||
146 | action='store_true', |
||
147 | help='generate permanent link.' |
||
148 | ) |
||
149 | parser.add_argument( |
||
150 | '--permlink', |
||
151 | metavar='ID', |
||
152 | help='get permanent link.' |
||
153 | ) |
||
154 | parser.add_argument( |
||
155 | '-o', |
||
156 | '--output', |
||
157 | metavar='FILE', |
||
158 | help='output source code.' |
||
159 | ) |
||
160 | parser.add_argument( |
||
161 | '--xml', |
||
162 | metavar='FILE', |
||
163 | help='output result xml.' |
||
164 | ) |
||
165 | parser.add_argument( |
||
166 | '--junit', |
||
167 | metavar='FILE', |
||
168 | help='output result junit xml.' |
||
169 | ) |
||
170 | parser.add_argument( |
||
171 | '--stderr', |
||
172 | action='store_true', |
||
173 | help='output stderr.' |
||
174 | ) |
||
175 | parser.add_argument( |
||
176 | '--encoding', |
||
177 | help='set encoding.' |
||
178 | ) |
||
179 | parser.add_argument( |
||
180 | '--expand-include', |
||
181 | '--expand_include', |
||
182 | action='store_true', |
||
183 | help='expand include file.' |
||
184 | ) |
||
185 | parser.add_argument( |
||
186 | '--make', |
||
187 | action='store_true', |
||
188 | help=SUPPRESS |
||
189 | ) |
||
190 | parser.add_argument( |
||
191 | '--retry-wait', |
||
192 | type=int, |
||
193 | default=api_retry_wait, |
||
194 | metavar='SECONDS', |
||
195 | help='Wait time for retry when HTTPError occurs' |
||
196 | ) |
||
197 | parser.add_argument( |
||
198 | '--retry', |
||
199 | type=int, |
||
200 | default=api_retries, |
||
201 | metavar='COUNT', |
||
202 | help='Number of retries when HTTPError occurs' |
||
203 | ) |
||
204 | parser.add_argument( |
||
205 | '--check-config', |
||
206 | '--check_config', |
||
207 | action='store_true', |
||
208 | help='check config.' |
||
209 | ) |
||
210 | parser.add_argument( |
||
211 | '--iutest-use-main', |
||
212 | action='store_true', |
||
213 | help='define IUTEST_USE_MAIN.' |
||
214 | ) |
||
215 | parser.add_argument( |
||
216 | '--iutest-use-wandbox-min', |
||
217 | action='store_true', |
||
218 | default=True, |
||
219 | help='!this option is deprecated! use iutest.wandbox.min.hpp (default true).' |
||
220 | ) |
||
221 | parser.add_argument( |
||
222 | '--no-iutest-use-wandbox-min', |
||
223 | action='store_true', |
||
224 | help='not use iutest.wandbox.min.hpp (experimental).' |
||
225 | ) |
||
226 | parser.add_argument( |
||
227 | '--verbose', |
||
228 | action='store_true', |
||
229 | help='verbose.' |
||
230 | ) |
||
231 | parser.add_argument( |
||
232 | '--dryrun', |
||
233 | action='store_true', |
||
234 | help='dryrun.' |
||
235 | ) |
||
236 | parser.add_argument( |
||
237 | 'code', |
||
238 | metavar='CODE', |
||
239 | nargs='*', |
||
240 | help='source code file' |
||
241 | ) |
||
242 | options = parser.parse_args() |
||
243 | api_retries = options.retry |
||
244 | api_retry_wait = options.retry_wait |
||
245 | if options.no_iutest_use_wandbox_min: |
||
246 | fused_src = "min" |
||
247 | else: |
||
248 | fused_src = "wandbox" |
||
249 | return options, parser |
||
250 | |||
251 | |||
252 | # file open |
||
253 | def file_open(path, mode, encoding): |
||
254 | if encoding: |
||
255 | file = codecs.open(path, mode, encoding) |
||
256 | else: |
||
257 | file = open(path, mode) |
||
258 | return file |
||
259 | |||
260 | |||
261 | # make include filename |
||
262 | def make_include_filename(path, includes, included_files): |
||
263 | if path in included_files: |
||
264 | return included_files[path] |
||
265 | include_dir, include_filename = os.path.split(path) |
||
266 | while include_filename in includes: |
||
267 | include_dir, dirname = os.path.split(include_dir) |
||
268 | include_filename = dirname + '__' + include_filename |
||
269 | included_files[path] = include_filename |
||
270 | return include_filename |
||
271 | |||
272 | |||
273 | def is_iutest_included_file(filepath): |
||
274 | if os.path.abspath(filepath).startswith(IUTEST_INCLUDE_PATH): |
||
275 | incg = 'INCG_IRIS_' + os.path.basename(filepath).upper().replace('.', '_') |
||
276 | for included_incg in iutest_incg_list: |
||
277 | if included_incg.startswith(incg): |
||
278 | return True |
||
279 | return False |
||
280 | |||
281 | |||
282 | def select_fused_src(compiler, group): |
||
283 | if group not in iutest_src_map: |
||
284 | return IUTEST_WANDBOX_FUSED_SRC |
||
285 | cxx = 'any' |
||
286 | if 'clang' in compiler: |
||
287 | cxx = 'clang' |
||
288 | elif 'gcc' in compiler: |
||
289 | cxx = 'gcc' |
||
290 | |||
291 | if cxx not in iutest_src_map[group]: |
||
292 | return iutest_src_map[group]['any'] |
||
293 | return iutest_src_map[group][cxx] |
||
294 | |||
295 | |||
296 | # make code |
||
297 | def make_code(path, compiler, encoding, expand, includes, included_files): |
||
298 | code = '' |
||
299 | file = file_open(path, 'r', encoding) |
||
300 | for line in file: |
||
301 | m = IUTEST_INCLUDE_REGEX.match(line) |
||
302 | if m: |
||
303 | code += '#include "iutest.hpp"\n' |
||
304 | code += '//origin>> ' + line |
||
305 | if 'iutest.hpp' not in includes: |
||
306 | fused_src_path = select_fused_src(compiler, fused_src) |
||
307 | try: |
||
308 | f = codecs.open(fused_src_path, 'r', 'utf-8-sig') |
||
309 | iutest_src = f.read() |
||
310 | f.close() |
||
311 | includes['iutest.hpp'] = iutest_src |
||
312 | global iutest_incg_list |
||
313 | iutest_incg_list = IUTEST_INCG_REGEX.findall(iutest_src) |
||
314 | except Exception: |
||
315 | print('{0} is not found...'.format(fused_src_path)) |
||
316 | print('please try \"make fused\"') |
||
317 | exit(1) |
||
318 | else: |
||
319 | m = EXPAND_INCLUDE_REGEX.match(line) |
||
320 | if m: |
||
321 | include_path = os.path.normpath(os.path.join(os.path.dirname(path), m.group(1))) |
||
322 | if is_iutest_included_file(include_path): |
||
323 | code += '//origin>> ' |
||
324 | elif os.path.exists(include_path): |
||
325 | if expand: |
||
326 | expand_include_file_code = make_code( |
||
327 | include_path, compiler, encoding, expand, includes, included_files) |
||
328 | code += expand_include_file_code |
||
329 | code += '//origin>> ' |
||
330 | else: |
||
331 | include_abspath = os.path.abspath(include_path) |
||
332 | include_filename = make_include_filename( |
||
333 | include_abspath, includes, included_files) |
||
334 | if not include_filename == include_path: |
||
335 | code += '#include "' + include_filename + '"\n' |
||
336 | code += '//origin>> ' |
||
337 | if include_filename not in includes: |
||
338 | includes[include_filename] = '' |
||
339 | expand_include_file_code = make_code( |
||
340 | include_path, compiler, encoding, expand, includes, included_files) |
||
341 | includes[include_filename] = expand_include_file_code |
||
342 | code += line |
||
343 | file.close() |
||
344 | return code |
||
345 | |||
346 | |||
347 | def print_undefined_option(option_name, compiler): |
||
348 | print('Wandbox is not supported option [{0}] ({1})'.format(option_name, compiler)) |
||
349 | |||
350 | |||
351 | def change_std_option(options, new_value): |
||
352 | print(' change std option: {0} -> {1}'.format(options.std, new_value)) |
||
353 | options.std = new_value |
||
354 | |||
355 | |||
356 | def check_std_option_compatible(options, old, new, optlist): |
||
357 | if (options.std == old) and (new in optlist): |
||
358 | print(' [{0}] is not supported option. you can use [{1}]'.format(old, new)) |
||
359 | change_std_option(options, new) |
||
360 | return True |
||
361 | elif (options.std == new) and (old in optlist): |
||
362 | print(' [{0}] is not supported option. you can use [{1}]'.format(new, old)) |
||
363 | change_std_option(options, old) |
||
364 | return True |
||
365 | return False |
||
366 | |||
367 | # check config |
||
368 | def check_config(options): |
||
369 | has_error = False |
||
370 | if not find_compiler(options.compiler): |
||
371 | print('Wandbox is not supported compiler [' + options.compiler + ']') |
||
372 | listup_compiler(options.verbose) |
||
373 | has_error = True |
||
374 | if options.options or options.std: |
||
375 | opt = get_options(options.compiler) |
||
376 | if options.options: |
||
377 | for o in options.options.split(','): |
||
378 | if o not in opt: |
||
379 | print_undefined_option(o, options.compiler) |
||
380 | has_error = True |
||
381 | if options.std: |
||
382 | if options.std not in opt: |
||
383 | print_undefined_option(options.std, options.compiler) |
||
384 | prev_std_option = options.std |
||
385 | if check_std_option_compatible(options, 'c++1z', 'c++17', opt) or \ |
||
386 | check_std_option_compatible(options, 'gnu++1z', 'gnu++17', opt) or \ |
||
387 | check_std_option_compatible(options, 'c++1y', 'c++14', opt) or \ |
||
388 | check_std_option_compatible(options, 'gnu++1y', 'gnu++14', opt) or \ |
||
389 | check_std_option_compatible(options, 'c++0x', 'c++11', opt) or \ |
||
390 | check_std_option_compatible(options, 'gnu++0x', 'gnu++11', opt): |
||
391 | pass |
||
392 | if (options.std == prev_std_option): |
||
393 | has_error = True |
||
394 | if has_error: |
||
395 | listup_options(options.compiler) |
||
396 | if has_error: |
||
397 | sys.exit(1) |
||
398 | if options.default: |
||
399 | print('--default option is deprecated. default options are always set.') |
||
400 | |||
401 | |||
402 | # setup additional files |
||
403 | def add_files(w, fileinfos): |
||
404 | for filename, code in fileinfos.items(): |
||
405 | w.add_file(filename, code) |
||
406 | |||
407 | |||
408 | # create opt list |
||
409 | def create_option_list(options): |
||
410 | def filterout_cppver(opt): |
||
411 | tmp = list(filter(lambda s: s.find('c++') == -1, opt)) |
||
412 | tmp = list(filter(lambda s: s.find('gnu++') == -1, tmp)) |
||
413 | return tmp |
||
414 | def find_cppname(opt): |
||
415 | if any((x.startswith('c++') for x in opt)): |
||
0 ignored issues
–
show
Comprehensibility
Best Practice
introduced
by
Loading history...
|
|||
416 | return 'c++' |
||
417 | return 'gnu++' |
||
418 | opt = [] |
||
419 | if not options.no_default: |
||
420 | opt = get_default_options(options.compiler) |
||
421 | if options.options: |
||
422 | for o in options.options.split(','): |
||
423 | if o not in opt: |
||
424 | if (o.find('c++') == 0) or (o.find('gnu++') == 0): |
||
425 | opt = filterout_cppver(opt) |
||
426 | opt.append(o) |
||
427 | # std |
||
428 | if options.std: |
||
429 | opt = filterout_cppver(opt) |
||
430 | opt.append(options.std) |
||
431 | # optimize |
||
432 | if options.optimize and ('optimize' not in opt): |
||
433 | opt.append('optimize') |
||
434 | # cpp-verbose |
||
435 | if options.cpp_verbose and ('cpp-verbose' not in opt): |
||
436 | opt.append('cpp-verbose') |
||
437 | # boost |
||
438 | if workaround: |
||
439 | if options.compiler in ['clang-3.1']: |
||
440 | cppname = find_cppname(opt) |
||
441 | opt = filterout_cppver(opt) |
||
442 | opt.append(cppname + '98') |
||
443 | # if options.compiler in ['clang-3.4', 'clang-3.3']: |
||
444 | # if not options.boost: |
||
445 | # options.boost = 'nothing' |
||
446 | if options.boost: |
||
447 | if options.compiler not in options.boost: |
||
448 | options.boost = options.boost + '-' + options.compiler |
||
449 | opt = list(filter(lambda s: s.find('boost') == -1, opt)) |
||
450 | opt.append('boost-' + str(options.boost)) |
||
451 | # sprout |
||
452 | if options.sprout and ('sprout' not in opt): |
||
453 | opt.append('sprout') |
||
454 | # msgpack |
||
455 | if options.msgpack and ('msgpack' not in opt): |
||
456 | opt.append('msgpack') |
||
457 | return opt |
||
458 | |||
459 | |||
460 | def expand_wandbox_options(w, compiler, options): |
||
461 | colist = [] |
||
462 | defs = {} |
||
463 | for d in w.get_compiler_list(): |
||
464 | if d['name'] == compiler: |
||
465 | if 'switches' in d: |
||
466 | switches = d['switches'] |
||
467 | for s in switches: |
||
468 | if 'options' in s: |
||
469 | for o in s['options']: |
||
470 | if ('name' in o) and ('display-flags' in o): |
||
471 | defs[o['name']] = o['display-flags'] |
||
472 | elif ('name' in s) and ('display-flags' in s): |
||
473 | defs[s['name']] = s['display-flags'] |
||
474 | for opt in options: |
||
475 | if opt in defs: |
||
476 | colist.extend(defs[opt].split()) |
||
477 | return colist |
||
478 | |||
479 | |||
480 | def wandbox_api_call(callback, retries, retry_wait): |
||
481 | return Wandbox.Call(callback, retries, retry_wait) |
||
482 | |||
483 | |||
484 | def wandbox_get_compilerlist(): |
||
485 | return wandbox_api_call(Wandbox.GetCompilerList, api_retries, api_retry_wait) |
||
486 | |||
487 | |||
488 | def wandbox_get_compilerswitches(compiler): |
||
489 | for d in wandbox_get_compilerlist(): |
||
490 | if d['name'] == compiler: |
||
491 | if 'switches' in d: |
||
492 | return d['switches'] |
||
493 | return [] |
||
494 | |||
495 | |||
496 | def run_wandbox_impl(w, options): |
||
497 | if options.dryrun: |
||
498 | sys.exit(0) |
||
499 | retries = options.retry |
||
500 | |||
501 | def run(): |
||
502 | return w.run() |
||
503 | return wandbox_api_call(run, retries, options.retry_wait) |
||
504 | |||
505 | |||
506 | def create_compiler_raw_option_list(options): |
||
507 | colist = [] |
||
508 | if options.compiler_option_raw: |
||
509 | raw_options = options.compiler_option_raw |
||
510 | for x in raw_options: |
||
511 | colist.extend(re.split('\s(?=-)', x.strip('"'))) |
||
512 | if options.iutest_use_main: |
||
513 | if len(options.code) < 2: |
||
514 | colist.append('-DIUTEST_USE_MAIN') |
||
515 | if '-D__WANDBOX__' not in colist: |
||
516 | colist.append('-D__WANDBOX__') |
||
517 | return colist |
||
518 | |||
519 | |||
520 | def get_compiler_exec(compiler): |
||
521 | if 'gcc' in compiler: |
||
522 | return 'g++' |
||
523 | if 'clang' in compiler: |
||
524 | return 'clang++' |
||
525 | if 'zapcc' in compiler: |
||
526 | return 'zapcc++' |
||
527 | return None |
||
528 | |||
529 | |||
530 | # run wandbox (makefile) |
||
531 | def run_wandbox_make(main_filepath, code, includes, implements, options): |
||
532 | with Wandbox() as w: |
||
533 | w.compiler('bash') |
||
534 | woptions = create_option_list(options) |
||
535 | if options.stdin: |
||
536 | w.stdin(options.stdin) |
||
537 | implements[os.path.basename(main_filepath)] = code |
||
538 | |||
539 | colist = create_compiler_raw_option_list(options) |
||
540 | colist.extend(expand_wandbox_options(w, options.compiler, woptions)) |
||
541 | |||
542 | rolist = [] |
||
543 | if options.runtime_option_raw: |
||
544 | for opt in options.runtime_option_raw: |
||
545 | rolist.extend(opt.split()) |
||
546 | |||
547 | makefile = '#!/bin/make\n# generate makefile by iuwandbox.py\n' |
||
548 | cxx = get_compiler_exec(options.compiler) |
||
549 | if cxx is None: |
||
550 | print('failed: invalid compiler...') |
||
551 | sys.exit(1) |
||
552 | makefile += '\nCXX=/opt/wandbox/' + options.compiler + '/bin/' + cxx |
||
553 | makefile += '\nCXXFLAGS+=' |
||
554 | for opt in colist: |
||
555 | makefile += opt + ' ' |
||
556 | makefile += '\nOBJS=' |
||
557 | for filename in implements.keys(): |
||
558 | makefile += os.path.splitext(filename)[0] + '.o ' |
||
559 | |||
560 | makefile += '\n\ |
||
561 | prog: $(OBJS)\n\ |
||
562 | \t$(CXX) -o $@ $^ $(CXXFLAGS) $(LDFLAGS)\n\ |
||
563 | ' |
||
564 | |||
565 | implements['Makefile'] = makefile |
||
566 | |||
567 | bashscript = 'make -j 4\n' |
||
568 | bashscript += './prog ' |
||
569 | for opt in rolist: |
||
570 | bashscript += opt + ' ' |
||
571 | bashscript += '\n' |
||
572 | w.code(bashscript) |
||
573 | |||
574 | if options.save: |
||
575 | w.permanent_link(options.save) |
||
576 | if options.verbose: |
||
577 | w.dump() |
||
578 | add_files(w, implements) |
||
579 | add_files(w, includes) |
||
580 | |||
581 | return run_wandbox_impl(w, options) |
||
582 | |||
583 | |||
584 | # run wandbox (cxx) |
||
585 | def run_wandbox_cxx(code, includes, implements, options): |
||
586 | with Wandbox() as w: |
||
587 | w.compiler(options.compiler) |
||
588 | woptions = ','.join(create_option_list(options)) |
||
589 | w.options(woptions) |
||
590 | if options.stdin: |
||
591 | w.stdin(options.stdin) |
||
592 | colist = create_compiler_raw_option_list(options) |
||
593 | |||
594 | if workaround: |
||
595 | if options.compiler in ['clang-3.2']: |
||
596 | colist.append('-ftemplate-depth=1024') |
||
597 | # if options.compiler in ['clang-3.4']: |
||
598 | # colist.append('-DIUTEST_HAS_HDR_CXXABI=0') |
||
599 | # if options.compiler in ['clang-3.3', 'clang-3.2', 'clang-3.1', 'clang-3.0']: |
||
600 | # colist.append('-Qunused-arguments') |
||
601 | if 'boost-nothing' in woptions: |
||
602 | if options.compiler in ['clang-3.4', 'clang-3.3']: |
||
603 | colist.append('-fno-exceptions') |
||
604 | colist.append('-fno-rtti') |
||
605 | # if 'gcc' in options.compiler: |
||
606 | # colist.append('-flarge-source-files') |
||
607 | if colist: |
||
608 | co = '\n'.join(colist) |
||
609 | co = co.replace('\\n', '\n') |
||
610 | w.compiler_options(co) |
||
611 | if options.runtime_option_raw: |
||
612 | rolist = [] |
||
613 | for opt in options.runtime_option_raw: |
||
614 | rolist.extend(opt.split()) |
||
615 | ro = '\n'.join(rolist) |
||
616 | ro = ro.replace('\\n', '\n') |
||
617 | w.runtime_options(ro) |
||
618 | if options.save: |
||
619 | w.permanent_link(options.save) |
||
620 | for filename in implements.keys(): |
||
621 | w.add_compiler_options(filename) |
||
622 | if options.verbose: |
||
623 | w.dump() |
||
624 | w.code(code) |
||
625 | add_files(w, implements) |
||
626 | add_files(w, includes) |
||
627 | |||
628 | return run_wandbox_impl(w, options) |
||
629 | |||
630 | |||
631 | # run wandbox |
||
632 | def run_wandbox(main_filepath, code, includes, implements, options): |
||
633 | if options.make: |
||
634 | return run_wandbox_make(main_filepath, code, includes, implements, options) |
||
635 | return run_wandbox_cxx(code, includes, implements, options) |
||
636 | |||
637 | |||
638 | def wandbox_hint(r): |
||
639 | if 'compiler_error' in r: |
||
640 | if 'undefined reference to `main' in r['compiler_error']: |
||
641 | print('hint:') |
||
642 | print(' In "iutest" you can omit the definition of the main function, please define IUTEST_USE_MAIN. (--iutest-use-main or -f"-DIUTEST_USE_MAIN")') |
||
643 | elif 'undefined reference to `init_unit_test_suite' in r['compiler_error']: |
||
644 | print('hint:') |
||
645 | print(' If you do not use boost test, please specify the file with the main function first.') |
||
646 | |||
647 | |||
648 | def text_transform(value): |
||
649 | try: |
||
650 | if isinstance(value, str): |
||
651 | return value.decode() |
||
652 | elif isinstance(value, unicode): |
||
0 ignored issues
–
show
Comprehensibility
Best Practice
introduced
by
|
|||
653 | return value.encode('utf_8') |
||
654 | except Exception: |
||
655 | pass |
||
656 | return value |
||
657 | |||
658 | |||
659 | # show result |
||
660 | def show_result(r, options): |
||
661 | if r is None: |
||
662 | print('failed: timeout...') |
||
663 | sys.exit(1) |
||
664 | if 'error' in r: |
||
665 | print(r['error']) |
||
666 | sys.exit(1) |
||
667 | if options.stderr: |
||
668 | if 'compiler_output' in r: |
||
669 | print('compiler_output:') |
||
670 | print(text_transform(r['compiler_output'])) |
||
671 | if 'compiler_error' in r: |
||
672 | sys.stderr.write(text_transform(r['compiler_error'])) |
||
673 | if 'program_output' in r: |
||
674 | print('program_output:') |
||
675 | print(text_transform(r['program_output'])) |
||
676 | if options.xml is None and options.junit is None and 'program_error' in r: |
||
677 | sys.stderr.write(text_transform(r['program_error'])) |
||
678 | else: |
||
679 | if 'compiler_message' in r: |
||
680 | print('compiler_message:') |
||
681 | print(text_transform(r['compiler_message'])) |
||
682 | if 'program_message' in r: |
||
683 | print('program_message:') |
||
684 | print(text_transform(r['program_message'])) |
||
685 | if 'url' in r: |
||
686 | print('permlink: ' + r['permlink']) |
||
687 | print('url: ' + r['url']) |
||
688 | if 'signal' in r: |
||
689 | print('signal: ' + r['signal']) |
||
690 | wandbox_hint(r) |
||
691 | |||
692 | if 'status' in r: |
||
693 | return int(r['status']) |
||
694 | return 1 |
||
695 | |||
696 | |||
697 | # show parameter |
||
698 | def show_parameter(r): |
||
699 | if 'compiler' in r: |
||
700 | print('compiler:' + r['compiler']) |
||
701 | if 'options' in r: |
||
702 | print('options:' + r['options']) |
||
703 | if 'compiler-option-raw' in r: |
||
704 | print('compiler-option-raw:' + r['compiler-option-raw']) |
||
705 | if 'runtime-option-raw' in r: |
||
706 | print('runtime-option-raw' + r['runtime-option-raw']) |
||
707 | if 'created-at' in r: |
||
708 | print(r['created-at']) |
||
709 | |||
710 | |||
711 | def set_output_xml(options, t, xml): |
||
712 | options.stderr = True |
||
713 | if options.runtime_option_raw: |
||
714 | options.runtime_option_raw.append('--iutest_output=' + t + ':' + xml) |
||
715 | else: |
||
716 | options.runtime_option_raw = ['--iutest_output=' + t + ':' + xml] |
||
717 | |||
718 | |||
719 | def run(options): |
||
720 | main_filepath = options.code[0].strip() |
||
721 | if not os.path.exists(main_filepath): |
||
722 | sys.exit(1) |
||
723 | includes = {} |
||
724 | included_files = {} |
||
725 | implements = {} |
||
726 | code = "" |
||
727 | if len(options.code) > 1 and options.iutest_use_main: |
||
728 | code += '#define IUTEST_USE_MAIN\n' |
||
729 | code += make_code(main_filepath, options.compiler, options.encoding, options.expand_include, includes, included_files) |
||
730 | |||
731 | |||
732 | for filepath_ in options.code[1:]: |
||
733 | filepath = filepath_.strip() |
||
734 | implements[os.path.basename(filepath)] = make_code(filepath, |
||
735 | options.compiler, options.encoding, options.expand_include, includes, included_files) |
||
736 | |||
737 | if options.output: |
||
738 | f = file_open(options.output, 'w', options.encoding) |
||
739 | f.write(code) |
||
740 | f.close() |
||
741 | xml = None |
||
742 | if options.xml: |
||
743 | xml = options.xml |
||
744 | set_output_xml(options, 'xml', xml) |
||
745 | if options.junit: |
||
746 | xml = options.junit |
||
747 | set_output_xml(options, 'junit', xml) |
||
748 | r = run_wandbox(main_filepath, code, includes, implements, options) |
||
749 | b = show_result(r, options) |
||
750 | if xml and 'program_error' in r: |
||
751 | f = file_open(xml, 'w', options.encoding) |
||
752 | f.write(r['program_error']) |
||
753 | f.close() |
||
754 | sys.exit(b) |
||
755 | |||
756 | |||
757 | # listup compiler |
||
758 | def listup_compiler(verbose): |
||
759 | r = wandbox_get_compilerlist() |
||
760 | for d in r: |
||
761 | if d['language'] == 'C++': |
||
762 | if verbose: |
||
763 | print(d['name'] + ' (' + d['version'] + ')') |
||
764 | else: |
||
765 | print(d['name']) |
||
766 | |||
767 | |||
768 | # find compiler |
||
769 | def find_compiler(c): |
||
770 | r = wandbox_get_compilerlist() |
||
771 | for d in r: |
||
772 | if d['language'] == 'C++' and d['name'] == c: |
||
773 | return True |
||
774 | return False |
||
775 | |||
776 | |||
777 | # listup options |
||
778 | def listup_options(compiler): |
||
779 | r = wandbox_get_compilerlist() |
||
780 | for d in r: |
||
781 | if d['name'] == compiler: |
||
782 | print('# ' + compiler) |
||
783 | if 'switches' in d: |
||
784 | switches = d['switches'] |
||
785 | for s in switches: |
||
786 | try: |
||
787 | if 'options' in s: |
||
788 | default_option = s['default'] |
||
789 | if 'name' in s: |
||
790 | print(s['name']) |
||
791 | for o in s['options']: |
||
792 | if o['name'] == default_option: |
||
793 | print(' ' + o['name'] + ' (default)') |
||
794 | else: |
||
795 | print(' ' + o['name']) |
||
796 | elif 'name' in s: |
||
797 | if s['default']: |
||
798 | print(s['name'] + ' (default)') |
||
799 | else: |
||
800 | print(s['name']) |
||
801 | except KeyError: |
||
802 | print("unknown format:") |
||
803 | print(s) |
||
804 | |||
805 | |||
806 | def get_options(compiler): |
||
807 | opt = [] |
||
808 | for s in wandbox_get_compilerswitches(compiler): |
||
809 | if 'options' in s: |
||
810 | opt.append(s['default']) |
||
811 | for o in s['options']: |
||
812 | opt.append(o['name']) |
||
813 | elif 'name' in s: |
||
814 | opt.append(s['name']) |
||
815 | return opt |
||
816 | |||
817 | |||
818 | # get default options |
||
819 | def get_default_options(compiler): |
||
820 | opt = [] |
||
821 | for s in wandbox_get_compilerswitches(compiler): |
||
822 | if 'options' in s: |
||
823 | opt.append(s['default']) |
||
824 | elif 'name' in s: |
||
825 | if s['default']: |
||
826 | opt.append(s['name']) |
||
827 | return opt |
||
828 | |||
829 | |||
830 | # get permlink |
||
831 | def get_permlink(options): |
||
832 | r = Wandbox.GetPermlink(options.permlink) |
||
833 | p = r['parameter'] |
||
834 | show_parameter(p) |
||
835 | print('result:') |
||
836 | b = show_result(r['result'], options) |
||
837 | if options.output: |
||
838 | f = open(options.output, 'w') |
||
839 | f.write(p['code']) |
||
840 | f.close() |
||
841 | sys.exit(b) |
||
842 | |||
843 | |||
844 | def main(): |
||
845 | options, parser = parse_command_line() |
||
846 | if options.list_compiler: |
||
847 | listup_compiler(options.verbose) |
||
848 | elif options.list_options: |
||
849 | listup_options(options.list_options) |
||
850 | elif options.permlink: |
||
851 | get_permlink(options) |
||
852 | else: |
||
853 | if options.check_config: |
||
854 | check_config(options) |
||
855 | elif not options.code: |
||
856 | parser.print_help() |
||
857 | sys.exit(1) |
||
858 | run(options) |
||
859 | |||
860 | |||
861 | if __name__ == '__main__': |
||
862 | main() |
||
863 |