<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE article PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY appversion "0.5.0">
<!ENTITY manrevision "2.0">
<!ENTITY date "February 2008">
<!ENTITY app "Nemiver">
<!ENTITY appcmd "nemiver">
<!ENTITY website "http://www.gnome.org/projects/nemiver/">
]>
<!--
(Do not remove this comment block.)
Maintained by the GNOME Documentation Project
http://developer.GNOME.org/projects/gdp
Template version: 2.0 beta
Template last modified Jan 30, 2002

-->
<!-- =============Document Header ============================= -->
<?chunk-depth 2?>
<article id="index" lang="oc">
  <!-- please do not change the id; for translations, change lang to -->
  <!-- appropriate code -->
  <articleinfo>
    <title>Manual de Nemiver</title>
    <copyright lang="en">
      <year>2008</year>
      <holder>Jonathon Jongsma</holder>
    </copyright>
    <!-- translators: uncomment this:

    <copyright>
      <year>2003</year>
      <holder>ME-THE-TRANSLATOR (Latin translation)</holder>
    </copyright>

    -->
    <publisher role="maintainer">
      <publishername>Projècte Nemiver</publishername>
    </publisher>
    <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="legal.xml"/>
    <authorgroup>
      <author lang="en">
        <firstname>Jonathon</firstname>
        <surname>Jongsma</surname>
        <affiliation>
          <orgname>GNOME</orgname>
        </affiliation>
      </author>
      <!-- This is appropriate place for other contributors: translators,
      maintainers,  etc. Commented out by default.
      <othercredit role="translator">
        <firstname>Latin</firstname>
        <surname>Translator 1</surname>
        <affiliation>
          <orgname>Latin Translation Team</orgname>
          <address> <email>translator@gnome.org</email> </address>
        </affiliation>
        <contrib>Latin translation</contrib>
      </othercredit>
      -->
    </authorgroup>
    <!-- According to GNU FDL, revision history is mandatory if you are -->
    <!-- modifying/reusing someone else's document.  If not, you can omit it. -->
    <revhistory>
      <!-- Remember to remove the &manrevision; entity from the revision entries other
      than the current revision. -->
      <revision lang="en">
        <revnumber>1.0</revnumber>
        <date>2007</date>
        <revdescription>
          <para lang="en">Initial version</para>
        </revdescription>
      </revision>
      <revision lang="en">
        <revnumber>2.0</revnumber>
        <date>2008</date>
        <revdescription>
          <para lang="en">Updated for 0.5.0 Release</para>
        </revdescription>
      </revision>
    </revhistory>
    <releaseinfo lang="en"> This manual describes version 0.5.0 of Nemiver.
    </releaseinfo>
    <legalnotice>
      <title lang="en">Feedback</title>
      <para lang="en">
        To report a bug or make a suggestion regarding the
        <application>Nemiver</application> application or this manual, see the
        <ulink url="http://www.gnome.org/projects/nemiver/" type="http">Nemiver Project website</ulink>.
      </para>
      <!-- Translators may also add here feedback address for translations -->
    </legalnotice>
    <abstract role="description">
      <para lang="en">
        Nemiver is a graphical debugger for the GNOME desktop environment.
      </para>
    </abstract>
  </articleinfo>
  <indexterm lang="en">
    <primary>Nemiver</primary>
  </indexterm>
  <indexterm lang="en">
    <primary>debugger</primary>
  </indexterm>
  <indexterm lang="en">
    <primary>gdb</primary>
  </indexterm>
  <!-- ============= Document Body ============================= -->
  <!-- ============= Introduction ============================== -->
  <sect1 id="nemiver-sect-intro">
    <title lang="en">Overview</title>
    <para lang="en">
      Nemiver is an ongoing effort to write a standalone graphical debugger that
      integrates well in the GNOME desktop environment.  It currently features a
      backend which uses the well known GNU Debugger gdb to debug C / C++
      programs.
    </para>
    <sect2 id="nemiver-sect-perspectives">
      <title lang="en">Perspectives</title>
      <para lang="en">
          Nemiver is designed as a generic graphical
          <interface>workbench</interface> and a plugin system that can offer
          several different perspectives.  Currently the only perspective
          provided is a debugging perspective, but in the future, there may be
          perspectives added for memory debugging with
          <application>valgrind</application>, or for profiling tools such as
          <application>oprofile</application>.
      </para>
    </sect2>
  </sect1>
  <sect1 id="nemiver-sect-getting-started">
    <title>Per començar</title>
    <para lang="en">
      This section explains how to start Nemiver and gives a basic overview of the
      application.
    </para>
    <sect2 id="nemiver-sect-starting">
      <title>Aviar Nemiver</title>
      <para lang="en">
        You can start Nemiver in the following ways:
      </para>
      <variablelist>
        <varlistentry>
          <term>Menut <guimenu>Applications</guimenu></term>
          <listitem>
            <para lang="en">
              Choose <menuchoice><guisubmenu>Programming</guisubmenu><guimenuitem>Nemiver Debugger</guimenuitem></menuchoice>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Linha de comanda</term>
          <listitem>
            <para lang="en">
              Type <command>nemiver</command>, then press
              <keycap>Return</keycap>.
            </para>
            <tip>
              <title>Opcions de linha de comanda suplementàrias</title>
              <para lang="en">
                You can find a list of options that can be passed to Nemiver on the
                command line by typing <command>nemiver --help-all</command>.
              </para>
            </tip>
          </listitem>
        </varlistentry>
      </variablelist>
    </sect2>
    <sect2 id="nemiver-sect-window">
      <title>La fenèstra de Nemiver</title>
      <para lang="en">
        When you start Nemiver, you will see a window that looks very much like
        the following:
      </para>
      <figure id="nemiver-window">
        <title>Fenèstra de Nemiver</title>
        <screenshot>
          <mediaobject lang="en">
            <imageobject>
              <imagedata fileref="figures/main-window.png" format="PNG"/>
            </imageobject>
            <textobject>
              <phrase>Shows Nemiver main window.</phrase>
            </textobject>
          </mediaobject>
        </screenshot>
      </figure>
      <para lang="en">
        The <application>Nemiver</application> window contains the following
        elements:
      </para>
      <variablelist>
        <varlistentry>
          <term>Barra de menuts</term>
          <listitem>
            <para lang="en">
              The menus on the menubar contain all of the commands you need to
              use <application>Nemiver</application>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Barra d'espleches</term>
          <listitem>
            <para lang="en">
              The toolbar contains the basic debugging actions that can be used
              to run or step through the program being debugged.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term lang="en">Source View Notebook</term>
          <listitem>
            <para lang="en">
              When source files are open, this area will display source files of
              the program being debugged.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term lang="en">Status Notebook</term>
          <listitem>
            <para lang="en">
              The Status notebook contains several tabs for displaying
              information about the program being debugged.  These include the
              following:
            </para>
            <variablelist>
              <varlistentry>
                <term lang="en">
                  Call Stack
                </term>
                <listitem>
                  <para lang="en">
                    Displays the current state of the call stack of the program
                    being debugged.
                  </para>
                </listitem>
              </varlistentry>
              <varlistentry>
                <term>Variables</term>
                <listitem>
                  <para lang="en">
                    Displays a list of all local variables and function
                    arguments, in addition to their values and types.
                  </para>
                </listitem>
              </varlistentry>
              <varlistentry>
                <term lang="en">
                  Target Terminal
                </term>
                <listitem>
                  <para lang="en">
                    If the program being debugged prints any output to the
                    terminal, it will be displayed in this tab.
                  </para>
                </listitem>
              </varlistentry>
              <varlistentry>
                <term lang="en">
                  Breakpoints
                </term>
                <listitem>
                  <para lang="en">
                    This tab displays a list of all breakpoints that have been
                    set.  You can view the source code of a particular
                    breakpoint by double-clicking an item in the list or by
                    right-clicking and selecting <menuchoice><guimenuitem>Go to
                        Source</guimenuitem></menuchoice> from the menu.  In
                    addition, breakpoints can be deleted, enabled, or disabled
                    in this tab. For more information about breakpoints, see
                    <xref linkend="nemiver-sect-breakpoints"/>.
                  </para>
                </listitem>
              </varlistentry>
              <varlistentry>
                <term lang="en">
                    Registers
                </term>
                <listitem>
                  <para lang="en">
                      This tab displays all of the CPU registers and their
                      values.  For more information, see <xref linkend="nemiver-sect-registers"/>.
                  </para>
                </listitem>
              </varlistentry>
              <varlistentry>
                <term lang="en">
                    Memory
                </term>
                <listitem>
                  <para lang="en">
                    This tab displays a view of the current state of a specific
                    memory location.  For more information, see <xref linkend="nemiver-sect-memory"/>.
                  </para>
                </listitem>
              </varlistentry>
            </variablelist>
          </listitem>
        </varlistentry>
      </variablelist>
    </sect2>
    <sect2 id="nemiver-sect-loading-program">
      <title lang="en">Choosing a Program to Debug</title>
      <para lang="en">There are several ways to begin debugging a program.  Nemiver
            allows you to load a local executable file, load a core file, attach
            to a running process, or connect to a remote debugging server.
        </para>
      <sect3 id="nemiver-sect-starting-executable">
        <title lang="en">Debugging an Executable Program</title>
        <sect4>
          <title lang="en">Using the Workbench</title>
          <para lang="en">
          To select an executable program to debug, select
          <menuchoice><guimenu>
              File
            </guimenu><guimenuitem>
              Execute...
            </guimenuitem></menuchoice>, which should display the following dialog:
        </para>
          <figure id="nemiver-execute-dialog">
            <title lang="en">Execute Dialog</title>
            <screenshot>
              <mediaobject lang="en">
                <imageobject>
                  <imagedata fileref="figures/execute-dialog.png" format="PNG"/>
                </imageobject>
                <textobject>
                  <phrase>Shows dialog for selecting an executable to run</phrase>
                </textobject>
              </mediaobject>
            </screenshot>
          </figure>
          <para lang="en">
          In this dialog, you can select the program to be debugged, any
          arguments or options to be passed to the executable on the command line, the
          working directory to run the executable in, and any Environment
          Variables that should be set when the executable is being debugged.
        </para>
        </sect4>
        <sect4>
          <title lang="en">Using the Command Line</title>
          <para lang="en">
          To start an executable program to debug from the command line, simply
          specify the name of the executable.  You can either give an absolute
          path to the executable, or if it is in the path, you can simply give
          the basename of the executable.  For example, if
          <filename>/usr/bin</filename> is in your path, both of the following
          are valid:
        </para>
          <itemizedlist>
            <listitem>
              <para lang="en">
                <command>nemiver /usr/bin/progname</command>
              </para>
            </listitem>
            <listitem>
              <para lang="en">
                <command>nemiver progname</command>
              </para>
            </listitem>
          </itemizedlist>
          <tip>
            <title lang="en">Passing Options on the Command Line</title>
            <para lang="en">
            If you would like to pass command line options to the program that
            you are debugging, you should enclose them in quotes to prevent
            Nemiver from processing them:
            <command>nemiver "prognam --arg1 --arg2"</command>.
          </para>
          </tip>
        </sect4>
      </sect3>
      <sect3 id="nemiver-sect-attach">
        <title lang="en">Attaching to a Running Program</title>
        <sect4>
          <title lang="en">Using the Workbench</title>
          <para lang="en">
          Select the menu item 
          <menuchoice><guimenu>
              File
            </guimenu><guimenuitem>
              Attach to Running Program...
            </guimenuitem></menuchoice>, which should display the following dialog:
        </para>
          <figure id="nemiver-attach-dialog">
            <title lang="en">Attach Dialog</title>
            <screenshot>
              <mediaobject lang="en">
                <imageobject>
                  <imagedata fileref="figures/attach-dialog.png" format="PNG"/>
                </imageobject>
                <textobject>
                  <phrase>Shows dialog for attaching to a running program</phrase>
                </textobject>
              </mediaobject>
            </screenshot>
          </figure>
          <para lang="en">
          Select a process from the list and click
          <guibutton>OK</guibutton> to start debugging the selected program.
          There may be a lot of processes listed in the dialog, so you can
          filter the list to only ones that that you are interested in by typing
          some text into the text entry located just below the list.
        </para>
        </sect4>
        <sect4>
          <title lang="en">Using the Command Line</title>
          <para lang="en">
          To attach to a running program from the command line, use the
          <option>--attach</option> option.  The <option>--attach</option>
          option accepts either a pid or a process name.  So, for example, to
          debug the running process <command>foo</command> which has a pid of
          1121, you could either type <command>nemiver --attach foo</command>
          or <command>nemiver --attach 1121</command>.
        </para>
        </sect4>
      </sect3>
      <sect3 id="nemiver-sect-core-file">
        <title lang="en">Loading a Core File</title>
        <sect4>
          <title lang="en">Using the Workbench</title>
          <para lang="en">
          Select the menu item
          <menuchoice><guimenu>
              File
            </guimenu><guimenuitem>
              Load Core File...
            </guimenuitem></menuchoice>
          to bring up the following dialog, which will let you load a core file:
        </para>
          <figure id="nemiver-load-core-dialog">
            <title lang="en">Load Core File Dialog</title>
            <screenshot>
              <mediaobject lang="en">
                <imageobject>
                  <imagedata fileref="figures/load-core-dialog.png" format="PNG"/>
                </imageobject>
                <textobject>
                  <phrase>Shows dialog for loading a core file</phrase>
                </textobject>
              </mediaobject>
            </screenshot>
          </figure>
        </sect4>
        <sect4>
          <title lang="en">Using the Command Line</title>
          <para lang="en">
          Core files cannot be loaded from the command line.
        </para>
        </sect4>
      </sect3>
      <sect3 id="nemiver-sect-remote">
        <title lang="en">Remote Debugging</title>
        <para lang="en">
            Nemiver allows you to connect to a remote debugging server.
        </para>
        <sect4>
          <title lang="en">Using the Workbench</title>
          <para lang="en">
                To connect to a remote debugging server, select
                <menuchoice><guimenu>File</guimenu><guimenuitem>Connect to
                        Remote Target...</guimenuitem></menuchoice>
            </para>
          <screenshot>
            <mediaobject lang="en">
              <imageobject>
                <imagedata fileref="figures/connect-remote-dialog.png" format="PNG"/>
              </imageobject>
              <textobject>
                <phrase>Remote Debugging Dialog</phrase>
              </textobject>
            </mediaobject>
          </screenshot>
          <para lang="en">
              Select the executable to load and the location where any shared
              libraries are located, and then fill in the details about
              connecting to the remote server.
          </para>
        </sect4>
        <sect4>
          <title lang="en">Using the Command Line</title>
          <para lang="en">
              Nemiver does not provide a way to connect to a remote server using
              the command line
        </para>
        </sect4>
      </sect3>
    </sect2>
  </sect1>
  <sect1 id="nemiver-sect-using">
    <title>Utilizar Nemiver</title>
    <para lang="en">
        This section describes how to use Nemiver to debug your application.
    </para>
    <sect2 id="nemiver-sect-basic-debugging">
      <title lang="en">Basic Debugging Actions</title>
      <para lang="en">
        The basic debugging actions are available on the main toolbar, in the
        <guimenu>Debug</guimenu> menu, and as keyboard shortcuts.
        The most common actions are listed below:
      </para>
      <variablelist>
        <varlistentry>
          <term>Contunhar</term>
          <listitem>
            <para lang="en">
              Starts the program.  The program will run until it hits a
              breakpoint or until the program ends, unless it is interrupted
              manually by the user by clicking <action>Stop</action>.  This
              action can be activated from the keyboard with
              <keycap>F5</keycap>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Seguent</term>
          <listitem>
            <para lang="en">
              Executes the next statement, and stops when it reaches the next
              line in this file.  Some debuggers may call this action "Step
              Over".  This action can be activated from the keyboard with
              <keycap>F6</keycap>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Pas</term>
          <listitem>
            <para lang="en">
              Executes the next statement, stepping into the function if possible.
              Some debuggers may call this action "Step In".  This action can be
              activated from the keyboard with <keycap>F7</keycap>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Sortir</term>
          <listitem>
            <para lang="en">
              Finishes execution of the current function and stops when it
              returns to the calling function.  This action can be
              activated from the keyboard with
              <keycombo><keycap>Shift</keycap><keycap>F7</keycap></keycombo>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Tornar lançar</term>
          <listitem>
            <para lang="en">
              Reloads the current executable and starts execution from the beginning.
              This action can be activated from the keyboard with
              <keycombo><keycap>Shift</keycap><keycap>F5</keycap></keycombo>.
            </para>
          </listitem>
        </varlistentry>
        <varlistentry>
          <term>Arrestar</term>
          <listitem>
            <para lang="en">
              Manually interrupt execution of the program.  This action is only
              available when the debugger is running the executable (e.g. after
              a user has clicked <action>Continue</action>).  This action can be
              activated from the keyboard with <keycap>F9</keycap>.
            </para>
          </listitem>
        </varlistentry>
      </variablelist>
      <para lang="en">
        By default, after loading an executable, Nemiver creates a breakpoint at
        <function>main()</function>, so when execution reaches
        <function>main()</function>, it will stop and wait for input.  You can
        then step through the program, examine variables (see <xref linkend="nemiver-sect-inspecting-variables"/>), or set additional
        breakpoints (see <xref linkend="nemiver-sect-breakpoints"/>).
      </para>
    </sect2>
    <sect2 id="nemiver-sect-inspecting-variables">
      <title lang="en">Inspecting Variables</title>
      <para lang="en">
        Nemiver displays a list of all local variables in the
        <interface>Variables</interface> tab of the
        <interface>Status Notebook</interface>.  If you'd like to examine a different variable (or even an arbitrary expression), you can use the <interface>Variable Inspector</interface>.  To bring up the <interface>Variable Inspector</interface>, select
        <menuchoice><guimenu>Debug</guimenu><guimenuitem>Inspect a Variable</guimenuitem></menuchoice>.  When the variable inspector comes up, you'll see a
        window that looks similar to the following:
      </para>
      <screenshot>
        <mediaobject lang="en">
          <imageobject>
            <imagedata fileref="figures/variable-inspector.png" format="PNG"/>
          </imageobject>
          <textobject>
            <phrase>Variable Inspector Dialog</phrase>
          </textobject>
        </mediaobject>
      </screenshot>
      <para lang="en">
        You can type any variable name or a simple expression (such as
        <literal>pFoo-&gt;bar</literal>) into the input box, and if the variable is
        valid and in scope, it will be display details about that expression.
      </para>
      <para lang="en">
        Alternately, if you select the name of a variable in the
        <interface>source editor</interface>, and then launch the
        <interface>Variable Inspector</interface>, it will attempt to display
        information about the selected variable name.
      </para>
      <tip>
        <title lang="en">Keyboard Shortcut</title>
        <para lang="en">
          You can also start the <interface>Variable Inspector</interface> by
          pressing <keycap>F12</keycap>.
        </para>
      </tip>
      <para lang="en">
          Nemiver will also let you display a list of all global variables in an application in a separate dialog.  To display the <interface>Global Variables</interface> dialog, select
          <menuchoice><guimenu>Debug</guimenu><guimenuitem>Show Global Variables</guimenuitem></menuchoice>
          or press
          <keycombo><keycap>Ctrl</keycap><keycap>G</keycap></keycombo>.
      </para>
      <screenshot>
        <mediaobject lang="en">
          <imageobject>
            <imagedata fileref="figures/global-variables-dialog.png" format="PNG"/>
          </imageobject>
          <textobject>
            <phrase>Global Variables Dialog</phrase>
          </textobject>
        </mediaobject>
      </screenshot>
      <warning>
        <para lang="en">
              For some programs (especially C++ programs), listing all of the
              global variables may take a very long time.
          </para>
      </warning>
    </sect2>
    <sect2 id="nemiver-sect-breakpoints">
      <title lang="en">Setting Breakpoints</title>
      <para lang="en">
        There are several different ways to set breakpoints in Nemiver.  Nemiver
        automatically sets a breakpoint at <function>main()</function> when you
        first begin debugging a new executable.  If you want to set additional
        breakpoints you can do one of the following:
      </para>
      <itemizedlist>
        <listitem>
          <para lang="en">Click in the margin next to the line where you want the
            breakpoint to be set</para>
        </listitem>
        <listitem>
          <para lang="en">Place your cursor on a line where you want the breakpoint to be set and set the breakpoint by either selecting 
            <menuchoice><guimenu>Debug</guimenu><guimenuitem>Toggle Breakpoint at Cursor</guimenuitem></menuchoice>, or by pressing <keycap>F8</keycap>
          </para>
        </listitem>
        <listitem>
          <para lang="en">Set a breakpoint at a specific function name or at a specific location in a file by selecting 
            <menuchoice><guimenu>Debug</guimenu><guimenuitem>Set Breakpoint...</guimenuitem></menuchoice> or by pressing 
            <keycombo><keycap>Ctrl</keycap><keycap>B</keycap></keycombo>.  This will bring up a dialog that looks like the following:
          </para>
          <screenshot>
            <mediaobject lang="en">
              <imageobject>
                <imagedata fileref="figures/set-breakpoint-dialog.png" format="PNG"/>
              </imageobject>
              <textobject>
                <phrase>Set Breakpoint Dialog</phrase>
              </textobject>
            </mediaobject>
          </screenshot>
          <para lang="en">
            You can specify a breakpoint at a particular location in a file, or
            by function name.  If there are more than one function with the same
            name, Nemiver will display a list of all matching functions and ask
            you to pick the one you want.
          </para>
        </listitem>
      </itemizedlist>
      <sect3>
        <title lang="en">Disabled Breakpoints</title>
        <para lang="en">
          Breakpoints can be either enabled or disabled.  The debugger will stop
          execution whenever it reaches an enabled breakpoint but will not be
          affected by any breakpoints in the disabled state.  This allows you to
          temporarily remove a breakpoint without actually deleting it.
        </para>
        <para lang="en">
          To disable or enable a breakpoint, click the checkbox next to the
          breakpoint number you want to enable or disable in the
          <interface>Breakpoints</interface> tab of the <interface>Status
            Notebook</interface>.  Alternately, you can press
          <keycombo><keycap>Shift</keycap><keycap>F8</keycap></keycombo> to enable or disable a breakpoint that is set on the
          line that the cursor is currently on.
        </para>
        <para lang="en">
            The following figures show the difference between enabled and
            disabled breakpoints in the source editor.
        </para>
        <screenshot>
          <mediaobject lang="en">
            <imageobject>
              <imagedata fileref="figures/enabled-breakpoint.png" format="PNG"/>
            </imageobject>
            <textobject>
              <phrase>Illustration of an enabled breakpoint</phrase>
            </textobject>
            <caption><para lang="en">Enabled Breakpoint</para></caption>
          </mediaobject>
        </screenshot>
        <screenshot>
          <mediaobject lang="en">
            <imageobject>
              <imagedata fileref="figures/disabled-breakpoint.png" format="PNG"/>
            </imageobject>
            <textobject>
              <phrase>Illustration of a disabled breakpoint</phrase>
            </textobject>
            <caption><para lang="en">Disabled Breakpoint</para></caption>
          </mediaobject>
        </screenshot>
      </sect3>
      <sect3>
        <title lang="en">Opening Source Files</title>
        <para lang="en">
          Sometimes you don't know exactly the function name or line number
          where you want a breakpoint to be set, so you must open a source file
          to figure it out.  You could just open arbitrary files from the
          filesystem, but Nemiver can also provide a list of source files that
          were used to build the executable and allow you to select from this
          list.  When you select 
          <menuchoice><guimenu>File</guimenu><guimenuitem>Open Source File...</guimenuitem></menuchoice>, the following window should be displayed:
        </para>
        <screenshot>
          <mediaobject lang="en">
            <imageobject>
              <imagedata fileref="figures/open-files-target.png" format="PNG"/>
            </imageobject>
            <textobject>
              <phrase>Shows dialog for opening source files</phrase>
            </textobject>
          </mediaobject>
        </screenshot>
        <para lang="en">
          To select an arbitrary file from the filesystem, choose the
          <guilabel>Select from Filesystem</guilabel> option.  To select from a
          list of files that produced the executable, choose <guilabel>Select
            from Target Executable</guilabel>.
        </para>
        <warning>
          <title lang="en">Determining Source Files for Dynamically Loaded Modules</title>
          <para lang="en">
            If the target executable loads modules at runtime (e.g. using
            <function>dlopen()</function>), Nemiver will not be able to determine
            which files were used to build these modules until they are actually
            loaded.
          </para>
        </warning>
      </sect3>
    </sect2>
    <sect2 id="nemiver-sect-advanced">
      <title lang="en">Advanced Debugging</title>
      <sect3 id="nemiver-sect-registers">
        <title lang="en">Registers</title>
        <para lang="en">
                The register editing widget is located in the
                <interface>Registers</interface> tab of the <interface>Status
                    Notebook</interface>.  Alternately, you can press
                <keycombo><keycap>Alt</keycap><keycap>F5</keycap></keycombo> to
                jump directly to the correct tab.
            </para>
        <screenshot>
          <mediaobject lang="en">
            <imageobject>
              <imagedata fileref="figures/registers-view.png" format="PNG"/>
            </imageobject>
            <textobject>
              <phrase>The Register Editing Widget</phrase>
            </textobject>
          </mediaobject>
        </screenshot>
        <para lang="en">
                This widget shows the current values of all of the CPU
                registers.  You can edit the register values by clicking in the
                <interface>Value</interface> column and entering a new value.
                If the value for the register changed since the last time the
                debugger stopped, it will be highlighted in red.
            </para>
      </sect3>
      <sect3 id="nemiver-sect-memory">
        <title lang="en">Memory</title>
        <para lang="en">
                The memory widget allows you to view a section of memory
                directly.  This enables you to get a lower-level view of what's
                happening while your program is running.
            </para>
        <screenshot>
          <mediaobject lang="en">
            <imageobject>
              <imagedata fileref="figures/memory-view.png" format="PNG"/>
            </imageobject>
            <textobject>
              <phrase>The Memory Editing Widget</phrase>
            </textobject>
          </mediaobject>
        </screenshot>
        <para lang="en">
                To display a segment of memory in the memory view widget, enter
                a memory address in the <interface>Address</interface> field.
                If the address is valid for the program being debugged, the
                memory view will display the memory values starting at the
                specified address.  Memory values can be displayed in byte
                format, word format (2 bytes), or long word format (4 bytes) by
                choosing an option from the <interface>Group By</interface>
                drop-down menu.  The memory values will automatically be updated
                as you step through the program.
            </para>
        <para lang="en">
                In addition to viewing the memory values, you can also use the
                memory widget to modify memory values.  You can edit either the
                hex byte representation (the left-hand section of the memory
                widget), or the ASCII representation (the right-hand section of
                the memory widget).  All changes will be applied immediately.
            </para>
      </sect3>
    </sect2>
  </sect1>
  <sect1 id="nemiver-sect-sessions">
    <title lang="en">Session Save and Restore</title>
    <para lang="en">
      Nemiver can save your debugging sessions for you so that you can resume
      them at a later time.  This includes saving information such as which
      executable is being debugged, what environment variables are set, what
      command-line options are passed to the executable, which files are open,
      and which breakpoints are set so that you can get back to where you left
      off last time as quickly as possible.
    </para>
    <sect2 id="nemiver-sect-saving-sessions">
      <title lang="en">Saving Sessions</title>
      <para lang="en">
        Nemiver will save your session automatically on exit, so you don't even
        have to worry about it.  However, if you want to explicitly save the
        session before closing Nemiver, you can do so by selecting 
        <menuchoice><guimenu>File</guimenu><guimenuitem>Save Session To Disk</guimenuitem></menuchoice>.
      </para>
    </sect2>
    <sect2 id="nemiver-sect-resuming-sessions">
      <title lang="en">Resuming Saved Sessions</title>
      <sect3>
        <title lang="en">Using the Workbench</title>
        <para lang="en">
          Select 
          <menuchoice><guimenu>File</guimenu><guimenuitem>Resume Saved Session...</guimenuitem></menuchoice>
          and select a session from the list.
        </para>
        <figure id="nemiver-sessions-dialog">
          <title lang="en">Session Dialog</title>
          <screenshot>
            <mediaobject lang="en">
              <imageobject>
                <imagedata fileref="figures/sessions-dialog.png" format="PNG"/>
              </imageobject>
              <textobject>
                <phrase>Shows dialog for resuming a saved session</phrase>
              </textobject>
            </mediaobject>
          </screenshot>
        </figure>
      </sect3>
      <sect3>
        <title lang="en">From the Command Line</title>
        <para lang="en">
          If you know the session ID of the session you want to run, you can
          start that debugging session from the command line.  For example, if
          you want to run session number 3, you can do so with the following
          command:
          <command>nemiver --session 3</command>.
        </para>
      </sect3>
    </sect2>
  </sect1>
  <!-- This should be the last section in the manual -->
  <sect1 id="nemiver-sect-about">
    <title>A prepaus de Nemiver</title>
    <para lang="en"><application>Nemiver</application> was written by Dodji Seketeli and
      Jonathon Jongsma, with contributions from many others.  To find more
      information about Nemiver, please visit the <ulink url="http://www.gnome.org/projects/nemiver/" type="http">Nemiver project website</ulink>.
    </para>
    <para lang="en">
      To report a bug or make a suggestion regarding this application or this
      manual, see the Feedback section of the <ulink url="ghelp:user-guide?feedback-bugs" type="help">GNOME User
        Guide</ulink>.
    </para>
    <para lang="en">
      This program is distributed 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. A copy of this license
      can be found at this <ulink url="ghelp:gpl" type="help">link</ulink>, or
      in the file COPYING included with the source code of this program.
    </para>
  </sect1>
</article>
<!--
vim: ts=2 sw=2 et
-->
