perf jevents: Sort JSON files entries

_arch_std_events = {}

# Track whether an events table is currently being defined and needs closing.

_close_table = False

# Events to write out when the table is closed

_pending_events = []

def removesuffix(s: str, suffix: str) -> str:

      eventcode |= int(jd['ExtSel']) << 8

    configcode = int(jd['ConfigCode'], 0) if 'ConfigCode' in jd else None

    self.name = jd['EventName'].lower() if 'EventName' in jd else None

    self.topic = ''

    self.compat = jd.get('Compat')

    self.desc = fixdesc(jd.get('BriefDescription'))

    self.long_desc = fixdesc(jd.get('PublicDescription'))

        s += f'\t{attr} = {value},\n'

    return s + '}'

  def to_c_string(self, topic_local: str) -> str:

  def to_c_string(self) -> str:

    """Representation of the event as a C struct initializer."""

    def attr_string(attr: str, value: str) -> str:

      return attr_string(attr, getattr(self, attr))

    s = '{\n'

    s += f'\t.topic = "{topic_local}",\n'

    for attr in [

        'aggr_mode', 'compat', 'deprecated', 'desc', 'event', 'long_desc',

        'metric_constraint', 'metric_expr', 'metric_group', 'metric_name',

        'name', 'perpkg', 'pmu', 'unit'

        'name', 'perpkg', 'pmu', 'topic', 'unit'

    ]:

      s += str_if_present(self, attr)

    s += '},\n'

    return s

def read_json_events(path: str) -> Sequence[JsonEvent]:

def read_json_events(path: str, topic: str) -> Sequence[JsonEvent]:

  """Read json events from the specified file."""

  try:

    return json.load(open(path), object_hook=lambda d: JsonEvent(d))

    result = json.load(open(path), object_hook=JsonEvent)

  except BaseException as err:

    print(f"Exception processing {path}")

    raise

  for event in result:

    event.topic = topic

  return result

def preprocess_arch_std_files(archpath: str) -> None:

  global _arch_std_events

  for item in os.scandir(archpath):

    if item.is_file() and item.name.endswith('.json'):

      for event in read_json_events(item.path):

      for event in read_json_events(item.path, topic=''):

        if event.name:

          _arch_std_events[event.name.lower()] = event

  _close_table = True

def print_events_table_entries(item: os.DirEntry, topic: str) -> None:

  """Create contents of an events table."""

def add_events_table_entries(item: os.DirEntry, topic: str) -> None:

  """Add contents of file to _pending_events table."""

  if not _close_table:

    raise IOError('Table entries missing prefix')

  for event in read_json_events(item.path):

    _args.output_file.write(event.to_c_string(topic))

  for e in read_json_events(item.path, topic):

    _pending_events.append(e)

def print_events_table_suffix() -> None:

  """Optionally close events table."""

  def event_cmp_key(j: JsonEvent):

    def fix_none(s: str):

      if s is None:

        return ''

      return s

    return (not j.desc is None, fix_none(j.topic), fix_none(j.name), fix_none(j.pmu),

            fix_none(j.metric_name))

  global _close_table

  if _close_table:

  if not _close_table:

    return

  global _pending_events

  for event in sorted(_pending_events, key=event_cmp_key):

    _args.output_file.write(event.to_c_string())

    _pending_events = []

  _args.output_file.write("""{

\t.name = 0,

\t.event = 0,

  if not item.is_file() or not item.name.endswith('.json'):

    return

  print_events_table_entries(item, get_topic(item.name))

  add_events_table_entries(item, get_topic(item.name))

def print_mapping_table(archs: Sequence[str]) -> None: