enabled = enabled_filters.get(id, False)

if not id:

id = 'None'

return '\n <label class="checkBtn%s"><input type="checkbox" onclick="%s(this)" id="%s"%s/>%s</label>'\

severity_bar = ''.join([filter_button(enabled, severity, 'toggleSeverity') for severity in ['error', 'warning', 'portability', 'performance', 'style', 'information']]) + '\n | '

classification_bar = ''.join([filter_button(enabled, _class, 'toggleClassification') for _class in ['Mandatory', 'Required', 'Advisory', 'Document', 'Disapplied', 'L1','L2','L3','']]) + '\n | '

if "checked/>" not in severity_bar:

severity_bar = ''

if "checked/>" not in classification_bar:

classification_bar = ''

return ''.join([

' <div id="filters">\n'

,severity_bar

, classification_bar

,''.join([filter_button(enabled, tool, 'toggleTool') for tool in ['cppcheck', 'clang-tidy']])

,'\n | '

,'\n <label class="severityHeader">File: <input type="search" oninput="filterFile(this.value)"/></label>'

,'\n <label class="severityHeader">Filter: <input type="search" oninput="filterText(this.value)"/></label>'

last_line= errors[-1]['line']

if last_line == 0:

return {}

first_line = next((error for error in errors if error['line'] > 0))['line']

full_path = os.path.join(path, file)

path, filename = os.path.split(full_path)

if not path:

path = None # make sure this is None

cmd_args = ['git', 'blame', '-L %d,%d' % (first_line, last_line)]

if '-w' in blame_options:

cmd_args.append('-w')

if '-M' in blame_options:

cmd_args.append('-M')

cmd_args = cmd_args + ['--porcelain', '--incremental', '--', filename]

try:

result = subprocess.check_output(cmd_args, cwd=path)

result = result.decode(locale.getpreferredencoding())

except:

return []

if result.startswith('fatal'):

return []

blame_data = []

line_from = 0

line_to = 0

blame_info = {}

for line_str in result.splitlines():

field, _, value = line_str.partition(' ')

if len(field) == 40:

line_nr, count = value.split(' ')[1:]

line_from = int(line_nr)

line_to = line_from + int(count)

elif field.startswith('author'):

blame_info[field] = value

if field == 'author-time':

author_date = date.fromtimestamp(int(blame_info['author-time']))

blame_info['author-time'] = author_date.strftime("%d/%m/%Y")

elif field == 'filename':

blame_data.append([line_from, line_to, blame_info.copy()])

ret = ''

items = [id, cwe]

if severity:

items.append(severity)

if classification:

items.extend([classification, guideline])

if htmlfile:

ret += '<%s><a href="%s#line-%d">%d</a></%s>' % (td_th, htmlfile, line, line, td_th)

for item in items:

ret += '<%s>%s</%s>' % (td_th, item, td_th)

else:

items.insert(0,line)

for item in items:

ret += '<%s>%s</%s>' % (td_th, item, td_th)

if message_class:

message_attribute = ' class="%s"' % message_class

else:

message_attribute = ''

ret += '<%s%s>%s</%s>' % (td_th, message_attribute, html_escape(message), td_th)

if timestamp:

ret += '<%s>%s</%s>' % (td_th, timestamp, td_th)

for field in add_author:

if field == 'name':

ret += '<%s>%s</%s>' % (td_th, html_escape(author), td_th)

elif field == 'email':

ret += '<%s>%s</%s>' % (td_th, html_escape(author_mail), td_th)

elif field == 'date':

ret += '<%s>%s</%s>' % (td_th, date, td_th)

if tr_class:

tr_attributes = ' class="%s"' % tr_class

else:

tr_attributes = ''

# https://www.w3.org/TR/CSS2/syndata.html#characters

# Note: for our usage, we don't consider escaped characters

invalid_css_chars = re.compile(r"[^-_a-zA-Z0-9\u00A0-\uFFFF]")

invalid_start = re.compile(r"^([0-9]|-[0-9]|--)")

# Replace forbidden characters by an hyphen

valid_chars = invalid_css_chars.sub("-", tag)

# Check that the start of the tag doesn't break the rules

start_invalid = invalid_start.match(valid_chars)

if start_invalid:

# otherwise, append a token to make it valid

valid_chars_valid_start = "cpp" + valid_chars

else:

valid_chars_valid_start = valid_chars

errors = []

def wrap(self, *args, **kwargs):

line_no = 1

for i, t in HtmlFormatter.wrap(self, *args, **kwargs):

# If this is a source code line we want to add a span tag at the

# end.

if i == 1:

for error in self.errors:

if error['line'] == line_no:

try:

if error['inconclusive'] == 'true':

# only print verbose msg if it really differs

# from actual message

if error.get('verbose') and (error['verbose'] != error['msg']):

index = t.rfind('\n')

t = t[:index] + HTML_EXPANDABLE_INCONCLUSIVE % (error['msg'], html_escape(error['verbose'].replace("\\012", '\n'))) + t[index + 1:]

else:

t = t.replace('\n', HTML_INCONCLUSIVE % error['msg'])

except KeyError:

if error.get('verbose') and (error['verbose'] != error['msg']):

index = t.rfind('\n')

t = t[:index] + HTML_EXPANDABLE_ERROR % (error['msg'], html_escape(error['verbose'].replace("\\012", '\n'))) + t[index + 1:]

else:

t = t.replace('\n', HTML_ERROR % error['msg'])

line_no = line_no + 1

"""Parses the cppcheck xml file and produces a list of all its errors."""

def __init__(self):

XmlContentHandler.__init__(self)

self.errors = []

self.version = '1'

self.versionCppcheck = ''

self.timestamp = ''

self.report_type = False

def startElement(self, name, attributes):

if name == 'results':

self.version = attributes.get('version', self.version)

if self.version == '1':

self.handleVersion1(name, attributes)

else:

self.handleVersion2(name, attributes)

def handleVersion1(self, name, attributes):

if name != 'error':

return

att_class = attributes.get('classification', '')

att_guide = attributes.get('guideline', '')

if att_class and not self.report_type:

self.report_type = True

self.errors.append({

'file': attributes.get('file', ''),

'line': int(attributes.get('line', 0)),

'locations': [{

'file': attributes.get('file', ''),

'line': int(attributes.get('line', 0)),

}],

'id': attributes['id'],

'severity': attributes['severity'],

'classification': att_class,

'guideline': att_guide,

'timestamp': self.timestamp,

'msg': attributes['msg']

})

def handleVersion2(self, name, attributes):

if name == 'cppcheck':

self.versionCppcheck = attributes['version']

if name == 'error':

att_class = attributes.get('classification', '')

att_guide = attributes.get('guideline', '')

if att_class and not self.report_type:

self.report_type = True

error = {

'locations': [],

'file': '',

'line': 0,

'id': attributes['id'],

'classification': att_class,

'severity': attributes['severity'],

'guideline': att_guide,

'timestamp': self.timestamp,

'msg': attributes['msg'],

'verbose': attributes.get('verbose')

}

if 'inconclusive' in attributes:

error['inconclusive'] = attributes['inconclusive']

if 'cwe' in attributes:

error['cwe'] = attributes['cwe']

self.errors.append(error)

elif name == 'location':

assert self.errors

error = self.errors[-1]

locations = error['locations']

file = attributes['file']

line = int(attributes['line'])

if not locations:

error['file'] = file

error['line'] = line

locations.append({

'file': file,

'line': line,

'info': attributes.get('info')

# Configure all the options this little utility is using.

parser = argparse.ArgumentParser()

parser.add_argument('--title', dest='title',

help='The title of the project.',

default='[project name]')

parser.add_argument('--file', dest='file', action="append",

help='The cppcheck xml output file to read defects '

'from. You can combine results from several '

'xml reports i.e. "--file file1.xml --file file2.xml ..". '

'Default is reading from stdin.')

parser.add_argument('--checkers-report-file', dest='checkers_report',

help='The cppcheck checkers report file as produced '

'with the "--checkers-report" option of cppcheck.')

parser.add_argument('--report-dir', dest='report_dir',

help='The directory where the HTML report content is '

'written.')

parser.add_argument('--source-dir', dest='source_dir',

help='Base directory where source code files can be '

'found.')

parser.add_argument('--add-author-information', dest='add_author_information',

help='Blame information to include. '

'Adds specified author information. '

'Specify as comma-separated list of either "name", "email", "date" or "n","e","d". '

'Default: "n,e,d"')

parser.add_argument('--source-encoding', dest='source_encoding',

help='Encoding of source code.', default='utf-8')

parser.add_argument('--blame-options', dest='blame_options',

help='[-w, -M] blame options which you can use to get author and author mail '

'-w --> not including white spaces and returns original author of the line '

'-M --> not including moving of lines and returns original author of the line')

# Parse options and make sure that we have an output directory set.

options = parser.parse_args()

try:

sys.argv[1]

except IndexError: # no arguments give, print --help

parser.print_help()

sys.exit(0)

if not options.report_dir:

parser.error('No report directory set.')

# Get the directory where source code files are located.

source_dir = os.getcwd()

if options.source_dir:

source_dir = options.source_dir

add_author_information = []

if options.add_author_information:

fields = [x.strip() for x in options.add_author_information.split(',')]

for x in fields:

if x.lower() in ['n', 'name']:

add_author_information.append('name')

elif x.lower() in ['e', 'email']:

add_author_information.append('email')

elif x.lower() in ['d', 'date']:

add_author_information.append('date')

else:

print('Unrecognized value "%s" for author information, using default (name, email, date)' % x)

add_author_information = ['name', 'email', 'date']

break

blame_options = ''

if options.blame_options:

blame_options = options.blame_options

add_author_information = add_author_information or ['name', 'email', 'date']

# Parse the xml from all files defined in file argument

# or from stdin. If no input is provided, stdin is used

# Produce a simple list of errors.

print('Parsing xml report.')

try:

contentHandler = CppCheckHandler()

for fname in options.file or [sys.stdin]:

if options.file is not None:

t = os.path.getmtime(fname)

else:

t = time.time()

t_s = time.ctime(t)

if t_s is not None:

contentHandler.timestamp = t_s

xml_parse(fname, contentHandler)

except (XmlParseException, ValueError) as msg:

print('Failed to parse cppcheck xml file: %s' % msg)

sys.exit(1)

# We have a list of errors. But now we want to group them on

# each source code file. Lets create a files dictionary that

# will contain a list of all the errors in that file. For each

# file we will also generate a HTML filename to use.

files = {}

file_no = 0

for error in contentHandler.errors:

filename = error['file']

if filename not in files:

files[filename] = {

'errors': [], 'htmlfile': str(file_no) + '.html'}

file_no = file_no + 1

files[filename]['errors'].append(error)

# Make sure that the report directory is created if it doesn't exist.

print('Creating %s directory' % options.report_dir)

if not os.path.exists(options.report_dir):

os.makedirs(options.report_dir)

# Generate a HTML file with syntax highlighted source code for each

# file that contains one or more errors.

print('Processing errors')

decode_errors = []

for filename, data in sorted(files.items()):

htmlfile = data['htmlfile']

errors = []

for error in data['errors']:

for location in error['locations']:

if filename == location['file']:

newError = dict(error)

del newError['locations']

newError['line'] = location['line']

if location.get('info'):

newError['msg'] = location['info']

newError['severity'] = 'information'

newError['classification'] = ''

newError['guideline'] = ''

del newError['verbose']

errors.append(newError)

lines = []

for error in errors:

lines.append(error['line'])

if filename == '':

continue

source_filename = os.path.join(source_dir, filename)

try:

with io.open(source_filename, 'r', encoding=options.source_encoding) as input_file:

content = input_file.read()

except IOError:

if error['id'] != 'unmatchedSuppression':

sys.stderr.write("ERROR: Source file '%s' not found.\n" %

source_filename)

continue

except UnicodeDecodeError:

sys.stderr.write("WARNING: Unicode decode error in '%s'.\n" %

source_filename)

decode_errors.append(source_filename[2:]) # "[2:]" gets rid of "./" at beginning

continue

htmlFormatter = AnnotateCodeFormatter(linenos=True,

style='colorful',

hl_lines=lines,

lineanchors='line',

encoding=options.source_encoding)

htmlFormatter.errors = errors

with io.open(os.path.join(options.report_dir, htmlfile), 'w', encoding='utf-8') as output_file:

output_file.write(HTML_HEAD %

(options.title,

htmlFormatter.get_style_defs('.highlight'),

options.title,

': ' + filename))

output_file.write(HTML_HEAD_END)

output_file.write(HTML_MENU % (filename.split('/')[-1]))

for error in sorted(errors, key=lambda k: k['line']):

output_file.write("<a href=\"%s#line-%d\"> %s %s</a>" % (data['htmlfile'], error['line'], error['id'], error['line']))

output_file.write(HTML_MENU_END)

try:

lexer = guess_lexer_for_filename(source_filename, '', stripnl=False)

except ClassNotFound:

try:

lexer = guess_lexer(content, stripnl=False)

except ClassNotFound:

sys.stderr.write("ERROR: Couldn't determine lexer for the file' " + source_filename + " '. Won't be able to syntax highlight this file.")

output_file.write("\n <tr><td colspan=\"5\"> Could not generate content because pygments failed to determine the code type.</td></tr>")

output_file.write("\n <tr><td colspan=\"5\"> Sorry about this.</td></tr>")

continue

if options.source_encoding:

lexer.encoding = options.source_encoding

output_file.write(

highlight(content, lexer, htmlFormatter).decode(

options.source_encoding))

output_file.write(HTML_FOOTER % contentHandler.versionCppcheck)

print(' ' + filename)

# Generate a master index.html file that will contain a list of

# all the errors created.

print('Creating index.html')

with io.open(os.path.join(options.report_dir, 'index.html'),

'w') as output_file:

stats_count = 0

stats = []

filter_enabled = {}

for filename, data in sorted(files.items()):

for error in data['errors']:

stats.append(error['id']) # get the stats

if contentHandler.report_type:

filter_enabled[error['severity']] = False

filter_enabled[error['classification']] = True

else:

filter_enabled[error['severity']] = True

filter_enabled[error['classification']] = False

filter_enabled['clang-tidy' if error['id'].startswith('clang-tidy-') else 'cppcheck'] = True

stats_count += 1

counter = Counter(stats)

stat_html = []

# the following lines sort the stat primary by value (occurrences),

# but if two IDs occur equally often, then we sort them alphabetically by warning ID

try:

cnt_max = counter.most_common()[0][1]

except IndexError:

cnt_max = 0

try:

cnt_min = counter.most_common()[-1][1]

except IndexError:

cnt_min = 0

stat_fmt = "\n <tr><td><input type=\"checkbox\" class=\"idToggle\" onclick=\"toggleDisplay(this)\" id=\"{}\" name=\"{}\" checked></td><td>{}</td><td>{}</td></tr>"

for occurrences in reversed(range(cnt_min, cnt_max + 1)):

for _id in [k for k, v in sorted(counter.items()) if v == occurrences]:

stat_html.append(stat_fmt.format(

to_css_selector(_id),

to_css_selector(_id),

dict(counter.most_common())[_id],

_id

))

output_file.write(HTML_HEAD % (options.title, '', options.title, ''))

output_file.write(filter_bar(filter_enabled))

output_file.write(HTML_HEAD_END)

output_file.write(HTML_MENU.replace('id="menu"', 'id="menu_index"', 1).replace("Defects:", "Defect summary", 1) % (''))

output_file.write('\n <label><input type="checkbox" class=\"idToggle\" onclick="toggleAll()" checked> Toggle all</label>')

output_file.write('\n <table>')

output_file.write('\n <tr><th>Show</th><th>#</th><th>Defect ID</th></tr>')

output_file.write(''.join(stat_html))

output_file.write('\n <tr><td></td><td>' + str(stats_count) + '</td><td>total</td></tr>')

output_file.write('\n </table>')

output_file.write('\n <p><a href="stats.html">Statistics</a></p>')

if options.checkers_report:

output_file.write('\n <p><a href="checkers.html">Checkers</a></p>')

output_file.write(HTML_MENU_END.replace("content", "content_index", 1))

output_file.write('\n <table class=\"summaryTable\">')

if contentHandler.report_type:

output_file.write(

'\n %s' %

tr_str('th', 'Line', 'Id', 'CWE', '', 'Classification', 'Guideline', 'Message', 'Timestamp',

'Author', 'Author mail', 'Date (DD/MM/YYYY)', add_author=add_author_information))

else:

output_file.write(

'\n %s' %

tr_str('th', 'Line', 'Id', 'CWE', 'Severity', '', '', 'Message', 'Timestamp', 'Author', 'Author mail', 'Date (DD/MM/YYYY)', add_author=add_author_information))

for filename, data in sorted(files.items()):

file_error = filename in decode_errors or filename.endswith('*')

is_file = filename != '' and not file_error

row_content = filename if file_error else "<a href=\"%s\">%s</a>" % (data['htmlfile'], filename)

htmlfile = data.get('htmlfile') if is_file else None

output_file.write("\n <tbody class=\"fileEntry\">")

output_file.write("\n <tr><td colspan=\"5\">%s</td></tr>" % row_content)

if filename in decode_errors:

output_file.write("\n <tr><td colspan=\"5\">Could not generated due to UnicodeDecodeError</td></tr>")

sorted_errors = sorted(data['errors'], key=lambda k: k['line'])

blame_data = git_blame(sorted_errors, source_dir, filename, blame_options) if add_author_information else []

for error in sorted_errors:

git_blame_dict = blame_lookup(blame_data, error['line'])

message_class = None

try:

if error['inconclusive'] == 'true':

message_class = 'inconclusive'

error['severity'] += ", inconcl."

except KeyError:

pass

cwe_url = ""

try:

if error['cwe']:

cwe_url = "<a href=\"https://cwe.mitre.org/data/definitions/" + error['cwe'] + ".html\">" + error['cwe'] + "</a>"

except KeyError:

pass

if error['severity'] in ['error', 'warning']:

message_class = error['severity']

line = error["line"] if is_file else ""

_severity = error.get('severity', '')

_classification = error.get('classification', '')

_guideline = error.get('guideline', '')

if contentHandler.report_type:

_severity = ''

if not _classification:

_classification = 'None'

_guideline = 'None'

output_file.write(

'\n %s' %

tr_str('td', line, error["id"], cwe_url, _severity, _classification, _guideline, error["msg"], error["timestamp"],

git_blame_dict.get('author', 'Unknown'), git_blame_dict.get('author-mail', '---'),

git_blame_dict.get('author-time', '---'),

tr_class=to_css_selector(error["id"]) + ' sev_' + _severity +' class_' + _classification + ' issue',

message_class=message_class,

add_author=add_author_information,

htmlfile=htmlfile))

output_file.write("\n </tbody>")

output_file.write('\n </table>')

output_file.write(HTML_FOOTER % contentHandler.versionCppcheck)

if decode_errors:

sys.stderr.write("\nGenerating html failed for the following files: " + ' '.join(decode_errors))

sys.stderr.write("\nConsider changing source-encoding (for example: \"htmlreport ... --source-encoding=\"iso8859-1\"\"\n")

print('Creating style.css file')

with io.open(os.path.join(options.report_dir, 'style.css'), 'w') as css_file:

css_file.write(STYLE_FILE)

print("Creating stats.html (statistics)\n")

stats_countlist = {}

for filename, data in sorted(files.items()):

if filename == '':

continue

stats_tmplist = []

for error in sorted(data['errors'], key=lambda k: k['line']):

stats_tmplist.append(error['severity'])