<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/share/gdb/python/gdb/command/xmethods.py</h2><form method='post'><textarea name='content' class='file-edit'># Xmethod commands.
# Copyright 2013-2021 Free Software Foundation, Inc.

# 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 3 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;.

import gdb
import re

&quot;&quot;&quot;GDB commands for working with xmethods.&quot;&quot;&quot;


def validate_xm_regexp(part_name, regexp):
    try:
        return re.compile(regexp)
    except SyntaxError:
        raise SyntaxError(&quot;Invalid %s regexp: %s&quot;, part_name, regexp)


def parse_xm_command_args(arg):
    &quot;&quot;&quot;Parses the arguments passed to a xmethod command.

    Arguments:
        arg: The argument string passed to a xmethod command.

    Returns:
        A 3-tuple: (&lt;locus matching regular expression&gt;,
                    &lt;matcher matching regular expression&gt;,
                    &lt;name matching regular experession&gt;)
    &quot;&quot;&quot;
    argv = gdb.string_to_argv(arg)
    argc = len(argv)
    if argc &gt; 2:
        raise SyntaxError(&quot;Too many arguments to command.&quot;)
    locus_regexp = &quot;&quot;
    matcher_name_regexp = &quot;&quot;
    xm_name_regexp = None
    if argc &gt;= 1:
        locus_regexp = argv[0]
    if argc == 2:
        parts = argv[1].split(&quot;;&quot;, 1)
        matcher_name_regexp = parts[0]
        if len(parts) &gt; 1:
            xm_name_regexp = parts[1]
    if xm_name_regexp:
        name_re = validate_xm_regexp(&quot;xmethod name&quot;, xm_name_regexp)
    else:
        name_re = None
    return (validate_xm_regexp(&quot;locus&quot;, locus_regexp),
            validate_xm_regexp(&quot;matcher name&quot;, matcher_name_regexp),
            name_re)


def get_global_method_matchers(locus_re, matcher_re):
    &quot;&quot;&quot;Returns a dict of matching globally registered xmethods.

    Arguments:
        locus_re: Even though only globally registered xmethods are
                  looked up, they will be looked up only if 'global' matches
                  LOCUS_RE.
        matcher_re: The regular expression matching the names of xmethods.

    Returns:
        A dict of matching globally registered xmethod matchers.  The only
        key in the dict will be 'global'.
    &quot;&quot;&quot;
    locus_str = &quot;global&quot;
    xm_dict = { locus_str: [] }
    if locus_re.match(&quot;global&quot;):
        xm_dict[locus_str].extend(
            [m for m in gdb.xmethods if matcher_re.match(m.name)])
    return xm_dict


def get_method_matchers_in_loci(loci, locus_re, matcher_re):
    &quot;&quot;&quot;Returns a dict of matching registered xmethods in the LOCI.

    Arguments:
        loci: The list of loci to lookup matching xmethods in.
        locus_re: If a locus is an objfile, then xmethod matchers will be
                  looked up in it only if its filename matches the regular
                  expression LOCUS_RE.  If a locus is the current progspace,
                  then xmethod matchers will be looked up in it only if the
                  string &quot;progspace&quot; matches LOCUS_RE.
        matcher_re: The regular expression to match the xmethod matcher
                    names.

    Returns:
        A dict of matching xmethod matchers.  The keys of the dict are the
        filenames of the loci the xmethod matchers belong to.
    &quot;&quot;&quot;
    xm_dict = {}
    for locus in loci:
        if isinstance(locus, gdb.Progspace):
            if not locus_re.match('progspace'):
                continue
            locus_type = &quot;progspace&quot;
        else:
            if not locus_re.match(locus.filename):
                continue
            locus_type = &quot;objfile&quot;
        locus_str = &quot;%s %s&quot; % (locus_type, locus.filename)
        xm_dict[locus_str] = [
            m for m in locus.xmethods if matcher_re.match(m.name)]
    return xm_dict


def print_xm_info(xm_dict, name_re):
    &quot;&quot;&quot;Print a dictionary of xmethods.&quot;&quot;&quot;
    def get_status_string(m):
        if not m.enabled:
            return &quot; [disabled]&quot;
        else:
          return &quot;&quot;

    if not xm_dict:
        return
    for locus_str in xm_dict:
        if not xm_dict[locus_str]:
            continue
        print (&quot;Xmethods in %s:&quot; % locus_str)
        for matcher in xm_dict[locus_str]:
            print (&quot;  %s%s&quot; % (matcher.name, get_status_string(matcher)))
            if not matcher.methods:
                continue
            for m in matcher.methods:
                if name_re is None or name_re.match(m.name):
                    print (&quot;    %s%s&quot; % (m.name, get_status_string(m)))


def set_xm_status1(xm_dict, name_re, status):
    &quot;&quot;&quot;Set the status (enabled/disabled) of a dictionary of xmethods.&quot;&quot;&quot;
    for locus_str, matchers in xm_dict.items():
        for matcher in matchers:
            if not name_re:
                # If the name regex is missing, then set the status of the
                # matcher and move on.
                matcher.enabled = status
                continue
            if not matcher.methods:
                # The methods attribute could be None.  Move on.
                continue
            for m in matcher.methods:
                if name_re.match(m.name):
                    m.enabled = status


def set_xm_status(arg, status):
    &quot;&quot;&quot;Set the status (enabled/disabled) of xmethods matching ARG.
    This is a helper function for enable/disable commands.  ARG is the
    argument string passed to the commands.
    &quot;&quot;&quot;
    locus_re, matcher_re, name_re = parse_xm_command_args(arg)
    set_xm_status1(get_global_method_matchers(locus_re, matcher_re), name_re,
                   status)
    set_xm_status1(
        get_method_matchers_in_loci(
            [gdb.current_progspace()], locus_re, matcher_re),
        name_re,
        status)
    set_xm_status1(
        get_method_matchers_in_loci(gdb.objfiles(), locus_re, matcher_re),
        name_re,
        status)


class InfoXMethod(gdb.Command):
    &quot;&quot;&quot;GDB command to list registered xmethod matchers.

Usage: info xmethod [LOCUS-REGEXP [NAME-REGEXP]]

LOCUS-REGEXP is a regular expression matching the location of the
xmethod matchers.  If it is omitted, all registered xmethod matchers
from all loci are listed.  A locus could be 'global', a regular expression
matching the current program space's filename, or a regular expression
matching filenames of objfiles.  Locus could be 'progspace' to specify that
only xmethods from the current progspace should be listed.

NAME-REGEXP is a regular expression matching the names of xmethod
matchers.  If this omitted for a specified locus, then all registered
xmethods in the locus are listed.  To list only a certain xmethods
managed by a single matcher, the name regexp can be specified as
matcher-name-regexp;xmethod-name-regexp.&quot;&quot;&quot;

    def __init__(self):
        super(InfoXMethod, self).__init__(&quot;info xmethod&quot;,
                                          gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        locus_re, matcher_re, name_re = parse_xm_command_args(arg)
        print_xm_info(get_global_method_matchers(locus_re, matcher_re),
                      name_re)
        print_xm_info(
            get_method_matchers_in_loci(
                [gdb.current_progspace()], locus_re, matcher_re),
            name_re)
        print_xm_info(
            get_method_matchers_in_loci(gdb.objfiles(), locus_re, matcher_re),
            name_re)


class EnableXMethod(gdb.Command):
    &quot;&quot;&quot;GDB command to enable a specified (group of) xmethod(s).

Usage: enable xmethod [LOCUS-REGEXP [NAME-REGEXP]]

LOCUS-REGEXP is a regular expression matching the location of the
xmethod matchers.  If it is omitted, all registered xmethods matchers
from all loci are enabled.  A locus could be 'global', a regular expression
matching the current program space's filename, or a regular expression
matching filenames of objfiles.  Locus could be 'progspace' to specify that
only xmethods from the current progspace should be enabled.

NAME-REGEXP is a regular expression matching the names of xmethods
within a given locus.  If this omitted for a specified locus, then all
registered xmethod matchers in the locus are enabled.  To enable only
a certain xmethods managed by a single matcher, the name regexp can be
specified as matcher-name-regexp;xmethod-name-regexp.&quot;&quot;&quot;

    def __init__(self):
        super(EnableXMethod, self).__init__(&quot;enable xmethod&quot;,
                                            gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        set_xm_status(arg, True)


class DisableXMethod(gdb.Command):
    &quot;&quot;&quot;GDB command to disable a specified (group of) xmethod(s).

Usage: disable xmethod [LOCUS-REGEXP [NAME-REGEXP]]

LOCUS-REGEXP is a regular expression matching the location of the
xmethod matchers.  If it is omitted, all registered xmethod matchers
from all loci are disabled.  A locus could be 'global', a regular
expression matching the current program space's filename, or a regular
expression filenames of objfiles. Locus could be 'progspace' to specify
that only xmethods from the current progspace should be disabled.

NAME-REGEXP is a regular expression matching the names of xmethods
within a given locus.  If this omitted for a specified locus, then all
registered xmethod matchers in the locus are disabled.  To disable
only a certain xmethods managed by a single matcher, the name regexp
can be specified as matcher-name-regexp;xmethod-name-regexp.&quot;&quot;&quot;

    def __init__(self):
        super(DisableXMethod, self).__init__(&quot;disable xmethod&quot;,
                                             gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        set_xm_status(arg, False)


def register_xmethod_commands():
    &quot;&quot;&quot;Installs the xmethod commands.&quot;&quot;&quot;
    InfoXMethod()
    EnableXMethod()
    DisableXMethod()


register_xmethod_commands()
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fshare%2Fgdb%2Fpython%2Fgdb%2Fcommand'>Back to Directory</a>