iuwandbox.create_option_list() - Code Metrics - Inspection of "refactoring" - srz-zumix/iutest - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1b7e63...915a02 )

by srz

created 2018-01-19 13:49 UTC

iuwandbox.create_option_list() F

↳ Parent: iuwandbox

Complexity

Conditions

Size

Total Lines	42
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	22
eloc	33
nop	1
dl	0
loc	42
rs	2.6652
c	0
b	0
f	0

How to fix Complexity

#!/usr/bin/env python
#
# iuwandbox.py
#
# Copyright (C) 2014-2018, Takazumi Shirayanagi
# This software is released under the new BSD License,
# see LICENSE
#

import os
import sys
import re
import codecs
import argparse

from time import sleep
from argparse import ArgumentParser
from wandbox import Wandbox
from requests.exceptions import HTTPError
from requests.exceptions import ConnectionError

IUTEST_FUSED_SRC = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../fused-src/iutest.min.hpp'))
IUTEST_INCLUDE_PATH = os.path.normpath(os.path.join(os.path.dirname(__file__), '../../include'))
IUTEST_INCLUDE_REGEX = re.compile(r'^\s*#\s*include\s*".*(iutest|iutest_switch)\.hpp"')
EXPAND_INCLUDE_REGEX = re.compile(r'^\s*#\s*include\s*"(.*?)"')
IUTEST_INCG_REGEX = re.compile(r'\s*#\s*define[/\s]*(INCG_IRIS_\S*)\s*')

iutest_incg_list = []
workaround = True
api_retries = 3
api_retry_wait = 60


# command line option
def parse_command_line():
    global api_retries
    global api_retry_wait

    parser = ArgumentParser()
    parser.add_argument(
        '-v',
        '--version',
        action='version',
        version=u'%(prog)s version 5.8'
    )
    parser.add_argument(
        '--list-compiler',
        '--list_compiler',
        action='store_true',
        help='listup compiler.'
    )
    parser.add_argument(
        '--list-options',
        '--list_options',
        metavar='COMPILER',
        help='listup compiler options.'
    )
    parser.add_argument(
        '-c',
        '--compiler',
        default='gcc-head',
        help='compiler select. default: %(default)s'
    )
    parser.add_argument(
        '-x',
        '--options',
        help='used options for a compiler.'
    )
    parser.add_argument(
        '--default',
        action='store_true',
        help='it is not work. default options are set by default (deprecated)'
    )
    parser.add_argument(
        '--no-default',
        action='store_true',
        help='no set default options.'
    )
    parser.add_argument(
        '--std',
        metavar='VERSION',
        help='set --std options.'
    )
    parser.add_argument(
        '--boost',
        metavar='VERSION',
        help='set boost options version X.XX or nothing.'
    )
    parser.add_argument(
        '--optimize',
        action='store_true',
        help='use optimization.'
    )
    parser.add_argument(
        '--cpp-verbose',
        action='store_true',
        help='use cpp-verbose.'
    )
    parser.add_argument(
        '--sprout',
        action='store_true',
        help='use sprout.'
    )
    parser.add_argument(
        '--msgpack',
        action='store_true',
        help='use msgpack.'
    )
    parser.add_argument(
        '--stdin',
        help='set stdin.'
    )
    parser.add_argument(
        '-f',
        '--compiler-option-raw',
        '--compiler_option_raw',
        metavar='OPTIONS',
        action='append',
        default=['-D__WANDBOX__'],
        help='compile-time any additional options.'
    )
    parser.add_argument(
        '-r',
        '--runtime-option-raw',
        '--runtime_option_raw',
        metavar='OPTIONS',
        action='append',
        help='runtime-time any additional options.'
    )
    parser.add_argument(
        '-s',
        '--save',
        action='store_true',
        help='generate permanent link.'
    )
    parser.add_argument(
        '--permlink',
        metavar='ID',
        help='get permanent link.'
    )
    parser.add_argument(
        '-o',
        '--output',
        metavar='FILE',
        help='output source code.'
    )
    parser.add_argument(
        '--xml',
        metavar='FILE',
        help='output result xml.'
    )
    parser.add_argument(
        '--junit',
        metavar='FILE',
        help='output result junit xml.'
    )
    parser.add_argument(
        '--stderr',
        action='store_true',
        help='output stderr.'
    )
    parser.add_argument(
        '--encoding',
        help='set encoding.'
    )
    parser.add_argument(
        '--expand-include',
        '--expand_include',
        action='store_true',
        help='expand include file.'
    )
    parser.add_argument(
        '--make',
        action='store_true',
        help=argparse.SUPPRESS
    )
    parser.add_argument(
        '--retry-wait',
        type=int,
        default=api_retry_wait,
        metavar='SECONDS',
        help='Wait time for retry when HTTPError occurs'
    )
    parser.add_argument(
        '--retry',
        type=int,
        default=api_retries,
        metavar='COUNT',
        help='Number of retries when HTTPError occurs'
    )
    parser.add_argument(
        '--check-config',
        '--check_config',
        action='store_true',
        help='check config.'
    )
    parser.add_argument(
        '--iutest-use-main',
        action='store_true',
        help='define IUTEST_USE_MAIN.'
    )
    parser.add_argument(
        '--verbose',
        action='store_true',
        help='verbose.'
    )
    parser.add_argument(
        '--dryrun',
        action='store_true',
        help='dryrun.'
    )
    parser.add_argument(
        'code',
        metavar='CODE',
        nargs='*',
        help='source code file'
    )
    options = parser.parse_args()
    api_retries = options.retry
    api_retry_wait = options.retry_wait
    return options, parser


# file open
def file_open(path, mode, encoding):
    if encoding:
        file = codecs.open(path, mode, encoding)
    else:
        file = open(path, mode)
    return file


# make include filename
def make_include_filename(path, includes, included_files):
    if path in included_files:
        return included_files[path]
    else:
        include_dir, include_filename = os.path.split(path)
        while include_filename in includes:
            include_dir, dirname = os.path.split(include_dir)
            include_filename = dirname + '__' + include_filename
        included_files[path] = include_filename
        return include_filename


def is_iutest_included_file(filepath):
    if os.path.abspath(filepath).startswith(IUTEST_INCLUDE_PATH):
        incg = 'INCG_IRIS_' + os.path.basename(filepath).upper().replace('.', '_')
        for included_incg in iutest_incg_list:
            if included_incg.startswith(incg):
                return True
    return False


# make code
def make_code(path, encoding, expand, includes, included_files):
    code = ''
    file = file_open(path, 'r', encoding)
    for line in file:
        m = IUTEST_INCLUDE_REGEX.match(line)
        if m:
            code += '#include "iutest.hpp"\n'
            code += '//origin>> ' + line
            if 'iutest.hpp' not in includes:
                try:
                    f = codecs.open(IUTEST_FUSED_SRC, 'r', 'utf-8-sig')
                    iutest_src = f.read()
                    f.close()
                    includes['iutest.hpp'] = iutest_src
                    global iutest_incg_list
                    iutest_incg_list = IUTEST_INCG_REGEX.findall(iutest_src)
                except:
                    print('{0} is not found...'.format(IUTEST_FUSED_SRC))
                    print('please try \"make fused\"')
                    exit(1)
        else:
            m = EXPAND_INCLUDE_REGEX.match(line)
            if m:
                include_path = os.path.normpath(os.path.join(os.path.dirname(path), m.group(1)))
                if is_iutest_included_file(include_path):
                    code += '//origin>> '
                elif os.path.exists(include_path):
                    if expand:
                        expand_include_file_code = make_code(
                            include_path, encoding, expand, includes, included_files)
                        code += expand_include_file_code
                        code += '//origin>> '
                    else:
                        include_abspath = os.path.abspath(include_path)
                        include_filename = make_include_filename(
                            include_abspath, includes, included_files)
                        if not include_filename == include_path:
                            code += '#include "' + include_filename + '"\n'
                            code += '//origin>> '
                        if include_filename not in includes:
                            includes[include_filename] = ''
                            expand_include_file_code = make_code(
                                include_path, encoding, expand, includes, included_files)
                            includes[include_filename] = expand_include_file_code
            code += line
    file.close()
    return code


def print_undefined_option(option_name, compiler):
    print('Wandbox is not supported option [{0}] ({1})'.format(option_name, compiler))


# check config
def check_config(options):
    has_error = False
    if not find_compiler(options.compiler):
        print('Wandbox is not supported compiler [' + options.compiler + ']')
        listup_compiler()
        has_error = True
    if options.options or options.std:
        opt = get_options(options.compiler)
        if options.options:
            for o in options.options.split(','):
                if o not in opt:
                    print_undefined_option(o, options.compiler)
                    has_error = True
        if options.std:
            if options.std not in opt:
                print_undefined_option(options.std, options.compiler)
                has_error = True
        if has_error:
            listup_options(options.compiler)
    if has_error:
        sys.exit(1)
    if options.default:
        print('--default option is not work. default options are set by default (deprecated)')


# setup additional files
def add_files(w, fileinfos):
    for filename, code in fileinfos.items():
        w.add_file(filename, code)


# create opt list
def create_option_list(options):
    def filterout_cppver(opt):
        tmp = list(filter(lambda s: s.find('c++') == -1, opt))
        tmp = list(filter(lambda s: s.find('gnu++') == -1, tmp))
        return tmp
    opt = []
    if not options.no_default:
        opt = get_default_options(options.compiler)
    if options.options:
        for o in options.options.split(','):
            if o not in opt:
                if (o.find('c++') == 0) or (o.find('gnu++') == 0):
                    opt = filterout_cppver(opt)
                opt.append(o)
    # std
    if options.std:
        opt = filterout_cppver(opt)
        opt.append(options.std)
    # optimize
    if options.optimize and ('optimize' not in opt):
        opt.append('optimize')
    # cpp-verbose
    if options.cpp_verbose and ('cpp-verbose' not in opt):
        opt.append('cpp-verbose')
    # boost
    if workaround:
        pass
#        if options.compiler in ['clang-3.4', 'clang-3.3']:
#            if not options.boost:
#                options.boost = 'nothing'
    if options.boost:
        if options.compiler not in options.boost:
            options.boost = options.boost + '-' + options.compiler
        opt = list(filter(lambda s: s.find('boost') == -1, opt))
        opt.append('boost-' + str(options.boost))
    # sprout
    if options.sprout and ('sprout' not in opt):
        opt.append('sprout')
    # msgpack
    if options.msgpack and ('msgpack' not in opt):
        opt.append('msgpack')
    return opt


def expand_wandbox_options(w, compiler, options):
    colist = []
    defs = {}
    for d in w.get_compiler_list():
        if d['name'] == compiler:
            if 'switches' in d:
                switches = d['switches']
                for s in switches:
                    if ('name' in s) and ('display-flags' in s):
                        defs[s['name']] = s['display-flags']
                    elif 'options' in s:
                        for o in s['options']:
                            if ('name' in o) and ('display-flags' in o):
                                defs[o['name']] = o['display-flags']
    for opt in options:
        if opt in defs:
            colist.extend(defs[opt].split())
    return colist


def wandbox_api_call(callback, retries, retry_wait):
    try:
        return callback()
    except (HTTPError, ConnectionError) as e:

        def is_retry(e):
            if not e.response:
                return True
            return e.response.status_code in [504]

        if is_retry(e) and retries > 0:
            try:
                print(e.message)
            except:
                pass
            print('wait {0}sec...'.format(retry_wait))
            sleep(retry_wait)
            return wandbox_api_call(callback, retries - 1, retry_wait)
        else:
            raise
    except:
        raise


def wandbox_get_compilerlist():
    return wandbox_api_call(Wandbox.GetCompilerList, api_retries, api_retry_wait)


def wandbox_get_compilerswitches(compiler):
    for d in wandbox_get_compilerlist():
        if d['name'] == compiler:
            if 'switches' in d:
                return d['switches']
    return []


def run_wandbox_impl(w, options):
    if options.dryrun:
        sys.exit(0)
    retries = options.retry

    def run():
        return w.run()
    return wandbox_api_call(run, retries, options.retry_wait)


def create_compiler_raw_option_list(options):
    colist = []
    if options.compiler_option_raw:
        raw_options = options.compiler_option_raw
        for x in raw_options:
            colist.extend(re.split('\s(?=-)', x.strip('"')))
    if options.iutest_use_main:
        colist.append('-DIUTEST_USE_MAIN')
    return colist


# run wandbox (makefile)
def run_wandbox_make(main_filepath, code, includes, impliments, options):
    with Wandbox() as w:
        w.compiler('bash')
        woptions = create_option_list(options)
        if options.stdin:
            w.stdin(options.stdin)
        impliments[os.path.basename(main_filepath)] = code

        colist = create_compiler_raw_option_list(options)
        colist.extend(expand_wandbox_options(w, options.compiler, woptions))

        rolist = []
        if options.runtime_option_raw:
            for opt in options.runtime_option_raw:
                rolist.extend(opt.split())

        makefile = '#!/bin/make\n# generate makefile by iuwandbox.py\n'
        makefile += '\nCXXFLAGS+='
        for opt in colist:
            makefile += opt + ' '
        makefile += '\nOBJS='
        for filename in impliments.keys():
            makefile += os.path.splitext(filename)[0] + '.o '

        makefile += '\n\
prog: $(OBJS)\n\
\t$(CXX) -o $@ $^ $(CXXFLAGS) $(LDFLAGS)\n\
'

        impliments['Makefile'] = makefile

        bashscript = 'make -j 4\n'
        bashscript += './prog '
        for opt in rolist:
            bashscript += opt + ' '
        bashscript += '\n'
        w.code(bashscript)

        if options.save:
            w.permanent_link(options.save)
        if options.verbose:
            w.dump()
        add_files(w, impliments)
        add_files(w, includes)

        return run_wandbox_impl(w, options)


# run wandbox (cxx)
def run_wandbox_cxx(code, includes, impliments, options):
    with Wandbox() as w:
        w.compiler(options.compiler)
        w.options(','.join(create_option_list(options)))
        if options.stdin:
            w.stdin(options.stdin)
        colist = create_compiler_raw_option_list(options)

        if workaround:
            if options.compiler in ['clang-3.2']:
                colist.append('-ftemplate-depth=1024')
    #        if options.compiler in ['clang-3.4']:
    #            colist.append('-DIUTEST_HAS_HDR_CXXABI=0')
    #        if options.compiler in ['clang-3.3', 'clang-3.2', 'clang-3.1', 'clang-3.0']:
    #            colist.append('-Qunused-arguments')
    #        if options.compiler in ['clang-3.4', 'clang-3.3']:
    #            colist.append('-fno-exceptions')
    #            colist.append('-fno-rtti')
            pass
        if len(colist) > 0:
            co = '\n'.join(colist)
            co = co.replace('\\n', '\n')
            w.compiler_options(co)
        if options.runtime_option_raw:
            rolist = []
            for opt in options.runtime_option_raw:
                rolist.extend(opt.split())
            ro = '\n'.join(rolist)
            ro = ro.replace('\\n', '\n')
            w.runtime_options(ro)
        if options.save:
            w.permanent_link(options.save)
        for filename in impliments.keys():
            w.add_compiler_options(filename)
        if options.verbose:
            w.dump()
        w.code(code)
        add_files(w, impliments)
        add_files(w, includes)

        return run_wandbox_impl(w, options)


# run wandbox
def run_wandbox(main_filepath, code, includes, impliments, options):
    if options.make:
        return run_wandbox_make(main_filepath, code, includes, impliments, options)
    else:
        return run_wandbox_cxx(code, includes, impliments, options)


def wandbox_hint(r):
    if 'compiler_error' in r:
        if 'undefined reference to `main' in r['compiler_error']:
            print('hint:')
            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")')
        elif 'undefined reference to `init_unit_test_suite' in r['compiler_error']:
            print('hint:')
            print('  If you do not use boost test, please specify the file with the main function first.')


def text_transform(value):
    try:
        if isinstance(value, str):
            return value.decode()
        elif isinstance(value, unicode):

            return value.encode('utf_8')
    except:
        pass
    return value


# show result
def show_result(r, options):
    if 'error' in r:
        print(r['error'])
        sys.exit(1)
    if options.stderr:
        if 'compiler_output' in r:
            print('compiler_output:')
            print(text_transform(r['compiler_output']))
        if 'compiler_error' in r:
            sys.stderr.write(text_transform(r['compiler_error']))
        if 'program_output' in r:
            print('program_output:')
            print(text_transform(r['program_output']))
        if options.xml is None and options.junit is None and 'program_error' in r:
            sys.stderr.write(text_transform(r['program_error']))
    else:
        if 'compiler_message' in r:
            print('compiler_message:')
            print(text_transform(r['compiler_message']))
        if 'program_message' in r:
            print('program_message:')
            print(text_transform(r['program_message']))
    if 'url' in r:
        print('permlink: ' + r['permlink'])
        print('url: ' + r['url'])
    if 'signal' in r:
        print('signal: ' + r['signal'])
    wandbox_hint(r)

    if 'status' in r:
        return int(r['status'])
    return 1


# show parameter
def show_parameter(r):
    if 'compiler' in r:
        print('compiler:' + r['compiler'])
    if 'options' in r:
        print('options:' + r['options'])
    if 'compiler-option-raw' in r:
        print('compiler-option-raw:' + r['compiler-option-raw'])
    if 'runtime-option-raw' in r:
        print('runtime-option-raw' + r['runtime-option-raw'])
    if 'created-at' in r:
        print(r['created-at'])


def set_output_xml(options, t, xml):
    options.stderr = True
    if options.runtime_option_raw:
        options.runtime_option_raw.append('--iutest_output=' + t + ':' + xml)
    else:
        options.runtime_option_raw = ['--iutest_output=' + t + ':' + xml]


def run(options):
    main_filepath = options.code[0].strip()
    if not os.path.exists(main_filepath):
        sys.exit(1)
    includes = {}
    included_files = {}
    impliments = {}
    code = make_code(main_filepath, options.encoding, options.expand_include, includes, included_files)

    for filepath_ in options.code[1:]:
        filepath = filepath_.strip()
        impliments[os.path.basename(filepath)] = make_code(filepath, options.encoding, options.expand_include, includes, included_files)

    if options.output:
        f = file_open(options.output, 'w', options.encoding)
        f.write(code)
        f.close()
    xml = None
    if options.xml:
        xml = options.xml
        set_output_xml(options, 'xml', xml)
    if options.junit:
        xml = options.junit
        set_output_xml(options, 'junit', xml)
    r = run_wandbox(main_filepath, code, includes, impliments, options)
    b = show_result(r, options)
    if xml and 'program_error' in r:
        f = file_open(xml, 'w', options.encoding)
        f.write(r['program_error'])
        f.close()
    sys.exit(b)


# listup compiler
def listup_compiler(verbose):
    r = wandbox_get_compilerlist()
    for d in r:
        if d['language'] == 'C++':
            if verbose:
                print(d['name'] + ' (' + d['version'] + ')')
            else:
                print(d['name'])


# find compiler
def find_compiler(c):
    r = wandbox_get_compilerlist()
    for d in r:
        if d['language'] == 'C++' and d['name'] == c:
            return True
    return False


# listup options
def listup_options(compiler):
    r = wandbox_get_compilerlist()
    for d in r:
        if d['name'] == compiler:
            print('# ' + compiler)
            if 'switches' in d:
                switches = d['switches']
                for s in switches:
                    if 'name' in s:
                        if s['default']:
                            print(s['name'] + ' (default)')
                        else:
                            print(s['name'])
                    elif 'options' in s:
                        print(s['default'] + ' (default)')
                        for o in s['options']:
                            print('  ' + o['name'])


def get_options(compiler):
    opt = []
    for s in wandbox_get_compilerswitches(compiler):
        if 'name' in s:
            opt.append(s['name'])
        elif 'options' in s:
            opt.append(s['default'])
            for o in s['options']:
                opt.append(o['name'])
    return opt


# get default options
def get_default_options(compiler):
    opt = []
    for s in wandbox_get_compilerswitches(compiler):
        if 'name' in s:
            if s['default']:
                opt.append(s['name'])
        elif 'options' in s:
            opt.append(s['default'])
    return opt


# get permlink
def get_permlink(options):
    r = Wandbox.GetPermlink(options.permlink)
    p = r['parameter']
    show_parameter(p)
    print('result:')
    b = show_result(r['result'], options)
    if options.output:
        f = open(options.output, 'w')
        f.write(p['code'])
        f.close()
    sys.exit(b)


def main():
    options, parser = parse_command_line()
    if options.list_compiler:
        listup_compiler(options.verbose)
    elif options.list_options:
        listup_options(options.list_options)
    elif options.permlink:
        get_permlink(options)
    else:
        if options.check_config:
            check_config(options)
        elif len(options.code) == 0:
            parser.print_help()
            sys.exit(1)
        run(options)


if __name__ == '__main__':
    main()


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

srz-zumix / iutest

Push — master ( 1b7e63...915a02 )

iuwandbox.create_option_list() F

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like