fused_iutest_files.IutestFused.StoreMinimze() - Code Metrics - srz-zumix/iutest - Measure and Improve Code Quality continuously with Scrutinizer

fused_iutest_files.IutestFused.StoreMinimze() A
last analyzed 2023-02-20 14:43 UTC

↳ Parent: fused_iutest_files

Complexity

Conditions

Size

Total Lines	14
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	9
nop	2
dl	0
loc	14
rs	9.95
c	0
b	0
f	0

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# fuse_iutest_files.py
#
# Copyright (C) 2014-2016, Takazumi Shirayanagi
# This software is released under the new BSD License,
# see LICENSE
#

""" fuse_iutest_files.py
fuse_iutest_files.py [IUTEST_ROOT_DIR] OUTPUT_DIR
"""

import os
import sys
import re
import codecs

IUTEST_INCLUDE_DIR = os.path.join(os.path.dirname(__file__), '../../include')
IUTEST_APPROVAL_INCLUDE_GUARD = {
    'INCG_IRIS_IUTEST_HPP_',
    'INCG_IRIS_IUTEST_SWITCH_HPP_',
    'INCG_IRIS_IUTEST_SPI_HPP_'
}


class IutestFused:
    INCLUDE_REGEX = re.compile(r'^\s*#\s*include\s*"(.*iutest.*)"')
    IFDEF_REGEX = re.compile(r'^\s*#\s*if(def\s*\S*|\s*defined\s*\(.*\))')
    PREPRO_REGEX = re.compile(r'^\s*#')
    COMMENT_REGEX = re.compile(r'^\s*//.*')
    C_COMMENT_BEGIN_REGEX = re.compile(r'^\s*(.*)/\*.*')
    C_COMMENT_END_REGEX = re.compile(r'^\s*\*/(.*)')
    STRING_REGEX = re.compile(r'(".*?")')
    INCG_REGEX = re.compile(r'^\s*#\s*(ifndef|define|endif)[/\s]*(INCG_\S*)\s*\Z')
    c_comment = False
    store_line = ""
    line_buffer = ""

    def IsUnnecessaryIncludeGuard(self, line):
        m = self.INCG_REGEX.match(line)
        if m:
            incg = m.group(2)
            if m.group(1) == 'define':
                return False
            if incg not in IUTEST_APPROVAL_INCLUDE_GUARD:
                return True
        return False

    def StoreStrings(self, src, list):
        tmp = src.replace(r'\"', '$$')
        prev = 0
        dst = ""
        for m in self.STRING_REGEX.finditer(tmp):
            dst += tmp[prev:m.start()]
            dst += '"@STRING@"'
            prev = m.end()
            list.append(m.group(0))
        dst += tmp[prev:]
        return dst

    def RestoreStrings(self, src, list):
        dst = src
        for s in list:
            dst = dst.replace('"@STRING@"', s, 1)
        dst = dst.replace('$$', r'\"')
        return dst

    def StoreMinimze(self, line):
        store = self.store_line + line
        # string store
        str_l = []
        store = self.StoreStrings(store, str_l)

        store = re.sub('"@STRING@""@STRING@"', '"@STRING@"##+##"@STRING@"', store)
        store = re.sub('\):\s+', '):', store)

        # string restore
        store = self.RestoreStrings(store, str_l)

        store = store.replace('"##+##"', '')
        self.store_line = store

    def Minimze(self, line):
        # if defined -> ifdef
        line = re.sub(r'\s*#\s*if\s*defined\((\S*)\)\s*\Z', r'#ifdef \1', line)
        # if !defined -> ifndef
        line = re.sub(r'\s*#\s*if\s*!defined\((\S*)\)\s*\Z', r'#ifndef \1', line)

        # C comment
        if self.c_comment:
            m = self.C_COMMENT_END_REGEX.match(line)
            if m:
                self.c_comment = False
                line = m.group(1)
            else:
                return ""
        m = self.C_COMMENT_BEGIN_REGEX.match(line)
        if m:
            self.c_comment = True
            line = m.group(1)
        line = line.strip()
        if len(line) == 0:
            return ""

        # C++ comment
        if self.COMMENT_REGEX.match(line):
            return ""
        # include guard
        if self.IsUnnecessaryIncludeGuard(line):
            return ""

        # string store
        str_l = []
        line = self.StoreStrings(line, str_l)

        # remove comment and strip
        line = re.sub('//[\S \t]*', '', line)
        line = line.strip(' \t')
        # remvoe \r
        line = line.rstrip()
        line += '\n'
        # remove preprocessor directive unnecessary whitespace
        line = re.sub('^\s*#\s*', '#', line)
        line = re.sub('^\s*#(.+?)[ \t]+', r'#\1 ', line)

        # remove unnecessary whitespace
        line = re.sub('\s+(".*?")', r' \1', line)
        line = re.sub(r'\)\s+>', r')>', line)
        line = re.sub(';[ \t]+', ';', line)
        line = re.sub('[ \t]+', ' ', line)
        line = re.sub('([\w)\]]+)\s+([&|\+\-<>=\?]+)[ \t]+([^>])', r'\1\2\3', line)
        line = re.sub('\s*([{\+\-\*/%=<>&|!]+=)[ \t]*', r'\1', line)
        line = re.sub('<\s+(\w)', r'<\1', line)
        line = re.sub('\s+:[ \t]+(\w)', r':\1', line)
        line = re.sub('\s*,[ \t]*', ',', line)
        line = re.sub('\s*\)', ')', line)
        line = re.sub('\)\s+{', '){', line)
        line = re.sub('\)\s+const', ')const', line)
        if not re.match('#define\s+.*\s+{.*', line):
            line = re.sub('\s*{\s*', '{', line)
            line = re.sub('\s*}\s*', '}', line)

        # define HOGE(x) vs define HOGE (x)
        m = re.match('^#define\s+(\w+)\s+(\([^)]*?\))$', line)
        line = re.sub('\s*\([ \t]*', '(', line)
        if m:
            line = re.sub('^#define\s+(\w+)(\([^)]*?\))$', r'#define \1 \2', line)
        else:
            line = re.sub('^#define\s+(\w+\([^)]*?\))(\S+)', r'#define \1 \2', line)

        # 0x00000X => 0xX
        line = re.sub('0x0+([0-9A-Fa-f])', r'0x\1', line)
        # 0x0 => 0
        line = re.sub('0x([0-9])([^0-9A-Fa-f])', r'\1\2', line)

        # string restore
        line = self.RestoreStrings(line, str_l)

        line = re.sub('^#define\s+(\w+)=', r'#define \1 =', line)
        return line

    def Flush(self, output_file):
        if len(self.store_line) > 0:
            line = self.store_line.strip()
            self.Write(output_file, line + '\n')
            self.store_line = ""

    def Translate(self, root, filename, output, output_dir, minimum):
        output_file = codecs.open(os.path.join(output_dir, output), 'w', 'utf-8-sig')
        processed_files = set()
        # fused-min not support gtest switch
        if minimum:
            processed_files.add(os.path.normpath(os.path.join(root, "gtest/iutest_switch.hpp")))

        def ProcessFile(curr, filename, fileset, minimum):
            path = os.path.join(root, filename)
            if not os.path.exists(path):
                path = os.path.join(curr, filename)

            path = os.path.normpath(path)
            if path in fileset:
                return

            find_ifdef = False
            fileset.add(path)
            # print(filename)
            for line in codecs.open(path, 'r', 'utf-8-sig'):
                line = re.sub('/\*.*?\*/', '', line)
                m = self.INCLUDE_REGEX.match(line)
                if m:
                    self.Flush(output_file)
                    include_file = m.group(1)
                    if find_ifdef:
                        s = set(fileset)
                        ProcessFile(os.path.dirname(path), include_file, s, minimum)
                    else:
                        ProcessFile(os.path.dirname(path), include_file, fileset, minimum)
                else:
                    find_ifdef = bool(self.IFDEF_REGEX.match(line))
                    if minimum:
                        line = self.Minimze(line)
                        if len(line):
                            if self.PREPRO_REGEX.match(self.store_line):
                                line = line.strip()
                                if line.endswith('\\'):
                                    self.StoreMinimze(line.rstrip(r'\\'))
                                else:
                                    self.StoreMinimze(line)
                                    self.Flush(output_file)
                            elif self.PREPRO_REGEX.match(line):
                                self.Flush(output_file)
                                if line.strip().endswith('\\'):
                                    self.StoreMinimze(line.strip().rstrip(r'\\'))
                                else:
                                    self.Write(output_file, line)
                            else:
                                strip_line = line.strip()
                                self.StoreMinimze(strip_line)
                                #if not re.match('.*[{};\(\)<>]$', strip_line):
                                #   self.Flush(output_file)
                                if re.match('.*(:|IUTEST_CXX_DEFAULT_FUNCTION)$', strip_line):
                                    self.store_line += " "
                    else:
                        self.Write(output_file, line)
            self.Flush(output_file)

        ProcessFile(root, filename, processed_files, minimum)
        output_file.close()

    def Write(self, output_file, line):
        if len(line) > 10000:
            idx = line.rfind('}', 0, 10000)
            if idx > 0:
                output_file.write(line[0:idx])
                output_file.write('\n')
                line = line[idx:]
        output_file.write(line)

def FusedSrc(root, filename, output, output_dir, minimum):
    f = IutestFused()
    f.Translate(root, filename, output, output_dir, minimum)


def FusedAll(root, output_dir):
    if not os.path.exists(output_dir):
        os.makedirs(output_dir, True)
    FusedSrc(root, 'iutest.hpp', 'iutest.hpp', output_dir, False)
    FusedSrc(root, 'iutest.hpp', 'iutest.min.hpp', output_dir, True)


def main():
    argc = len(sys.argv)
    if argc == 2:
        FusedAll(IUTEST_INCLUDE_DIR, sys.argv[1])
    elif argc == 3:
        FusedAll(os.path.join(sys.argv[1], "include"), sys.argv[2])
    else:
        print(__doc__)
        sys.exit(1)


if __name__ == '__main__':
    main()


1			#!/usr/bin/env python
2			# -- coding: utf-8 --
3			#
4			# fuse_iutest_files.py
5			#
6			# Copyright (C) 2014-2016, Takazumi Shirayanagi
7			# This software is released under the new BSD License,
8			# see LICENSE
9			#
10
11			""" fuse_iutest_files.py
12			fuse_iutest_files.py [IUTEST_ROOT_DIR] OUTPUT_DIR
13			"""
14
15			import os
16			import sys
17			import re
18			import codecs
19
20			IUTEST_INCLUDE_DIR = os.path.join(os.path.dirname(__file__), '../../include')
21			IUTEST_APPROVAL_INCLUDE_GUARD = {
22			'INCG_IRIS_IUTEST_HPP_',
23			'INCG_IRIS_IUTEST_SWITCH_HPP_',
24			'INCG_IRIS_IUTEST_SPI_HPP_'
25			}
26
27
28			class IutestFused:
29			INCLUDE_REGEX = re.compile(r'^\s#\sinclude\s"(.iutest.*)"')
30			IFDEF_REGEX = re.compile(r'^\s#\sif(def\s\S\|\sdefined\s\(.*\))')
31			PREPRO_REGEX = re.compile(r'^\s*#')
32			COMMENT_REGEX = re.compile(r'^\s//.')
33			C_COMMENT_BEGIN_REGEX = re.compile(r'^\s(.)/\.')
34			C_COMMENT_END_REGEX = re.compile(r'^\s\/(.*)')
35			STRING_REGEX = re.compile(r'(".*?")')
36			INCG_REGEX = re.compile(r'^\s#\s(ifndef\|define\|endif)[/\s](INCG_\S)\s*\Z')
37			c_comment = False
38			store_line = ""
39			line_buffer = ""
40
41			def IsUnnecessaryIncludeGuard(self, line):
42			m = self.INCG_REGEX.match(line)
43			if m:
44			incg = m.group(2)
45			if m.group(1) == 'define':
46			return False
47			if incg not in IUTEST_APPROVAL_INCLUDE_GUARD:
48			return True
49			return False
50
51			def StoreStrings(self, src, list):
52			tmp = src.replace(r'\"', '$$')
53			prev = 0
54			dst = ""
55			for m in self.STRING_REGEX.finditer(tmp):
56			dst += tmp[prev:m.start()]
57			dst += '"@STRING@"'
58			prev = m.end()
59			list.append(m.group(0))
60			dst += tmp[prev:]
61			return dst
62
63			def RestoreStrings(self, src, list):
64			dst = src
65			for s in list:
66			dst = dst.replace('"@STRING@"', s, 1)
67			dst = dst.replace('$$', r'\"')
68			return dst
69
70			def StoreMinimze(self, line):
71			store = self.store_line + line
72			# string store
73			str_l = []
74			store = self.StoreStrings(store, str_l)
75
76			store = re.sub('"@STRING@""@STRING@"', '"@STRING@"##+##"@STRING@"', store)
77			store = re.sub('\):\s+', '):', store)
78
79			# string restore
80			store = self.RestoreStrings(store, str_l)
81
82			store = store.replace('"##+##"', '')
83			self.store_line = store
84
85			def Minimze(self, line):
86			# if defined -> ifdef
87			line = re.sub(r'\s#\sif\sdefined\((\S)\)\s*\Z', r'#ifdef \1', line)
88			# if !defined -> ifndef
89			line = re.sub(r'\s#\sif\s!defined\((\S)\)\s*\Z', r'#ifndef \1', line)
90
91			# C comment
92			if self.c_comment:
93			m = self.C_COMMENT_END_REGEX.match(line)
94			if m:
95			self.c_comment = False
96			line = m.group(1)
97			else:
98			return ""
99			m = self.C_COMMENT_BEGIN_REGEX.match(line)
100			if m:
101			self.c_comment = True
102			line = m.group(1)
103			line = line.strip()
104			if len(line) == 0:
105			return ""
106
107			# C++ comment
108			if self.COMMENT_REGEX.match(line):
109			return ""
110			# include guard
111			if self.IsUnnecessaryIncludeGuard(line):
112			return ""
113
114			# string store
115			str_l = []
116			line = self.StoreStrings(line, str_l)
117
118			# remove comment and strip
119			line = re.sub('//[\S \t]*', '', line)
120			line = line.strip(' \t')
121			# remvoe \r
122			line = line.rstrip()
123			line += '\n'
124			# remove preprocessor directive unnecessary whitespace
125			line = re.sub('^\s#\s', '#', line)
126			line = re.sub('^\s*#(.+?)[ \t]+', r'#\1 ', line)
127
128			# remove unnecessary whitespace
129			line = re.sub('\s+(".*?")', r' \1', line)
130			line = re.sub(r'\)\s+>', r')>', line)
131			line = re.sub(';[ \t]+', ';', line)
132			line = re.sub('[ \t]+', ' ', line)
133			line = re.sub('([\w)\]]+)\s+([&\|\+\-<>=\?]+)[ \t]+([^>])', r'\1\2\3', line)
134			line = re.sub('\s([{\+\-\/%=<>&\|!]+=)[ \t]*', r'\1', line)
135			line = re.sub('<\s+(\w)', r'<\1', line)
136			line = re.sub('\s+:[ \t]+(\w)', r':\1', line)
137			line = re.sub('\s,[ \t]', ',', line)
138			line = re.sub('\s*\)', ')', line)
139			line = re.sub('\)\s+{', '){', line)
140			line = re.sub('\)\s+const', ')const', line)
141			if not re.match('#define\s+.\s+{.', line):
142			line = re.sub('\s{\s', '{', line)
143			line = re.sub('\s}\s', '}', line)
144
145			# define HOGE(x) vs define HOGE (x)
146			m = re.match('^#define\s+(\w+)\s+(\([^)]*?\))$', line)
147			line = re.sub('\s\([ \t]', '(', line)
148			if m:
149			line = re.sub('^#define\s+(\w+)(\([^)]*?\))$', r'#define \1 \2', line)
150			else:
151			line = re.sub('^#define\s+(\w+\([^)]*?\))(\S+)', r'#define \1 \2', line)
152
153			# 0x00000X => 0xX
154			line = re.sub('0x0+([0-9A-Fa-f])', r'0x\1', line)
155			# 0x0 => 0
156			line = re.sub('0x([0-9])([^0-9A-Fa-f])', r'\1\2', line)
157
158			# string restore
159			line = self.RestoreStrings(line, str_l)
160
161			line = re.sub('^#define\s+(\w+)=', r'#define \1 =', line)
162			return line
163
164			def Flush(self, output_file):
165			if len(self.store_line) > 0:
166			line = self.store_line.strip()
167			self.Write(output_file, line + '\n')
168			self.store_line = ""
169
170			def Translate(self, root, filename, output, output_dir, minimum):
171			output_file = codecs.open(os.path.join(output_dir, output), 'w', 'utf-8-sig')
172			processed_files = set()
173			# fused-min not support gtest switch
174			if minimum:
175			processed_files.add(os.path.normpath(os.path.join(root, "gtest/iutest_switch.hpp")))
176
177			def ProcessFile(curr, filename, fileset, minimum):
178			path = os.path.join(root, filename)
179			if not os.path.exists(path):
180			path = os.path.join(curr, filename)
181
182			path = os.path.normpath(path)
183			if path in fileset:
184			return
185
186			find_ifdef = False
187			fileset.add(path)
188			# print(filename)
189			for line in codecs.open(path, 'r', 'utf-8-sig'):
190			line = re.sub('/\.?\*/', '', line)
191			m = self.INCLUDE_REGEX.match(line)
192			if m:
193			self.Flush(output_file)
194			include_file = m.group(1)
195			if find_ifdef:
196			s = set(fileset)
197			ProcessFile(os.path.dirname(path), include_file, s, minimum)
198			else:
199			ProcessFile(os.path.dirname(path), include_file, fileset, minimum)
200			else:
201			find_ifdef = bool(self.IFDEF_REGEX.match(line))
202			if minimum:
203			line = self.Minimze(line)
204			if len(line):
205			if self.PREPRO_REGEX.match(self.store_line):
206			line = line.strip()
207			if line.endswith('\\'):
208			self.StoreMinimze(line.rstrip(r'\\'))
209			else:
210			self.StoreMinimze(line)
211			self.Flush(output_file)
212			elif self.PREPRO_REGEX.match(line):
213			self.Flush(output_file)
214			if line.strip().endswith('\\'):
215			self.StoreMinimze(line.strip().rstrip(r'\\'))
216			else:
217			self.Write(output_file, line)
218			else:
219			strip_line = line.strip()
220			self.StoreMinimze(strip_line)
221			#if not re.match('.*[{};\(\)<>]$', strip_line):
222			# self.Flush(output_file)
223			if re.match('.*(:\|IUTEST_CXX_DEFAULT_FUNCTION)$', strip_line):
224			self.store_line += " "
225			else:
226			self.Write(output_file, line)
227			self.Flush(output_file)
228
229			ProcessFile(root, filename, processed_files, minimum)
230			output_file.close()
231
232			def Write(self, output_file, line):
233			if len(line) > 10000:
234			idx = line.rfind('}', 0, 10000)
235			if idx > 0:
236			output_file.write(line[0:idx])
237			output_file.write('\n')
238			line = line[idx:]
239			output_file.write(line)
240
241			def FusedSrc(root, filename, output, output_dir, minimum):
242			f = IutestFused()
243			f.Translate(root, filename, output, output_dir, minimum)
244
245
246			def FusedAll(root, output_dir):
247			if not os.path.exists(output_dir):
248			os.makedirs(output_dir, True)
249			FusedSrc(root, 'iutest.hpp', 'iutest.hpp', output_dir, False)
250			FusedSrc(root, 'iutest.hpp', 'iutest.min.hpp', output_dir, True)
251
252
253			def main():
254			argc = len(sys.argv)
255			if argc == 2:
256			FusedAll(IUTEST_INCLUDE_DIR, sys.argv[1])
257			elif argc == 3:
258			FusedAll(os.path.join(sys.argv[1], "include"), sys.argv[2])
259			else:
260			print(__doc__)
261			sys.exit(1)
262
263
264			if __name__ == '__main__':
265			main()
266

srz-zumix / iutest

fused_iutest_files.IutestFused.StoreMinimze() A last analyzed 2023-02-20 14:43 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

fused_iutest_files.IutestFused.StoreMinimze() A
last analyzed 2023-02-20 14:43 UTC