forked from numpy/numpy
-
Notifications
You must be signed in to change notification settings - Fork 0
/
c_coverage_report.py
executable file
·183 lines (157 loc) · 5.83 KB
/
c_coverage_report.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
#!/usr/bin/env python
"""
A script to create C code-coverage reports based on the output of
valgrind's callgrind tool.
"""
from __future__ import division, absolute_import, print_function
import optparse
import os
import re
import sys
from xml.sax.saxutils import quoteattr, escape
try:
import pygments
if tuple([int(x) for x in pygments.__version__.split('.')]) < (0, 11):
raise ImportError()
from pygments import highlight
from pygments.lexers import CLexer
from pygments.formatters import HtmlFormatter
has_pygments = True
except ImportError:
print("This script requires pygments 0.11 or greater to generate HTML")
has_pygments = False
class FunctionHtmlFormatter(HtmlFormatter):
"""Custom HTML formatter to insert extra information with the lines."""
def __init__(self, lines, **kwargs):
HtmlFormatter.__init__(self, **kwargs)
self.lines = lines
def wrap(self, source, outfile):
for i, (c, t) in enumerate(HtmlFormatter.wrap(self, source, outfile)):
as_functions = self.lines.get(i-1, None)
if as_functions is not None:
yield 0, ('<div title=%s style="background: #ccffcc">[%2d]' %
(quoteattr('as ' + ', '.join(as_functions)),
len(as_functions)))
else:
yield 0, ' '
yield c, t
if as_functions is not None:
yield 0, '</div>'
class SourceFile:
def __init__(self, path):
self.path = path
self.lines = {}
def mark_line(self, lineno, as_func=None):
line = self.lines.setdefault(lineno, set())
if as_func is not None:
as_func = as_func.split("'", 1)[0]
line.add(as_func)
def write_text(self, fd):
source = open(self.path, "r")
for i, line in enumerate(source):
if i + 1 in self.lines:
fd.write("> ")
else:
fd.write("! ")
fd.write(line)
source.close()
def write_html(self, fd):
source = open(self.path, 'r')
code = source.read()
lexer = CLexer()
formatter = FunctionHtmlFormatter(
self.lines,
full=True,
linenos='inline')
fd.write(highlight(code, lexer, formatter))
source.close()
class SourceFiles:
def __init__(self):
self.files = {}
self.prefix = None
def get_file(self, path):
if path not in self.files:
self.files[path] = SourceFile(path)
if self.prefix is None:
self.prefix = path
else:
self.prefix = os.path.commonprefix([self.prefix, path])
return self.files[path]
def clean_path(self, path):
path = path[len(self.prefix):]
return re.sub("[^A-Za-z0-9\.]", '_', path)
def write_text(self, root):
for path, source in self.files.items():
fd = open(os.path.join(root, self.clean_path(path)), "w")
source.write_text(fd)
fd.close()
def write_html(self, root):
for path, source in self.files.items():
fd = open(os.path.join(root, self.clean_path(path) + ".html"), "w")
source.write_html(fd)
fd.close()
fd = open(os.path.join(root, 'index.html'), 'w')
fd.write("<html>")
paths = sorted(self.files.keys())
for path in paths:
fd.write('<p><a href="%s.html">%s</a></p>' %
(self.clean_path(path), escape(path[len(self.prefix):])))
fd.write("</html>")
fd.close()
def collect_stats(files, fd, pattern):
# TODO: Handle compressed callgrind files
line_regexs = [
re.compile("(?P<lineno>[0-9]+)(\s[0-9]+)+"),
re.compile("((jump)|(jcnd))=([0-9]+)\s(?P<lineno>[0-9]+)")
]
current_file = None
current_function = None
for i, line in enumerate(fd):
if re.match("f[lie]=.+", line):
path = line.split('=', 2)[1].strip()
if os.path.exists(path) and re.search(pattern, path):
current_file = files.get_file(path)
else:
current_file = None
elif re.match("fn=.+", line):
current_function = line.split('=', 2)[1].strip()
elif current_file is not None:
for regex in line_regexs:
match = regex.match(line)
if match:
lineno = int(match.group('lineno'))
current_file.mark_line(lineno, current_function)
if __name__ == '__main__':
parser = optparse.OptionParser(
usage="[options] callgrind_file(s)")
parser.add_option(
'-d', '--directory', dest='directory',
default='coverage',
help='Destination directory for output [default: coverage]')
parser.add_option(
'-p', '--pattern', dest='pattern',
default='numpy',
help='Regex pattern to match against source file paths [default: numpy]')
parser.add_option(
'-f', '--format', dest='format', default=[],
action='append', type='choice', choices=('text', 'html'),
help="Output format(s) to generate, may be 'text' or 'html' [default: both]")
(options, args) = parser.parse_args()
files = SourceFiles()
for log_file in args:
log_fd = open(log_file, 'r')
collect_stats(files, log_fd, options.pattern)
log_fd.close()
if not os.path.exists(options.directory):
os.makedirs(options.directory)
if options.format == []:
formats = ['text', 'html']
else:
formats = options.format
if 'text' in formats:
files.write_text(options.directory)
if 'html' in formats:
if not has_pygments:
print("Pygments 0.11 or later is required to generate HTML")
sys.exit(1)
files.write_html(options.directory)