/usr/share/doc/gnat-gps/html/Customizing-the-Debugger.html

<html lang="en">
<head>
<title>Customizing the Debugger - Using the GNAT Programming Studio</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using the GNAT Programming Studio">
<meta name="generator" content="makeinfo 4.13">
<link title="Top" rel="start" href="index.html#Top">
<link rel="up" href="Debugging.html#Debugging" title="Debugging">
<link rel="prev" href="The-Debugger-Console.html#The-Debugger-Console" title="The Debugger Console">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
<!--
Copyright (C) 2002-2010 AdaCore.

This document is free; 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 document 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 `http://www.gnu.org/licenses/'.-->
<meta http-equiv="Content-Style-Type" content="text/css">
<style type="text/css"><!--
  pre.display { font-family:inherit }
  pre.format  { font-family:inherit }
  pre.smalldisplay { font-family:inherit; font-size:smaller }
  pre.smallformat  { font-family:inherit; font-size:smaller }
  pre.smallexample { font-size:smaller }
  pre.smalllisp    { font-size:smaller }
  span.sc    { font-variant:small-caps }
  span.roman { font-family:serif; font-weight:normal; } 
  span.sansserif { font-family:sans-serif; font-weight:normal; } 
pre.smallexample {background-color:rgb(240,240,240);
                     font-family: courier new,courier,fixed;
                     font-size: 14px;
                     margin: 0px 40px 0px 40px;
                     border-width: 1px 2px 2px 1px;
                     border-top-style: dotted;
                     border-left-style: dotted;
                     border-right-style: solid;
                     border-bottom-style: solid;
                     border-color: black;}
   code             {color:black;
                     font-family: courier new,courier,fixed;
                     font-size: 14px;}
   body             {font-family: arial,helvetica,sans-serif;
                     font-size: 16px;
                     max-width: 800px;
                     text-align: justify}
   samp             {font-family: courier new,courier,fixed;
                     font-size: 14px}
                    
--></style>
</head>
<body>
<div class="node">
<a name="Customizing-the-Debugger"></a>
<p>
Previous:&nbsp;<a rel="previous" accesskey="p" href="The-Debugger-Console.html#The-Debugger-Console">The Debugger Console</a>,
Up:&nbsp;<a rel="up" accesskey="u" href="Debugging.html#Debugging">Debugging</a>
<hr>
</div>

<h3 class="section">11.9 Customizing the Debugger</h3>

<p><a name="index-debugger-579"></a><!--  -->

<p class="noindent">GPS is a high-level interface to several debugger backends, in particular gdb. 
Each back end has its own strengths, but you can enhance the command line
interface to these backends through GPS, using Python.

   <p>This section will provide a small such example. The idea is to provide the
notion of "alias" in the debugger console. For example, this can be used so
that you type "foo", and this really executes a longer command, like displaying
the value of a variable with a long name.

   <p><code>gdb</code> already provides this feature through the <code>define</code> keywords,
but we will in fact rewrite that feature in terms of python.

   <p>GPS provides an extensive Python API to interface with each of the running
debugger. In particular, it provides the function "send", which can be used
to send a command to the debugger, and get its output, and the function
"set_output", which can be used when you implement your own functions.

   <p>It also provides, through <code>hook</code>, the capability to monitor the state of
the debugger back-end. In particular, one such hook,
<code>debugger_command_action_hook</code> is called when the user has typed a
command in the debugger console, and before the command is executed. This can
be used to add your own commands. The example below uses this hook.

   <p>Here is the code:

<pre class="smallexample">     import GPS
     
     aliases={}
     
     def set_alias (name, command):
        """Set a new debugger alias. Typing this alias in a debugger window
           will then execute command"""
        global aliases
        aliases[name] = command
     
     def execute_alias (debugger, name):
        return debugger.send (aliases[name], output=False)
     
     def debugger_commands (hook, debugger, command):
        global aliases
        words = command.split()
        if words[0] == "alias":
           set_alias (words[1], " ".join (words [2:]))
           return True
        elif aliases.has_key (words [0]):
           debugger.set_output (execute_alias (debugger, words[0]))
           return True
        else:
           return False
     
     GPS.Hook ("debugger_command_action_hook").add (debugger_commands)
</pre>
   <p>The list of aliases is stored in the global variable <code>aliases</code>, which
is modified by <code>set_alias</code>. Whenever the user executes an alias, the
real command send to the debugger is sent through <code>execute_alias</code>.

   <p>The real part of the work is done by <code>debugger_commands</code>. If the user
is executing the <code>alias</code> command, it defines a new alias. Otherwise, if
he typed the name of an alias, we really want to execute that alias. Else,
we let the debugger back-end handle that command.

   <p>After you have copied this example in the <samp><span class="file">$HOME/.gps/plug-ins</span></samp> directory,
you can start a debugger as usual in GPS, and type the following in its
console:

<pre class="smallexample">        (gdb) alias foo print a_long_long_name
        (gdb) foo
</pre>
   <p>The first command defines the alias, the second line executes it.

   <p>This alias can also be used within the <code>graph display</code> command, so that
the value of the variable is in fact displayed in the data window automatically,
for instance:

<pre class="smallexample">        (gdb) graph display `foo`
</pre>
   <p>Other examples can be programmed. You could write complex python functions,
which would for instance query the value of several variables, and pretty
print the result. This complex python function can then be called from the
debugger console, or automatically every time the debugger stops through the
<code>graph display</code> command.

<!--  -->
   </body></html>
gnat-gps-doc 5.0-6 / usr / share / doc / gnat-gps / html / Customizing-the-Debugger.html
