<HTML>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<!-- Created on March, 27 2008 by texi2html 1.64 -->
<!--
Written by: Lionel Cons <Lionel.Cons@cern.ch> (original author)
Karl Berry <karl@freefriends.org>
Olaf Bachmann <obachman@mathematik.uni-kl.de>
and many others.
Maintained by: Olaf Bachmann <obachman@mathematik.uni-kl.de>
Send bugs and suggestions to <texi2html@mathematik.uni-kl.de>
-->
<HEAD>
<TITLE>Debugging with GDB: Languages</TITLE>
<META NAME="description" CONTENT="Debugging with GDB: Languages">
<META NAME="keywords" CONTENT="Debugging with GDB: Languages">
<META NAME="resource-type" CONTENT="document">
<META NAME="distribution" CONTENT="global">
<META NAME="Generator" CONTENT="texi2html 1.64">
</HEAD>
<BODY LANG="" BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080" ALINK="#FF0000">
<A NAME="SEC102"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC101"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC103"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_3.html#SEC6"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_14.html#SEC146"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H1> 12. Using GDB with Different Languages </H1>
<!--docid::SEC102::-->
<P>
Although programming languages generally have common aspects, they are
rarely expressed in the same manner. For instance, in ANSI C,
dereferencing a pointer <CODE>p</CODE> is accomplished by <CODE>*p</CODE>, but in
Modula-2, it is accomplished by <CODE>p^</CODE>. Values can also be
represented (and displayed) differently. Hex numbers in C appear as
<SAMP>`0x1ae'</SAMP>, while in Modula-2 they appear as <SAMP>`1AEH'</SAMP>.
</P><P>
<A NAME="IDX568"></A>
Language-specific information is built into GDB for some languages,
allowing you to express operations like the above in your program's
native language, and allowing GDB to output values in a manner
consistent with the syntax of your program's native language. The
language you use to build expressions is called the <EM>working
language</EM>.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC103">12.1 Switching Between Source Languages</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Switching between source languages</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC107">12.2 Displaying the Language</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Displaying the language</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC108">12.3 Type and Range Checking</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Type and range checks</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC111">12.4 Supported Languages</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Supported languages</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC145">12.5 Unsupported Languages</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Unsupported languages</TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="Setting"></A>
<HR SIZE="6">
<A NAME="SEC103"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC104"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC107"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H2> 12.1 Switching Between Source Languages </H2>
<!--docid::SEC103::-->
<P>
There are two ways to control the working language--either have GDB
set it automatically, or select it manually yourself. You can use the
<CODE>set language</CODE> command for either purpose. On startup, GDB
defaults to setting the language automatically. The working language is
used to determine how expressions you type are interpreted, how values
are printed, etc.
</P><P>
In addition to the working language, every source file that
GDB knows about has its own working language. For some object
file formats, the compiler might indicate which language a particular
source file is in. However, most of the time GDB infers the
language from the name of the file. The language of a source file
controls whether C<TT>++</TT> names are demangled--this way <CODE>backtrace</CODE> can
show each frame appropriately for its own language. There is no way to
set the language of a source file from within GDB, but you can
set the language associated with a filename extension. See section <A HREF="gdb_13.html#SEC107">Displaying the Language</A>.
</P><P>
This is most commonly a problem when you use a program, such
as <CODE>cfront</CODE> or <CODE>f2c</CODE>, that generates C but is written in
another language. In that case, make the
program use <CODE>#line</CODE> directives in its C output; that way
GDB will know the correct language of the source code of the original
program, and will display that source code, not the generated C code.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC104">12.1.1 List of Filename Extensions and Languages</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Filename extensions and languages.</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC105">12.1.2 Setting the Working Language</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Setting the working language manually</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC106">12.1.3 Having GDB Infer the Source Language</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Having GDB infer the source language</TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="Filenames"></A>
<HR SIZE="6">
<A NAME="SEC104"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC103"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC105"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC103"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC107"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.1.1 List of Filename Extensions and Languages </H3>
<!--docid::SEC104::-->
<P>
If a source file name ends in one of the following extensions, then
GDB infers that its language is the one indicated.
</P><P>
<DL COMPACT>
<DT><TT>`.ada'</TT>
<DD><DT><TT>`.ads'</TT>
<DD><DT><TT>`.adb'</TT>
<DD><DT><TT>`.a'</TT>
<DD>Ada source file.
<P>
<DT><TT>`.c'</TT>
<DD>C source file
<P>
<DT><TT>`.C'</TT>
<DD><DT><TT>`.cc'</TT>
<DD><DT><TT>`.cp'</TT>
<DD><DT><TT>`.cpp'</TT>
<DD><DT><TT>`.cxx'</TT>
<DD><DT><TT>`.c++'</TT>
<DD>C<TT>++</TT> source file
<P>
<DT><TT>`.m'</TT>
<DD>Objective-C source file
<P>
<DT><TT>`.f'</TT>
<DD><DT><TT>`.F'</TT>
<DD>Fortran source file
<P>
<DT><TT>`.mod'</TT>
<DD>Modula-2 source file
<P>
<DT><TT>`.s'</TT>
<DD><DT><TT>`.S'</TT>
<DD>Assembler source file. This actually behaves almost like C, but
GDB does not skip over function prologues when stepping.
</DL>
<P>
In addition, you may set the language associated with a filename
extension. See section <A HREF="gdb_13.html#SEC107">Displaying the Language</A>.
</P><P>
<A NAME="Manually"></A>
<HR SIZE="6">
<A NAME="SEC105"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC104"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC106"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC106"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC103"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC107"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.1.2 Setting the Working Language </H3>
<!--docid::SEC105::-->
<P>
If you allow GDB to set the language automatically,
expressions are interpreted the same way in your debugging session and
your program.
</P><P>
<A NAME="IDX569"></A>
If you wish, you may set the language manually. To do this, issue the
command <SAMP>`set language <VAR>lang</VAR>'</SAMP>, where <VAR>lang</VAR> is the name of
a language, such as
<CODE>c</CODE> or <CODE>modula-2</CODE>.
For a list of the supported languages, type <SAMP>`set language'</SAMP>.
</P><P>
Setting the language manually prevents GDB from updating the working
language automatically. This can lead to confusion if you try
to debug a program when the working language is not the same as the
source language, when an expression is acceptable to both
languages--but means different things. For instance, if the current
source file were written in C, and GDB was parsing Modula-2, a
command such as:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>print a = b + c
</FONT></pre></td></tr></table></P><P>
might not have the effect you intended. In C, this means to add
<CODE>b</CODE> and <CODE>c</CODE> and place the result in <CODE>a</CODE>. The result
printed would be the value of <CODE>a</CODE>. In Modula-2, this means to compare
<CODE>a</CODE> to the result of <CODE>b+c</CODE>, yielding a <CODE>BOOLEAN</CODE> value.
</P><P>
<A NAME="Automatically"></A>
<HR SIZE="6">
<A NAME="SEC106"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC105"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC107"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC103"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC107"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.1.3 Having GDB Infer the Source Language </H3>
<!--docid::SEC106::-->
<P>
To have GDB set the working language automatically, use
<SAMP>`set language local'</SAMP> or <SAMP>`set language auto'</SAMP>. GDB
then infers the working language. That is, when your program stops in a
frame (usually by encountering a breakpoint), GDB sets the
working language to the language recorded for the function in that
frame. If the language for a frame is unknown (that is, if the function
or block corresponding to the frame was defined in a source file that
does not have a recognized extension), the current working language is
not changed, and GDB issues a warning.
</P><P>
This may not seem necessary for most programs, which are written
entirely in one source language. However, program modules and libraries
written in one source language can be used by a main program written in
a different source language. Using <SAMP>`set language auto'</SAMP> in this
case frees you from having to set the working language manually.
</P><P>
<A NAME="Show"></A>
<HR SIZE="6">
<A NAME="SEC107"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC106"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC108"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC108"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_14.html#SEC146"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H2> 12.2 Displaying the Language </H2>
<!--docid::SEC107::-->
<P>
The following commands help you find out which language is the
working language, and also what language source files were written in.
</P><P>
<DL COMPACT>
<DT><CODE>show language</CODE>
<DD><A NAME="IDX570"></A>
Display the current working language. This is the
language you can use with commands such as <CODE>print</CODE> to
build and compute expressions that may involve variables in your program.
<P>
<DT><CODE>info frame</CODE>
<DD><A NAME="IDX571"></A>
Display the source language for this frame. This language becomes the
working language if you use an identifier from this frame.
See section <A HREF="gdb_7.html#SEC50">Information about a Frame</A>, to identify the other
information listed here.
<P>
<DT><CODE>info source</CODE>
<DD><A NAME="IDX572"></A>
Display the source language of this source file.
See section <A HREF="gdb_14.html#SEC146">Examining the Symbol Table</A>, to identify the other
information listed here.
</DL>
<P>
In unusual circumstances, you may have source files with extensions
not in the standard list. You can then set the extension associated
with a language explicitly:
</P><P>
<DL COMPACT>
<DT><CODE>set extension-language <VAR>ext</VAR> <VAR>language</VAR></CODE>
<DD><A NAME="IDX573"></A>
Tell GDB that source files with extension <VAR>ext</VAR> are to be
assumed as written in the source language <VAR>language</VAR>.
<P>
<DT><CODE>info extensions</CODE>
<DD><A NAME="IDX574"></A>
List all the filename extensions and the associated languages.
</DL>
<P>
<A NAME="Checks"></A>
<HR SIZE="6">
<A NAME="SEC108"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC107"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC109"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H2> 12.3 Type and Range Checking </H2>
<!--docid::SEC108::-->
<P>
<BLOCKQUOTE>
<EM>Warning:</EM> In this release, the GDB commands for type and range
checking are included, but they do not yet have any effect. This
section documents the intended facilities.
</BLOCKQUOTE>
<P>
Some languages are designed to guard you against making seemingly common
errors through a series of compile- and run-time checks. These include
checking the type of arguments to functions and operators, and making
sure mathematical overflows are caught at run time. Checks such as
these help to ensure a program's correctness once it has been compiled
by eliminating type mismatches, and providing active checks for range
errors when your program is running.
</P><P>
GDB can check for conditions like the above if you wish.
Although GDB does not check the statements in your program,
it can check expressions entered directly into GDB for
evaluation via the <CODE>print</CODE> command, for example. As with the
working language, GDB can also decide whether or not to check
automatically based on your program's source language.
See section <A HREF="gdb_13.html#SEC111">Supported Languages</A>, for the default
settings of supported languages.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC109">12.3.1 An Overview of Type Checking</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">An overview of type checking</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC110">12.3.2 An Overview of Range Checking</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">An overview of range checking</TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="IDX575"></A>
<A NAME="IDX576"></A>
<A NAME="Type Checking"></A>
<HR SIZE="6">
<A NAME="SEC109"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC108"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC110"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC108"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.3.1 An Overview of Type Checking </H3>
<!--docid::SEC109::-->
<P>
Some languages, such as Modula-2, are strongly typed, meaning that the
arguments to operators and functions have to be of the correct type,
otherwise an error occurs. These checks prevent type mismatch
errors from ever causing any run-time problems. For example,
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>1 + 2 => 3
but
error--> 1 + 2.3
</FONT></pre></td></tr></table></P><P>
The second example fails because the <CODE>CARDINAL</CODE> 1 is not
type-compatible with the <CODE>REAL</CODE> 2.3.
</P><P>
For the expressions you use in GDB commands, you can tell the
GDB type checker to skip checking;
to treat any mismatches as errors and abandon the expression;
or to only issue warnings when type mismatches occur,
but evaluate the expression anyway. When you choose the last of
these, GDB evaluates expressions like the second example above, but
also issues a warning.
</P><P>
Even if you turn type checking off, there may be other reasons
related to type that prevent GDB from evaluating an expression.
For instance, GDB does not know how to add an <CODE>int</CODE> and
a <CODE>struct foo</CODE>. These particular type errors have nothing to do
with the language in use, and usually arise from expressions, such as
the one described above, which make little sense to evaluate anyway.
</P><P>
Each language defines to what degree it is strict about type. For
instance, both Modula-2 and C require the arguments to arithmetical
operators to be numbers. In C, enumerated types and pointers can be
represented as numbers, so that they are valid arguments to mathematical
operators. See section <A HREF="gdb_13.html#SEC111">Supported Languages</A>, for further
details on specific languages.
</P><P>
GDB provides some additional commands for controlling the type checker:
</P><P>
<A NAME="IDX577"></A>
<A NAME="IDX578"></A>
<DL COMPACT>
<DT><CODE>set check type auto</CODE>
<DD>Set type checking on or off based on the current working language.
See section <A HREF="gdb_13.html#SEC111">Supported Languages</A>, for the default settings for
each language.
<P>
<DT><CODE>set check type on</CODE>
<DD><DT><CODE>set check type off</CODE>
<DD>Set type checking on or off, overriding the default setting for the
current working language. Issue a warning if the setting does not
match the language default. If any type mismatches occur in
evaluating an expression while type checking is on, GDB prints a
message and aborts evaluation of the expression.
<P>
<DT><CODE>set check type warn</CODE>
<DD>Cause the type checker to issue warnings, but to always attempt to
evaluate the expression. Evaluating the expression may still
be impossible for other reasons. For example, GDB cannot add
numbers and structures.
<P>
<DT><CODE>show type</CODE>
<DD>Show the current setting of the type checker, and whether or not GDB
is setting it automatically.
</DL>
<P>
<A NAME="IDX579"></A>
<A NAME="IDX580"></A>
<A NAME="Range Checking"></A>
<HR SIZE="6">
<A NAME="SEC110"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC109"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC108"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.3.2 An Overview of Range Checking </H3>
<!--docid::SEC110::-->
<P>
In some languages (such as Modula-2), it is an error to exceed the
bounds of a type; this is enforced with run-time checks. Such range
checking is meant to ensure program correctness by making sure
computations do not overflow, or indices on an array element access do
not exceed the bounds of the array.
</P><P>
For expressions you use in GDB commands, you can tell
GDB to treat range errors in one of three ways: ignore them,
always treat them as errors and abandon the expression, or issue
warnings but evaluate the expression anyway.
</P><P>
A range error can result from numerical overflow, from exceeding an
array index bound, or when you type a constant that is not a member
of any type. Some languages, however, do not treat overflows as an
error. In many implementations of C, mathematical overflow causes the
result to "wrap around" to lower values--for example, if <VAR>m</VAR> is
the largest integer value, and <VAR>s</VAR> is the smallest, then
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre><VAR>m</VAR> + 1 => <VAR>s</VAR>
</FONT></pre></td></tr></table></P><P>
This, too, is specific to individual languages, and in some cases
specific to individual compilers or machines. See section <A HREF="gdb_13.html#SEC111">Supported Languages</A>, for further details on specific languages.
</P><P>
GDB provides some additional commands for controlling the range checker:
</P><P>
<A NAME="IDX581"></A>
<A NAME="IDX582"></A>
<DL COMPACT>
<DT><CODE>set check range auto</CODE>
<DD>Set range checking on or off based on the current working language.
See section <A HREF="gdb_13.html#SEC111">Supported Languages</A>, for the default settings for
each language.
<P>
<DT><CODE>set check range on</CODE>
<DD><DT><CODE>set check range off</CODE>
<DD>Set range checking on or off, overriding the default setting for the
current working language. A warning is issued if the setting does not
match the language default. If a range error occurs and range checking is on,
then a message is printed and evaluation of the expression is aborted.
<P>
<DT><CODE>set check range warn</CODE>
<DD>Output messages when the GDB range checker detects a range error,
but attempt to evaluate the expression anyway. Evaluating the
expression may still be impossible for other reasons, such as accessing
memory that the process does not own (a typical example from many Unix
systems).
<P>
<DT><CODE>show range</CODE>
<DD>Show the current setting of the range checker, and whether or not it is
being set automatically by GDB.
</DL>
<P>
<A NAME="Supported Languages"></A>
<HR SIZE="6">
<A NAME="SEC111"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC110"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H2> 12.4 Supported Languages </H2>
<!--docid::SEC111::-->
<P>
GDB supports C, C<TT>++</TT>, Objective-C, Fortran, Java, Pascal,
assembly, Modula-2, and Ada.
Some GDB features may be used in expressions regardless of the
language you use: the GDB <CODE>@</CODE> and <CODE>::</CODE> operators,
and the <SAMP>`{type}addr'</SAMP> construct (see section <A HREF="gdb_9.html#SEC60">Expressions</A>) can be used with the constructs of any supported
language.
</P><P>
The following sections detail to what degree each source language is
supported by GDB. These sections are not meant to be language
tutorials or references, but serve only as a reference guide to what the
GDB expression parser accepts, and what input and output
formats should look like for different languages. There are many good
books written on each of these languages; please look to these for a
language reference or tutorial.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC112">12.4.1 C and C<TT>++</TT></A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC121">12.4.2 Objective-C</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC124">12.4.3 Fortran</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC128">12.4.4 Pascal</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC129">12.4.5 Modula-2</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC139">12.4.6 Ada</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="C"></A>
<HR SIZE="6">
<A NAME="SEC112"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC113"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.4.1 C and C<TT>++</TT> </H3>
<!--docid::SEC112::-->
<P>
<A NAME="IDX583"></A>
<A NAME="IDX584"></A>
</P><P>
Since C and C<TT>++</TT> are so closely related, many features of GDB apply
to both languages. Whenever this is the case, we discuss those languages
together.
</P><P>
<A NAME="IDX585"></A>
<A NAME="IDX586"></A>
<A NAME="IDX587"></A>
The C<TT>++</TT> debugging facilities are jointly implemented by the C<TT>++</TT>
compiler and GDB. Therefore, to debug your C<TT>++</TT> code
effectively, you must compile your C<TT>++</TT> programs with a supported
C<TT>++</TT> compiler, such as GNU <CODE>g++</CODE>, or the HP ANSI C<TT>++</TT>
compiler (<CODE>aCC</CODE>).
</P><P>
For best results when using GNU C<TT>++</TT>, use the DWARF 2 debugging
format; if it doesn't work on your system, try the stabs+ debugging
format. You can select those formats explicitly with the <CODE>g++</CODE>
command-line options <SAMP>`-gdwarf-2'</SAMP> and <SAMP>`-gstabs+'</SAMP>.
See section `Options for Debugging Your Program or GCC' in <CITE>Using the GNU Compiler Collection (GCC)</CITE>.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC113">12.4.1.1 C and C<TT>++</TT> Operators</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">C and C<TT>++</TT> operators</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC114">12.4.1.2 C and C<TT>++</TT> Constants</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">C and C<TT>++</TT> constants</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC115">12.4.1.3 C<TT>++</TT> Expressions</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">C<TT>++</TT> expressions</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC116">12.4.1.4 C and C<TT>++</TT> Defaults</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Default settings for C and C<TT>++</TT></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC117">12.4.1.5 C and C<TT>++</TT> Type and Range Checks</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">C and C<TT>++</TT> type and range checks</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC118">12.4.1.6 GDB and C</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC119">12.4.1.7 GDB Features for C<TT>++</TT></A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">GDB features for C<TT>++</TT></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC120">12.4.1.8 Decimal Floating Point format</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Numbers in Decimal Floating Point format</TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="C Operators"></A>
<HR SIZE="6">
<A NAME="SEC113"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC114"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.1 C and C<TT>++</TT> Operators </H4>
<!--docid::SEC113::-->
<P>
<A NAME="IDX588"></A>
</P><P>
Operators must be defined on values of specific types. For instance,
<CODE>+</CODE> is defined on numbers, but not on structures. Operators are
often defined on groups of types.
</P><P>
For the purposes of C and C<TT>++</TT>, the following definitions hold:
</P><P>
<UL>
<LI>
<EM>Integral types</EM> include <CODE>int</CODE> with any of its storage-class
specifiers; <CODE>char</CODE>; <CODE>enum</CODE>; and, for C<TT>++</TT>, <CODE>bool</CODE>.
<P>
<LI>
<EM>Floating-point types</EM> include <CODE>float</CODE>, <CODE>double</CODE>, and
<CODE>long double</CODE> (if supported by the target platform).
<P>
<LI>
<EM>Pointer types</EM> include all types defined as <CODE>(<VAR>type</VAR> *)</CODE>.
<P>
<LI>
<EM>Scalar types</EM> include all of the above.
<P>
</UL>
<P>
The following operators are supported. They are listed here
in order of increasing precedence:
</P><P>
<DL COMPACT>
<DT><CODE>,</CODE>
<DD>The comma or sequencing operator. Expressions in a comma-separated list
are evaluated from left to right, with the result of the entire
expression being the last expression evaluated.
<P>
<DT><CODE>=</CODE>
<DD>Assignment. The value of an assignment expression is the value
assigned. Defined on scalar types.
<P>
<DT><CODE><VAR>op</VAR>=</CODE>
<DD>Used in an expression of the form <CODE><VAR>a</VAR> <VAR>op</VAR>= <VAR>b</VAR></CODE>,
and translated to <CODE><VAR>a</VAR> = <VAR>a op b</VAR></CODE>.
<CODE><VAR>op</VAR>=</CODE> and <CODE>=</CODE> have the same precedence.
<VAR>op</VAR> is any one of the operators <CODE>|</CODE>, <CODE>^</CODE>, <CODE>&</CODE>,
<CODE><<</CODE>, <CODE>>></CODE>, <CODE>+</CODE>, <CODE>-</CODE>, <CODE>*</CODE>, <CODE>/</CODE>, <CODE>%</CODE>.
<P>
<DT><CODE>?:</CODE>
<DD>The ternary operator. <CODE><VAR>a</VAR> ? <VAR>b</VAR> : <VAR>c</VAR></CODE> can be thought
of as: if <VAR>a</VAR> then <VAR>b</VAR> else <VAR>c</VAR>. <VAR>a</VAR> should be of an
integral type.
<P>
<DT><CODE>||</CODE>
<DD>Logical OR. Defined on integral types.
<P>
<DT><CODE>&&</CODE>
<DD>Logical AND. Defined on integral types.
<P>
<DT><CODE>|</CODE>
<DD>Bitwise OR. Defined on integral types.
<P>
<DT><CODE>^</CODE>
<DD>Bitwise exclusive-OR. Defined on integral types.
<P>
<DT><CODE>&</CODE>
<DD>Bitwise AND. Defined on integral types.
<P>
<DT><CODE>==, !=</CODE>
<DD>Equality and inequality. Defined on scalar types. The value of these
expressions is 0 for false and non-zero for true.
<P>
<DT><CODE><, >, <=, >=</CODE>
<DD>Less than, greater than, less than or equal, greater than or equal.
Defined on scalar types. The value of these expressions is 0 for false
and non-zero for true.
<P>
<DT><CODE><<, >></CODE>
<DD>left shift, and right shift. Defined on integral types.
<P>
<DT><CODE>@</CODE>
<DD>The GDB "artificial array" operator (see section <A HREF="gdb_9.html#SEC60">Expressions</A>).
<P>
<DT><CODE>+, -</CODE>
<DD>Addition and subtraction. Defined on integral types, floating-point types and
pointer types.
<P>
<DT><CODE>*, /, %</CODE>
<DD>Multiplication, division, and modulus. Multiplication and division are
defined on integral and floating-point types. Modulus is defined on
integral types.
<P>
<DT><CODE>++, --</CODE>
<DD>Increment and decrement. When appearing before a variable, the
operation is performed before the variable is used in an expression;
when appearing after it, the variable's value is used before the
operation takes place.
<P>
<DT><CODE>*</CODE>
<DD>Pointer dereferencing. Defined on pointer types. Same precedence as
<CODE>++</CODE>.
<P>
<DT><CODE>&</CODE>
<DD>Address operator. Defined on variables. Same precedence as <CODE>++</CODE>.
<P>
For debugging C<TT>++</TT>, GDB implements a use of <SAMP>`&'</SAMP> beyond what is
allowed in the C<TT>++</TT> language itself: you can use <SAMP>`&(&<VAR>ref</VAR>)'</SAMP>
to examine the address
where a C<TT>++</TT> reference variable (declared with <SAMP>`&<VAR>ref</VAR>'</SAMP>) is
stored.
</P><P>
<DT><CODE>-</CODE>
<DD>Negative. Defined on integral and floating-point types. Same
precedence as <CODE>++</CODE>.
<P>
<DT><CODE>!</CODE>
<DD>Logical negation. Defined on integral types. Same precedence as
<CODE>++</CODE>.
<P>
<DT><CODE>~</CODE>
<DD>Bitwise complement operator. Defined on integral types. Same precedence as
<CODE>++</CODE>.
<P>
<DT><CODE>., -></CODE>
<DD>Structure member, and pointer-to-structure member. For convenience,
GDB regards the two as equivalent, choosing whether to dereference a
pointer based on the stored type information.
Defined on <CODE>struct</CODE> and <CODE>union</CODE> data.
<P>
<DT><CODE>.*, ->*</CODE>
<DD>Dereferences of pointers to members.
<P>
<DT><CODE>[]</CODE>
<DD>Array indexing. <CODE><VAR>a</VAR>[<VAR>i</VAR>]</CODE> is defined as
<CODE>*(<VAR>a</VAR>+<VAR>i</VAR>)</CODE>. Same precedence as <CODE>-></CODE>.
<P>
<DT><CODE>()</CODE>
<DD>Function parameter list. Same precedence as <CODE>-></CODE>.
<P>
<DT><CODE>::</CODE>
<DD>C<TT>++</TT> scope resolution operator. Defined on <CODE>struct</CODE>, <CODE>union</CODE>,
and <CODE>class</CODE> types.
<P>
<DT><CODE>::</CODE>
<DD>Doubled colons also represent the GDB scope operator
(see section <A HREF="gdb_9.html#SEC60">Expressions</A>). Same precedence as <CODE>::</CODE>,
above.
</DL>
<P>
If an operator is redefined in the user code, GDB usually
attempts to invoke the redefined version instead of using the operator's
predefined meaning.
</P><P>
<A NAME="C Constants"></A>
<HR SIZE="6">
<A NAME="SEC114"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC113"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC115"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC115"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.2 C and C<TT>++</TT> Constants </H4>
<!--docid::SEC114::-->
<P>
<A NAME="IDX589"></A>
</P><P>
GDB allows you to express the constants of C and C<TT>++</TT> in the
following ways:
</P><P>
<UL>
<LI>
Integer constants are a sequence of digits. Octal constants are
specified by a leading <SAMP>`0'</SAMP> (i.e. zero), and hexadecimal constants
by a leading <SAMP>`0x'</SAMP> or <SAMP>`0X'</SAMP>. Constants may also end with a letter
<SAMP>`l'</SAMP>, specifying that the constant should be treated as a
<CODE>long</CODE> value.
<P>
<LI>
Floating point constants are a sequence of digits, followed by a decimal
point, followed by a sequence of digits, and optionally followed by an
exponent. An exponent is of the form:
<SAMP>`e[[+]|-]<VAR>nnn</VAR>'</SAMP>, where <VAR>nnn</VAR> is another
sequence of digits. The <SAMP>`+'</SAMP> is optional for positive exponents.
A floating-point constant may also end with a letter <SAMP>`f'</SAMP> or
<SAMP>`F'</SAMP>, specifying that the constant should be treated as being of
the <CODE>float</CODE> (as opposed to the default <CODE>double</CODE>) type; or with
a letter <SAMP>`l'</SAMP> or <SAMP>`L'</SAMP>, which specifies a <CODE>long double</CODE>
constant.
<P>
<LI>
Enumerated constants consist of enumerated identifiers, or their
integral equivalents.
<P>
<LI>
Character constants are a single character surrounded by single quotes
(<CODE>'</CODE>), or a number--the ordinal value of the corresponding character
(usually its ASCII value). Within quotes, the single character may
be represented by a letter or by <EM>escape sequences</EM>, which are of
the form <SAMP>`\<VAR>nnn</VAR>'</SAMP>, where <VAR>nnn</VAR> is the octal representation
of the character's ordinal value; or of the form <SAMP>`\<VAR>x</VAR>'</SAMP>, where
<SAMP>`<VAR>x</VAR>'</SAMP> is a predefined special character--for example,
<SAMP>`\n'</SAMP> for newline.
<P>
<LI>
String constants are a sequence of character constants surrounded by
double quotes (<CODE>"</CODE>). Any valid character constant (as described
above) may appear. Double quotes within the string must be preceded by
a backslash, so for instance <SAMP>`"a\"b'c"'</SAMP> is a string of five
characters.
<P>
<LI>
Pointer constants are an integral value. You can also write pointers
to constants using the C operator <SAMP>`&'</SAMP>.
<P>
<LI>
Array constants are comma-separated lists surrounded by braces <SAMP>`{'</SAMP>
and <SAMP>`}'</SAMP>; for example, <SAMP>`{1,2,3}'</SAMP> is a three-element array of
integers, <SAMP>`{{1,2}, {3,4}, {5,6}}'</SAMP> is a three-by-two array,
and <SAMP>`{&"hi", &"there", &"fred"}'</SAMP> is a three-element array of pointers.
</UL>
<P>
<A NAME="C Plus Plus Expressions"></A>
<HR SIZE="6">
<A NAME="SEC115"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC114"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC116"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC116"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.3 C<TT>++</TT> Expressions </H4>
<!--docid::SEC115::-->
<P>
<A NAME="IDX590"></A>
GDB expression handling can interpret most C<TT>++</TT> expressions.
</P><P>
<A NAME="IDX591"></A>
<A NAME="IDX592"></A>
<A NAME="IDX593"></A>
<A NAME="IDX594"></A>
<BLOCKQUOTE>
<EM>Warning:</EM> GDB can only debug C<TT>++</TT> code if you use the
proper compiler and the proper debug format. Currently, GDB
works best when debugging C<TT>++</TT> code that is compiled with
GCC 2.95.3 or with GCC 3.1 or newer, using the options
<SAMP>`-gdwarf-2'</SAMP> or <SAMP>`-gstabs+'</SAMP>. DWARF 2 is preferred over
stabs+. Most configurations of GCC emit either DWARF 2 or
stabs+ as their default debug format, so you usually don't need to
specify a debug format explicitly. Other compilers and/or debug formats
are likely to work badly or not at all when using GDB to debug
C<TT>++</TT> code.
</BLOCKQUOTE>
<P>
<OL>
<A NAME="IDX595"></A>
<LI>
Member function calls are allowed; you can use expressions like
<P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>count = aml->GetOriginal(x, y)
</FONT></pre></td></tr></table></P><P>
<A NAME="IDX596"></A>
<A NAME="IDX597"></A>
<LI>
While a member function is active (in the selected stack frame), your
expressions have the same namespace available as the member function;
that is, GDB allows implicit references to the class instance
pointer <CODE>this</CODE> following the same rules as C<TT>++</TT>.
<P>
<A NAME="IDX598"></A>
<A NAME="IDX599"></A>
<A NAME="IDX600"></A>
<LI>
You can call overloaded functions; GDB resolves the function
call to the right definition, with some restrictions. GDB does not
perform overload resolution involving user-defined type conversions,
calls to constructors, or instantiations of templates that do not exist
in the program. It also cannot handle ellipsis argument lists or
default arguments.
<P>
It does perform integral conversions and promotions, floating-point
promotions, arithmetic conversions, pointer conversions, conversions of
class objects to base classes, and standard conversions such as those of
functions or arrays to pointers; it requires an exact match on the
number of function arguments.
</P><P>
Overload resolution is always performed, unless you have specified
<CODE>set overload-resolution off</CODE>. See section <A HREF="gdb_13.html#SEC119">GDB Features for C<TT>++</TT></A>.
</P><P>
You must specify <CODE>set overload-resolution off</CODE> in order to use an
explicit function signature to call an overloaded function, as in
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>p 'foo(char,int)'('x', 13)
</FONT></pre></td></tr></table></P><P>
The GDB command-completion facility can simplify this;
see <A HREF="gdb_4.html#SEC16">Command Completion</A>.
</P><P>
<A NAME="IDX601"></A>
<LI>
GDB understands variables declared as C<TT>++</TT> references; you can use
them in expressions just as you do in C<TT>++</TT> source--they are automatically
dereferenced.
<P>
In the parameter list shown when GDB displays a frame, the values of
reference variables are not displayed (unlike other variables); this
avoids clutter, since references are often used for large structures.
The <EM>address</EM> of a reference variable is always shown, unless
you have specified <SAMP>`set print address off'</SAMP>.
</P><P>
<LI>
GDB supports the C<TT>++</TT> name resolution operator <CODE>::</CODE>---your
expressions can use it just as expressions in your program do. Since
one scope may be defined in another, you can use <CODE>::</CODE> repeatedly if
necessary, for example in an expression like
<SAMP>`<VAR>scope1</VAR>::<VAR>scope2</VAR>::<VAR>name</VAR>'</SAMP>. GDB also allows
resolving name scope by reference to source files, in both C and C<TT>++</TT>
debugging (see section <A HREF="gdb_9.html#SEC61">Program Variables</A>).
</OL>
<P>
In addition, when used with HP's C<TT>++</TT> compiler, GDB supports
calling virtual functions correctly, printing out virtual bases of
objects, calling functions in a base subobject, casting objects, and
invoking user-defined operators.
</P><P>
<A NAME="C Defaults"></A>
<HR SIZE="6">
<A NAME="SEC116"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC115"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC117"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC117"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.4 C and C<TT>++</TT> Defaults </H4>
<!--docid::SEC116::-->
<P>
<A NAME="IDX602"></A>
</P><P>
If you allow GDB to set type and range checking automatically, they
both default to <CODE>off</CODE> whenever the working language changes to
C or C<TT>++</TT>. This happens regardless of whether you or GDB
selects the working language.
</P><P>
If you allow GDB to set the language automatically, it
recognizes source files whose names end with <TT>`.c'</TT>, <TT>`.C'</TT>, or
<TT>`.cc'</TT>, etc, and when GDB enters code compiled from one of
these files, it sets the working language to C or C<TT>++</TT>.
See section <A HREF="gdb_13.html#SEC106">Having GDB Infer the Source Language</A>,
for further details.
</P><P>
<A NAME="C Checks"></A>
<HR SIZE="6">
<A NAME="SEC117"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC116"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC118"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC118"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.5 C and C<TT>++</TT> Type and Range Checks </H4>
<!--docid::SEC117::-->
<P>
<A NAME="IDX603"></A>
</P><P>
By default, when GDB parses C or C<TT>++</TT> expressions, type checking
is not used. However, if you turn type checking on, GDB
considers two variables type equivalent if:
</P><P>
<UL>
<LI>
The two variables are structured and have the same structure, union, or
enumerated tag.
<P>
<LI>
The two variables have the same type name, or types that have been
declared equivalent through <CODE>typedef</CODE>.
<P>
</UL>
<P>
Range checking, if turned on, is done on mathematical operations. Array
indices are not checked, since they are often used to index a pointer
that is not itself an array.
</P><P>
<A NAME="Debugging C"></A>
<HR SIZE="6">
<A NAME="SEC118"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC117"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC119"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC119"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.6 GDB and C </H4>
<!--docid::SEC118::-->
<P>
The <CODE>set print union</CODE> and <CODE>show print union</CODE> commands apply to
the <CODE>union</CODE> type. When set to <SAMP>`on'</SAMP>, any <CODE>union</CODE> that is
inside a <CODE>struct</CODE> or <CODE>class</CODE> is also printed. Otherwise, it
appears as <SAMP>`{...}'</SAMP>.
</P><P>
The <CODE>@</CODE> operator aids in the debugging of dynamic arrays, formed
with pointers and a memory allocation function. See section <A HREF="gdb_9.html#SEC60">Expressions</A>.
</P><P>
<A NAME="Debugging C Plus Plus"></A>
<HR SIZE="6">
<A NAME="SEC119"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC118"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC120"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC120"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.7 GDB Features for C<TT>++</TT> </H4>
<!--docid::SEC119::-->
<P>
<A NAME="IDX604"></A>
</P><P>
Some GDB commands are particularly useful with C<TT>++</TT>, and some are
designed specifically for use with C<TT>++</TT>. Here is a summary:
</P><P>
<DL COMPACT>
<A NAME="IDX605"></A>
<DT><CODE>breakpoint menus</CODE>
<DD>When you want a breakpoint in a function whose name is overloaded,
GDB breakpoint menus help you specify which function definition
you want. See section <A HREF="gdb_6.html#SEC40">Breakpoint Menus</A>.
<P>
<A NAME="IDX606"></A>
<DT><CODE>rbreak <VAR>regex</VAR></CODE>
<DD>Setting breakpoints using regular expressions is helpful for setting
breakpoints on overloaded functions that are not members of any special
classes.
See section <A HREF="gdb_6.html#SEC33">Setting Breakpoints</A>.
<P>
<A NAME="IDX607"></A>
<DT><CODE>catch throw</CODE>
<DD><DT><CODE>catch catch</CODE>
<DD>Debug C<TT>++</TT> exception handling using these commands. See section <A HREF="gdb_6.html#SEC35">Setting Catchpoints</A>.
<P>
<A NAME="IDX608"></A>
<DT><CODE>ptype <VAR>typename</VAR></CODE>
<DD>Print inheritance relationships as well as other information for type
<VAR>typename</VAR>.
See section <A HREF="gdb_14.html#SEC146">Examining the Symbol Table</A>.
<P>
<A NAME="IDX609"></A>
<DT><CODE>set print demangle</CODE>
<DD><DT><CODE>show print demangle</CODE>
<DD><DT><CODE>set print asm-demangle</CODE>
<DD><DT><CODE>show print asm-demangle</CODE>
<DD>Control whether C<TT>++</TT> symbols display in their source form, both when
displaying code as C<TT>++</TT> source and when displaying disassemblies.
See section <A HREF="gdb_9.html#SEC66">Print Settings</A>.
<P>
<DT><CODE>set print object</CODE>
<DD><DT><CODE>show print object</CODE>
<DD>Choose whether to print derived (actual) or declared types of objects.
See section <A HREF="gdb_9.html#SEC66">Print Settings</A>.
<P>
<DT><CODE>set print vtbl</CODE>
<DD><DT><CODE>show print vtbl</CODE>
<DD>Control the format for printing virtual function tables.
See section <A HREF="gdb_9.html#SEC66">Print Settings</A>.
(The <CODE>vtbl</CODE> commands do not work on programs compiled with the HP
ANSI C<TT>++</TT> compiler (<CODE>aCC</CODE>).)
<P>
<A NAME="IDX610"></A>
<A NAME="IDX611"></A>
<DT><CODE>set overload-resolution on</CODE>
<DD>Enable overload resolution for C<TT>++</TT> expression evaluation. The default
is on. For overloaded functions, GDB evaluates the arguments
and searches for a function whose signature matches the argument types,
using the standard C<TT>++</TT> conversion rules (see <A HREF="gdb_13.html#SEC115">C<TT>++</TT> Expressions</A>, for details).
If it cannot find a match, it emits a message.
<P>
<DT><CODE>set overload-resolution off</CODE>
<DD>Disable overload resolution for C<TT>++</TT> expression evaluation. For
overloaded functions that are not class member functions, GDB
chooses the first function of the specified name that it finds in the
symbol table, whether or not its arguments are of the correct type. For
overloaded functions that are class member functions, GDB
searches for a function whose signature <EM>exactly</EM> matches the
argument types.
<P>
<A NAME="IDX612"></A>
<DT><CODE>show overload-resolution</CODE>
<DD>Show the current setting of overload resolution.
<P>
<DT><CODE>Overloaded symbol names</CODE>
<DD>You can specify a particular definition of an overloaded symbol, using
the same notation that is used to declare such symbols in C<TT>++</TT>: type
<CODE><VAR>symbol</VAR>(<VAR>types</VAR>)</CODE> rather than just <VAR>symbol</VAR>. You can
also use the GDB command-line word completion facilities to list the
available choices, or to finish the type list for you.
See section <A HREF="gdb_4.html#SEC16">Command Completion</A>, for details on how to do this.
</DL>
<P>
<A NAME="Decimal Floating Point"></A>
<HR SIZE="6">
<A NAME="SEC120"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC119"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC112"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.1.8 Decimal Floating Point format </H4>
<!--docid::SEC120::-->
<P>
GDB can examine, set and perform computations with numbers in
decimal floating point format, which in the C language correspond to the
<CODE>_Decimal32</CODE>, <CODE>_Decimal64</CODE> and <CODE>_Decimal128</CODE> types as
specified by the extension to support decimal floating-point arithmetic.
</P><P>
There are two encodings in use, depending on the architecture: BID (Binary
Integer Decimal) for x86 and x86-64, and DPD (Densely Packed Decimal) for
PowerPC. GDB will use the appropriate encoding for the configured
target.
</P><P>
Because of a limitation in <TT>`libdecnumber'</TT>, the library used by GDB
to manipulate decimal floating point numbers, it is not possible to convert
(using a cast, for example) integers wider than 32-bit to decimal float.
</P><P>
In addition, in order to imitate GDB's behaviour with binary floating
point computations, error checking in decimal float operations ignores
underflow, overflow and divide by zero exceptions.
</P><P>
In the PowerPC architecture, GDB provides a set of pseudo-registers
to inspect <CODE>_Decimal128</CODE> values stored in floating point registers. See
<A HREF="gdb_19.html#SEC219">PowerPC</A> for more details.
</P><P>
<A NAME="Objective-C"></A>
<HR SIZE="6">
<A NAME="SEC121"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC120"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC122"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.4.2 Objective-C </H3>
<!--docid::SEC121::-->
<P>
<A NAME="IDX613"></A>
This section provides information about some commands and command
options that are useful for debugging Objective-C code. See also
<A HREF="gdb_14.html#SEC146">info classes</A>, and <A HREF="gdb_14.html#SEC146">info selectors</A>, for a
few more commands specific to Objective-C support.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC122">12.4.2.1 Method Names in Commands</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC123">12.4.2.2 The Print Command With Objective-C</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="Method Names in Commands"></A>
<HR SIZE="6">
<A NAME="SEC122"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC123"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.2.1 Method Names in Commands </H4>
<!--docid::SEC122::-->
<P>
The following commands have been extended to accept Objective-C method
names as line specifications:
</P><P>
<A NAME="IDX614"></A>
<A NAME="IDX615"></A>
<A NAME="IDX616"></A>
<A NAME="IDX617"></A>
<A NAME="IDX618"></A>
<UL>
<LI><CODE>clear</CODE>
<LI><CODE>break</CODE>
<LI><CODE>info line</CODE>
<LI><CODE>jump</CODE>
<LI><CODE>list</CODE>
</UL>
<P>
A fully qualified Objective-C method name is specified as
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>-[<VAR>Class</VAR> <VAR>methodName</VAR>]
</FONT></pre></td></tr></table></P><P>
where the minus sign is used to indicate an instance method and a
plus sign (not shown) is used to indicate a class method. The class
name <VAR>Class</VAR> and method name <VAR>methodName</VAR> are enclosed in
brackets, similar to the way messages are specified in Objective-C
source code. For example, to set a breakpoint at the <CODE>create</CODE>
instance method of class <CODE>Fruit</CODE> in the program currently being
debugged, enter:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>break -[Fruit create]
</FONT></pre></td></tr></table></P><P>
To list ten program lines around the <CODE>initialize</CODE> class method,
enter:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>list +[NSText initialize]
</FONT></pre></td></tr></table></P><P>
In the current version of GDB, the plus or minus sign is
required. In future versions of GDB, the plus or minus
sign will be optional, but you can use it to narrow the search. It
is also possible to specify just a method name:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>break create
</FONT></pre></td></tr></table></P><P>
You must specify the complete method name, including any colons. If
your program's source files contain more than one <CODE>create</CODE> method,
you'll be presented with a numbered list of classes that implement that
method. Indicate your choice by number, or type <SAMP>`0'</SAMP> to exit if
none apply.
</P><P>
As another example, to clear a breakpoint established at the
<CODE>makeKeyAndOrderFront:</CODE> method of the <CODE>NSWindow</CODE> class, enter:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>clear -[NSWindow makeKeyAndOrderFront:]
</FONT></pre></td></tr></table></P><P>
<A NAME="The Print Command with Objective-C"></A>
<HR SIZE="6">
<A NAME="SEC123"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC122"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC121"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.2.2 The Print Command With Objective-C </H4>
<!--docid::SEC123::-->
<P>
The print command has also been extended to accept methods. For example:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>print -[<VAR>object</VAR> hash]
</FONT></pre></td></tr></table></P><P>
<A NAME="IDX619"></A>
<A NAME="IDX620"></A>
will tell GDB to send the <CODE>hash</CODE> message to <VAR>object</VAR>
and print the result. Also, an additional command has been added,
<CODE>print-object</CODE> or <CODE>po</CODE> for short, which is meant to print
the description of an object. However, this command may only work
with certain Objective-C libraries that have a particular hook
function, <CODE>_NSPrintForDebugger</CODE>, defined.
</P><P>
<A NAME="Fortran"></A>
<HR SIZE="6">
<A NAME="SEC124"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC123"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC125"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.4.3 Fortran </H3>
<!--docid::SEC124::-->
<P>
GDB can be used to debug programs written in Fortran, but it
currently supports only the features of Fortran 77 language.
</P><P>
<A NAME="IDX621"></A>
Some Fortran compilers (GNU Fortran 77 and Fortran 95 compilers
among them) append an underscore to the names of variables and
functions. When you debug programs compiled by those compilers, you
will need to refer to variables and functions with a trailing
underscore.
</P><P>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC125">12.4.3.1 Fortran Operators and Expressions</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Fortran operators and expressions</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC126">12.4.3.2 Fortran Defaults</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Default settings for Fortran</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC127">12.4.3.3 Special Fortran Commands</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Special GDB commands for Fortran</TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="Fortran Operators"></A>
<HR SIZE="6">
<A NAME="SEC125"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC126"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.3.1 Fortran Operators and Expressions </H4>
<!--docid::SEC125::-->
<P>
<A NAME="IDX622"></A>
</P><P>
Operators must be defined on values of specific types. For instance,
<CODE>+</CODE> is defined on numbers, but not on characters or other non-
arithmetic types. Operators are often defined on groups of types.
</P><P>
<DL COMPACT>
<DT><CODE>**</CODE>
<DD>The exponentiation operator. It raises the first operand to the power
of the second one.
<P>
<DT><CODE>:</CODE>
<DD>The range operator. Normally used in the form of array(low:high) to
represent a section of array.
</DL>
<P>
<A NAME="Fortran Defaults"></A>
<HR SIZE="6">
<A NAME="SEC126"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC125"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC127"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC127"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.3.2 Fortran Defaults </H4>
<!--docid::SEC126::-->
<P>
<A NAME="IDX623"></A>
</P><P>
Fortran symbols are usually case-insensitive, so GDB by
default uses case-insensitive matches for Fortran symbols. You can
change that with the <SAMP>`set case-insensitive'</SAMP> command, see
<A HREF="gdb_14.html#SEC146">13. Examining the Symbol Table</A>, for the details.
</P><P>
<A NAME="Special Fortran Commands"></A>
<HR SIZE="6">
<A NAME="SEC127"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC126"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC124"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.3.3 Special Fortran Commands </H4>
<!--docid::SEC127::-->
<P>
<A NAME="IDX624"></A>
</P><P>
GDB has some commands to support Fortran-specific features,
such as displaying common blocks.
</P><P>
<DL COMPACT>
<A NAME="IDX625"></A>
<A NAME="IDX626"></A>
<DT><CODE>info common [<VAR>common-name</VAR>]</CODE>
<DD>This command prints the values contained in the Fortran <CODE>COMMON</CODE>
block whose name is <VAR>common-name</VAR>. With no argument, the names of
all <CODE>COMMON</CODE> blocks visible at the current program location are
printed.
</DL>
<P>
<A NAME="Pascal"></A>
<HR SIZE="6">
<A NAME="SEC128"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC127"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.4.4 Pascal </H3>
<!--docid::SEC128::-->
<P>
<A NAME="IDX627"></A>
Debugging Pascal programs which use sets, subranges, file variables, or
nested functions does not currently work. GDB does not support
entering expressions, printing values, or similar features using Pascal
syntax.
</P><P>
The Pascal-specific command <CODE>set print pascal_static-members</CODE>
controls whether static members of Pascal objects are displayed.
See section <A HREF="gdb_9.html#SEC66">pascal_static-members</A>.
</P><P>
<A NAME="Modula-2"></A>
<HR SIZE="6">
<A NAME="SEC129"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC128"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC130"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.4.5 Modula-2 </H3>
<!--docid::SEC129::-->
<P>
<A NAME="IDX628"></A>
</P><P>
The extensions made to GDB to support Modula-2 only support
output from the GNU Modula-2 compiler (which is currently being
developed). Other Modula-2 compilers are not currently supported, and
attempting to debug executables produced by them is most likely
to give an error as GDB reads in the executable's symbol
table.
</P><P>
<A NAME="IDX629"></A>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC130">12.4.5.1 Operators</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Built-in operators</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC131">12.4.5.2 Built-in Functions and Procedures</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Built-in functions and procedures</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC132">12.4.5.3 Constants</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Modula-2 constants</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC133">12.4.5.4 Modula-2 Types</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Modula-2 types</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC134">12.4.5.5 Modula-2 Defaults</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Default settings for Modula-2</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC135">12.4.5.6 Deviations from Standard Modula-2</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Deviations from standard Modula-2</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC136">12.4.5.7 Modula-2 Type and Range Checks</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Modula-2 type and range checks</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC137">12.4.5.8 The Scope Operators <CODE>::</CODE> and <CODE>.</CODE></A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">The scope operators <CODE>::</CODE> and <CODE>.</CODE></TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC138">12.4.5.9 GDB and Modula-2</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP"></TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="M2 Operators"></A>
<HR SIZE="6">
<A NAME="SEC130"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC131"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.1 Operators </H4>
<!--docid::SEC130::-->
<P>
Operators must be defined on values of specific types. For instance,
<CODE>+</CODE> is defined on numbers, but not on structures. Operators are
often defined on groups of types. For the purposes of Modula-2, the
following definitions hold:
</P><P>
<UL>
<LI>
<EM>Integral types</EM> consist of <CODE>INTEGER</CODE>, <CODE>CARDINAL</CODE>, and
their subranges.
<P>
<LI>
<EM>Character types</EM> consist of <CODE>CHAR</CODE> and its subranges.
<P>
<LI>
<EM>Floating-point types</EM> consist of <CODE>REAL</CODE>.
<P>
<LI>
<EM>Pointer types</EM> consist of anything declared as <CODE>POINTER TO
<VAR>type</VAR></CODE>.
<P>
<LI>
<EM>Scalar types</EM> consist of all of the above.
<P>
<LI>
<EM>Set types</EM> consist of <CODE>SET</CODE> and <CODE>BITSET</CODE> types.
<P>
<LI>
<EM>Boolean types</EM> consist of <CODE>BOOLEAN</CODE>.
</UL>
<P>
The following operators are supported, and appear in order of
increasing precedence:
</P><P>
<DL COMPACT>
<DT><CODE>,</CODE>
<DD>Function argument or array index separator.
<P>
<DT><CODE>:=</CODE>
<DD>Assignment. The value of <VAR>var</VAR> <CODE>:=</CODE> <VAR>value</VAR> is
<VAR>value</VAR>.
<P>
<DT><CODE><, ></CODE>
<DD>Less than, greater than on integral, floating-point, or enumerated
types.
<P>
<DT><CODE><=, >=</CODE>
<DD>Less than or equal to, greater than or equal to
on integral, floating-point and enumerated types, or set inclusion on
set types. Same precedence as <CODE><</CODE>.
<P>
<DT><CODE>=, <>, #</CODE>
<DD>Equality and two ways of expressing inequality, valid on scalar types.
Same precedence as <CODE><</CODE>. In GDB scripts, only <CODE><></CODE> is
available for inequality, since <CODE>#</CODE> conflicts with the script
comment character.
<P>
<DT><CODE>IN</CODE>
<DD>Set membership. Defined on set types and the types of their members.
Same precedence as <CODE><</CODE>.
<P>
<DT><CODE>OR</CODE>
<DD>Boolean disjunction. Defined on boolean types.
<P>
<DT><CODE>AND, &</CODE>
<DD>Boolean conjunction. Defined on boolean types.
<P>
<DT><CODE>@</CODE>
<DD>The GDB "artificial array" operator (see section <A HREF="gdb_9.html#SEC60">Expressions</A>).
<P>
<DT><CODE>+, -</CODE>
<DD>Addition and subtraction on integral and floating-point types, or union
and difference on set types.
<P>
<DT><CODE>*</CODE>
<DD>Multiplication on integral and floating-point types, or set intersection
on set types.
<P>
<DT><CODE>/</CODE>
<DD>Division on floating-point types, or symmetric set difference on set
types. Same precedence as <CODE>*</CODE>.
<P>
<DT><CODE>DIV, MOD</CODE>
<DD>Integer division and remainder. Defined on integral types. Same
precedence as <CODE>*</CODE>.
<P>
<DT><CODE>-</CODE>
<DD>Negative. Defined on <CODE>INTEGER</CODE> and <CODE>REAL</CODE> data.
<P>
<DT><CODE>^</CODE>
<DD>Pointer dereferencing. Defined on pointer types.
<P>
<DT><CODE>NOT</CODE>
<DD>Boolean negation. Defined on boolean types. Same precedence as
<CODE>^</CODE>.
<P>
<DT><CODE>.</CODE>
<DD><CODE>RECORD</CODE> field selector. Defined on <CODE>RECORD</CODE> data. Same
precedence as <CODE>^</CODE>.
<P>
<DT><CODE>[]</CODE>
<DD>Array indexing. Defined on <CODE>ARRAY</CODE> data. Same precedence as <CODE>^</CODE>.
<P>
<DT><CODE>()</CODE>
<DD>Procedure argument list. Defined on <CODE>PROCEDURE</CODE> objects. Same precedence
as <CODE>^</CODE>.
<P>
<DT><CODE>::, .</CODE>
<DD>GDB and Modula-2 scope operators.
</DL>
<P>
<BLOCKQUOTE>
<EM>Warning:</EM> Set expressions and their operations are not yet supported, so GDB
treats the use of the operator <CODE>IN</CODE>, or the use of operators
<CODE>+</CODE>, <CODE>-</CODE>, <CODE>*</CODE>, <CODE>/</CODE>, <CODE>=</CODE>, , <CODE><></CODE>, <CODE>#</CODE>,
<CODE><=</CODE>, and <CODE>>=</CODE> on sets as an error.
</BLOCKQUOTE>
<P>
<A NAME="Built-In Func/Proc"></A>
<HR SIZE="6">
<A NAME="SEC131"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC130"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC132"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC132"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.2 Built-in Functions and Procedures </H4>
<!--docid::SEC131::-->
<P>
Modula-2 also makes available several built-in procedures and functions.
In describing these, the following metavariables are used:
</P><P>
<DL COMPACT>
<DT><VAR>a</VAR>
<DD>represents an <CODE>ARRAY</CODE> variable.
<P>
<DT><VAR>c</VAR>
<DD>represents a <CODE>CHAR</CODE> constant or variable.
<P>
<DT><VAR>i</VAR>
<DD>represents a variable or constant of integral type.
<P>
<DT><VAR>m</VAR>
<DD>represents an identifier that belongs to a set. Generally used in the
same function with the metavariable <VAR>s</VAR>. The type of <VAR>s</VAR> should
be <CODE>SET OF <VAR>mtype</VAR></CODE> (where <VAR>mtype</VAR> is the type of <VAR>m</VAR>).
<P>
<DT><VAR>n</VAR>
<DD>represents a variable or constant of integral or floating-point type.
<P>
<DT><VAR>r</VAR>
<DD>represents a variable or constant of floating-point type.
<P>
<DT><VAR>t</VAR>
<DD>represents a type.
<P>
<DT><VAR>v</VAR>
<DD>represents a variable.
<P>
<DT><VAR>x</VAR>
<DD>represents a variable or constant of one of many types. See the
explanation of the function for details.
</DL>
<P>
All Modula-2 built-in procedures also return a result, described below.
</P><P>
<DL COMPACT>
<DT><CODE>ABS(<VAR>n</VAR>)</CODE>
<DD>Returns the absolute value of <VAR>n</VAR>.
<P>
<DT><CODE>CAP(<VAR>c</VAR>)</CODE>
<DD>If <VAR>c</VAR> is a lower case letter, it returns its upper case
equivalent, otherwise it returns its argument.
<P>
<DT><CODE>CHR(<VAR>i</VAR>)</CODE>
<DD>Returns the character whose ordinal value is <VAR>i</VAR>.
<P>
<DT><CODE>DEC(<VAR>v</VAR>)</CODE>
<DD>Decrements the value in the variable <VAR>v</VAR> by one. Returns the new value.
<P>
<DT><CODE>DEC(<VAR>v</VAR>,<VAR>i</VAR>)</CODE>
<DD>Decrements the value in the variable <VAR>v</VAR> by <VAR>i</VAR>. Returns the
new value.
<P>
<DT><CODE>EXCL(<VAR>m</VAR>,<VAR>s</VAR>)</CODE>
<DD>Removes the element <VAR>m</VAR> from the set <VAR>s</VAR>. Returns the new
set.
<P>
<DT><CODE>FLOAT(<VAR>i</VAR>)</CODE>
<DD>Returns the floating point equivalent of the integer <VAR>i</VAR>.
<P>
<DT><CODE>HIGH(<VAR>a</VAR>)</CODE>
<DD>Returns the index of the last member of <VAR>a</VAR>.
<P>
<DT><CODE>INC(<VAR>v</VAR>)</CODE>
<DD>Increments the value in the variable <VAR>v</VAR> by one. Returns the new value.
<P>
<DT><CODE>INC(<VAR>v</VAR>,<VAR>i</VAR>)</CODE>
<DD>Increments the value in the variable <VAR>v</VAR> by <VAR>i</VAR>. Returns the
new value.
<P>
<DT><CODE>INCL(<VAR>m</VAR>,<VAR>s</VAR>)</CODE>
<DD>Adds the element <VAR>m</VAR> to the set <VAR>s</VAR> if it is not already
there. Returns the new set.
<P>
<DT><CODE>MAX(<VAR>t</VAR>)</CODE>
<DD>Returns the maximum value of the type <VAR>t</VAR>.
<P>
<DT><CODE>MIN(<VAR>t</VAR>)</CODE>
<DD>Returns the minimum value of the type <VAR>t</VAR>.
<P>
<DT><CODE>ODD(<VAR>i</VAR>)</CODE>
<DD>Returns boolean TRUE if <VAR>i</VAR> is an odd number.
<P>
<DT><CODE>ORD(<VAR>x</VAR>)</CODE>
<DD>Returns the ordinal value of its argument. For example, the ordinal
value of a character is its ASCII value (on machines supporting the
ASCII character set). <VAR>x</VAR> must be of an ordered type, which include
integral, character and enumerated types.
<P>
<DT><CODE>SIZE(<VAR>x</VAR>)</CODE>
<DD>Returns the size of its argument. <VAR>x</VAR> can be a variable or a type.
<P>
<DT><CODE>TRUNC(<VAR>r</VAR>)</CODE>
<DD>Returns the integral part of <VAR>r</VAR>.
<P>
<DT><CODE>TSIZE(<VAR>x</VAR>)</CODE>
<DD>Returns the size of its argument. <VAR>x</VAR> can be a variable or a type.
<P>
<DT><CODE>VAL(<VAR>t</VAR>,<VAR>i</VAR>)</CODE>
<DD>Returns the member of the type <VAR>t</VAR> whose ordinal value is <VAR>i</VAR>.
</DL>
<P>
<BLOCKQUOTE>
<EM>Warning:</EM> Sets and their operations are not yet supported, so
GDB treats the use of procedures <CODE>INCL</CODE> and <CODE>EXCL</CODE> as
an error.
</BLOCKQUOTE>
<P>
<A NAME="IDX630"></A>
<A NAME="M2 Constants"></A>
<HR SIZE="6">
<A NAME="SEC132"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC131"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC133"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC133"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.3 Constants </H4>
<!--docid::SEC132::-->
<P>
GDB allows you to express the constants of Modula-2 in the following
ways:
</P><P>
<UL>
<LI>
Integer constants are simply a sequence of digits. When used in an
expression, a constant is interpreted to be type-compatible with the
rest of the expression. Hexadecimal integers are specified by a
trailing <SAMP>`H'</SAMP>, and octal integers by a trailing <SAMP>`B'</SAMP>.
<P>
<LI>
Floating point constants appear as a sequence of digits, followed by a
decimal point and another sequence of digits. An optional exponent can
then be specified, in the form <SAMP>`E[+|-]<VAR>nnn</VAR>'</SAMP>, where
<SAMP>`[+|-]<VAR>nnn</VAR>'</SAMP> is the desired exponent. All of the
digits of the floating point constant must be valid decimal (base 10)
digits.
<P>
<LI>
Character constants consist of a single character enclosed by a pair of
like quotes, either single (<CODE>'</CODE>) or double (<CODE>"</CODE>). They may
also be expressed by their ordinal value (their ASCII value, usually)
followed by a <SAMP>`C'</SAMP>.
<P>
<LI>
String constants consist of a sequence of characters enclosed by a
pair of like quotes, either single (<CODE>'</CODE>) or double (<CODE>"</CODE>).
Escape sequences in the style of C are also allowed. See section <A HREF="gdb_13.html#SEC114">C and C<TT>++</TT> Constants</A>, for a brief explanation of escape
sequences.
<P>
<LI>
Enumerated constants consist of an enumerated identifier.
<P>
<LI>
Boolean constants consist of the identifiers <CODE>TRUE</CODE> and
<CODE>FALSE</CODE>.
<P>
<LI>
Pointer constants consist of integral values only.
<P>
<LI>
Set constants are not yet supported.
</UL>
<P>
<A NAME="M2 Types"></A>
<HR SIZE="6">
<A NAME="SEC133"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC132"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC134"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC134"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.4 Modula-2 Types </H4>
<!--docid::SEC133::-->
<P>
Currently GDB can print the following data types in Modula-2
syntax: array types, record types, set types, pointer types, procedure
types, enumerated types, subrange types and base types. You can also
print the contents of variables declared using these type.
This section gives a number of simple source code examples together with
sample GDB sessions.
</P><P>
The first example contains the following section of code:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>VAR
s: SET OF CHAR ;
r: [20..40] ;
</FONT></pre></td></tr></table></P><P>
and you can request GDB to interrogate the type and value of
<CODE>r</CODE> and <CODE>s</CODE>.
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) print s
{'A'..'C', 'Z'}
(gdb) ptype s
SET OF CHAR
(gdb) print r
21
(gdb) ptype r
[20..40]
</FONT></pre></td></tr></table></P><P>
Likewise if your source code declares <CODE>s</CODE> as:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>VAR
s: SET ['A'..'Z'] ;
</FONT></pre></td></tr></table></P><P>
then you may query the type of <CODE>s</CODE> by:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) ptype s
type = SET ['A'..'Z']
</FONT></pre></td></tr></table></P><P>
Note that at present you cannot interactively manipulate set
expressions using the debugger.
</P><P>
The following example shows how you might declare an array in Modula-2
and how you can interact with GDB to print its type and contents:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>VAR
s: ARRAY [-10..10] OF CHAR ;
</FONT></pre></td></tr></table></P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) ptype s
ARRAY [-10..10] OF CHAR
</FONT></pre></td></tr></table></P><P>
Note that the array handling is not yet complete and although the type
is printed correctly, expression handling still assumes that all
arrays have a lower bound of zero and not <CODE>-10</CODE> as in the example
above.
</P><P>
Here are some more type related Modula-2 examples:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>TYPE
colour = (blue, red, yellow, green) ;
t = [blue..yellow] ;
VAR
s: t ;
BEGIN
s := blue ;
</FONT></pre></td></tr></table></P><P>
The GDB interaction shows how you can query the data type
and value of a variable.
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) print s
$1 = blue
(gdb) ptype t
type = [blue..yellow]
</FONT></pre></td></tr></table></P><P>
In this example a Modula-2 array is declared and its contents
displayed. Observe that the contents are written in the same way as
their <CODE>C</CODE> counterparts.
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>VAR
s: ARRAY [1..5] OF CARDINAL ;
BEGIN
s[1] := 1 ;
</FONT></pre></td></tr></table></P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) print s
$1 = {1, 0, 0, 0, 0}
(gdb) ptype s
type = ARRAY [1..5] OF CARDINAL
</FONT></pre></td></tr></table></P><P>
The Modula-2 language interface to GDB also understands
pointer types as shown in this example:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>VAR
s: POINTER TO ARRAY [1..5] OF CARDINAL ;
BEGIN
NEW(s) ;
s^[1] := 1 ;
</FONT></pre></td></tr></table></P><P>
and you can request that GDB describes the type of <CODE>s</CODE>.
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) ptype s
type = POINTER TO ARRAY [1..5] OF CARDINAL
</FONT></pre></td></tr></table></P><P>
GDB handles compound types as we can see in this example.
Here we combine array types, record types, pointer types and subrange
types:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>TYPE
foo = RECORD
f1: CARDINAL ;
f2: CHAR ;
f3: myarray ;
END ;
myarray = ARRAY myrange OF CARDINAL ;
myrange = [-2..2] ;
VAR
s: POINTER TO ARRAY myrange OF foo ;
</FONT></pre></td></tr></table></P><P>
and you can ask GDB to describe the type of <CODE>s</CODE> as shown
below.
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) ptype s
type = POINTER TO ARRAY [-2..2] OF foo = RECORD
f1 : CARDINAL;
f2 : CHAR;
f3 : ARRAY [-2..2] OF CARDINAL;
END
</FONT></pre></td></tr></table></P><P>
<A NAME="M2 Defaults"></A>
<HR SIZE="6">
<A NAME="SEC134"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC133"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC135"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC135"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.5 Modula-2 Defaults </H4>
<!--docid::SEC134::-->
<P>
If type and range checking are set automatically by GDB, they
both default to <CODE>on</CODE> whenever the working language changes to
Modula-2. This happens regardless of whether you or GDB
selected the working language.
</P><P>
If you allow GDB to set the language automatically, then entering
code compiled from a file whose name ends with <TT>`.mod'</TT> sets the
working language to Modula-2. See section <A HREF="gdb_13.html#SEC106">Having GDB Infer the Source Language</A>, for further details.
</P><P>
<A NAME="Deviations"></A>
<HR SIZE="6">
<A NAME="SEC135"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC134"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC136"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC136"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.6 Deviations from Standard Modula-2 </H4>
<!--docid::SEC135::-->
<P>
A few changes have been made to make Modula-2 programs easier to debug.
This is done primarily via loosening its type strictness:
</P><P>
<UL>
<LI>
Unlike in standard Modula-2, pointer constants can be formed by
integers. This allows you to modify pointer variables during
debugging. (In standard Modula-2, the actual address contained in a
pointer variable is hidden from you; it can only be modified
through direct assignment to another pointer variable or expression that
returned a pointer.)
<P>
<LI>
C escape sequences can be used in strings and characters to represent
non-printable characters. GDB prints out strings with these
escape sequences embedded. Single non-printable characters are
printed using the <SAMP>`CHR(<VAR>nnn</VAR>)'</SAMP> format.
<P>
<LI>
The assignment operator (<CODE>:=</CODE>) returns the value of its right-hand
argument.
<P>
<LI>
All built-in procedures both modify <EM>and</EM> return their argument.
</UL>
<P>
<A NAME="M2 Checks"></A>
<HR SIZE="6">
<A NAME="SEC136"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC135"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC137"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC137"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.7 Modula-2 Type and Range Checks </H4>
<!--docid::SEC136::-->
<P>
<BLOCKQUOTE>
<EM>Warning:</EM> in this release, GDB does not yet perform type or
range checking.
</BLOCKQUOTE>
<P>
GDB considers two Modula-2 variables type equivalent if:
</P><P>
<UL>
<LI>
They are of types that have been declared equivalent via a <CODE>TYPE
<VAR>t1</VAR> = <VAR>t2</VAR></CODE> statement
<P>
<LI>
They have been declared on the same line. (Note: This is true of the
GNU Modula-2 compiler, but it may not be true of other compilers.)
</UL>
<P>
As long as type checking is enabled, any attempt to combine variables
whose types are not equivalent is an error.
</P><P>
Range checking is done on all mathematical operations, assignment, array
index bounds, and all built-in functions and procedures.
</P><P>
<A NAME="M2 Scope"></A>
<HR SIZE="6">
<A NAME="SEC137"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC136"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC138"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC138"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.8 The Scope Operators <CODE>::</CODE> and <CODE>.</CODE> </H4>
<!--docid::SEC137::-->
<P>
There are a few subtle differences between the Modula-2 scope operator
(<CODE>.</CODE>) and the GDB scope operator (<CODE>::</CODE>). The two have
similar syntax:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>
<VAR>module</VAR> . <VAR>id</VAR>
<VAR>scope</VAR> :: <VAR>id</VAR>
</FONT></pre></td></tr></table></P><P>
where <VAR>scope</VAR> is the name of a module or a procedure,
<VAR>module</VAR> the name of a module, and <VAR>id</VAR> is any declared
identifier within your program, except another module.
</P><P>
Using the <CODE>::</CODE> operator makes GDB search the scope
specified by <VAR>scope</VAR> for the identifier <VAR>id</VAR>. If it is not
found in the specified scope, then GDB searches all scopes
enclosing the one specified by <VAR>scope</VAR>.
</P><P>
Using the <CODE>.</CODE> operator makes GDB search the current scope for
the identifier specified by <VAR>id</VAR> that was imported from the
definition module specified by <VAR>module</VAR>. With this operator, it is
an error if the identifier <VAR>id</VAR> was not imported from definition
module <VAR>module</VAR>, or if <VAR>id</VAR> is not an identifier in
<VAR>module</VAR>.
</P><P>
<A NAME="GDB/M2"></A>
<HR SIZE="6">
<A NAME="SEC138"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC137"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC129"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.5.9 GDB and Modula-2 </H4>
<!--docid::SEC138::-->
<P>
Some GDB commands have little use when debugging Modula-2 programs.
Five subcommands of <CODE>set print</CODE> and <CODE>show print</CODE> apply
specifically to C and C<TT>++</TT>: <SAMP>`vtbl'</SAMP>, <SAMP>`demangle'</SAMP>,
<SAMP>`asm-demangle'</SAMP>, <SAMP>`object'</SAMP>, and <SAMP>`union'</SAMP>. The first four
apply to C<TT>++</TT>, and the last to the C <CODE>union</CODE> type, which has no direct
analogue in Modula-2.
</P><P>
The <CODE>@</CODE> operator (see section <A HREF="gdb_9.html#SEC60">Expressions</A>), while available
with any language, is not useful with Modula-2. Its
intent is to aid the debugging of <EM>dynamic arrays</EM>, which cannot be
created in Modula-2 as they can in C or C<TT>++</TT>. However, because an
address can be specified by an integral constant, the construct
<SAMP>`{<VAR>type</VAR>}<VAR>adrexp</VAR>'</SAMP> is still useful.
</P><P>
<A NAME="IDX631"></A>
In GDB scripts, the Modula-2 inequality operator <CODE>#</CODE> is
interpreted as the beginning of a comment. Use <CODE><></CODE> instead.
</P><P>
<A NAME="Ada"></A>
<HR SIZE="6">
<A NAME="SEC139"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC138"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC140"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC111"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H3> 12.4.6 Ada </H3>
<!--docid::SEC139::-->
<P>
The extensions made to GDB for Ada only support
output from the GNU Ada (GNAT) compiler.
Other Ada compilers are not currently supported, and
attempting to debug executables produced by them is most likely
to be difficult.
</P><P>
<A NAME="IDX632"></A>
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC140">12.4.6.1 Introduction</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">General remarks on the Ada syntax
and semantics supported by Ada mode
in GDB.</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC141">12.4.6.2 Omissions from Ada</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Restrictions on the Ada expression syntax.</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC142">12.4.6.3 Additions to Ada</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Extensions of the Ada expression syntax.</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC143">12.4.6.4 Stopping at the Very Beginning</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Debugging the program during elaboration.</TD></TR>
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_13.html#SEC144">12.4.6.5 Known Peculiarities of Ada Mode</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Known peculiarities of Ada mode.</TD></TR>
</TABLE></BLOCKQUOTE>
<P>
<A NAME="Ada Mode Intro"></A>
<HR SIZE="6">
<A NAME="SEC140"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC141"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.6.1 Introduction </H4>
<!--docid::SEC140::-->
<P>
The Ada mode of GDB supports a fairly large subset of Ada expression
syntax, with some extensions.
The philosophy behind the design of this subset is
</P><P>
<UL>
<LI>
That GDB should provide basic literals and access to operations for
arithmetic, dereferencing, field selection, indexing, and subprogram calls,
leaving more sophisticated computations to subprograms written into the
program (which therefore may be called from GDB).
<P>
<LI>
That type safety and strict adherence to Ada language restrictions
are not particularly important to the GDB user.
<P>
<LI>
That brevity is important to the GDB user.
</UL>
<P>
Thus, for brevity, the debugger acts as if there were
implicit <CODE>with</CODE> and <CODE>use</CODE> clauses in effect for all user-written
packages, making it unnecessary to fully qualify most names with
their packages, regardless of context. Where this causes ambiguity,
GDB asks the user's intent.
</P><P>
The debugger will start in Ada mode if it detects an Ada main program.
As for other languages, it will enter Ada mode when stopped in a program that
was translated from an Ada source file.
</P><P>
While in Ada mode, you may use `<TT>--</TT>' for comments. This is useful
mostly for documenting command files. The standard GDB comment
(<SAMP>`#'</SAMP>) still works at the beginning of a line in Ada mode, but not in the
middle (to allow based literals).
</P><P>
The debugger supports limited overloading. Given a subprogram call in which
the function symbol has multiple definitions, it will use the number of
actual parameters and some information about their types to attempt to narrow
the set of definitions. It also makes very limited use of context, preferring
procedures to functions in the context of the <CODE>call</CODE> command, and
functions to procedures elsewhere.
</P><P>
<A NAME="Omissions from Ada"></A>
<HR SIZE="6">
<A NAME="SEC141"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC140"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC142"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC142"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.6.2 Omissions from Ada </H4>
<!--docid::SEC141::-->
<P>
Here are the notable omissions from the subset:
</P><P>
<UL>
<LI>
Only a subset of the attributes are supported:
<P>
<UL>
<LI>
<TT>'First</TT>, <TT>'Last</TT>, and <TT>'Length</TT>
on array objects (not on types and subtypes).
<P>
<LI>
<TT>'Min</TT> and <TT>'Max</TT>.
<P>
<LI>
<TT>'Pos</TT> and <TT>'Val</TT>.
<P>
<LI>
<TT>'Tag</TT>.
<P>
<LI>
<TT>'Range</TT> on array objects (not subtypes), but only as the right
operand of the membership (<CODE>in</CODE>) operator.
<P>
<LI>
<TT>'Access</TT>, <TT>'Unchecked_Access</TT>, and
<TT>'Unrestricted_Access</TT> (a GNAT extension).
<P>
<LI>
<TT>'Address</TT>.
</UL>
<P>
<LI>
The names in
<CODE>Characters.Latin_1</CODE> are not available and
concatenation is not implemented. Thus, escape characters in strings are
not currently available.
<P>
<LI>
Equality tests (<SAMP>`='</SAMP> and <SAMP>`/='</SAMP>) on arrays test for bitwise
equality of representations. They will generally work correctly
for strings and arrays whose elements have integer or enumeration types.
They may not work correctly for arrays whose element
types have user-defined equality, for arrays of real values
(in particular, IEEE-conformant floating point, because of negative
zeroes and NaNs), and for arrays whose elements contain unused bits with
indeterminate values.
<P>
<LI>
The other component-by-component array operations (<CODE>and</CODE>, <CODE>or</CODE>,
<CODE>xor</CODE>, <CODE>not</CODE>, and relational tests other than equality)
are not implemented.
<P>
<LI>
<A NAME="IDX633"></A>
<A NAME="IDX634"></A>
<A NAME="IDX635"></A>
There is limited support for array and record aggregates. They are
permitted only on the right sides of assignments, as in these examples:
<P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>set An_Array := (1, 2, 3, 4, 5, 6)
set An_Array := (1, others => 0)
set An_Array := (0|4 => 1, 1..3 => 2, 5 => 6)
set A_2D_Array := ((1, 2, 3), (4, 5, 6), (7, 8, 9))
set A_Record := (1, "Peter", True);
set A_Record := (Name => "Peter", Id => 1, Alive => True)
</FONT></pre></td></tr></table></P><P>
Changing a
discriminant's value by assigning an aggregate has an
undefined effect if that discriminant is used within the record.
However, you can first modify discriminants by directly assigning to
them (which normally would not be allowed in Ada), and then performing an
aggregate assignment. For example, given a variable <CODE>A_Rec</CODE>
declared to have a type such as:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>type Rec (Len : Small_Integer := 0) is record
Id : Integer;
Vals : IntArray (1 .. Len);
end record;
</FONT></pre></td></tr></table></P><P>
you can assign a value with a different size of <CODE>Vals</CODE> with two
assignments:
</P><P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>set A_Rec.Len := 4
set A_Rec := (Id => 42, Vals => (1, 2, 3, 4))
</FONT></pre></td></tr></table></P><P>
As this example also illustrates, GDB is very loose about the usual
rules concerning aggregates. You may leave out some of the
components of an array or record aggregate (such as the <CODE>Len</CODE>
component in the assignment to <CODE>A_Rec</CODE> above); they will retain their
original values upon assignment. You may freely use dynamic values as
indices in component associations. You may even use overlapping or
redundant component associations, although which component values are
assigned in such cases is not defined.
</P><P>
<LI>
Calls to dispatching subprograms are not implemented.
<P>
<LI>
The overloading algorithm is much more limited (i.e., less selective)
than that of real Ada. It makes only limited use of the context in
which a subexpression appears to resolve its meaning, and it is much
looser in its rules for allowing type matches. As a result, some
function calls will be ambiguous, and the user will be asked to choose
the proper resolution.
<P>
<LI>
The <CODE>new</CODE> operator is not implemented.
<P>
<LI>
Entry calls are not implemented.
<P>
<LI>
Aside from printing, arithmetic operations on the native VAX floating-point
formats are not supported.
<P>
<LI>
It is not possible to slice a packed array.
</UL>
<P>
<A NAME="Additions to Ada"></A>
<HR SIZE="6">
<A NAME="SEC142"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC141"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC143"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC143"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.6.3 Additions to Ada </H4>
<!--docid::SEC142::-->
<P>
As it does for other languages, GDB makes certain generic
extensions to Ada (see section <A HREF="gdb_9.html#SEC60">8.1 Expressions</A>):
</P><P>
<UL>
<LI>
If the expression <VAR>E</VAR> is a variable residing in memory (typically
a local variable or array element) and <VAR>N</VAR> is a positive integer,
then <CODE><VAR>E</VAR>@<VAR>N</VAR></CODE> displays the values of <VAR>E</VAR> and the
<VAR>N</VAR>-1 adjacent variables following it in memory as an array. In
Ada, this operator is generally not necessary, since its prime use is
in displaying parts of an array, and slicing will usually do this in
Ada. However, there are occasional uses when debugging programs in
which certain debugging information has been optimized away.
<P>
<LI>
<CODE><VAR>B</VAR>::<VAR>var</VAR></CODE> means "the variable named <VAR>var</VAR> that
appears in function or file <VAR>B</VAR>." When <VAR>B</VAR> is a file name,
you must typically surround it in single quotes.
<P>
<LI>
The expression <CODE>{<VAR>type</VAR>} <VAR>addr</VAR></CODE> means "the variable of type
<VAR>type</VAR> that appears at address <VAR>addr</VAR>."
<P>
<LI>
A name starting with <SAMP>`$'</SAMP> is a convenience variable
(see section <A HREF="gdb_9.html#SEC68">8.9 Convenience Variables</A>) or a machine register (see section <A HREF="gdb_9.html#SEC69">8.10 Registers</A>).
</UL>
<P>
In addition, GDB provides a few other shortcuts and outright
additions specific to Ada:
</P><P>
<UL>
<LI>
The assignment statement is allowed as an expression, returning
its right-hand operand as its value. Thus, you may enter
<P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>set x := y + 3
print A(tmp := y + 1)
</FONT></pre></td></tr></table></P><P>
<LI>
The semicolon is allowed as an "operator," returning as its value
the value of its right-hand operand.
This allows, for example,
complex conditional breaks:
<P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>break f
condition 1 (report(i); k += 1; A(k) > 100)
</FONT></pre></td></tr></table></P><P>
<LI>
Rather than use catenation and symbolic character names to introduce special
characters into strings, one may instead use a special bracket notation,
which is also used to print strings. A sequence of characters of the form
<SAMP>`["<VAR>XX</VAR>"]'</SAMP> within a string or character literal denotes the
(single) character whose numeric encoding is <VAR>XX</VAR> in hexadecimal. The
sequence of characters <SAMP>`["""]'</SAMP> also denotes a single quotation mark
in strings. For example,
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre> "One line.["0a"]Next line.["0a"]"
</FONT></pre></td></tr></table>contains an ASCII newline character (<CODE>Ada.Characters.Latin_1.LF</CODE>)
after each period.
<P>
<LI>
The subtype used as a prefix for the attributes <TT>'Pos</TT>, <TT>'Min</TT>, and
<TT>'Max</TT> is optional (and is ignored in any case). For example, it is valid
to write
<P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>print 'max(x, y)
</FONT></pre></td></tr></table></P><P>
<LI>
When printing arrays, GDB uses positional notation when the
array has a lower bound of 1, and uses a modified named notation otherwise.
For example, a one-dimensional array of three integers with a lower bound
of 3 might print as
<P>
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(3 => 10, 17, 1)
</FONT></pre></td></tr></table></P><P>
That is, in contrast to valid Ada, only the first component has a <CODE>=></CODE>
clause.
</P><P>
<LI>
You may abbreviate attributes in expressions with any unique,
multi-character subsequence of
their names (an exact match gets preference).
For example, you may use <TT>a'len</TT>, <TT>a'gth</TT>, or <TT>a'lh</TT>
in place of <TT>a'length</TT>.
<P>
<LI>
<A NAME="IDX636"></A>
Since Ada is case-insensitive, the debugger normally maps identifiers you type
to lower case. The GNAT compiler uses upper-case characters for
some of its internal identifiers, which are normally of no interest to users.
For the rare occasions when you actually have to look at them,
enclose them in angle brackets to avoid the lower-case mapping.
For example,
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>gdb print <JMPBUF_SAVE>[0]
</FONT></pre></td></tr></table><P>
<LI>
Printing an object of class-wide type or dereferencing an
access-to-class-wide value will display all the components of the object's
specific type (as indicated by its run-time tag). Likewise, component
selection on such a value will operate on the specific type of the
object.
<P>
</UL>
<P>
<A NAME="Stopping Before Main Program"></A>
<HR SIZE="6">
<A NAME="SEC143"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC142"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC144"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC144"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.6.4 Stopping at the Very Beginning </H4>
<!--docid::SEC143::-->
<P>
<A NAME="IDX637"></A>
It is sometimes necessary to debug the program during elaboration, and
before reaching the main procedure.
As defined in the Ada Reference
Manual, the elaboration code is invoked from a procedure called
<CODE>adainit</CODE>. To run your program up to the beginning of
elaboration, simply use the following two commands:
<CODE>tbreak adainit</CODE> and <CODE>run</CODE>.
</P><P>
<A NAME="Ada Glitches"></A>
<HR SIZE="6">
<A NAME="SEC144"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC143"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC139"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC145"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H4> 12.4.6.5 Known Peculiarities of Ada Mode </H4>
<!--docid::SEC144::-->
<P>
Besides the omissions listed previously (see section <A HREF="gdb_13.html#SEC141">12.4.6.2 Omissions from Ada</A>),
we know of several problems with and limitations of Ada mode in
GDB,
some of which will be fixed with planned future releases of the debugger
and the GNU Ada compiler.
</P><P>
<UL>
<LI>
Currently, the debugger
has insufficient information to determine whether certain pointers represent
pointers to objects or the objects themselves.
Thus, the user may have to tack an extra <CODE>.all</CODE> after an expression
to get it printed properly.
<P>
<LI>
Static constants that the compiler chooses not to materialize as objects in
storage are invisible to the debugger.
<P>
<LI>
Named parameter associations in function argument lists are ignored (the
argument lists are treated as positional).
<P>
<LI>
Many useful library packages are currently invisible to the debugger.
<P>
<LI>
Fixed-point arithmetic, conversions, input, and output is carried out using
floating-point arithmetic, and may give results that only approximate those on
the host machine.
<P>
<LI>
The type of the <TT>'Address</TT> attribute may not be <CODE>System.Address</CODE>.
<P>
<LI>
The GNAT compiler never generates the prefix <CODE>Standard</CODE> for any of
the standard symbols defined by the Ada language. GDB knows about
this: it will strip the prefix from names when you use it, and will never
look for a name you have so qualified among local symbols, nor match against
symbols in other packages or subprograms. If you have
defined entities anywhere in your program other than parameters and
local variables whose simple names match names in <CODE>Standard</CODE>,
GNAT's lack of qualification here can cause confusion. When this happens,
you can usually resolve the confusion
by qualifying the problematic names with package
<CODE>Standard</CODE> explicitly.
</UL>
<P>
<A NAME="Unsupported Languages"></A>
<HR SIZE="6">
<A NAME="SEC145"></A>
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC144"> < </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_14.html#SEC146"> > </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> Up </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_14.html#SEC146"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<H2> 12.5 Unsupported Languages </H2>
<!--docid::SEC145::-->
<P>
<A NAME="IDX638"></A>
<A NAME="IDX639"></A>
In addition to the other fully-supported programming languages,
GDB also provides a pseudo-language, called <CODE>minimal</CODE>.
It does not represent a real programming language, but provides a set
of capabilities close to what the C or assembly languages provide.
This should allow most simple operations to be performed while debugging
an application that uses a language currently not supported by GDB.
</P><P>
If the language is set to <CODE>auto</CODE>, GDB will automatically
select this language if the current frame corresponds to an unsupported
language.
</P><P>
<A NAME="Symbols"></A>
<HR SIZE="6">
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> << </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_14.html#SEC146"> >> </A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
</TR></TABLE>
<BR>
<FONT SIZE="-1">
<address>
<p>Please send FSF & GNU inquiries & questions to <a
href="mailto:gnu@gnu.org">gnu@gnu.org</a>. There are also <a
href="http://www.gnu.org/home.html#ContactInfo">other ways to
contact</a> the FSF.</p>
<p>These pages are maintained by <a
href="http://www.gnu.org/software/gdb/">the GDB developers</a>.</p>
<p>Copyright Free Software Foundation, Inc., 59 Temple Place - Suite
330, Boston, MA 02111, USA.</p>
<p>Verbatim copying and distribution of this entire article is
permitted in any medium, provided this notice is preserved.</p>
</address>
This document was generated
by <I>GDB Administrator</I> on <I>March, 27 2008</I>
using <A HREF="http://www.mathematik.uni-kl.de/~obachman/Texi2html
"><I>texi2html</I></A>
</BODY>
</HTML>