警告：可用的文件描述符（256）数量不够。如果程序中包含太多线程，
您可能需要设置mt_scalable 选项，或在文件描述符的数量上增加硬限制。
参见 mt_scalable 下的“help dbxenv”。

# Copyright 06/23/98 Sun Microsystems, Inc. All Rights Reserved
#
# helpfile.dbx 1.326 98/06/23
# This is the dbx help file
# Written by Neil Smithline on Sun Sep 20 07:52:08 1992 by copying
# from dbx online help (the old printf mechanism).
#
# The file format is that:
#       comments begin with a `#' and are ignored.
#       #ifdef FOO, #endif works
#       topics begin with a `:topicname' on a line by itself
#       topics with subtopics are `:topicname$$subtopicname' on a line
#               by itself
#       one-line help (for the "commands" command) is `%cmd - helpstring'
#       CDE help-tag markup may be placed on a line that begins with `$'
# A `\' can be put at the beginning of a line and will escape the next
# character.
#
# CDE help-tag markup: use $<ex> ... $<\ex> for examples
#   use $<image> ... $<\image> for fixed format, but not typewriter font
#   use $<p indent> for an indented paragraph
#   use $<otherhead> or $<procedure> for headings
#   use $<newline> to force a newline
#   use $# to prefix text lines that should NOT appear in the CDE helpfile
#
# "See also" should start a separate line.
#
# The script is smart enough to recognize most lists.  For nested lists,
# the second level should use " o " for the bullet, not " * ".
#
# I18N - topicnames should not be translated unless immediately preceded by
# a comment line containing "I18N"
#
# I18N - do not translate any of the command names in this file. To generate
# a list of all dbx command names, run dbx and type
#
#        commands -all
#
# Try not to leave unintentional blank lines as they might end up
# in the output.  If you want to skip a line for clarity, make it
# a null comment.
#
# Tabs are expanded by the preprocessing step to avoid dependencies on
# the user's tab settings.  The filter assumes tabs are set every 8 columns.
#
# Top-level help, result of `help' with no arguments
:command$$summary

使用“commands”命令查看命令摘要，它由每个 dbx 命令的单行描述组成。

执行与跟踪
  cancel       catch        clear        cont         delete       
  fix          fixed        handler      ignore       intercept    
  next         pop          replay       rerun        restore      
  run          runargs      save         status       step         
  stop         trace        unintercept  when         whocatches   

显示和命名数据
  assign       call         dis          display      down       
  dump         examine      exists       frame        hide       
  print        undisplay    unhide       up           whatis
  where        whereami     whereis      which      

访问源文件
  bsearch      cd           edit         file         files        
  func         funcs        line         list         loadobject   
  loadobjects  module       modules      pathmap      pwd          
  search

调试多线程
  lwp          lwps         sync         syncs        thread       threads 

运行时检查
  check        showblock    showleaks    showmemuse   suppress    
  uncheck      unsuppress

杂项
  attach       collector    commands     dalias        dbxenv
  debug        detach       document     help          history
  import       kalias       kill         language      mmapfile
  quit         setenv       sh           source        !
  !!

dbx 的 GUI 界面
  button       unbutton

机器级别
  adb          examine      listi        nexti        registers    
  regs         stepi        stopi        tracei       wheni    

特定语言的信息帮助主题
  c++          fortran      fortran90    fortran77

# I18N (do not translate "alias", ".dbxrc", "-E", "FAQ", "forwardref",
# "ksh", "lwpid", "MT", or "tid" from the message below)

其他帮助主题
  alias           anachronisms  array-slicing  callbacks     changes
  .dbxrc          dbx           editing        environment   events
  FAQ             fix-pitfalls  follow-fork    format        forwardref
  invocation      ksh           lwpid          MT            OpenMP
  optimized-code  options       path           prettyprint   redirection
  registers       rtc           scope          signals       startup
  tid

  changes301      changes31     changes32      changes40     changes50
  changes60       changes61     changes62      changes70     changes71
  changes72
  
‘help <cmdname>’命令为每一个命令或主题提供附加的帮助。要了解新的和更改过的
功能，参见“help changes”和“help FAQ”以获取对 dbx 相关常见问题的解答。

########################################################################
################################# Other Topics #########################
########################################################################
# I18N - translate this topicname to match same word in `Other Topics' message
:array-slicing（主题）
dbx 支持 C、C++ 和 Fortran 语言中“print”和“display”命令中的
array-slicing 功能。

C 和 C++ 的 array-slicing 功能的语法是：

    print <arr-exp>[<first-exp>..<last-exp>:<stride-exp>]

这里：

    <arr-exp> 是一个等价于一个数组类型或指针类型的表达式，
    <first-exp> 和 <last-exp> 是要输出的第一个与最后一个元素，
    <stride-exp> 是跨距。

<first-exp>、<last-exp> 和 <stride-exp> 都是（可选的）表达式，但它们的值都
必须是整数。<first-exp> 和 <stride-exp> 的缺省值分别为 0 和 1。对数组类型来说 
<last-exp> 是可选的，并且缺省值为该数组的上界。

实例：

(dbx) print arr[2..4]
arr[2..4] =
[2] = 2
[3] = 3
[4] = 4

(dbx) print arr[..2]
arr[0..2] =
[0] = 0
[1] = 1
[2] = 2

(dbx) print arr[2..6:2]
arr[2..8:2] =
[2] = 2
[4] = 4
[6] = 6


Fortran 中 array-slicing 功能的语法是：

   print <arr-exp>(<first-exp>:<last-exp>:<stride-exp>)

这里：
   
    <arr-exp> 必须是一个等价于数组类型的表达式，
    <first-exp> 和 <last-exp> 是要输出的第一个与最后一个元素，
    <stride-exp> 是跨距。

<first-exp>、<last-exp> 和 <stride-exp> 都是（可选的）表达式，但它们的值都
必须是整数。<first-exp> 和 <last-exp> 的缺省值分别为数组的上界和下界。
<stride-exp> 缺省值为 1。

实例:

(dbx) print arr(2:6)
arr(2:6) =
    (2) 2
    (3) 3
    (4) 4
    (5) 5
    (6) 6

(dbx) print arr(2:6:2)
arr(2:6:2) =
    (2) 2
    (4) 4
    (6) 6

#
# I18N - translate this topicname to match same word in `Other Topics' message
:changes（标题）
 dbx 7.3 相对于 7.2 的主要新增功能为:

o dbx 支持在 Linux 上使用 gcc 和 g++ 编译的二进制文件。

o RTC 支持 Solaris 10 上的访问检查，并使用链接审计接口。
  如果你以后要附件 dbx 并使用 RTC，那么现在您应该使用
  LD_AUDIT=rtcaudit.so，而不是 LD_PRELOAD=librtc.so。
  另请参见 `help rtc attach'

另请参见 `help changes72'

:changes72 (topic)
dbx 7.2 相对于 7.1 的新增功能为：

o dbx 已增强了其对 IDE 的支持。

另请参见“help changes71”

:changes71（标题）
dbx 7.1 相对于 7.0 的主要新特征是：

#o 用新的 dbxenv 变量“mi_mode”控制 dbx 输出“stop”、“run”、“cont”等等
#  命令的 GDB/MI 格式。（参见“mi_mode”下的“help dbxenv”）。
#
o “detach”的新的 -stop 选项，将使进程保持挂起状态。
  参见“help detach”。

o 事件处理程序的新的修饰符“-resumeone”，它对多线程程序中带函数调用的条件
  很有帮助。参见“help resumeone”。

o OpenMP 支持 Fortran 和 C。

另请参见“help changes70”

:changes70（标题）
7.0（Forte Developer 7）相对于 6.2 的主要新特征是：

o 下列 dbxenv 变量已被删除：
     aout_cache_size
     locache_enable
     delay_xs

  aout_cache_size 和 locache_enable 变量被用于控制 dbx 何时丢弃程序和共享库中
  的符号信息。缺省行为现在不可更改，当一个新的可执行程序被调试后，dbx 将丢弃前
  一个可执行程序的符号信息，并且这些库将被重用直至它们在磁盘上被更新，或直至
   dbx 会话被终止。

  delay_xs 变量被用于禁用采用 -xs 标志编译的程序和共享库的符号信息的按需加载，
  并强制立刻载入所有的信息。按需加载现在始终打开。

  在处理 dbxenv 变量和 dbx 版本差异时需要帮助，
  参见“help dbxenv”。

o 现在可以使用一个新的“loadobject”命令来控制和罗列 dbx 加载的符号。
  参见“help loadobject”。
  例如，“excluded”加载对象的实现就是不同的。

o 现在将用 argv[0] 的最后一个路径组件来替代 argv[0] 中的完整字符串作为缺省
  提示符。它修正了以下错误：没有设置 PS1 的 V9 dbx 用户看到的提示符是
  “(.../mumble/foo/bar/dbx)”而不是“(dbx)”。

o 添加了新的命令行选项“-x exec32”以抑制支持 SparcV9 二进制的系统的 64 位
  dbx 二进制。

另请参见“help changes62”

:changes62（标题）
6.2（Forte Developer 6 update 2）相对于 6.1 的主要新特征是：

o dbx 环境变量“rtc_use_traps”已被删除。只要硬件是 UltraSparc，陷阱就会被
  自动使用。
o 现在有一些基本支持，可以查看不同版本的 Solaris 的核心文件。参见“help core 
  mismatch”以了解详细内容。
o 支持步进特定的函数。参见“help step to”以了解详细内容。
o Intel 上对 Fortran intrinsics 的支持已被删除。
o Dbx 自动将一些过时的 dbxenv 变量的名称转换为它们新的名称。参见“help 
  dbxenv”以了解详细内容。
o 当前的缺省命令行编辑模式是 emacs。参见 FAQ 中的“我该如何启用命令行编辑？”
  以了解详细内容（“help FAQ”）。
o 已实现了两个新的采集器命令：“pause”和“resume”。
  参见 “help collector” 了解详细内容。
o 采集器的 enable_once 命令已被删除。
o 采集器 store 命令已被扩展来包含实验组。
  
另请参见“help changes61”

:changes61（标题）
6.1 版（Forte Developer 6 update 1）相对于 6.0 版的主要新特征是：

o dbx 环境变量“cfront_demangling”已被删除。
  dbx（允许 cfront-demangling）的“-F”选项也已被删除。
  使用一个 dbx 的早期版本以获取 cfront 支持。
o 该发行版本继续支持 Intel 上的 Fortran intrinsics，即使 WorkShop 6 中并不带
  Intel Fortran 编译器。
  下一个 dbx 发行版本将不再支持 Intel 上的 Fortran intrinsics。
  
另请参见“help changes60”

:changes60（标题）
6.0 版（WorkShop 6）相对于 5.0 版的主要新特征是：

o 只读 ksh 变量“firedhandlers”可以与“delete”和“handler”命令配合使用，
  作为“clear”的另一选择。（参见“help handler”和“help delete”）。
o “clear”命令简化了被 inclass、inmethod 和 infunction 使用的单独断点的部分
  清除。（参见“help clear”）。
o 跟踪的输出可以被重定向到文件（参见“help trace”）。
o 程序停止时，可用新的 dbxenv 变量“stack_find_source”来控制 dbx 是否自动
  “提升”为一个包含源的堆栈帧。（参见 “stack_find_source”下的“help 
  dbxenv”）。
o 新的 dbxenv 变量 “proc_exclusive_attach” 可以控制 dbx 是否能绑定一个被
  其他调试器或调试工具控制的进程。（参见“proc_exclusive_attach”下的“help 
  dbxenv”）。
o 新的 dbxenv 变量“step_granularity”可以控制“step”和“next”是否能在语句
  或整个行上工作。（参见“step_granularity”下的“help dbxenv”）。
o 新的 dbxenv 变量“mt_scalable”有助于调试带有许多 LWP 的多线程应用程序。
（参见“mt_scalable”下的“help dbxenv”）。
o C++ 内联成员函数中的断点可以正确工作。它包含了处理程序条件（-if）的正确
  求值。
o 与 LWP 相关的命令（参见“help lwp”和“help lwps”）当前一直可用，而不仅仅
  是在调试一个多线程应用程序时才可用。
o 如果 Control-C 似乎并未停止一个挂起的进程，连续三次按下 Control-C 将以其他
  方法强制停止进程。（参见“help interrupt”）。
o 现在使用 -g -O 进行编译时，完整的行号信息将被记录下。您现在可以在优化了的
  代码中进行“step”和“next”了，当前行将随着代码的调度向前和向后跳跃。
  dbx 内输出的变量值在优化后的代码中仍然是不可靠的.

该版本和发行版本 5.0 存在下列不兼容：

o 早期的跟踪命令语法不再被接受。（参见“help trace”以了解更多信息。）
o dbxenv “mt_watchpoints”已被删除。始终允许监视点。
o 不再支持 Objective C。使用发行版本 5.0 调试 Objective C。

另请参见“help changes50”

:changes50（标题）
5.0 版（WorkShop 5.0）相对于 4.0 版的主要新特征是：

o 速度更快、功能更强的数据监视点（参见“help event watchpoint”）
  （Solaris 2.6，2.7）
o 新的 shell 变量 $machtype & $datamodel（参见“help event variables”）。
o 在一个失败的“调用”之后可调用“pop -c”进行清除（参见“help pop”和“help 
  call”）。
o 功能更强、“扩展性更好”的 button 命令（参见“help buttonx”）。
o 在启动过程中加载对象的符号信息可以被忽略（参见“help loadobjects”和“help 
  loadobject management”）。
o 可以预加载加载对象的符号信息，因此可以将断点放置在将被执行 dlopen() 命令的
  共享对象中（参见“help loadobjects”和“help loadobject management”）。
o 新命令能处理线程级同步（锁）（参见“help sync”和“help thread”）。
o 在 dbx 启动时不会加载采用 -xs 选项编译的模块的调试信息。取而代之的是按需
  加载。这将导致固定启动速度的改进，减少了对 -xs 使用的禁止。
  （参见“help dbxenv”中的“delay_xs”）。
o Dbx 提供了显式控制是否可截取未处理和未预料的 C++ 异常。在早期的版本中，
  它们始终是可截取的。（参见“help intercept”）
o 支持从远程主机调试核心文件。（参见“help loadobject exclusion”）。

该版本和发行版本 4.0 存在下列不兼容：

o 不再接受没有“-”的事件规范修饰符。参见“help anachronisms”。
另请参见“help changes40”

:changes40（标题）
4.0 版（WorkShop 4.0）相对于 3.2 版的主要新特征是：

o 采集器现在支持 MT 应用程序（参见“help collector mt”）
o fork/exec/attach 支持运行时检查（RTC）（参见“help rtc attach”以了解
  详细内容）
o RTC 带有一个用于跟踪应用程序指定分配器的 API（参见“help rtc api”）
o 新命令“regs”可输出寄存器的当前值（参见“help regs”）
o 新命令“showblock”可给出堆栈块的详细内容（参见“help showblock”）
o 增强的“pathmap”命令（参见“help pathmap”）
o 新的 dbxenv 变量“language_mode”（参见“language_mode”下的“help 
  dbxenv”）
o 新的 dbxenv 变量 “output_inherited_members”
  （参见“output_inherited_members”下的“help dbxenv”）
o 两个新的 dbx 只读变量：$helpfile 和 $helpfile_html（参见“help help”）
o 用于“module”和“modules”命令的新的 -v（verbose）标志（参见“help 
  module”和“help modules”）
o 用于 print 和 display 命令的新 +r 标志（参见“help print”）
o dbxenv 变量“scope_look_aside”的缺省值已更改为 on
  （参见 scope_look_aside 下的“help dbxenv”和“help scope”）
o 提供“stop inobject <c++_obj_exp>”支持的新“inobject”事件
  （参见“help c++ inobject”和“help event specification”）
o “inclass”事件现在支持模板类（参见“help c++ inclass”和“help event 
  specification”）
o “stop at <lineno>”现在支持 C++ 模板定义以及在头文件中定义的 C++ 内联函数
  （参见“at”事件下的“help event specification”）
o 支持新的 C++ 运算符：“const_cast”、“dynamic_cast”、
  “reinterpret_cast”和“static_cast”
o 支持新的 C++ “typeid”运算符
o 提供了帮助文件的 HTML 版本（参见“help help”）

另请参见“help changes32”
# I18N - translate this topicname to match same word in `Other Topics' message
:changes32（标题）
3.2 版（PARCWorks 3.1）相对于 3.1 版的主要新特征是：

o  Objective C 支持
o  Fortran 90 支持（参见“help fortran”）
o  运行时检查（RTC）会给出关于内存使用的信息（参见“help check”和“help 
   showmemuse”）
o  “whereis -a”显示了地址的符号名称（参见“help whereis”）
o  支持 Pascal 的“with”语句
o  SPARC V8+ 支持（参见“help dbxenv”和“help registers”）
o  更好的支持精简二进制
o  所有命令的单行描述符（参见“help commands”）
o  dbx 输出并接受“U”、“L”和“LL”后缀以表示 unsigned，long 和 long long 
   数量。

另请参见“help changes31”。
# I18N - translate this topicname to match same word in `Other Topics' message
:changes31（标题）
3.1 版（SparcWorks 3.0.2）相对于 3.0.1 版的主要新特征是：

o  运行时检查 (RTC) 现在支持多线程应用程序。参见“help rtc mt”。
o  “adb” 模式（参见“help adb”以了解详细内容）
o  输出格式控制（参见“output_base”下的“help dbxenv”）
o  C 和 C++ 的 array-slicing（参见“help array-slicing”）
o  支持 Fortran 的内函数。
o  用于 $[] 的“print”标志（参见“help ksh expressions”）
o  类 Printf 输出格式控制（参见“help format”）
o  支持用户提供的灵活的输出函数（参见“help prettyprint”）
o  “runargs”命令（参见“help runargs”）

另请参见“help changes301”。
#
# I18N - translate this topicname to match same word in `Other Topics' message
:changes301（主题）
3.0.1 版相对于 2.0.1 版的主要新特征是：

(1) 类似于 KornShell 命令的新解释器（参见“help ksh”以了解详细内容）
(2) 支持多线程程序（参见“help MT”）
(3) 对于 C++ 有更好的支持（参见“help c++”）
(4) 语言表达式使用 $[]（参见“help ksh expressions”）
(5) 更强的事件机制（参见“help events”）
(6) 快速的数据监视点（参见“help event watchpoint”）
(7) 自动跟随 exec() 和 fork()（参见“help follow-fork”和“help debug 
    clone”）
(8) 修复和继续（参见“help fix”）
(9) 运行时检查（参见“help rtc”、“help check”和“help showleaks”）

该版本和发行版本 2.0.1 中存在下列不兼容：

(1) “address/format”命令现在为“x address/format”
(2) “address=format”命令现在为“x address=format”
(3) “/pattern”命令现在为“search pattern”
(4) “?pattern”命令现在为“bsearch pattern”
(5) “set”命令现在为KornShell“set”命令；使用“assign”
(6) “modules”命令的语法已更改（参见“help module”和“help modules”）
(7) 仅在明确被请求时使用核心文件
(8) 来自“status”的重定向输出不再像输入一样可用（参见“help status”）
#
#
:anachronisms（主题）
随着 dbx 的发展，它的命令和语法也发展为新的形式。尝试维护向下兼容性时，
并不总是可行的。在这样的情况下，当 dbx 检测到早期的语法时，它会接受该语法，
但同时会发出一个“过时的”警告消息。这意味着在以后的 dbx 发行版本中将不再
接受这样的命令或语法。

当前所维护的向下兼容性如下所示：

o 在 dbx 发行版本 4.0 中，“trace”命令符合“stop”和“when”所使用的语法。
  在可能的情况下，仍然接受“trace”的 BSD dbx 样式命令语法。参见“help 
  trace”和“help tracei”。

o 在 dbx 发行版本 4.0 中，“use”命令被映射为相应的“pathmap”命令。
  参见“help use”。

o dbx 发行版本 4.0 切换到与 getopt() 兼容的 command-line 选项，
  但仍然接受旧样式的 cmdline 选项。

o 在 dbx 的发行版本 3.2 中，fix 命令的 -d 选项被 -f 替换。

o 从发行版本 3.0 起，“stop”和“when”命令一直使用“in”和“at”之类的
  关键字来区分事件。如果无法识别这个关键字，将会把它假定为一个 <variable> 
  或 <expression>。之所以在发行版本 4.0 中引入关键字“cond”和“change”，
  是为了逐步淘汰格式 <variable>、<cond-expr> 的事件规范的非关键字语法，但是
  仍然接受这些格式。参见“help event specification”。

不再支持下列向下兼容性：

o 在 dbx 发行版本 3.0 中，“stop”和“when”接受的事件规范的自由格式类
  英语语法已被正规化。参见“help event specification”。所有事件规范
  修饰符现在都被加上了“-”前缀。不再接受下列没有“-”的修饰符：

        if <cond>
        in <func>
        <lwpid>
        <tid>
#
:.dbxinit（dbx 主题）
很早以前的 dbx 版本读取一个名为“.dbxinit”的启动文件，该文件使用的语法略有
不同。就在不久前，如果 dbx 没有找到一个“.dbxrc”文件却找到了
“.dbxinit”文件，它仍然能够读取那些旧格式文件。而现在 Dbx 不再支持此功能。
如果您仍想使用一个“.dbxinit”文件，则需要稍微更新一下它的语法并将其重命名为
“.dbxrc”。

如果您愿意，您可以简单地将任何“alias”命令更改为“dalias”，或者您也可以更改
语法以匹配新的 ksh 样式的“alias”命令。

换句话说，就是将“alias foo bar baz”更改为“dalias foo bar baz”，或者 
             将“alias foo bar baz”命令更改为“alias foo="bar baz"”

要了解一些有用的别名和定制，您可以查阅“help .dbxrc”。




:.dbxrc（dbx 主题）
\# 生成一个新的 .dbxrc 文件并包含此帮助主题的内容，
\# 使用以下命令：
\#      help .dbxrc >$HOME/.dbxrc
\# 要启用一个有用的选项集，请使用：
\#      help .dbxrc | sed 's/^##/  /' >$HOME/.dbxrc
\# 然后使用：
\#      source $HOME/.dbxrc
\
\
\# 下面一节提供了 .dbxrc 文件中的典型条目：
\
\#  set +o path              # 取消注释此行以禁用 $PATH 搜索
\## set -o ignoresuspend     # 取消注释以使 dbx 忽略 ^Z
\## set -o emacs             # 取消注释以启用 emacs 风格命令编辑
\#  set -o vi                # 取消注释此行以便进行 vi 风格编辑
\## dbxenv output_short_file_name on  # 输出文件的短路径名
\## dbxenv scope_look_aside on # 查找文件的静态符号，即使不在范围内
\## dbxenv output_dynamic_type on  # 使“-d”作为输出和显示的缺省值 (C++)
\#  dbxenv stack_verbose off # 禁止输出“where”中的参数和行号（提高性能）
\## 按钮忽略设置    # 将“step up”按钮添加到 GUI
\
\# 启用 dbx 日志以帮助 Sun 支持人员对错误进行诊断
\# 在字段中。如果您正在运行中的 sparcv9 机器上进行调试
\# 一个 64 位内核，取消注释以下两个命令：
\#
\#  import /opt/SUNWspro/lib/v9/debugging.so >/dev/null
\#  log -default -start
\#
\# 否则，取消注释以下两个命令：
\#
\#  import /opt/SUNWspro/lib/debugging.so >/dev/null
\#  log -default -start

\
\# 有用的别名：
\#
\## kalias alias=kalias         # 确保使用了 KSH 别名语法
\## alias n=next
\## alias N=nexti
\## alias s=step
\## alias S=stepi
\## alias su="step up"
\## alias c=cont
\## alias p=print
\## alias q=quit
\## alias w=where
\## alias si="stop in"
\## alias sa="stop at"
\## alias sm="stop modify"
\## alias sr="stop returns"
\## alias sif="stop infunction"
\## alias sim="stop inmember"
\## alias sic="stop inclass"
\## alias en="handler -enable"
\## alias di="handler -disable"
\## alias wi=whatis
\## alias l=list
\## alias u=up
\## alias d=down
\## alias h=history
\## alias f=frame
\## alias goto="stop at !:1 -temp; cont"
\## button lineno goto
\
\# 有用的函数：
\
\## function hex    # 以十六进制输出参数
\## {
\##     : ${1?"usage: $0 <expr>  # print <expr> in hex"}
\##     typeset -i16 x
\##     ((x = $[(int)$*]))
\##     echo - $* = $x
\## }
\## typeset -q hex
\
\## 函数 pp # 输出指针；将表达式输出为符号
\## {           # 地址和十六进制值
\##   : ${1?"usage: $0 <expr> # print expr as symbolic address and hex value"}
\##     builtin examine $[(int)$*]/X
\## }
\## typeset -q pp
\
\## 函数 offsetof  # 以 $1 类型输出 $2 的偏移：offsetof strct fld
\## {
\##     : ${2?"usage: $0 <structname> <fieldname>  # 以 struct 输出 fld 的偏移"}
\##     [ -z "$3" ] || { echo "$0: 未预料的参数" >&2 && return; }
\##     echo - $[(int)(&((($1*)0)->$2))]
\## }
\## alias off=offsetof
\
\## 函数环境  # 转储目标进程的环境变量
\## {
\##     [ -z "$1" ] || { echo "$0: 未预料的参数" >&2 && return; }
\##     typeset -i i=0
\##     typeset env="((char **)$[(char**)environ])"
\##     while :
\##     do
\##         x=$[($env)[$i]]
\##         echo "$i: " "${x#0x*\ }"
\##         case "$x" in
\##         *\(nil\)*)    break;;
\##         esac
\##         ((i += 1))
\##     done
\## }
\
\## 函数 hexdump         # dump $2 (default: sizeof $1) bytes in hex
\## {
\##     : ${1?"usage: $0 <exp> [<size>]  # dump <size> bytes in hex"}
\##     typeset -i16 p="$[(void *)&$1]"                     # address of $1
\##     typeset -i s="${2:-$[sizeof ($1)]}" >/dev/null 2>&1 # number of bytes
\## 
\##     builtin examine $p/$[(${s:-4}+3)/4]X
\## }
\## typeset -q hexdump
\
\## alias hd=hexdump
\
\## 按钮文字 hexdump        # 取消注释以安装 GUI 按钮
\
\## if $havegui
\## then
\##     SMSO=                    # 不能使用 GUI 中的保留视频
\##     RMSO=
\## else
\##     SMSO=$(tput smso)        # 开始 standout 模式（保留视频）
\##     RMSO=$(tput rmso)        # 结束 standout 模式
\## fi
\
\## PS1="$SMSO(dbx !)$RMSO " # 附带保留历史编号的保留视频提示
\
\# _cb_prompt 回调例程的实例（参见“help callbacks”）
\
\# function _cb_prompt
\# {
\#     if $mtfeatures
\#     then    # 设置 MT 调试提示
\#             PS1='${SMSO}${thread} ${lwp} <!>${RMSO} '
\#     else    # 设置非线程调试提示
\#             PS1='${SMSO}dbx<!>${RMSO} '
\#     fi
\# }
\
#
# I18N - translate this topicname to match same word in `Other Topics' message
:事件（主题）
发生事件时，dbx 允许您停止进程、执行任意命令或输出信息。一个最简单的事件实例
就是断点。其他事件的实例包括错误、信号、系统调用、dlopen 和监视点。

下列命令用于创建事件的“句柄”，每一个都具有特定的副作用：

        stop <eventspec>        # 在指定事件发生时停止并提示用户
        when <eventspec> { <cmd> ; [ ... ] }
                                # 在指定事件发生时执行命令
        trace <eventspec>       # 为给定的事件输出“跟踪”

要了解完整的事件列表、它们的定义以及“stop”、“when”和“trace”命令
接受的 <eventspec> 语法，请参见“help event specification”。

上述命令返回由它们创建句柄的 ID <hid>。可在下列命令中使用该 ID。
“all”通常可以取代 <hid>。

status [ <hid> ]        # 列出指定句柄；如果没有指定就列出全部
handler -disable <hid>  # 禁用指定句柄
handler -enable <hid>   # 启用指定句柄
handler -reset <hid>    # 重置 <hid> 的计数器（参见“help event 
                        # specification”）
delete <hid>            # 删除指定句柄
clear <lineno>          # 删除指定行上的任何句柄。
clear                   # “clear $lineno”的速记

另请参见“help event”。
# I18N - translate this topicname to match same word in `Other Topics' message
:finding-files（主题）
查找与程序相关的源文件和目标文件时，Dbx 偶尔会遇到困难。下面是相关机制、环境和
解决方法...

机制

缺省情况下符号信息被存储在“.o”文件中。为了在源行获取信息，dbx 不得不发现并
加载“.o”文件。“.o”文件的位置被记录在可执行文件中的一个索引中。这个完整
路径名由编译器记录，并且反映了工作目录和完整路径的编译器概念。

并不是所有的符号信息都被存储在可执行文件中以减少容量大小。如果仍要使用
早期的行为，用编译器的 -xs 标志对源进行编译，这样所有的符号信息将被复制到
可执行文件中

在以前发布的版本中，何时将所有符号信息加载到 dbx 中是一个问题。然而从版本 5.0
开始，信息是按需提取的，初始加载时间同未使用 -xs 时一样快。

一旦符号信息被加载，dbx 可能会显示源行并尝试打开与“.o”相对应的源文件。
源文件和“.o”文件的对应关系记录在可执行文件的索引中。

Dbx 根据所记录的完整路径名来访问目标文件，但对于源文件，用户往往只想指定
文件的基名：
        stop at test.cc:34
Dbx 将在内部数据库中查找该文件。

故障环境以及如何处理...

o 源文件已经被删除。
  无需采取太多措施。Dbx 将不能显示源文件，但如果可以在目标文件中获取它（或者
  曾经使用了 -xs），则可以获取堆栈跟踪、输出变量的值甚至了解您在哪一行上。

o 目标文件已被删除。
  这种情况有些糟糕，因为符号信息的大小将变得不可接受。为避免这种情况，您可以
  通过使用 -xs 标记来编译您的代码。

o 源文件或目标文件已被移动（但没有被重命名）。
  使用 pathmap 命令。有关完整讨论，请参见“help pathmap”；但是简而言之，
  如果一个文件已从
        /home/jack/project/main.c
  移动到
        /home/jill/project/main.c，
  请执行“pathmap /home/jack /home/jill”。Pathmap 只在目录路径上有效，
  所以如果 Jill 将“main.c”重命名为“Main.c”，pathmap 将不起作用。

o 目录名称的符号链接
  您在 
        /home/jack/project 
  中编译您的代码，但是在通过软连接执行 cd 之后，您正在调试该代码
        /company/projects/project-j -> /home/jack/project
  (或采用其他方式)。但在任何情况下都应该没有问题。

o 文件名称的符号链接
  如果您的项目布局如下所示
        .../proj/src/t.c
        .../proc/sparc/t.c -> ../src/t.c
        .../proc/intel/t.c -> ../src/t.c
  那就应该没有问题了。
  然而，如果软连接的名称和实际文件的名称不一样，dbx 将不能在任何情况下
  都正确地定位源文件。下面是一个实例：
        .../proj/win/Toot.cpp
        .../proj/unix/toot.cc -> ../win/Toot.cpp
  这种情况下的规则是：“如果您采用软连接名称进行编译，dbx 将通过文件的
  软连接名称找到该文件，反之亦然”。

o 从不同的机器访问源文件或目标文件。
  文件在机器“bean”上被编译，但 Jack 正在 Jill 的机器上调试它们。调试器将
  寻找 /home/jack/project 下的文件，却无法从 Jill 的机器上访问这些文件。
  解决方案还是 pathmap，使用方法如下所示：
        pathmap /home/jack /net/bean/home/jack

o 不确定的源文件名
  您的项目结构如下所示：
        /home/professor/project/main/file.c
        /home/professor/project/module1/file.c
        /home/professor/project/module2/file.c
  更为普遍的情况是，您的应用程序是由不同人员所维护的组件构成的：
        /home/jack/project/...
        /home/jack/project/test.c
        /home/jill/project/...
        /home/jill/project/test.c
  （在大型项目中，这是不可避免的。）如果您在此处执行“stop at test.c:35”，
  dbx 将随机选取一个文件。要解决这个问题，请注意 dbx 搜索文件名时是使用一种
  右锚定最匹配算法，所以会执行以下之一：
        stop at main/file.c:50
        stop at jill/project/test.c

#
# I18N - translate this topicname to match same word in `Other Topics' message
:fix-pitfalls（主题）
        修复、继续限制和预防
        -----------------

使用“修复”和“继续”时，可以通过以下方式修改源：

 * 添加、删除或更改函数中的各代码行
 * 添加或删除函数
 * 添加或删除全局变量和静态变量


        限制
        ----

将函数从旧文件映射到新文件时，dbx 可能会有问题。为了在编辑源文件时尽量减少
此类问题，请注意不要：

 * 更改函数的名称
 * 添加、删除参数或将其类型更改为函数
 * 添加、删除或修改函数中当前在堆栈中激活的局部变量（参阅“pop”
   以了解更多信息）
 * 只有 C++ 模板函数定义的函数体可以被更改。如果对模板声明或模板实例进行任何
   更改，都需要完全重新创建程序
 * 修复共享目标文件 (.so) 可能需要更改 a.out 的源。必须在一种特殊的模式
   （“RTLD_NOW|RTLD_GLOBAL”或“RTLD_LAZY|RTLD_GLOBAL”）下对共享对象
   执行 dlopen，才能使“修复”和“继续”正确工作。

        预防
        ----

如果在执行“修复”和“继续”之后恢复程序执行，可能会导致源文件出现无法直接
关联到实际修改的错误。在对源进行修改之后以及恢复程序执行之前，您应该注意以
下条件：

 * 如果正在被修改的函数已安装在堆栈上（不是顶部帧上），程序将在返回该帧时执行
   旧代码（未修改的代码）。

 * 在旧代码的堆栈上，已实例化函数中的断点将会丢失。

 * pop 或 fix 命令不能撤消对全局变量的更改。使用“assign”为全局变量手动赋予
   正确的值。

 * 静态变量的值在“修复”之后一般都能保留。然而，如果文件初始未能和调试信息
   一起被编译，该文件中的静态变量会在每次修复之后被重新初始化。使用“assign”
   为静态变量手动赋予正确的值。

 * 如果由于编辑而更改了源代码的行数，断点的放置可能会不正确。dbx 会警告您
   断点被移动至新行。在运行程序之前，您应该在新代码中使用状态命令来检查断点的
   位置。

 * 程序计数器被移至新（修复后）函数所在相同行的起始处。如果该函数被修改，
   程序计数器可能会在错误的一行上结束。在此情况下，请执行以下一项操作：

        o 使用“pop”命令。它从堆栈中弹出一个或多个帧。然后执行“cont”
          以重新进入函数。

        o 使用“cont at <linenum>”命令，从另一行开始继续（在执行前有效地
          移动 pc）。

        o 在继续之前手动修复数据结构（使用“assign”）。

        o 重新运行程序。

 * 如果您更改了一个 C++ 模板定义，则必须对定义该模板实例的所有文件发出
   修复命令。

# I18N - translate this topicname to match same word in `Other Topics' message
:forwardref（主题）
dbx 能正确处理在当前范围内随后被定义的所有向前引用。例如，使用以下代码：

        struct foo;
        struct foo *fp;
        struct foo { /* stuff */ };

dbx 允许您继承 fp（例如：“print *fp”)。如果向前引用没有在该范围中定义，
则 dbx 在处理继承时可能会遇到一些问题。例如：

        struct bar;
        struct bar *bp;
        /* no further definition of struct bar */

dbx 并非始终可以对“print *bp”命令进行求值。如果是这样的话，
您可以将指针显式地指向一个已知的类型，例如：

        print *(`bar.cc`struct bar *)bp

其中，“bar.cc”是一个定义了结构 bar 的文件。在 C++ 中，该命令可以缩写成：

        print *(`bar.cc`bar *)bp

或者，作为另一种选择，您可以发布“module bar.cc”命令，
使得随后 bar 类型的所有输出都能成功。
:follow-fork（命令）

dbxenv follow_fork_mode ...     # 进程执行一个 fork/vfork/fork1 时...
dbxenv follow_fork_mode parent  # ... 跟随父进程（缺省）
dbxenv follow_fork_mode child   # ... 跟在子进程后面
dbxenv follow_fork_mode both    # ... 跟在父进程和子进程后面（仅限于 GUI）
dbxenv follow_fork_mode ask     # ... 询问用户需要以上哪种模式

dbxenv follow_fork_inherit ...  # 跟在子进程后面时 ...
dbxenv follow_fork_inherit on   # ... 继承事件
dbxenv follow_fork_inherit off  # ... 不继承事件（缺省）
另请参见变量名 follow_fork_mode_inner 下的“help dbxenv”。

有时候进程要经过几次派生，而且很难知道您要跟在哪个派生后面。
我们建议使用 GUI，那样现有的堆栈跟踪可以帮助您作出正确的选择。
如果没有 GUI，我们建议您使用“ask”模式，该模式允许您弹出菜单以便
可以发出一个“where”命令。其后的“cont”将会再次询问您。
:OpenMP（主题）

dbx 中的 OpenMP 调试支持基于 dbx 中的一般多线程调试功能。
要获得完整的调试信息，程序必须通过 -xopenmp=noopt -g 标志来编译。

dbx允许您进入一个 OpenMP 并行区域的单步执行。但是步入并行区域的线程
可能与发起步入操作的线程不是同一个线程。这是因为并行区域是从运行时库中
被“outline”和调用的。进入并行区域的单步执行事实上包含了几个库调用和
线程创建。

dbx 还允许输出共享的、专用的和线程专用的变量。如果尝试过从并行区域外部输出
一个线程专用变量，则会输出线程专用变量的主线程副本。
:optimized-code（主题）

如果在同时启用优化和调试的情况下 (-O -g) 编译程序，dbx 将在限定模式下
进行操作。

关于在什么情况下哪些编译器发出哪种符号信息的详细信息通常被认为是不稳定的接口，
可能随版本的变化而不同。

源行的信息可用，但一个源行的代码可能出现在一个优化程序的几处不同位置，
所以通过按源行步过程序会导致“当前行”在源文件中跳转，这取决于优化器
如何调度代码。

函数中的最后有效操作是对另一个函数的调用时，尾部调用优化会导致丢失堆栈帧。

通常，参数、局部参数和全局参数的符号信息均可用于优化的程序。关于结构、
联合和 C++ 类的类型信息以及局部参数、全局参数的类型和名称应该可用。
C++ 编译器不会提供局部参数的符号类型信息，但 C 编译器却可以。
 
程序中关于这些项的位置的完整信息对于优化的程序是不可用的。

全局变量可以正常输出和赋值，尽管可能会由于最后的寄存器到内存的存储
并未发生而导致它们的值不准确。

只有当您在一个函数刚开始就停止时才会输出参数，这是因为参数寄存器可以
被编译器重复使用。堆栈变量的值不能在优化的程序中被输出或使用，因为
这些变量的堆栈和寄存器位置没被记录下来。

在 Forte Developer Analyzer 手册中也有一章内容与编译器优化有关，
在调试一个优化的程序时可能会有帮助。
:optimization
                        # 参见“help optimized-code”。
#
# I18N - translate this topicname to match same word in `Other Topics' message
:dbx
                        # 参见“help invocation”。
:options
                        # 参见“help invocation”。
:^C（主题）
参见“help interrupt”
:interrupt（主题）
一个运行的进程可以用 ^C 来中断。该进程将在 SIGINT 上停止，dbx 将会给出提示。
“cont”、“step”等将恢复执行并去掉 SIGINT。要转发 SIGINT，请使用
“cont -sig int”或类似的命令。

在某些情况下，您会看到这样的警告：
        warning: Interrupt ignored but forwarded to child.
如果 dbx 和被调试的进程在同一个终端控制之下（在 GUI 外调试并使用
“run”命令时的通常情况），^C 将被转换成 SIGINT 并传递给 dbx 和该进程。
dbx 将忽略发送给它的 SIGINT，最后您会在被调试的进程收到其 SIGINT 时
得到一个提示。

有时 ^C 会无效。此情况通常发生在调试多线程应用程序或是 SIGINT 被
应用程序阻塞时。这种情况下，如果三次使用 ^C 后仍然无效，dbx 会尝试
使用其它侵入式方法来停止该进程。

:invocation（主题）
dbx 识别以下命令行选项：

        -c <cmds>       # 在提示输入前执行 <cmds>
        -C              # 预加载运行时检查库（参见“help check”）
        -d              # 与 -s 一起使用，读后删除 <file>
        -f              # 强制加载核心文件，即使它不匹配。
        -h              # 输出关于 dbx 的用法帮助
        -I <dir>        # 将 <dir> 添加至“pathmap”集合
                          （参见“help pathmap”）
        -k              # 保存并恢复键盘转换状态
        -q              # 禁止关于读 stabs 的消息
        -r              # 运行程序；如果程序正常退出，则退出
        -R              # 输出关于 dbx 的自述文件
        -s <file>       # 用 <file> 替代 .dbxrc 
        -S              # 禁止读取特定站点初始化文件
        -V              # 输出 dbx 的版本
        -w <n>          # 在“where”命令上跳过 <n> 帧  
        -x exec32       # 32位模式。
                          禁止使用支持 SparcV9 二进制的系统的 64 位 
                          dbx 二进制。用 SparcV8/32 位二进制替代。
        --              # 标记选项列表的末尾；如果程序名称以短线开头，
                        # 则使用此选项

以下选项可用于调试 dbx：
        -e              # 在执行前回显每个命令

如果使用了“-r”，则程序的参数将跟随在程序名称之后。
在其它所有情况下，程序名称必须位于最后，或者后跟核心文件名或进程 ID。

        dbx [options] <prog>              # 调试 <prog>
        dbx [options] <prog> <core>       # 用核心文件 <core> 调试 <prog>
        dbx [options] <prog> <pid>        # 用进程 ID <pid> 调试 <prog>
        dbx [options] - <pid>             # 调试进程 ID <pid>；dbx 
                                          # 通过 /proc 查找程序
        dbx [options] - <core>            # 用核心文件 <core> 调试；
                                          # 另请参见“help debug”
        dbx [options] -r <prog> <args>    # 用参数 <args> 运行 <prog>；
                                          # 如果异常终止，则开始调试 <prog>，
                                          # 否则退出

#
:core (主题)
可以在 dbx 启动时在命令行上指定一个核心文件，或者在 dbx 运行时将其作为
一个选项提供给“debug”命令。通过这种方法可以检查已损坏进程的映像，
从而找出损坏的原因。指定一个核心文件后，可以通过对其文件名加“-”
来选择性地省略可执行文件。

查找二进制
---------

如果一个核心文件没有用一个二进制命名，则 dbx 将试图从核心文件中抽取程序名。
如果核心文件中未提供可执行文件的完全路径名，Dbx 可能找不到该文件。
长路径名用于运行一个程序时，该路径名有时会在核心文件中被截断。如果出现此情况，
只要在通知 dbx 加载该核心文件时指明二进制的完整路径名即可。

被截断的核心文件
--------------

如果您在加载一个核心文件时遇到问题，首先要注意是否使用了被截断的核心文件。
有一个 shell 命令可以指定允许的最大核心文件大小。如果在该核心文件被创建时
将此值设得太低，dbx 在读取最终被截断的核心文件时会遇到麻烦。在 csh shell 
中可读取“limit”命令，在 sh 和 ksh shell 中可读取“ulimit”命令。

如果 dbx 拒绝一个被截断的核心文件，最好的办法就是在您的 shell 启动文件中
更改“limit”设置，重新寻找源启动文件，然后尝试创建一个新的核心文件。

如果核心文件不完整并且缺少堆栈段，则不会提供堆栈再跟踪信息。如果缺少运行时
连接器信息，则不会提供加载对象列表。在此情况下，您还会收到一则关于
“librtld-db.so”没被初始化的错误消息。如果缺少 LWP 列表，则不会提供线程信息、
lwp 信息或堆栈再跟踪信息；如果您运行“where”，则会收到一则关于程序没被
“激活”的错误信息。

如果可能的话，dbx 将在核心文件被截断时通知您并告知此情况可能持续了多久。

Solaris 兼容性
--------------

如果您在加载核心文件时遇到问题，另一个可能性是由于该核心文件是在不同的 
Solaris 版本上创建的。最好的解决方法是在与创建核心文件的系统使用相同操作系统
和补丁级别的一台系统上运行 dbx。

有关在与当前 Solaris 版本不同的版本上支持转储核心文件的信息，请参见“help 
core mismatch”。

（另请参见“help debug”、“help invocation”和“help core mismatch”）
#
:core$$mismatch（副标题）
对这一功能的支持可能随 dbx 的将来版本而有所不同。
当前的执行方法似乎有点笨拙。

== 这是对于该问题的解释：

有时一个核心文件在一台系统（核心主机）上创建，而您想在另一台机器（dbx 机器）
上加载该核心文件。有一个问题，就是核心主机上的程序所用的共享库与 dbx 机器上的
共享库并不相同。为了获得合适的涉及库的堆栈跟踪，您要使这些原始库在 dbx 机器上
可用，并使用以下所述选项来告诉 dbx 在何处查找那些库。另一个问题是，dbx 使用 
/usr/lib 中的系统库来帮助了解该系统上的运行时连接器和线程库的执行详细信息。
可能还需要通过核心主机提供这些系统库，以便 dbx 能够了解运行时连接器数据结构
和线程数据结构。

用户库和系统库可能会随着补丁以及主要 Solaris 升级而改变，因此如果在收集核心
文件之后但在核心文件上运行 dbx 之前安装补丁，此问题仍然会出现（例如在同一台
主机上）。

以下列出了一些错误，它们可能会在查看一个失配的核心文件时出现。通常，一次只会
出现其中的一个或两个。

dbx: core file read error: address 0xff3dd1bc not available
dbx: warning: could not initialize librtld_db.so.1 -- trying libDP_rtld_db.so
dbx: cannot get thread info for 1 -- generic libthread_db.so error
dbx: attempt to fetch registers failed - stack corrupted
dbx: read of registers from (0xff363430) failed -- debugger service failed


== 以下介绍了如何在一个失配的核心文件上使用 dbx：

1. 打开“core_lo_pathmap”dbxenv 变量。
2. 使用 pathmap 命令来告诉 dbx 库的位置
3. 使用调试命令来加载程序和核心文件

以下实例假设核心主机的根分区已通过 NFS 导出，并且可以通过 dbx 机器上的 
/net/core-host/ 访问。

(dbx) dbxenv core_lo_pathmap on
(dbx) pathmap /usr      /net/core-host/usr
(dbx) pathmap /appstuff /net/core-host/appstuff
(dbx) debug prog prog.core

如果您不是在输出核心主机的根分区，则需要手动复制这些库。
不需要重新创建符号链接。（例如，您不必建立从 libc.so 到 
libc.so.1 的连接，只要确保 libc.so.1 可用。）

注意事项：

 - pathmap 命令不能识别“/”路径映射，因此当前不能指定：
   "pathmap / /net/core-host"

 - 路径映射的单参数模式不能与加载对象路径名同时使用，因此
   请使用二元模式 <from-path to-path>。

 - 如果 dbx 机器使用的 Solaris 版本与核心主机相同或更新，
   效果可能会更好。虽然这并不总是必要的。

 - 可能需要的系统库是：
   对于运行时连接器：
       /usr/lib/ld.so.1
       /usr/lib/librtld_db.so.1
       /usr/lib/sparcv9/ld.so.1
       /usr/lib/sparcv9/librtld_db.so.1
   对于线程库：
       /usr/lib/libthread_db.so.1
       /usr/lib/sparcv9/libthread_db.so.1
       /usr/lib/lwp/libthread_db.so.1
       /usr/lib/lwp/sparcv9/libthread_db.so.1
   取决于您在用哪个库线程的实现。
   /usr/lib/lwp 文件仅适用于 Solaris 8，并且仅在您使用“alternate libthread”
   库时适用。

   对于 xxx_db.so 库，如果 dbx 在 64 位兼容 Solaris 上运行，则需要
   “sparcv9”版本（如果命令“isalist”显示 sparcv9），因为这些系统库是作为
    dbx 的一部分而不是目标程序的一部分被加载和使用。

   ld.so.1 库是核心文件映像的一部分，就像 libc.so 或其它任何库一样。
   因此，您需要使用与创建核心文件的程序相匹配的 sparc/sparcv9。

 - 如果您在查看来自某个线程程序的核心文件，并且“where”不显示一个堆栈，
   请尝试使用以下类似 lwp 命令。

   (dbx) where
   current thread: t@0
     [1] 0x0(), at 0xffffffff
   (dbx) lwps
   o>l@1 signal SIGSEGV in _sigfillset()
   (dbx) lwp l@1
   (dbx) where
   =>[1] _sigfillset(), line 2 in "lo.c"
     [2] _liblwp_init(0xff36291c, 0xff2f9740, ...
     [3] _init(0x0, 0xff3e2658, 0x1, ...
     ...
   
   缺少一个线程堆栈表示 thread_db.so.1 存在问题。
   因此，您可能还需要从核心主机中复制适当的 libthread_db.so.1 库
   （参见以上内容）。

   另请参见“help rtld”。

#
:env
                        # 参见“help environment”。
：environment（主题）
如果在调用时间内定义某些环境变量，则会影响 dbx。

        TMPDIR          在所有 dbx 临时文件中用它来代替 /tmp

dbx 特定环境变量具有“DBX_”前缀。前缀“_DBX_”已保留用于内部环境变量名称。
参见“help ksh environment”和“help dbxenv”。
#
# I18N - translate this topicname to match same word in `Other Topics' message
:format（主题）
“print”、“rprint”和“display”命令以及“$[]”构造使用一个标志
（“-f”或“-F”，另请参见“help print”），它将输出格式设置为整数、字符串
或浮点类型。此格式在 dbx 要输出一个整数（长或短）、字符串（char * 或 
wchar_t *）或浮点（浮点、双精度、长双精度）表达式时使用。也就是说，此表达式
本身可能就是一个结构或数组；如果适用，每个整数、字符串或浮点成员都将用给定的
格式输出。如果该格式不适用于给定类型，则会无提示忽略该格式字符串，并且 dbx 
会使用其内建输出机制。

允许的格式是“printf（3S）”所使用的子集。下面是一些限制条件：

      *  没有“n”转换。
      *  没有将“*”用于域宽度或精度。
      *  没有“%<digits>$”参数选择。
      *  每个格式字符串只有一项转换规范说明。

下列简单语法定义了允许的格式：

        FORMAT  ::=  CHARS % FLAGS WIDTH PREC MOD SPEC CHARS
        CHARS   ::=  <any character sequence not containing a %>
                |    %%
                |    <empty>
                |    CHARS CHARS
        FLAGS   ::=  + | - | <space> | # | 0 | <empty>
        WIDTH   ::=  <decimal_number> | <empty>
        PREC    ::=  . | . <decimal_number> | <empty>
        MOD     ::=  h | l | L | ll | <empty>
        SPEC    ::=  d | i | o | u | x | X | f | e | E | g | G | 
                         c | wc | s | ws | p

如果给定的格式字符串不包含一个 %，dbx 会自动预置一个。如果该格式字符串包含
空格、分号或制表符，则整个格式字符串必须加上双引号。

实例：

(dbx) print i
i = 31
(dbx) print -fx i       ;# 格式字符串可以使用 -f 进行连结
i = 1f
(dbx) print -f 0x%12.12X 1234
0x0000000004D2
(dbx) print -f "The value of 0x1000 is %o in octal" 0x1000
The value of 0x1000 is 10000 in octal
(dbx) print x/10.0       ;# 和下面进行比较
x/10 = 12.3
(dbx) print -F"10%% of x is %.2e" x/10.0  ;# 禁止输出左侧
10% of x is 1.23e+01
(dbx) print -fx struct1  ;# 它甚至适用于成员...
struct1 = {
    x = 7b
}

#
# I18N - translate this topicname to match same word in `Other Topics' message
:prettyprint（主题）
如果为“print”、“rprint”或“display”添加“-p”标志，dbx 会调用 ksh 函数
“prettyprint”；该函数使用名称“db_pretty_print”在目标进程中搜索一个函数，
该函数包含三个参数：一个指向表达式类型的指针、一个整数和一个字符 *：

        char *db_pretty_print(const Foo *, int flags, char *formatstring);

如果找到，dbx 会调用该函数并输出（或显示）其返回值；如果没找到，dbx 会输出
（或显示）表达式本身。dbxenv 变量“output_pretty_print”如果设置为“on”，
则会将“-p”作为缺省值传递；使用“+p”可覆盖一个命令的此行为。

“prettyprint”在系统范围的 dbx 启动文件中定义（参见“help startup”）。
 “flages”参数中传递的值是按位值或以下之一：

   FVERBOSE        0x1       当前未实行，始终已设置
   FDYNAMIC        0x2       -d
   FRECURSE        0x4       -r
   FFORMAT         0x8       -f（如果已设置，则“formatstring”是 <fmt> 部分）
   FLITERAL        0x10      -l

参见“help print”以了解这些标志的含义。

:linker
   参见“help rtld”
:dynamic$$linker
   参见“help rtld”
:ld.so
   参见“help rtld”
:ld.so.1
   参见“help rtld”
:rtld
与运行时连接器交互

运行时连接器（也被称为 rtld 或 ld.so）被加载到每个动态连接的进程，
以便提供对共享库的支持。某个程序调用 dlopen() 或类似函数时，dbx 
将在进程中跟踪库的加载和卸载过程，并在必要时加载新的符号。

动态连接器支持多组共享库（连接映射），其中每组库都被视为一个独立的名字空间。
大多数程序只使用由 dlopen 函数访问的缺省连接映射。

某个程序调用 dlmopen 时，可以指定应该由哪个名字空间来包含新库。如果是使用 
dlopen() 来加载库，库将在缺省连接映射处停止。

注意：缺省连接映射上的库就是那些将自动加载并可供 dbx 查看的库。

另一个连接映射用于包含动态连接器本身以及该连接器执行其作业时所需的库。
如果您希望 dbx 加载用于 ld.so 本身的符号，则需要使用加载对象命令来执行。
其方法类似于：
    (dbx) loadobject -use ld.so.1

另请参见“man ld.so.1”、“man dlmopen”
另请参见“help loadobject”

#
# I18N - translate this topicname to match same word in `Other Topics' message
:redirect（主题）
在 dbx 中有两类命令：可重定向的和不可重定向的。不可重定向的命令将语言表达式
或模式作为变量。由于输入/输出重定向运算符也是 dbx 支持的语言中的表达式运算
符，所以任何带有表达式的命令都会将输入/输出运算符作为表达式运算符。

不可重定向命令的实例包括：assign, bsearch, call, display, dump, examine, files, 
funcs, hide, print, run, rerun, search, stop, stopi, trace, tracei, 
undisplay, whatis, where, whereis, which。

要重定向命令，您可以把输入/输出重定向放在命令关键字前：

        (dbx) >foo print a > b

如果您想通过管道输出一个不可重定向的命令，则可以用花括号将命令括起来：

        (dbx) { print *p; } | awk '/member[0-3]/ { print }'

只有 dbx 的输出可以用这种方式重定向；由目标进程产生的输出（例如，
通过 printf()）仍然输出到目标进程的“stdout”：

        (dbx) >foo print printf("hello")

使“hello”显示在终端上，并使文件“foo”包含

        printf("hello") = 5

它是 printf() 调用的返回值。

查看“typeset”命令来找出您该如何使一个 ksh 函数不可重定向的
（这样它可以参数方式接受语言表达式）。

注意：不可重定向命令也不将“#”作为一个注释的开始来识别。
要将一个注释添加到这样一个命令，可以使用“;#”。

在一个管道中使用某些 dbx 命令可能会产生意外的结果。任何更改目标进程状态
（或更改 dbx 的关于目标进程状态的信息）的命令在管道中的行为都将无法预计。
不能在管道中使用的命令包括：alias, attach, bsearch, call, catch, check, 
clear, collector, cont, dbxenv, debug, delete, detach, display, down, fix, 
frame, func, handler, hide, ignore, import, intercept, kill, language, 
next, nexti, pathmap, pop, quit, replay, rerun, restore, run, save, search, 
set, setenv, step, stepi, stop, stopi, suppress, trace, tracei, unalias, 
uncheck, undisplay, unhide, unintercept, unsuppress, up, use, when, wheni。

要重定向这些命令，应使用一个临时文件：

        (dbx) >/tmp/xxx call foo(); cat /tmp/xxx | sed 's/foo/FOO/'
#
# I18N - translate this topicname to match same word in `Other Topics' message
:register（主题）

寄存器名是和机器有关的。这些名称已保留，不能用作 ksh 环境变量名称。

在表达式中使用下列寄存器名：

在 SPARC 上：
  $g0 $g1 ... $g7
  $o0 $o1 ... $o7
  $l0 $l1 ... $l7
  $i0 $i1 ... $i7
  $f0 $f1 ... $f31
  $pc $npc $y $psr $wim $tbr $fsr $fq $fp $sp

  下列浮点型寄存器对被视为具有 C 的“double”类型（通常 $fN 寄存器被
  视为 C 的“float”类型）：

  $f0f1  $f2f3  ...  $f30f31
or
  $d0 $d2 ... d30

  下列浮点寄存器四联组被视为具有 C 的“long double”类型。
  SPARC V9 硬件提供了此类寄存器：

  $q0 $q4 ... $q60


  V8+ 硬件提供了以下结合两个寄存器的最低有效 32 位的寄存器对：

  $g0g1 $g2g3 $g4g5 $g6g7
  $o0o1 $o2o3 $o4o5 $o6o7


  SPARC V9 和 V8+ 硬件上提供了这些额外的寄存器：

  $xg0 $xg1 ... $xg7
  $xo0 $xo1 ... $xo7
  $xfsr $tstate $gsr
  $f32f33 $f34f35 ... $f62f63

在 Intel 上：
  $pc $ps $fp $sp
  $gs $fs $es $ds
  $edi $esi $ebp $esp $ebx $edx $ecx $eax
  $trapno $err $eip $cs $eflags $uesp $ss
  $di $si $bp $SP
  $bx $dx $cx $ax
  $bl $bh $dl $dh $cl $ch $al $ah
  $ip $flags
  $st0 $st1 ... $st7
  $fctrl $fstat $ftag $fip $fcs $fopoff $fopsel
  $xmm0a $xmm0b $xmm0c $xmm0d
  $xmm1a ...

要以十六进制数字输出寄存器，请使用以下之一：

        print -fx $pc

        print (void *)$pc

另请参见“help regs”。
#
:regs（命令）
%regs - 输出寄存器的当前值
regs [-f] [-F]          # 输出寄存器的值
                        # -f: 包括浮点寄存器（单精度）。
                        # -F: 包括浮点寄存器（双精度）。
                        #     仅用于 SPARC。

实例（SPARC）:
dbx[13] regs -F
当前线程：t@1
当前帧：[1]
g0-g3    0x00000000 0x0011d000 0x00000000 0x00000000
g4-g7    0x00000000 0x00000000 0x00000000 0x00020c38
o0-o3    0x00000003 0x00000014 0xef7562b4 0xeffff420
o4-o7    0xef752f80 0x00000003 0xeffff3d8 0x000109b8
l0-l3    0x00000014 0x0000000a 0x0000000a 0x00010a88
l4-l7    0xeffff438 0x00000001 0x00000007 0xef74df54
i0-i3    0x00000001 0xeffff4a4 0xeffff4ac 0x00020c00
i4-i7    0x00000001 0x00000000 0xeffff440 0x000108c4
y        0x00000000
psr      0x40400086
pc       0x000109c0:main+0x4    mov     0x5, %l0
npc      0x000109c4:main+0x8    st      %l0, [%fp - 0x8]
f0f1     +0.00000000000000e+00
f2f3     +0.00000000000000e+00
f4f5     +0.00000000000000e+00
f6f7     +0.00000000000000e+00
...

实例: (intel)
当前帧:  [1]
gs       0x00000107
fs       0x00000000
es       0x0000001f
ds       0x0000001f
edi      0x08047914
esi      0x0804782c
ebp      0x0804783c
esp      0xf1d3bfe4
ebx      0xddbee504
edx      0x08047870
ecx      0xddba1e1c
eax      0xddba1eec
trapno   0x00000003
err      0x00000000
eip      0x080506ae:main+0x6    movl     0xfffffff4(%ebp),%eax
cs       0x00000017
eflags   0x00000206
uesp     0x08047830
ss       0x0000001f
st0      +0.00000000000000e+00
st1      +0.00000000000000e+00
st2      +0.00000000000000e+00
st3      +0.00000000000000e+00
st4      +0.00000000000000e+00
st5      +0.00000000000000e+00
st6      +0.00000000000000e+00
st7      +0.00000000000000e+00
fctrl    0x00000000
fstat    0x00000000
ftag     0x00000000
fip      0x00000000
fcs      0x00000000
fopoff   0x00000000
fopsel   0x00000000
xmm0a-xmm0d      0x00000000 0x00000000 0x00000000 0x00000000
xmm1a-xmm1d      0x00000000 0x00000000 0x00000000 0x00000000
xmm2a-xmm2d      0x00000000 0x00000000 0x00000000 0x00000000
xmm3a-xmm3d      0x00000000 0x00000000 0x00000000 0x00000000
xmm4a-xmm4d      0x00000000 0x00000000 0x00000000 0x00000000
xmm5a-xmm5d      0x00000000 0x00000000 0x00000000 0x00000000
xmm6a-xmm6d      0x00000000 0x00000000 0x00000000 0x00000000
xmm7a-xmm7d      0x00000000 0x00000000 0x00000000 0x00000000
mxcsr    0x00000000
mxcsrex  0x00000000


另请参见“help registers”。
# I18N - translate this topicname to match same word in `Other Topics' message
:scope（主题）
范围是针对变量或函数的可见性而定义的程序子集。如果某个符号名称在给定执行点上
是可见的，则称为“在范围内”。在 C 语言中，函数可能具有全局或静态文件的范围；
变量可能具有全局、静态文件或块范围。

在 dbx 中，范围同样也可以指程序中搜索一个给定符号的起始位置。
通常，它和当前行一样，但有几个命令会在不引起执行点移动的情况
下更改当前范围：

        func
        file
        up, down, frame
        list <procedure>

要获得某个符号的完整限定名，请使用：

        which <name>

要查找某个名称的所有声明，请使用：

        whereis <name>

您还可以使用反引号显式地给出一个名称的范围：

        print `file.c`func1`x
        print `file.c`func2:212`y       # “y”在第 212 行的块中声明
        stop in `libxx.so.1`func3       # func3 在 dyn.library 的 xx 中声明
        stop in `file.c`func1
        stop in `file.c`classname::func2
        stop in ``func3                 # “func3”是外部函数或静态文件函数
        stop in `func4                  # “func4”是外部函数
        stop in #fun                    # “fun”是一个连接器符号；dbx 将
                                          在其出现时在全局范围内寻找它
        stop in `file.c`#fun            # 在“file.c”的静态范围内搜索
                                          连接器名“fun”

要为静态符号和 C++ 成员函数放宽范围查找规则，请使用：

        dbxenv scope_look_aside on

或者使用“双反引号”前缀：

        stop in ``func4                 # “func4”可以是静态的，
                                          也可以不在范围中


如果 scope_look_aside 已打开，dbx 将查找：

- 在其它文件中定义的静态变量（如果在当前范围中没有找到）。
  /usr/lib 的库中未搜索的文件。
- 没有类限定的 C++ 成员函数
- 其它文件中的 C++ 内联成员函数实例（如果当前文件中的某个成员函数未实例化）。

#
# I18N - translate this topicname to match same word in `Other Topics' message
:signals（主题）

dbx 接受的信号名称和编号列表是一种尝试，它会合并所有 Solaris 版本都支持
同时也被当前版本支持的信号列表。那就意味着有时候在旧版 Solaris 上运行时
新的信号名称也能被接受。如果您有疑问，请参考 Solaris 特定发行版本中关于
信号的手册页（在第三部分的开头）

SIGHUP          1               # 挂起
SIGINT          2               # 中断（擦掉）
SIGQUIT         3               # 退出 (ASCII FS)
SIGILL          4               # 非法指令（找到时不重置）
        ILL_ILLOPC      1       # 非法操作码
        ILL_ILLOPN      2       # 非法操作数
        ILL_ILLADR      3       # 非法寻址模式
        ILL_ILLTRP      4       # 非法陷阱
        ILL_PRVOPC      5       # 特权操作码
        ILL_PRVREG      6       # 特权寄存器
        ILL_COPROC      7       # 协处理程序
        ILL_BADSTK      8       # 坏堆栈
SIGTRAP         5               # 跟踪陷阱（找到时不重置）
        TRAP_BRKPT      1       # 断点陷阱
        TRAP_TRACE      2       # 跟踪陷阱
        TRAP_RWATCH     3       # 读访问监视点陷阱
        TRAP_WWATCH     4       # 写访问监视点陷阱
        TRAP_XWATCH     5       # 执行访问监视点陷阱
SIGIOT          6               # IOT 指令
SIGABRT         6               # 由中止使用，以后替代 SIGIOT
SIGEMT          7               # EMT 指令
        EMT_TAGOVF      1       # 标记溢出
SIGFPE          8               # 浮点异常
        FPE_INTDIV      1       # 整数除以 0
        FPE_INTOVF      2       # 整数溢出
        FPE_FLTDIV      3       # 浮点除以 0
        FPE_FLTOVF      4       # 浮点溢出
        FPE_FLTUND      5       # 浮点下溢
        FPE_FLTRES      6       # 浮点不精确的结果
        FPE_FLTINV      7       # 无效的浮点操作
        FPE_FLTSUB      8       # 下标越界
SIGKILL         9               # kill（不能被找到或忽略）
SIGBUS          10              # 总线错误
        BUS_ADRALN      1       # 无效的地址对齐
        BUS_ADRERR      2       # 不存在的物理地址
        BUS_OBJERR      3       # 对象特定硬件错误
SIGSEGV         11              # 段违例
        SEGV_MAPERR     1       # 地址没有映射到对象
        SEGV_ACCERR     2       # 无效的许可
SIGSYS          12              # 系统调用的错误参数
SIGPIPE         13              # 在管道上写，但无读取者
SIGALRM         14              # 闹钟
SIGTERM         15              # 来自“kill”命令的软件终端信号
SIGUSR1         16              # 用户定义的信号1
SIGUSR2         17              # 用户定义的信号2
SIGCLD          18              # 子进程状态更改
SIGCHLD         18              # 子进程状态更改别名（POSIX）
        CLD_EXITED      1       # 子进程已退出
        CLD_KILLED      2       # 子进程已被 kill
        CLD_DUMPED      3       # 子进程已转储核心
        CLD_TRAPPED     4       # 跟踪子进程已停止
        CLD_STOPPED     5       # 子进程已在信号处停止
        CLD_CONTINUED   6       # 停止的子进程已继续
SIGPWR          19              # 电源故障，重新启动
SIGWINCH        20              # 窗口大小改变
SIGURG          21              # 紧急套接字条件
SIGPOLL         22              # 发生可轮询事件
        POLL_IN         1       # 输入可用
        POLL_OUT        2       # 输出可能
        POLL_MSG        3       # 消息可用
        POLL_ERR        4       # 输入/输出错误
        POLL_PRI        5       # 高优先级的输入可用
        POLL_HUP        6       # 设备分离
SIGIO           22              # 可能的套接字输入/输出（SIGPOLL 别名）
SIGSTOP         23              # 停止（不能找到或忽略）
SIGTSTP         24              # 来自 tty 的用户停止请求
SIGCONT         25              # 停止的进程已继续
SIGTTIN         26              # 背景 tty 读尝试
SIGTTOU         27              # 背景 tty 写尝试
SIGVTALRM       28              # 虚拟计时器过期
SIGPROF         29              # 分析计时器过期
SIGXCPU         30              # 超出 cpu 限制
SIGXFSZ         31              # 超出文件大小限制
SIGWAITING      32              # 进程的 lwps 受阻
SIGLWP          33              # 线程库使用的特殊信号
SIGFREEZE       34              # 特殊的 CPR 信号
SIGTHAW         35              # 特殊的 CPR 信号
SIGCANCEL       36              # 线程库使用的特殊信号
SIGLOST         37              # 资源丢失
# New signal numbers may be added here in future releases of Solaris.
SIGRTMIN        *               # 第一个实时信号
SIGRTMIN+1      *               # 第二个实时信号
...             *               # 其它实时信号
SIGRTMAX-1      *               # 倒数第二个实时信号
SIGRTMAX        *               # 最后一个实时信号

在从 SIGRTMIN 到 SIGRTMAX 的范围内使用的“*”表示实际的信号数是动态的，
可能根据 Solaris 的版本不同而有所变化。
#
# I18N - translate this topicname to match same word in `Other Topics' message
:startup（主题）
首先，如果没有给出“-S”标志，并且文件 <install-directory>/lib/dbxrc 存在
且可读，dbx 将读取该文件。（站点特定初始化文件的路径从 dbx 可执行文件的路
径派生而来。）

dbx 在当前目录中搜索文件“.dbxrc”，然后在 \$HOME 中搜索。
一个不同的启动文件可能通过“-S”命令行选项显式给出。
参见“help .dbxrc”，查看样本 .dbxrc 文件。

一个启动文件可能包含任何 dbx 命令。最常见的是它包含别名和函数定义。
它还可以使用“source”或“.”命令来“source”其它文件（参见“help source”
和“help”）。启动文件也是一个通过“set -o”和“dbxenv”来设置变量选项的
好地方。

#
：tid（主题）
进程号。语法“t@<number>” 被各种命令使用和接受来指明一个线程。
其中的“number”指 thr_create() 返回的线程 ID。“all”或“t@all”
有时也能被用来指所有的线程。

#
# I18N - translate this topicname to match same word in `Other Topics' message
:callbacks（主题）
回调是一种 ksh 函数，这种函数能够在对象执行的某一点处被 dbx 自动调用。
您能够根据需要针对这些函数定义自己的版本，以便完成所需的任务。
缺省版本不会执行任何任务。当前支持以下回调：

        _cb_aoutchange          _cb_prompt
        _cb_fix_comp            _cb_fix_link

请参见具体函数名称的帮助以获得详细信息。
#
:_cb_aoutchange (callback)
_cb_aoutchange <old_a.out_name> <new_a.out_name>

正在调试的程序发生更改时（完全路径名不同），此 ksh 函数会被 dbx 调用。
这是设置 a.out 特定断点的好地方。

例如：

        _cb_aoutchange() {
                case "$2" in
                *producer)      stop in make_some_more ;;
                *consumer)      stop in get_another_one ;;
                esac
        }
#
:_cb_prompt (callback)
_cb_prompt

在输出顶层提示符 (PS1) 前，这个 ksh 函数将被 dbx 调用。这是一个设置 PS1 的
好地方，它能够反映进程的当前状态。_cb_prompt 不接受任何参数。
#
:_cb_fix_comp (callback)
_cb_fix_comp <compilation_arguments>

如果定义了这个 ksh 函数，在“修复”期间将由 dbx 调用这个函数，
而不会直接调用编译器。通过添加或更改选项以及修改路径等方法，
用户可以在这里定制编译行。使用时需谨慎。

例如：

        _cb_fix_comp() {
            echo $*
            eval $*
        }

它只会回显和执行编译行，而不会作出任何修改：

        _cb_fix_comp() {
            eval "$(echo $* | sed -e 's! -g0 ! -g !')"
        }

用“-g”命令替代“-g0”命令，在编译器运行时关闭 C++ 的从头至尾的内联处理。

这个函数的参数来自于原始的、无修改的编译行，
外加一些内部添加供 dbx 使用的选项。

另请参见“help _cb_fix_link”。
#
:_cb_fix_link (callback)
_cb_fix_link <linker_arguments>

如果定义了这个 ksh 函数，在“修复”期间将由 dbx 调用这个函数，
而不会直接调用连接器。通过添加或更改选项以及修改路径等方法，
用户可以在这里定制连接行。使用时需谨慎。这个连接建立了一个共享
对象，这个对象被 dlopen'd 入到目标进程中。它并不修改 a.out 文件。

例如：

        _cb_fix_link() {
            echo $*
            eval $*
        }

回显和执行连接行。

另请参见“help _cb_fix_comp”。
#
:event
“help event <subtopic>”的副标题：

specification           描述所有公认事件规范。
fault                   错误规范。
sig                     信号规范。
variables               与事件有关的内建变量。
watchpoint              监视点。
resumeone               多线程应用程序中的条件断点。

另请参见“help events”。
#
:resumeone（主题）
参考以下的条件断点

        stop in lookup -if strcmp(name, "troublesome") == 0

假设它设置在某个多线程应用程序中，位于许多线程需要调用 lookup() 的位置。
@1 达到 lookup() 时，dbx 将尝试对条件求值并调用“strcmp()”。
调用“strcmp()”时，dbx 有两种选择。

1) 仅仅使 t@1 恢复执行。如果“strcmp()”函数尝试攫取已被另一个线程占用
   的锁，可能会导致死锁的发生。现在 strcmp() 已经不太可能这样了，
   但是 dbx 并不能断定，因此用户可能会放入其他一些函数。因此，
   为了避免死锁，dbx ...

2) 在调用期间恢复所有线程。这种策略同 dbx 在执行“next”时
   采用的方法一样。

如果条件表达式正在访问已被其它线程改变的全局数据，这种全部恢复的方法
可能会产生一些异常副作用。假定认为被调用的函数是相对具有局部性的原子
操作且没有副作用，而且用户能确知这一点。

如果考虑到具有死锁风险的函数，就不能得出同样的结论了。
死锁会比您所预想的更频繁地发生。例如...

- 条件可能是一个 C++ 表达式，附带包含隐式函数调用的过载运算符。
  一个无害的“-if bag[i]”可能涉及到 STL“map”集合，后者具有 
  MT 安全性并包含互斥！

- 函数调用可能在动态连接器中竞争一个公共锁。
  例如，如果使用了 memcmp() 函数，它将转向并通过动态连接器转而调用
  一个平台优化 memcmp()（在“libc_psr.so”中）。

- 一个信号可能达到并调用一个可能竞争锁的信号处理程序。

这就是 dbx 采用方法（2）的原因。

这种全部恢复策略有一个缺点：目前的 dbx 无法处理另一种称为“t@2”的线程。
这种线程在 strcmp()函数调用时将到达 lookup() 处的断点。它将会发出以下警告：
        无限事件循环导致在如下的处理程序中缺乏事件：
或
        事件可重入性
        第一个事件 BPT(VID 6, TID 6, PC echo+0x8)
        第二个事件 BPT(VID 10, TID 10, PC echo+0x8)
        以下处理程序将会缺少事件：

在这种情况下，如果您可确信在条件表达式中调用的函数不会去争夺一个互斥，
则可以使用 -resumeone 事件修饰符强制 dbx 使用策略 (1)：

        stop in lookup -resumeone -if strcmp(name, "troublesome") == 0

只有在“lookup()”中到达断点的线程才会被恢复，以便对 strcmp() 求值。

请注意，这一点并不是在所有情况下都会有所帮助。例如 ...
- 如果 lookup() 函数中的第二个断点在同一个线程中发生，这是因为 lookup() 
  函数被有条件的回归调用了。
- 如果在条件上运行的线程要让出运行，那么这个线程将睡眠或以某种方式把
  控制权放弃给另一个线程。

#
:eventspec
参见“help event specification”

:event$$spec
参见“help event specification”

:event$$specification（主题）
事件规范由事件管理器命令 stop、when 和 trace 使用，用于指定某个
感兴趣的事件。它拥有以下的通用语法：

        <keyword> [ <arg> ] [ <modifier> ... ]  

关键字指定了事件的种类；最常用的是“at”和“in”。
某些事件会使用附加的参数，如下所示。
修饰符以“-”符号开始，能够应用到所有类型的事件和命令中。
然而，某些命令和（或）事件也接受一些非通用修饰符。

通常，某个事件规范的具体含义在 stop、when 和 trace 中使用时通常是相同的，
但是确实还存在一些异常，并且已针对每个特定命令单独作出了说明。

以下预定义事件列表在 SPARCworks 3.1 之前的版本中就已推出：

        in <func>       # <func> 的入口。序进程后的第一个可执行代码将用作
                        # 实际断点位置。适用于与 <func> 配合使用的其它事件。
        at <line>
        at <filename>:<line>
                        # <line> 即将被执行
        at <addr-expr>  # 给定地址处的指令即将被执行。
                        # 仅在用到了 -instr 或“stopi”等时才有效。
        inmethod <func> # 任何方法的入口，名称为 <func>
        inmember <func> # “inmethod”的别名
        infunction <func>
                        # 任意 <func> 过载版本的入口   
        inclass <classname> [ -recurse | -norecurse ]
                        # 任意 <classname> 方法的入口，
                        # <classname> 是一个 C++ 结构、联合、类或模板类。
                        # 如果使用了 -recurse，-norecurse 将作为缺省值，
                        # 它包括了基类。
        inobject <object_address>  [ -recurse | -norecurse ] 
                        # 从对象调用时，任何非静态类方法及其所有基类的
                        # 入口。<object_address> 应该求值为一个 C++ 对象
                        # 的地址。
                        # -recurse 是缺省值。
                        # 如果指定 -norecurse，它将不包括基类。

下列预定义事件列表在 SPARCworks 3.0 版本中就已推出：

        modify <addr-expr> [ , <byte-size-expr> ]
                        # 给定的地址范围已经被写入
                        # （参见“help event watchpoint”）。
                        # 任何表达式都可用于 <addr-expr>，但它必须
                        # 求值为一个地址。参见“help event watchpoint”
                        # 以获得更多信息。
        step            # 遇到一个单步指定此事件隐式打开步进。
        next            # 遇到一个 next。与 next 命令相似，
                        # 这将在当前函数的每一源文件行上触发，
                        # 然后在调用方的每一源文件行中触发。
                        # 如果您在堆栈上没有附带源信息的函数时使用此事件，
                        # 它将不执行任何操作，因为没有行要在其上操作。
        sig <sig>       # 指定的信号已被中断（参见“help event sig”）
        sig <sig> <code>
                        # 附带给定信号子码的信号已被截取
                        # （参见“help event sig”）
        fault <fault>   # 指定的错误已被截取(参见“help event fault”)
        throw           # 抛出一个 C++ 异常
        throw <type>    # 抛出一个 <type> 类型的 C++ 异常
                        # -unhandled 或 -unexpected 可以用于 <type>
                        # （参见 “help intercept”以获得更多信息）
        stop            # 进程停止；用户即将得到提示
        attach          # 一个附加操作刚刚完成
        sync            # 目标进程刚刚执行，并与 dbx 同步。虽然您仍能
                        # 使用“when sync”，但“stop sync”是无效的。
        syncrtld        # rtld 已运行，并且所有 loadobject 符号已经
                        # 被 dbx 加载。一些约束将“stop”申请视为
                        # “sync”事件。
        lastrites       # 进程即将过期。对 _exit 的调用、一个终止信号
                        # 或 kill 命令的执行结果都会导致出现此情况。
                        # 此事件触发时，通常都会提供进程的最终状态
                        # （但并不是始终都会提供）。（仅限 Solaris）
        dlopen          # 一系列加载对象已被加载。
        dlopen [ <lib-path> ]   
                        # 指定的加载对象已被加载。库的完全路径名必须
                        # 为 <lib-path> 引用。
        dlclose ...     # dlclose 也类似。
        exit [ <exitcode> ]     
                        # 进程已使用任何退出值（或指定的值）退出。
                        # <exitcode> 必须是十进制。
        sysin           # 进程已进入内核陷阱中或从中
        sysout          # 返回。参见“help event syscall”
        sysin <code>|<name>
        sysout <code>|<name>
        returns <func>  # 指定的函数已返回。
        returns         # 当前访问函数已返回。

以下的预定义事件列表在 dbx 4.0 版本中就已推出：

        detach          # “attach”的补充
        lwp_exit        # 通报任何 lwp 的消亡。在事件处理程序执行期间，
                        # 与事件相关的 lwp 会在 $lwp 中给出。
                        # 在事件被处理后，lwp 不再有效，因此 $lwp 会有
                        # 不同的值。
                        # （仅限 Solaris）
        proc_gone       # 当 dbx 不再与一个被调试的进程相关联时发生。
                        # 事件变量 $reason 可以是：signal、exit、kill 
                        # 或 detach。
        prog_new        # 将新程序加载至 dbx 时发生。在调试命令期间或
                        # 随后的执行发生时，将会出现此情况。因为所有句柄
                        # 在调试时都会被删除，所以只有在使用 -perm 修饰
                        # 符来创建此句柄时才有意义。
        timer <seconds> # 调试器已经运行了 <seconds> 秒。<seconds> 是
                        # 一个浮点编号。dbx 的简单区间定时器也会被数据
                        # 观测仪和收集器命令共享。单独使用这些功能的其中
                        # 一项。
        change <variable>
                        # <variable> 的值已更改。
                        # 使用单步方式进行，为了达到更快的性能，
                        # 可以使用下面介绍的访问事件。即使并没有检测到
                        # 任何更改，变量的第一次检查也会引发一个事件。
                        # 这使得可以访问它的初始值。随后，被检测出来的
                        # 更改都会引起额外的事件。
        cond <cond-expr># 条件已被更改。可以使用任何表达式，
                        # 但是必须求值为整数类型。

以下的预定义事件列表在 dbx 5.0 中就已推出：

        access <mode> <addr-expr> [ , <byte-size-expr> ]
                        # 访问了给定的地址范围。
                        # 任何表达式都能用于 <addr-expr>，但是必须求值
                        # 为一个地址。
                        # <mode> 可以由一个或所有字母组成
                        # “r”（读访问）
                        # “w”（写访问）
                        # “x”（访问以便执行）
                        # <mode> 还可以包含“a”（在访问发生后停止，缺省）
                        # 和“b”（在访问发生前停止）中的一个。
                        # 参见“help event watchpoint”以获得更多信息。

为实现向下兼容，尽管以下 eventspecs 句法变种（注意，它们没有“关键字”）
被认为已过时且会在以后的版本中被删除，但它们还是可以被接受。

        <variable>      # 值已更改。改为使用“change <variable>”。
        <cond-expr>     # 条件已更改。可以使用任何表达式，但是必须求值为
                        # 整数类型。改为使用“cond <cond-expr>”。

以下是通用 eventspec 修饰符列表：

        -if <cond>      # 事件仅仅在 <cond>“filter”为真时发生。
                        # 任何表达式都能用于 <cond>，只要它求值为整数类型。
        -resumeone      # -if 的修饰符。如果<cond> 包含函数调用，则仅恢复一
                        # 个线程。参见“help resumeone”以获得详细信息。
        -in <func>      # 只有在达到 <func> 的第一个指令之后和返回 <func> 
                        # 之前，事件才会发生。<func> 上的递归已被忽略。
        -disable        # 创建禁用状态的事件。
        -count <n>      # 从 0 开始计数；在达到 <n> 时发生事件并将计数器重
                        # 置为 0。使用“debug -r”或“attach -r”调试新
                        # 程序时，此计数会被重置。程序运行或再次运行时，所有
                        # 计数都会被重置。
        -count infinity # 计数，但不开始。
        -temp           # 临时性事件，在开始时删除。
        -instr          # 发生指令级变异。例如，“step”变为指令级步长，
                        # 并且“at”使用参数的文本地址而不是行数。
        -perm           # 通过“调试”保持此事件的“持久性”。
                        # 某些事件（例如断点）不适宜保持持久性。
                        # 应使用“delete <hid>”，“delete all”
                        # 不会删除持久性处理程序。
        -hidden         # 通过“status”命令隐藏事件。一些导入模块可能
                        # 会选择使用它。使用“status -h”查看它们。

        -lwp <lwpid>    # 只有在给定的 LWP 中出现时，事件才会发生。
        -thread <tid>   # 只有在给定的线程中出现时，事件才会发生。

以下是关于命令和事件特定的 eventspec 修饰符列表：

        -nosrc          # 仅适用于：“trace step”。
                        # 有关更多细节，参见“help trace”。
        -nocalls        # 仅适用于：“trace step”。
                        # 有关更多细节，参见“help trace”。

虽然下列 eventspec 修饰符的句法变更被认为是过时的而且会在以后的版本中被
删除，但是因为向后兼容的原因，它们都被接受了。

        if <cond>       
        in <func>       
        <lwpid>
        <tid>
#
#
#
:event$$sig（主题）
信号规范。您可以使用十进制数和大写或小写的信号名，
并可以将“sig”用作前缀，例如：

        11 segv SEGV sigsegv SIGSEGV    

您可以添加信号子代码。您可以使用十进制数和大写或小写的子代码名。
由信号名和“_”符号组成的前缀可被丢弃。

        3 fltdiv FLTDIV fpe_fltdiv FPE_FLTDIV

有关信号及其子代码的列表，请使用“help signals”。
:event$$syscall（主题）
本事件的语法是：
   sysin  [ <num> | <name> ] 
   sysout [ <num> | <name> ] 
例如：“sysin read”或“sysout”或“sysout 27”

在进入具有给定编号或名称的系统调用陷阱或所有系统
调用陷阱（如果未给定参数），或是从上述陷阱中返回时，
会发生这些事件。

<sys/syscall.h> 中的内核陷阱列表是一个专用 Solaris 接口，
该接口不稳定。dbx 中可用的陷阱名称列表意在合
并存在于所有支持的 Solaris 版本上的名称集，
因此 dbx 支持的名称不可能与任何 Solaris 特定
版本完全匹配。<sys/syscall.h> 中的某些名称有
可能不可用。

任何陷阱号均会被接受并如期工作，但如果陷阱号
不与某个已知系统陷阱相对应，您将会得到警告。

不能显式跟踪系统调用 0（通用“syscall”陷阱号），
但它会基于相应参数触发其它事件。因此，举例而言，
类似 syscall(4, ....) 这样的库调用将会触发
系统调用 4 中的事件。

注意：对于更稳定的系统内核接口列表，您可以
在“man -s 2 intro”的输出中看到系统调用库函数列表。
对于较早的库例程，内核陷阱名称与库例程名称
时常是一一对应的，而该部分中有许多新的库例 
程并不与陷阱一一对应。
（仅限 Solaris）

:event$$fault（主题）
硬件错误规范。您可以使用十进制数和大写或小写的错误名，
并可以将 “flt”用作前缀，如下列各种情况：

        8 izdiv IZDIV fltizdiv FLTIZDIV 

它们都表示相同的错误。
有关 Solaris 当前版本的错误列表，参见：
/usr/include/sys/fault.h
（仅限 Solaris）
#
:watch
参见“help event watchpoint”
:modify
参见“help event watchpoint”
:access
参见“help event watchpoint”
:event$$watchpoint（主题）

dbx 中有两种监视点生成机制。

1) 使用：

        stop|when|trace access <mode> <addr-exp> [ , <byte-size-exp> ]

<mode> 可以指定需要监视的访问类型：
        r       读，内存载入
        w       写，内存存储
        x       执行，代码执行
至少要为 <mode> 指定一种访问类型。

此外，您还可以使用下列某项：
        b       stop _before_ the access
        a       stop _after_ the access（缺省）
在这两种情况下，程序计数器都指向相关的指令。
之前或之后将引用副作用。

<addr-exp> 是指任何可求出一个地址的表达式。
如果使用了符号表达式，则可以自动推导出要监视的区域大小，
您也可以使用“,”语法将其覆盖。在大小处于强制状态时，
您还可以使用无符号、无类型的地址表达式，例如：

        stop access w 0x5678, sizeof(Complex)

此机制通常用于内核（参见 PCWATCH 下的 proc(4) 以了解更多详情），
较之早期的机制它还具有下列优势：
        * 速度更快。
        * 监视点的数目不受限制。
        * 可正常运行多线程应用程序。
        * 适用于堆栈地址。
        * 可在尚未映射的地址中设置监视点。
        * 可检测系统调用进行的访问。
        * 监视共享内存。

同时存在下列限制：
        * 两个监视区域不能交迭。

早期的语法 ...
        stop|when|trace modify <addr-exp> [ , <byte-size-exp> ]
仍为向后兼容所接受，并将映射至相应的“stop access”命令。

2} 使用:

        stop|when|trace cond <cond-expr>
        stop|when|trace change <variable>

这些语句可以自动单步运行程序并检查给定的条件或改变。
由于它们是单步运行，所以其速度非常慢并且无法用于多线程应用程序。

:event$$variables（主题）
下列预定义的只读变量表示了 dbx 的当前状态。它们将一直有效。
它们紧随当前的 LWP 或线程。
        $ins            # 反汇编当前指令        

        $lineno         # 以十进制数表示的当前行号
        $vlineno        # 以十进制数表示的当前“正在访问”的行号
        $line           # 当前行的内容

        $func           # 当前函数名
        $vfunc          # 当前“正在访问”的函数名。
        $class          # $func 所属的类名。
        $vclass         # $vfunc 所属的类名。
        $file           # 当前文件名
        $vfile          # 当前正在访问的文件名。
        $loadobj        # 类似于可加载的对象
        $vloadobj       # ...
        $scope          # 当前 PC 在反引用符号中的范围。
        $vscope         # ...

        $funcaddr       # 以十六进制数表示的 $func 地址。
        $caller         # 调用 $func 的函数名。

        $newhandlerid   # 最近创建的句柄的事件 ID。在任何可用于删除
                        # 句柄的命令后，此变量将具有一个未定义的值。
                        # 创建句柄后立即使用。对于可用于创建多个句柄的命令，
                        # 当前无法获取所有句柄的 ID。
        $firedhandlers  # 导致最近中断的句柄 ID 列表。此列表中的句柄将在
                        # “status”命令中以“*”进行标记。

        $proc           # 当前正在调试的进程的 ID 。
        $lwp            # 当前 LWP 的 ID（仅限于 MT）
        $thread         # 当前线程的 ID（仅限于 MT）

        $prog           # 所加载程序的完整路径名。
        $oprog          # $prog 的前一个值。当 $prog 还原为“-”时
                        # 用于 follow-exec 之后。
                        # 注意: $prog 可扩展为完整路径，但 $oprog 包含了
                        # 命令行中指定的或提供给调试命令的程序。
                        # 如果这个程序运行多次，将没有办法返回到初始程序。
        $dllist         # 最后 dlopen 或 dlclose 的所有加载对象列表。
        $exception      # 指向当前 C++ 异常的指针，如果没有则为 0

        $exitcode       # 最后运行程序的退出状态。
                        # 如果没有实际退出进程，则此值为空字符串。

        $machtype       # 如果已加载程序，则返回其机器类型：
                        # sparcv8 sparcv8+ sparcv9 intel，否则返回“未知”
        $datamodel      # 如果已加载程序，则返回其数据模型：
                        # ilp32 lp64 
                        # 否则返回“未知”
                        # 
                        # 要查找所加载程序的模型，请在 .dbxrc 中
                        # 使用下列命令：
                                when prog_new -perm {
                                        echo machine: $machtype $datamodel;
                                }

以下内容仅在 WHEN 的循环体中有效：

        $handlerid      # 在循环体执行过程中，$handlerid 是循环体所属
                        # 的 WHEN 命令的 ID。

        $booting        # 如果事件发生在“boot”进程中，则设置为“true”。
                        # 无论何时对一个新程序进行调试，首先都需要进行引导，
                        # 以便确定共享库的列表和地点。然后，进程将被终止。
                        # 引导时发生“behind the users back”时将出现
                        # “Reading symbolic information or libc.so.1”消息，
                        # 所有的事件仍然可用。例如，此变量可用于区分“sync”
                        # 和“syncrtld”事件，而这些事件会在“debug”和
                        # 正常“run”期间出现。

以下内容仅在 WHEN 的循环体中有效，并仅限于特定事件。

关于 sig 事件：

        $sig            # 引起事件的信号数
        $sigstr         #  $sig 的名称
        $sigcode        # $sig 的子代码（如果可用）
        $sigcodestr     # $sigcode 的名称
        $sigsender      # $sigsender 为信号发出方的 pid（如果相关），否则为 0

关于 exit 事件：

        $exitcode       # 传递给 exit() 的参数。此值在 WHEN 循环体外仍然有效。
                        # 参见以上内容。

关于 access 事件：

        $watchaddr      # 正在写入、读取或执行的地址。
        $watchmode      # 由“rwx”中分别表示读、写或执行的某个字母后
                        # 紧跟“ab”中表示之前和之后的某个字母组成。

关于 sysin 和 sysout 事件：

        $syscode        # 系统调用代码
        $sysname        # <sys/syscall.h> 中定义的系统调用名

关于 dlopen 和 dlclose 事件（仅适用于提供了参数的情况）：

        $dlobj          # 引发事件的装入对象

关于 proc_gone 事件：

        $reason         # 进程迁移的原因。可以“signal”、
                        # “exit”、“kill”或“detach”

#
:MT（主题）
dbx 可使用多个命令来处理多线程程序。
参见下列帮助主题以获得更多信息：

        threads thread lwps lwp

此外，某些命令可采用线程或 LWP 限定符。

参见下列帮助主题以获取更多信息：

        cont step events `event specification' mtfeatures where

或使用“help -k <keyword>”查找提到 <keyword> 一词的帮助主题。
#
########################################################################
########################### Dbx Commands ###############################
########################################################################
:!（ksh 命令）
!!                     # 执行前一个命令
!<num>                 # 执行命令数 <num>
!-<num>                # 执行当前命令数减去 <num>
!<str>                 # 执行以 <str> 开头的最近的命令

修饰符：                # 添加这些标记用来修改以上的命令
\:s/<l>/<r>/           # 替代修饰符：用 <r> 替代 <l>
\:p                    # 输出修饰符：输出但不执行命令

缩写：
^<l>^<r>^              # 快速替换：用 <r> 代替 <l>，然后重新运行最后
                       # 键入的命令。
#
:!!
参见“help !”
#
:adb（命令）
%adb - 执行“adb-style”命令或进入“adb”模式
adb <adbcmd>            # 执行“adb-style”命令
adb                     # 进入“adb”模式；使用“$q”退出 adb 模式

                        # 第一次提供“adb”命令时，它将动态装入执行命令的
                        # 共享对象。有关“adb-mode”的详细帮助，
                        # 请输入一个 adb 命令，然后再输入“help”：

                            (dbx) adb $q
                            搜索 libdbxadb.so...
                            重新定义 adb
                            (dbx) help adb
                            ...
#
:alias（主题）
“alias”是“dalias”和“kalias”的别名。键入“alias alias”可找出别名，
然后查看相应的“help kalias”或“help dalias ”。缺省值为“kalias”。
“dalias”可与老版本的 .dbxinit 启动文件兼容。参见“help .dbxinit”。
#
:assign（命令）
%assign - 对一个程序变量进行赋值 
assign <var> = <exp>   # 把 <exp> 的值赋给 <var>
#
:attach（命令）
%attach - 更改正在调试的程序
attach <pid>                  # 开始调试进程 ID 为 <pid> 的 <prog>。
                              # dbx finds <prog> using /proc.
attach -p <pid> <prog>        # 开始调试进程 ID 为 <pid> 的 <prog>。
attach <prog> <pid>           # 开始调试进程 ID 为 <pid> 的 <prog>。
                                <prog> 可能为“-”；dbx 可使用 /proc 对
                                其进行查找
attach -r ...                 # “-r”选项导致 dbx 保留所有的 display、
                                trace、when 和 stop。如果没有“-r”选项，
                                则执行隐式“delete all”和“undisplay 0”。

如果要绑定一个新进程，并且当前已有一个进程正在调试，则其过程如下。
如果现在的进程是运行命令的结果，则该进程将在绑定该新进程前停止。
如果当前进程由前一个绑定命令获取（或通过在命令行中指定进程 ID），
则 dbx 将在绑定新进程前与当前进程分离。


#
:bsearch（命令）
%bsearch - 在当前源文件中向后搜索
bsearch <string>       # 在当前源文件中向后搜索 <string> 
bsearch                # 再次查找最后查找过的字符串
#
:button（命令）
%button - 为 GUI 的“自定义按钮”窗口定义新按钮。
button <seltype> <cmd>      # 定义软件按钮

选择类型 <seltype> 为：

                   ignore    # 忽略选择
                   literal   # 逐字选择
                   lineno    # 源窗口的行号

除非在 GUI 下运行 dbx，否则此命令将被默认忽略。

另请参见“help unbutton”。

#
:buttonx（命令）
%buttonx - 为 GUI 的“自定义按钮”窗口定义新按钮。
buttonx <seltype> <name> <cmd>       # 定义扩展软件按钮

选择类型 <seltype> 为：
                   ignore    # 忽略选择
                   literal   # 逐字选择
                   lineno    # 源窗口的行号

<name> 为按钮名称。名称可能包含空格，在此情况下需要为名称加上引号。
名称可用作由“unbutton”搜索到的关键字。

<cmd> 可以是 dbx 命令、ksh 函数或 mini-script。如果其名称包含多个词，
则需要加上引号。

除非在 GUI 下运行 dbx，否则此命令将被默认忽略。

要使 dbx 启动脚本在所有版本中正常工作，请使用：
        dalias goto "stop at !:1 -temp; cont"
        if [ ${versionno:-3} = "5.0" ]
        then
                buttonx lineno  "GoTo" goto
        else
                button lineno  "goto"
        fi

另请参见“help unbutton”。

#
:call（命令）
%call - 调用一个过程
call <proc>([params])  # 调用过程

此外，在调用函数时，要查看返回值，请使用 print 命令。
有时，调用的函数会到达断点。您可以选择继续使用“cont”，或使用“pop -c”
来终止调用。如果调用的函数引发 SEGV，则可以使用后者。
#
:cancel（命令）
%cancel - 取消当前信号
cancel                  # 取消当前信号。主要用于
                        # WHEN 循环体
当 dbx 由于信号导致停止时，信号通常将被取消。
如果“when”命令已与信号事件绑定，则该信号将*不会*被自动取消。
“cancel”命令可用于显式取消信号。
#
:catch（命令）
%catch - 捕获给定的信号
catch                   # 输出已捕获信号的列表
catch <num> <num>...    # 捕获编号为 <num> 的信号
catch <sig> <sig>...    # 捕获名为 <sig> 的信号
                        # 无法捕获或忽略 SIGKILL。
catch $(ignore)         # 捕获所有信号。
如果进程收到给定信号，则捕获该信号将导致 dbx 停止运行程序。
如果在该点继续运行程序，则程序将*不会*处理该信号。
另请参见 -sig 选项下的“help ignore”、“help cancel”和“help cont”。
#
:clear（命令）
%clear - 清除断点
clear                  # 清除当前停止点的所有断点
clear <line>           # 清除 <line> 的所有断点
clear <filename>:<line># 清除 <filename> 中 <line> 的所有断点

使用“stop|trace|when inclass|inmethod|infunction ...”创建的事件处理
程序可创建多个断点集。如果要“clear”的给定行与这些断点中某个断点匹配，
则只有该断点将被清除。一旦以此方法清除，属于该集合的单个断点将无法再启用。
但是，禁用并再次启用相关的事件处理程序将重建所有的断点。
#
:commands（命令）
%commands - 以单行描述方式列出所有内建命令
commands                # 以单行描述方式列出所有内建命令
#
:cont（命令）
%cont - 使进程继续执行
cont                    # 继续执行。MT 进程中的所有线程都会被恢复。
                        # 使用 ^C 停止执行程序。
cont ... -sig <signo>   # 继续执行信号 <signo>
cont ... <id>           # <id> 指定要继续的线程或 LWP。
cont at <line> [ <id> ] # 在行 <line> 处继续执行。如果是多线程应用程序，
                        # 则 <id> 为必需。
cont ... -follow parent|child|both
                        # 如果将 $DBX_follow_fork_mode 设置为“ask”，
                        # 并且选择了“stop”，则可以使用此选项选择要跟
                        # 随的进程。“both”仅适用于 GUI。

另请参见“help dbxenv”。
                                        
参见“help continue”以获取有关 dbx 命令语言循环控制的详细信息。
#
:dbxdebug（命令）
%dbxdebug - 显示 dbx 的内部状态（供 dbx 开发人员使用）
dbxdebug                # 显示各种内部数据结构。仅在导入了
                          “debugging.so”时有效。
#
:dbxenv（命令）
%dbxenv - 列出或设置 dbx 定制变量
dbxenv                  # 显示 dbx 定制变量

如果要使用多个版本的 dbx，这些版本采用不同的 dbxenv 变量（或版本间
存在其它差异），则您可以使用类似于下列 .dbxrc 文件中的代码，以便为
每个版本选择不同选项。

        if [ $versionno = "6.1" ]
        then
                dbxenv rtc_use_traps on
        else
                # on by default in 6.2 and 7.0
        fi


        dbxenv 变量列表及变量含义：
        ------------------------

dbxenv array_bounds_check <on | off> 
                                # 如果为 on，则 dbx 将检查数组边界。
                                # 缺省值：on
dbxenv core_lo_pathmap <on | off>
                                # 使用 pathmap 设置控制核心文件的共享库位置。
                                # 参见“help core mismatch”以获取详情。
                                # 缺省值：off
dbxenv disassembler_version <autodetect | v8 | v9 | v9vis>
                                # SPARC:
                                # 
                                # 为 SPARC V8，V9 或具有可视化指令集的 V9 设置
                                # dbx 的内建反汇编的版本。缺省值：autodetect，
                                # 可根据运行的机器 a.out 类型设置模式对模式
                                # 进行动态设置。
                                # 
                                # non-SPARC:
                                # 
                                # 只可选择 autodetect。
                                # 
dbxenv fix_verbose <on | off>   
                                # 可控制“fix”过程中编辑行的输出。缺省值：off
dbxenv follow_fork_inherit <on | off>
                                # 当跟在子进程后面时 ...
       follow_fork_inherit on   # ... 继承事件
       follow_fork_inherit off  # ... 不继承事件。
                                # 缺省值：off
dbxenv follow_fork_mode <parent | child | both | ask>
                                # 当进程执行一个 fork/vfork/fork1 ...
       follow_fork_mode parent  # ... 跟随父进程
       follow_fork_mode child   # ... 跟随子进程
       follow_fork_mode both    # ... 同时跟随父进程和子进程（仅用于 GUI）
       follow_fork_mode ask     # ... 询问用户将上述何项设置为缺省值：父进程
dbxenv follow_fork_mode_inner <unset | parent | child | both>
                                # 在检测到派生后，将 follow_fork_mode 
                                # 设置为“ask”，并选择了“stop”时适用。
                                # 设置了此变量后便不需要使用
                                # “cont -follow ...”。
dbxenv input_case_sensitive <autodetect | true | false>
                                # 如果设置为“autodetect”，dbx 会根据文件语言
                                # 自动选择区分大小写：对于 fortran 文件为
                                # “false”，否则为“true”。如果为真，
                                # 大小写在变量和函数名中有效，否则，
                                # 大小写无实际意义。
                                # 缺省值：autodetect
dbxenv language_mode <autodetect | main | c | c++ | fortran | fortran90>
                                # 控制用于解析和计算表达式的语言。
                                # 
                                # “autodetect”模式：
                                # 将表达式评估语言设置为当前文件语言。
                                # 用于调试使用混合语言的程序（默认模式）。
                                #
                                # “main”模式：
                                # 将表达式评估语言设置为程序中主要例程语言。
                                # 用于调试同类程序。
                                #
                                # “c”，“c++”，“fortran”，“fortran90”
                                # 模式：将表达式语言设置为选定语言。
                                # 另请参见“help language”。
#dbxenv mi_mode <on | off>      # 如果启用，dbx 将以 MI 格式输出命令“stop”、
                                # “status”、 “run”、“cont”、“next”、
                                # “step”、“print”、“where”。
dbxenv mt_scalable <on | off>   # 如果启用，dbx 将限制资源的使用，
                                # 并可使用 300 个以上的 LWP 调试进程。
                                # 下方速度将明显减慢。
                                # 缺省值：off
dbxenv output_auto_flush <on | off>
                                # 每次“call”后自动调用 fflush()
                                # 缺省值：on
dbxenv output_base <auto[matic] | 8 | 10 | 16>
                                # 输出整数常量的缺省基数
                                # 缺省值：automatic
dbxenv output_class_prefix <on | off>
                                # 用 classname(s) 给类成员加前缀
                                # 输出值 (print -r)
                                # 或声明时 (whatis -t)。
                                # 缺省值：on
dbxenv output_dynamic_type <on | off>
                                # 如果启用，“-d”是用于输出和显示的缺省值。
                                # 缺省值：off
dbxenv output_inherited_members <on | off>
                                # 如果启用，“-r”是用于输出和显示的缺省值。
                                # 缺省值：off
dbxenv output_list_size <num>   # 控制列表命令中输出的默认行数。缺省值：10
dbxenv output_log_file_name <filename>
                                # 命令登记文件的名称。
                                # 仅记录命令，不包括命令输出。
                                # 缺省值：/tmp/dbx.log.<uniqueID>
dbxenv output_max_string_length <num>
                                # 设置为“char *”输出的字符数。
                                # 缺省值：512
dbxenv output_pretty_print <on | off>
                                # 如果为“on”，“-p”是用于输出和显示的
                                # 缺省值。缺省值：off
                                # 参见“help prettyprint”。
dbxenv output_short_file_name <on | off>
                                # 显示文件的短路径名。
                                # 缺省值：on
dbxenv overload_function <on | off>
                                # 如果启用，则使用自动函数重载方案
                                # （仅适用于 C++）。缺省值：on
dbxenv overload_operator <on | off>
                                # 如果启用，则使用自动运算符重载方案
                                # （仅适用于 C++）。缺省值：on
dbxenv pop_auto_destruct <on | off>
                                # 如果启用，在弹出一个框时自动为本地调用
                                # 相应的析构函数。
                                # 缺省值：on
dbxenv proc_exclusive_attach <on | off>
                                # 如果启用，且已绑定另一工具，将阻止 dbx 
                                # 绑定。警告：请注意，如果多个工具绑定某个进程
                                # 并试图对其进行控制，则会出现混乱。
                                # 缺省值：on
dbxenv rtc_auto_continue <on | off>
                                # 记录 RTC 错误到 rtc_error_log_file_name 
                                # 并继续。缺省值：off
dbxenv rtc_auto_suppress <on | off>
                                # 如果启用，则只报告一次给定位置的 RTC 错误。
                                # 缺省值：on
dbxenv rtc_biu_at_exit <on | off | verbose>
                                # 用于显式启用“check -memuse”或
                                # 通过“check -all”。如果值为“on”，
                                # 在退出程序时会生成一个非冗余内存使用
                                # （使用的块）报告。
                                # 如果为“verbose”，在退出程序时会生成
                                # 一个冗余报告。
                                # 如果为“off”，则不生成任何输出。
                                # 此变量对“showmemuse”命令无效。
                                # 缺省值：on
另请参见“help check”和“help showmemuse”。

dbxenv rtc_error_limit <num>  
                                # 将报告的 RTC 错误数。
                                # 缺省值：1000
dbxenv rtc_error_log_file_name <filename>
                                # 如果设置了“rtc_auto_continue”，
                                # 记录 RTC 错误的文件名。
                                # 缺省值：/tmp/dbx.errlog.<uniqueID>
dbxenv rtc_error_stack <on | off>
                                # 如果为“on”，堆栈跟踪将显示与 RTC 内部机制
                                # 对应的帧。
                                # 将此选项设置为“on”以防止 rtc_auto_suppress
                                # 工作，因此请谨慎使用。
                                # $DBX_rtc_error_stack
dbxenv rtc_inherit <on | off>
                                # 如果为“on”，则可启用从调试程序执行的
                                # 子进程中的 RTC。
                                # “on”使得 LD_AUDIT 被继承。
                                # 缺省值：off
dbxenv rtc_mel_at_exit <on | off | verbose>
                                # 在启用泄露检查时使用。
                                # 
                                # 如果值为“on”，则在退出程序时将生成一个非冗
                                # 余内存泄露报告。
                                # 如果为“verbose”，则在退出程序时将生成一个
                                # 冗余内存泄露报告。如果为“off”，则不生成
                                # 任何输出。此变量对“showleaks”命令无效。
                                # 缺省值：on
dbxenv run_autostart <on | off> 
                                # 如果为“on”并且没有活动程序，“step”、
                                # “next”、“stepi”和“nexti”将隐式
                                # 运行程序，并在语言相关的“main”例程处停止，
                                # 需要时可通过“cont”开始“run”。
                                # 缺省值：off
dbxenv run_io <stdio | pty>     
                                # 控制是否将用户程序的 I/O 重定向至 dbx 的
                                # stdio 或特定 pty。
                                # pty 由 $DBX_run_pty 提供。
                                # 缺省值：stdio
dbxenv run_pty <ptyname>        
                                # 当 $DBX_run_io 设置为“pty”时，设置 pty 
                                # 名称以供使用。Pty 主要供 dbx 的 GUI 包装器
                                # 使用。
dbxenv run_quick <on | off>     
                                # 如果启用，则不会通过“debug”装入任何符号
                                # 信息。符号信息可根据需要使用
                                # “prog -readsysms”装入。
                                # 直到 dbx 的行为如同所调试的程序被剥离。
                                # 缺省值：off
dbxenv run_savetty <on | off>   
                                # dbx 和被调试对象间的多路复用 tty 设置、
                                # 进程组和键盘设置（如果命令行中使用了 kbd）；
                                # 用于调试编辑器和 shell。
                                # 如果 dbx 获取了 SIGTTIN 或 SIGTTOU，
                                # 并弹回到 shell，则将其设置为“on”。
                                # 将其设置为“off”可稍稍加快速度。
                                # 如果将 dbx 绑定到被调试对象或正在 GUI 下
                                # 运行，则此设置无关。
                                # 缺省值：on
dbxenv run_setpgrp <on | off>   
                                # 如果启用，则“run” 程序时，“setpgrp(2)”
                                # 将在派生后立即调用。
                                # 缺省值：off
dbxenv scope_global_enums <on | off>
                                # 如果启用，枚举器将被置于全局范围，
                                # 而不是文件范围。在处理调试信息前设置。
                                # (~/.dbxrc). 缺省值：off
dbxenv scope_look_aside <on | off>
                                # 在当前范围之外查找文件静态符号。
                                # 参见“help scope”以获取讨论信息。
                                # 缺省值：on
dbxenv session_log_file_name <filename>
                                # dbx 记录所有命令及其输出的文件名。
                                # 输出将被附加至文件。
                                # 缺省值："" (no session logging)
dbxenv stack_find_source <on | off> 
                                # 如果设置为“on”，当被调试对象在未使用 -g 
                                # 编译的函数中停止时，dbx 将尝试查找源并将其
                                # 自动移至堆栈的第一个帧。
                                # 缺省值：on
dbxenv stack_max_size <num>     
                                # 设置“where”命令的大小缺省值。
                                # 缺省值：100
dbxenv stack_verbose <on | off> 
                                # 控制“where”中参数和行信息的输出。
                                # 缺省值：on
dbxenv step_events <on | off>   
                                # 在 step/next 时允许断点。
                                # 缺省值：off
dbxenv step_granularity <statement | line>
                                # 控制源行步长的粒度。
                                # 如果设置为“statement”，则下列代码：
                                #       a(); b();
                                # 将使用两个“next”结束。
                                # 如果设置为“line”，则执行单个“next”。
                                # “line”的粒度在处理多行宏时非常有用。
                                # 缺省值：statement
注意：“statement”的粒度并不能始终达到期望的效果，因为编译器可能
无法发出语句边界信息。

dbxenv suppress_startup_message <num>
                                # 设置释放级别，低于该级别则不输出启动消息。
                                # 缺省值：3.01
dbxenv symbol_info_compression <on | off>
                                # 每个 include 文件的调试信息仅读取一次，
                                # 并且仅为 FORTRAN 创建一次公共块符号表。
                                # 缺省值：on
dbxenv mt_sync_tracking         # 当 dbx 启动过程时，dbx 应开启此选项
                                # 跟踪同步对象。
                                # 缺省值: on
dbxenv trace_speed <num>
                                # 设置跟踪执行的速度。值为步间暂停的秒数。
                                # 缺省值：0.50

上述中每项均有对应的 ksh 环境变量，如 DBX_trace_speed。变量可直接分配，
也可以使用 dbxenv 命令；两者作用相同。

#
:debug（命令）
%debug - 列出或更改正在调试的程序
debug                         # 输出程序名和参数
                                正在调试
debug <prog>                  # 不使用进程或核心开始调试 <prog>。
debug -c <core> <prog>        # 使用核心文件 <core> 开始调试 <prog>。
debug -p <pid> <prog>         # 使用进程 ID <pid> 开始调试 <prog>。
debug <prog> <core>           # 使用核心文件 <core> 开始调试 <prog>。
                                <prog> 可能为“-”；dbx 将尝试提取
                                来自于核心文件的可执行名称。
                                参见“help core” 以获取更多详情。
debug <prog> <pid>            # 使用进程 ID <pid> 开始调试 <prog>。
                                <prog> 可能为“-”； dbx 可使用 /proc 对其
                                进行查找
debug -f ...                  # 强制装入核心文件，即使它不
                              # 匹配。
debug -r ...                  # “-r”选项导致 dbx 保留所有
                                display、trace、when 和 stop。
                                没有“-r”选项，将执行隐式“delete all”
                                和“undisplay 0”。
debug -clone ...              # “-clone” 选项导致另一个 dbx 开始执行，
                                允许一次调试多个进程。仅在 GUI 下运行时有效。
debug -clone                  # 启动另一个 dbx 但不进行任何调试。
                                仅在 GUI 下运行时有效。
debug [<options>] -- <prog>   # 开始调试 <prog>，即使 <prog> 以破折号开始。

注意：在使用“debug”装入程序时，内存泄露检查和访问检查将被关闭。您可以通过
“check”命令启用它们。

另请参见“help prog”。
#
:delete（命令）
%delete - 删除断点和其它事件
delete [-h] <number> ...    # 删除给定数量的 trace、when 或 stop。
                            # 要删除隐藏的句柄，则必需提供“-h”选项。
delete [-h] 0 | all | -all  # 删除所有 trace、when 和 stop，不包括
                            # 永久的和隐藏的句柄。指定 -h
                            # 同时删除隐藏的句柄。
delete -temp                # 删除所有临时句柄
delete $firedhandlers       # 删除所有的导致最近停止的句柄。
#
:detach（命令）
%detach - 从 dbx 的控制下释放目标进程
detach                  # 从目标中分离 dbx，并且取消所有未定信号。
detach -sig <sig>       # 在发送给定信号时分离。
detach -stop            # 在停止状态下分离并离开进程。

-stop 选项允许使用其它基于 /proc 调试工具的临时应用程序，但可能由于独占访问
而受阻。例如：
        (dbx) oproc=$proc       # 记住旧的进程 ID
        (dbx) detach -stop
        (dbx) /usr/proc/bin/pwdx $oproc
        (dbx) attach $oproc
#
:dis（命令）
%dis - 反汇编机器指令
dis <addr> [/ <count>]  # 反汇编 <count> 指令（缺省值为 10）
                          从地址 <addr> 开始。
dis <addr1>, <addr2>    # 从 <addr1> 到 <addr2> 的反汇编指令。
dis                     # 反汇编 10 个指令，开始于
                          “+”（参见 “help examine”）。
dis /<count>            # 反汇编 <count> 个指令，开始于“+”。

    <addr> 的缺省值为最后一个反汇编的指令后的地址。“current address”
    的值由命令 examine（别名为“x”）共享。（另请参见“help examine”）。
#
:display（命令）
%display - 在每个停止点评估和输出表达式。
display                # 输出所显示的表达式列表
display <exp>, ...     # 在每个停止点显示表达式 <exp>, ...的值
display [-r|+r|-d|+d|-p|+p|-L|-f<fmt>|-F<fmt>|--] <exp>, ...
                         参见“help print”获取有关标记的信息。
                         
另请参见“help undisplay”。
#
:document（命令）
%document - 添加命令或主题的帮助信息
document <cmdname>      # 提供 <cmdname> 的文档。“document”命令可从标准输入
                          中读取。要为名为“foo”的新命令添加文档，使用
                          
                         (dbx) document foo
                         foo <arg>   # 以全大写方式回显 <arg>。
                          ^D

                          键入 Control-D 来结束输入。

                          要为命令“foo”删除文档，使用
                          
                          (dbx) document foo </dev/null
#
:down（命令）
%down - 下移调用堆栈（远离“main”）
down                   # 将调用堆栈下移一级
down <number>          # 将调用堆栈下移 <number> 级
down -h [<number>]     # 将调用堆栈下移，但不跳过隐藏的帧
#
:dump（命令）
%dump - 输出过程局部的所有变量
dump                   # 输出当前过程中局部的所有变量
dump <proc>            # 输出 <proc> 中局部的所有变量
#
:edit（命令）
%edit - 调用源文件中的 $EDITOR（GUI：显示源）
edit                   # 编辑当前文件
edit <filename>        # 编辑指定文件 <filename>
edit <proc>            # 编辑包含函数或过程 <proc> 的文件

如果没有在 GUI 下运行 dbx，“edit”使用 $EDITOR。否则，
它将向 GUI 发送消息以显示相应的文件。
# 如果使用“-E”选项调用了 GUI，则会使用处理源显示的外部编辑器，除非已将
# 源窗格更新为显示请求的文件。
#
:examine（命令）
%examine - 显示内存内容
examine [ <addr> ] [ / [ <count> ] [ <fmt> ] ]

        以 <fmt> 格式显示从 <addr> 处开始的 <count> 项的内存内容。<addr> 的
        缺省值是上次显示的最近地址的下一个地址。<count> 的缺省值为 1。<fmt>
        的缺省值与上一次使用“examine”命令时相同，如果是首次使用，则与“X”
        中使用的相同。“examine”命令（其别名为“x”）所使用的地址与“dis”
        命令使用的地址相同。（参见“help dis”)。

examine <addr1> , <addr2> [ / [ <fmt> ] ]

        以 <fmt> 格式显示从 <addr1> 到 <addr2>（包括 <addr2>）的内存内容。
        
examine <addr> = [ <fmt> ]

        以给定格式显示地址（不是地址中的内容）。
                
         <addr> 可以为“+”，这表明这个地址位于上次显示的最后一个地址后
         （与省略它相同）。

        “x”为“examine”的预定义别名。

        <fmt> 的合法值为：

            i       指令（反汇编）
            d,D     十进制（2 或 4 字节）
            o,O     八进制（2 或 4 字节）
            x,X     十六进制（2 或 4 字节）
            b       八进制（1 字节）
            n       十进制 (1 字节)
            c       字符
            w       宽字符
            s       字符串
            W       宽字符串
            f       十六进制和浮点（4 字节，6 位精确度）
            F       十六进制和浮点（8 字节，14 位精确度）
            g       同“F”
            E       十六进制和浮点（16 字节，14 位精确度）
            ld,lD   十进制（4 字节，同 D）
            lo,lO   八进制（4 字节，同 O）
            lx,lX   十六进制（4 字节，同 X）
            Ld,LD   十进制（8 字节）
            Lo,LO   八进制（8 字节）
            Lx,LX   十六进制（8 字节）
#
:gdb（命令）
%gdb - 支持 gdb 命令集
gdb on | off
使用“gdb on”进入 gdb 命令模式，在此模式下 dbx 将理解
并接受 gdb 命令。要退出 gdb 命令模式并返回 dbx 命令模式，
请输入“gdb off”。请注意：dbx 命令在 gdb 命令模式下不被
接受，反之亦然。所有的调试设置（如断点）在不同的命令模式间
均受到保护。
当前版本不支持下列 gdb 命令：
        - commands      - define
        - handle        - hbreak
        - interrupt     - maintenance
        - printf        - rbreak
        - return        - signal
        - tcatch        - until
#
:fix（命令）
%fix - 重新编译和重新连接源文件
使用“fix”来更改给定程序。“fix”重新编译修改的源文件并动态地将修改的函数
连接至应用程序。

fix                    # 修复当前文件
fix <filename> <filename> ... 
                       # 修复列表中的文件
fix -f                 # 即使源文件未被修改，也强制修复文件
fix -a                 # 修复所有修改的文件
fix -g                 # 去掉 -O 标志并添加 -g 标志
fix -c                 # 输出编译行（可能包含某些内部添加以供 dbx 使用的选项）
fix -n                 # 不执行编译/连接命令（与 -v 一起使用）
fix -v                 # 冗余模式（覆盖 dbxenv 设置）
fix +v                 # 非冗余模式（覆盖 dbxenv 设置）

有关如何定制编译和连接步骤，请参见“help _cb_fix_comp”和
“help _cb_fix_link”。要了解更多信息，请参见“fix_verbose”
下的“help fix-pitfalls”和“help dbxenv”。
#
:fixed（命令）
%fixed - 列出所有“已修改”文件的名称
fixed                  # 列出所有已修改文件的名称
#
:exception（命令）
%exception - 输出当前 C++ 异常的值
exception [-d | +d]    # 输出当前 C++ 异常的值（如果有）
                         有关“-d”标志的含义，请参见“help print”。

另请参见“help whocatches”和“help event specification”。
#
:exists（命令）
%exists - 检查某个符号名是否存在
exists <name>          # 如果在当前程序中找到 <name> 则返回 ０，否则返回 １
#
:file（命令）
%file - 列出或更改当前文件
file                   # 输出当前文件的名称
file <filename>        # 更改当前文件
#
:files（命令）
%files - 列出与某个正规表达式匹配的文件名
files                  # 列出提供当前程序调试信息的所有文件
                         （带“-g”标志编译的文件）的名称
files <regexp>         # 列出与给定正规表达式匹配的所有“-g”文件的名称
例如：
   (dbx) files ^r
myprog:
  retregs.cc
  reg_sorts.cc
  reg_errmsgs.cc
  rhosts.cc
                         
有关正规表达式格式的更多信息，请参见“help regexp”。
#
:frame（命令）
%frame - 列出或更改当前堆栈帧号
frame                  # 显示当前帧的帧号
frame [-h] <number>    # 将当前帧设置为帧 <number>
frame [-h] +[<number>] # 在堆栈中上移 <number> 个帧；缺省值为 1
frame [-h] -[<number>] # 在堆栈中下移 <number> 个帧；缺省值为 1
       -h              # 即使帧隐藏，也转至帧
#
:visiting$$scope（主题）
当您在 dbx 中检查各种程序元素时，请修改 dbx 的“访问范围”。
某些内建变量可以向您显示部分访问范围。访问范围在表达式评估时使用，
解决诸如符号不明确等问题。例如：“print i”使用访问范围来指明
您所讨论的是哪个“i”。

命令“debug”和“attach”会设置初始的访问范围。任何时候，
只要程序停在一个断点上，dbx 将把访问范围设置在当前位置。
此时，dbx 通常会查找含有源代码的堆栈帧。参见变量
“stack_find_source”下的“help dbxenv”。

每个线程和 LWP 都有自己的访问范围。从上一个线程到下一个线程，
访问范围会被记住。

当您使用堆栈帧命令来更改当前堆栈帧时（“up”、“down”和
“frame <n>”），系统将根据来自新堆栈帧的 PC 来设置
访问范围。

可设置访问范围的命令如下：
`line', `func', `file', `list <func>', `list <file>'

除非您使用“list <func>”或“list <file>”，否则在“list”命令
中使用的行号位置不会移动访问范围。

当设置了访问范围时，当前“list”的行号被设置为新范围的开始。此后，
list 命令会更新当前行，但是列出当前文件中的行不会更改访问范围。
例如，“list my_func”和“list 127”会向您显示相同的源行块，但是
前者将把访问范围更改为“my_func”，而后者将只向您显示源行。

某些显示当前访问范围的内建变量为：
   $vscope $vlineno $vfunc $vclass $vfile $vloadobj

还有一些变量始终反映了当前线程或 LWP 的当前 PC：
   $scope  $lineno  $func  $class  $file  $loadobj
这些值并不受更改访问范围的各种命令的影响。
#
:func（命令）
%func - 列出或更改当前函数
func                   # 输出当前函数的名称
func <proc>            # 将当前函数更改为函数或过程 <proc>
#
:funcs（命令）
%funcs - 列出与某个正规表达式匹配的所有函数名
funcs                  # 列出当前程序中的所有函数
funcs [-f <filename>] [-g] [<regexp>]
      -f <filename>    # 列出文件中的所有函数
      -g               # 列出具有调试信息的所有函数
      <regexp>         # 列出与正规表达式匹配的所有函数
例如：
  (dbx) funcs [vs]print
  `libc.so.1`isprint
  `libc.so.1`wsprintf
  `libc.so.1`sprintf
  `libc.so.1`vprintf
  `libc.so.1`vsprintf
                           
要了解有关正规表达式的更多信息，请参见“help regexp”                         
#
:handler（命令）
%handler - 修改事件处理程序（启用、禁止等）
对于每个需要在调试会话中管理的事件，创建一个处理程序。命令“trace”、
“stop”和“when”创建处理程序。上述命令返回一个数字，称为“处理程序 
ID”（<hid>）。命令“handler”、“status”和“delete”以通用方式
处理或提供处理程序信息：

handler -enable <hid> ...       # 启用给定处理程序，“all”表示启用全部
                                # 处理程序
handler -disable <hid> ...      # 禁止给定处理程序，“all”代表禁止全部处理
                                # 程序。使用 $firedhandlers 而非 <hid> 来
                                # 禁止那些引起最近停止的处理程序。
handler -count <hid>            # 输出给定处理程序的行程计数器的值
handler -count <hid> <newlimit> # 设置给定事件的新计数限制
handler -reset <hid>            # 使给定处理程序的行程计数器复位

另请参见“help event”。
#
:help（命令）
%help - 提供关于某个命令或主题的更详细的信息
help                     # 输出内建 dbx 命令的摘要
help <cmd>               # 输出关于 <cmd> 的帮助
help <topic> <subtopic>  # 输出主题或副标题的帮助
help -k <keyword>        # 输出包含 <keyword> 的每个主题的名称

           当 dbx 不是在 GUI 下运行时，“help”输出将通过 
           $PAGER（如果设置），或者通过 /usr/ucb/more（如果
           存在并且未设置 $PAGER）。（如果未设置“path”选项，
           $PAGER 的值必须是完全路径名。）要禁止该功能，将
           “unalias help”写入 dbxrc 文件。

           使用命令“commands”来查看所有命令的单行摘要。
           要了解新增和更改的功能，请参见“help changes”。
#
:hide（命令）
%hide - 隐藏与某个正规表达式匹配的堆栈帧
hide                   # 列出当前正在使用的堆栈帧过滤器
hide <regexp>          # 隐藏与正规表达式 <regexp> 匹配的堆栈帧
                         正规表达式与函数名或装入对象的名称匹配，
                         并且是与样式正规表达式匹配的 sh 或 ksh 文件。

另请参见“help unhide”。
#
:history（ksh 命令）
%history - 处理命令历史列表
history                # 输出最近使用命令的列表
history <num>          # 重新调整历史列表以存储 <num> 个命令
history -              # 停止在历史中记录命令
history +              # 恢复记录命令
#
:ignore（命令）
%ignore - 忽略给定信号
ignore                  # 输出忽略信号列表
ignore <num>...         # 忽略编号为 <num> 的信号
ignore <sig>...         # 忽略命名为 <sig> 的信号。不能捕获或忽略 SIGKILL。
ignore $(catch)         # 忽略所有信号。
当进程收到这种信号时，忽略信号会导致 dbx 无法停止。
另请参见 -sig 选项下的“help catch”、“help cancel”和“help cont”。
#
:import（命令）
%import - 从一个 dbx 命令库中导入命令
import <pathname>    # 从 dbx 命令库 <pathname> 中导入命令。
#
:intercept（命令）
%intercept - 截获给定类型的 throw（C++ 异常），仅适用于 C++
intercept <typename>       # 截获类型 <typename> 的 throw。
intercept -a               # 截获所有 throw。
intercept -x <typename>    # 不截获 <typename>
intercept -a -x <typename> # 截获除类型 <typename> 之外的所有类型
intercept                  # 列出被截获的类型。

<typename> 可为 -unhandled 或 -unexpected 之一。
无匹配 catch 的抛出异常称为“未处理”throw。与抛出主体函数的异常规范
不匹配的抛出异常称为“意外”throw。

缺省情况下，截获未处理和意外 throw。

另请参见“help event specification”下的“throw”，“help event variables”
下的“$exception”和“help unintercept”。
#
:kill（ksh/dbx 命令）
%kill - 向进程发送信号；终止目标进程
kill -l                 # 列出所有已知信号编号、名称和描述
kill                    # 终止受控进程
kill <job>...           # 向列出的作业发送 SIGTERM 信号
kill -<sig> <job>...    # 向列出的作业发送给定信号
                          <job> 可以是进程 ID，或者以
                          “help fg”下列出的任何方式指定，但在此情况下，“%”
                          不是可选的。
#
:language（命令）
%language - 列出或更改当前源语言
language               # 输出当前语言模式（参见 dbxenv 语言模式）。
                       # 如果模式是“autodetect”或“main”，
                       # 还会输出当前语言。这用于解析和评估表达式。
language <lang>        # 不赞成使用这种命令模式。
                       # 使用“dbxenv language_mode”代替。

另请参见“language_mode”下的“help dbxenv”。
#
:line（命令）
%line - 列出或更改当前行号
line                   # 显示当前行号
line <num>             # 设置当前行号
line "<filename>"      # 在 <filename> 中将当前行号设置为 １
line "<filename>":<n>  # 在 <filename> 中将当前行号设置为 <n>
                         带“"”的文件名是可选的。

实例：
    line 100
    line "/root/test/test.cc":100
#
:list（命令）
%list - 显示源文件的行
列出的缺省行数 N 受 dbxenv 变量“output_list_size”控制。要了解更多信息，
请参见“output_list_size”下的“help dbxenv”。

list                # 列出 N 行
list <n>            # 列出第 <n> 行    
list +              # 列出后 N 行
list +<n>           # 列出后 <n> 行
list -              # 列出前 N 行
list -<n>           # 列出前 <n> 行
list <n1>,<n2>      # 列出第 <n1> 行到第 <n2> 行
list <n1>,+         # 列出第 <n1> 行到第 <n1> + N 行
list <n1>,+<n2>     # 列出第 <n1> 行到第 <n1> + <n2> 行
list <n1>,-         # 列出第 <n1>-N 行到第 <n1> 行
list <n1>,-<n2>     # 列出第 <n1>-<n2> 到第 <n1> 行
list <function>     # 列出 <function> 源函数的开头
list <filename>     # 列出文件 <filename> 的开头
list <filename>:<n> # 从行 <n> 开始显示文件 <filename>
                    # 在适当的地方，行号可能为“$”，表示文件最后一行。
                      逗号是可选的。“list <function>”更改当前范围。
                      要了解更多信息，请参见“help scope”。

选项：
-i 或 -instr        # 混合源行和汇编代码
-w 或 -w<n>         # 围绕行或函数列出 N（或 <n>）行（窗口）。如果使用“+”
                      或“-”语法进行组合，或者指定了两个行号时，
                      不允许使用此选项。 

实例：
    list                      // 从当前行开始列出 N 行
    list +5                   // 从当前行开始列出后 ５ 行
    list -                    // 列出前 N 行
    list -20                  // 列出前 20 行
    list 1000                 // 列出第 1000 行
    list 1000,$               // 列出第 1000 行到最后一行
    list 2737 +24             // 列出第 2737 行及其后 24 行
    list 1000 -20             // 列出第 980 行到第 1000 行
    list "test.cc":33         // 列出文件“test.cc”中第 33 源行。
    list -w                   // 列出当前行周围的 N 行
    list -w8 `test.cc`func1   // 列出函数 func1 周围的 8 行
    list -i 500 +10           // 列出从第 500 行到第 510 行的源代码和汇编代码
另请参见“listi”，以获得汇编级源代码列表。
#
:listi（命令）
%listi - 显示源指令和汇编指令
同“list -I”。有关详情，请参见“help list”。
#
:loadobject（命令）
%loadobject - 列出并管理来自装入对象的符号信息
loadobject <subcommand> <subcommand args>
（此命令有一个缺省别名“lo”）

loadobject -list    <regexp>      显示当前装入的装入对象
loadobject -load    <loadobject>  装入指定装入对象的符号
loadobject -unload  <regexp>      卸下指定的装入对象
loadobject -hide    <regexp>      从 dbx 的搜索算法中删除装入对象
loadobject -use     <regexp>      将装入对象添加至 dbx 的搜索算法
loadobject -dumpelf <regexp>      显示装入对象的各种 ELF 细节
loadobject -exclude <ex-regexp>   不自动将装入对象装入
                                  与 <ex-pattern> 匹配
loadobject -exclude               显示排除模式的列表
loadobject -exclude -clear        清除模式的排除列表

<regexp> 是可选的。如果未指定该选项，该命令适用于所有
装入对象。

<ex-regexp> 不是可选的，必须指定。

要了解有关这里使用的“regexps”的更多信息，请参见“help regexp”。

有关装入对象如何在 dbx 内部工作的一般描述，
请参见“help loadobject management”。

loadobject -list
loadobject -list -a
loadobject -list <regexp>

    显示每个装入对象的完全路径名，并在页边显示表示状态的字母。
    当使用“-a”选项时，将只列出当前隐藏的装入对象。

    'h' : 表示隐藏的装入对象。这些符号将
          不会被 ` 之类的符号查询发现。
    'u' : 如有活动进程，“u”表示“已取消映射”。
    'p' : 这个字母表示“预装入”的装入对象，即程序中的“loadobject -load”
          命令或 dlopen 事件的结果。（参见“help loadobject preloading”）

    例如：
    
      (dbx) lo -list libm
         /usr/lib/64/libm.so.1
         /usr/lib/64/libmp.so.2
         
      (dbx) lo -list ld.so
       h  /usr/lib/sparcv9/ld.so.1 (rtld)

   最后这个实例显示，运行时连接器的符号缺省情况下隐藏。要在 dbx 命令中
   使用这些符号，请参见下面的“lo -use”命令。

loadobject -load <loadobject> ...
loadobject -load -all

    <loadobject> 可以是一个完整的路径名，也可以是 /usr/lib 
    或 /usr/lib/sparcv9 路径下的一个库。如果某个程序正在调试，
    将仅搜索正确的 ABI 库目录。

    您可以使用 -all 选项让 dbx 装入进程当前映射的所有尚未装入的装入对象。
    如果使用某些“lo -exclude”命令强制启动程序，但是接着删除某些排除，
    则可以使用这个命令。

loadobject -unload <regexp>

    该命令卸下与命令行中的 regexp 匹配的任何装入对象的符号。使用“debug”
    装入的主程序不能卸下。Dbx 也可能拒绝卸下当前正在使用的或者会影响到 dbx 
    正常运行的装入对象。

loadobject -dumpelf <regexp>

    该命令转出磁盘上与装入目标文件的 ELF 结构相关的信息。该输出的详细极易
    被更改。如果您要分析该输出，最好使用 Solaris 命令“dump”或“elfdump”。

loadobject -exclude  <ex-regexp>

    该命令防止 dbx 自动装入与命令“loadobject -exclude”所给的 regexp 相
    匹配的装入对象的符号。与其它子命令中的 regexp 不同，这个 regexp 不是
    可选的，并且缺省值不是“all”。
    
    目前这种功能不能防止装入主程序或运行时连接器。
    另外，使用它来防止装入 C++ 运行时库会影响 C++ 功能。
    该选项不能与运行时检查（RTC）一起使用。

loadobject -use <regexp>

    该命令将隐藏的装入对象放入程序范围，并允许 dbx 查看该装入对象
    的类型和函数。装入对象必须已装入，或者被 dbx 自动装入，或者使
    用“lo -load”命令装入。

loadobject -hide <regexp>

    该命令将一个装入对象从程序范围中删除，并从 dbx 中隐藏它的函数和符号。
    该命令也将重置“preload”位。（参见“help loadobject preloading”）

有关装入对象以及 dbx 如何处理装入对象的更多信息，
参见：“help loadobject management”、“help loadobject preloading”
和“help core mismatch”

#
:loadobject$$management（主题）
装入对象是 SVR4 ABI 定义的可装入对象的简称。可执行文件（“a.out”）和
共享库（“*.so”）都是装入对象。

当执行开始时，动态连接器预装入可执行文件附属列表中的一组装入对象。
Dbx 对此进行跟踪并读取这些装入对象的符号表。一个很大的应用程序可能
拥有众多的大型共享库，有时会造成启动速度显著下降。为此，最初装入符号
表时可以排除装入对象。要了解更多信息，请参见“exclude”选项下
的“help loadobject”。

一旦一个应用程序运行，它可以通过使用 lopen(3) 系统功能来动态装入更多的
装入对象。这样的装入对象以后可以通过 dlclose(3) 来卸下。Dbx 跟踪这些事件，
用户可以通过使用以下命令请求通知：
        stop dlopen                     # 停止每个 dlopen 进程
        stop dlopen libjava_g.so        # 当“libjava_g.so”已
                                        # 被 dlopen 时停止。
（“stop in dlopen”的效果不完全相同。）要了解更多信息，
请参见“help event specification”和“help event variables”。

可以编写一个事件处理程序（使用“when”命令）来设置 dlopen 事件后的断点，
但这是不可取的。更简单的方法是，预装入一个装入对象的符号表，然后在它
被 dlopen 之前在其中设置一个虚拟断点。要了解更多信息，
请参见“help loadobject preloading”。

dbx（特别是在 GUI 下运行时）可以调试许多可执行文件，它们重新使用相同的
一组基本装入对象（例如“libc.so”、“libthread.so”或“libX11.so”）。
每次运行程序时并不重新读取这些库的符号，而是从一次运行到下一次运行时简
单地重新使用这些符号。

为节省内存，在调试新程序时，dbx 将卸下可执行文件的符号。但是库会积累并
在需要时重新使用。装入对象中的符号未被当前程序使用时会“隐藏”。
有关“使用”和“隐藏”装入对象的信息，请参见“help loadobject”。

相关主题：

   当装入对象不适合当前系统时装入一个核心文件：“help core mismatch”

   防止 dbx 将装入对象的符号装入，以加速程序装入速度：“help loadobject”
   （在“-exclude”选项下）

   在尚未被程序 dlopen() 的库中设置断点：“help loadobject preloading”
#
:loadobject$$preloading（主题）
Dbx 无法“浏览”（通过类似 whatis、func 和 list 的命令），或者在尚未装入的
装入对象中设置断点。（有关 dbx 如何处理装入对象的一般描述，
请参见“help loadobject managerment”和“help loadobject”）。
例如，如果应用程序使用 dlopen(3) 装入库，dbx 通常不能在库中设置断点，
直到 dlopen() 发生之后才可以。但是，可以使用“loadobject -load”命令将
装入对象预装入，从而启用这些功能（参见“help loadobject”）。

或者，您可以运行一次程序来装入库，然后设置断点，再接着运行程序。

显式装入或被程序 dlopen 的装入对象被标记为“预装入”。这些装入对象的符号
在程序没有打开那些库时也可以使用。预装入的库在“loadobject -list”命令的
输出中显示带一个“p”。
#
：loadobjects（命令）
“loadobjects”命令被新命令“loadobject”（或“lo”）代替。
使用“help loadobject”来查看如何使用这个新命令。地址映射（旧的 -v 选项）
被替换成“proc -map”。

要列出装入对象，       请使用“loadobject -list”
要排除装入对象，       请使用“loadobject -exclude ...”
要将装入对象装入，     请使用“loadobject -load ...”

对于此选项，            请使用这个新命令
----------            --------------
loadobjects -a         loadobject -list
loadobjects -v         proc -map 
loadobjects -p xxx     loadobject -load xxx
loadobjects -x xxx     loadobject -exclude xxx

-f 选项：

   某些旧的装入对象选项还有一个辅助选项“-f<file>”。新的“loadobject”
   命令中没有与此选项直接对等的选项。如果您先前有一个带有装入对象路径名
   列表的文件，您应该在每一行开头简单添加“lo -load”，然后在您想要装入
   那些文件时，使用“source”命令来执行那些命令。另外，如果您的多个路径名
   可以用一个 regexp 来描述（例如 /home/foo/myapp/lib/libf.*.so），
   您可以使用更少的 regexp 来替换先前文件中的多行。
#
:lwp（命令）
%lwp - 列出或更改当前的 LWP
lwp                    # 显示当前的 LWP
lwp <lwpid>            # 转换到 LWP <lwpid>
#
:lwps（命令）
%lwps - 列出进程中所有的 LWP
lwps                   # 列出当前进程中所有 LWP
#
:mmapfile（命令）
%mmapfile - 查看核心转储中缺少的 mmap 文件内容
mmapfile <mmapped_file> <address> <offset> <length>
Solaris 核心文件不包含只读内存段。
(注意：在 Solaris 的最新版本中，可能使用“coreadm”命令控制
核心文件内容。)

可执行只读段（例如文本）被自动处理，dbx 通过浏览可执行文件和相关共享
对象来解决内存访问问题。
另请参见“help core mismatch”

只读数据段通常在应用程序内存映射某些数据库时出现。例如：
        caddr_t vaddr = NULL;
        off_t offset = 0;
        size_t = 10 * 1024;
        int fd;
        fd = open("../DATABASE", ...)
        vaddr = mmap(vaddr, size, PROT_READ, MAP_SHARED, fd, offset);
        index = (DBIndex *) vaddr;

如果您要通过调试器像访问内存一样访问数据库，您应该使用
        mmapfile ../DATABASE $[vaddr] $[offset] $[size]
现在您可以使用结构方式来查看数据库内容
        print *index
#
:module（命令）
%module - 读取一个或多个模块的调试信息
module [-v]                  # 输出当前模块的名称
module [-f] [-v] [-q] <name> # 读取 <name> 的调试信息
module [-f] [-v] [-q] -a     # 读取所有模块的调试信息
标记：                         -f : 强制读取调试信息，即使
                                   此文件比可执行文件更新
                                   （使用时需谨慎！）。
                              -v : 冗余模式。输出语言、文件
                                   名称等。
                              -q : 安静模式
#
:modules（命令）
%modules - 列出模块名
modules [-v]            # 列出所有模块
modules [-v] -debug     # 列出包含调试信息的所有模块
modules [-v] -read      # 列出包含已读取的调试信息的模块名称，
标志：                  -v : 冗余模式。输出语言、文件
                            名称等。
#
:next（命令）
%next - 跳过一个源行（跳过调用）
next                   # 跳过一行（跳过调用）。
                       # 对于 MT 程序，当函数调用被跳过，
                       # 所有 LWP 在函数调用期间
                       # 被隐式恢复，
                       # 以避免死锁。
                       # 非活动线程不能跳过。
next <n>               # 跳过 <n> 行（跳过调用）
next ... -sig <sig>    # 执行 next 时传递给定信号

dbxenv 变量“step_events”控制步骤中是否启用断点。

next ... <tid>         # 跳过给定线程。
next ... <lwpid>       # 跳过给定 LWP。

要了解机器级跳过调用的情况，另请参见“nexti”。
另请参见“step_granularity”下的“help dbxenv”。
#
:nexti（命令）
%nexti - 跳过一个机器指令（跳过调用）
nexti                 # 跳过一个机器指令（跳过调用）
nexti <n>             # 跳过 <n> 个机器指令（跳过调用）
nexti -sig <sig>      # 执行 next 时传递给定信号
nexti ... <lwpid>     # ... 给定 LWP。
nexti ... <tid>       # ... 给定线程在其中处于活动状态的 LWP 当跳过一个
                        函数时，并不隐式恢复所有 LWP。
#
:pathmap（命令）
%pathmap - 将一个路径名映射至另一个路径名，以查找源文件等
pathmap [ -c ] [-<index>] <from> <to>
pathmap [ -c ] [-<index>] <to>
                        # 建立一个从 <from> 到 <to> 的新映射，其中 <from> 
                          和 <to> 是文件路径前缀。<from> 表示编译到可执行
                          文件或目标文件中的文件路径，<to> 表示调试时的文
                          件路径。如果使用“-c”，映射还应用于当前工作目录。
                          如果 <from> 为空，所有路径都被映射至 <to>
                          （旧“use”命令的功能）。如果指定了一个索引，
                          映射连同索引插入到表中，否则添加到列表结尾。
pathmap                 # 列出所有现存的路径映射（使用索引）
pathmap -s              # 相同，但 dbx 可以读取输出
pathmap -d <from1> <from2> ...
                        # 通过路径删除给定映射
pathmap -d <index1> <index2> ...
                        # 通过索引删除给定映射

“pathmap”创建从一个路径名到另一个路径名的映射。映射应用于源路径、
目标文件路径和当前工作目录（如果使用“-c”）。

“pathmap”对于处理位于不同主机上不同路径的自动安装或显式 NFS 安装的文件
系统非常有用。因为 CWD 在自动安装的文件系统上不准确，所以当您解决由于自
动安装而引起的问题时，请使用“-c”。如果原始树或构建树被移动，
使用“pathmap”命令也非常有用。

缺省情况下“pathmap /tmp_mnt /”存在。

当“dbxenv core_lo_pathmap”设置为“on”时，“pathmap”用来查找核心文件
的装入对象。与这种情况不同，pathmap 对查找装入对象（共享库）没有影响。
有关 pathmap 如何工作的详情，请参见“help core mismatch”。

实例：
(dbx) pathmap /export/home/work1 /net/mmm/export/home/work2
  # 将 /export/home/work1/abc/test.c 映射
    至 /net/mmm/export/home/work2/abc/test.c
(dbx) pathmap /export/home/newproject
  # 将 /export/home/work1/abc/test.c 映射
    至 /export/home/newproject/test.c
(dbx) pathmap
(1) -c /tmp_mnt /
(2) /export/home/work1 /net/mmm/export/home/work2
(3) /export/home/newproject

#
:pop（命令）
%pop - 从调用堆栈中删除一个或多个帧
pop                    # 从堆栈中弹出当前顶部帧
pop <num>              # 从堆栈中弹出 <num> 个帧
pop -f <num>           # 从堆栈中弹出帧，直到达到指定的帧号
pop -c                 # 弹出从调试器中进行的最后一个调用

弹出过程最多只能到达使用 -g 编译过的函数的帧。程序计数器将复位为调用点
的源行开头。您无法弹出在调试器调用的函数之后的帧，请使用“pop -c”。
通常一个 pop 命令将调用与弹出的帧相关的所有 C++ 析构函数；可以通过将 
dbxenv“pop_autodestruct”设置为“off”来覆盖此选项。
#
:print（命令）
%print - 输出表达式的值
print <exp>, ...       # 输出表达式 <exp> 等的值
print -r <exp>         # 输出表达式 <exp> 的值
                         包括它的继承成员（仅限于 C++）
print +r <exp>         # 不输出继承成员，
                         当 dbxenv“output_inherited_members”
                         设置为 on 时(仅限于 C++)
print -d [-r] <exp>    # 显示表达式 <exp> 的动态类型
                         而非静态类型（仅限于 C++）
print +d [-r] <exp>    # 不使用表达式 <exp> 的动态类型，
                         当 dbxenv“output_dynamic_type”
                         设置为 on 时（仅限于 C++）
print -p <exp>         # 调用“prettyprint”函数
print +p <exp>         # 不调用“prettyprint”，当 dbxenv
                         “output_pretty_print”设置为 on 时
                         （参见“help prettyprint”）
print -L <exp>         # 如果输出对象 <exp> 大于 4K，
                         -L 强制输出。
print -l <exp>         # （“Literal”）不输出左侧。如果表达式是一个字符串
                         （字符 *），不输出地址，只输出字符串不带引号的原
                         始字符。
print -f<fmt> <exp>    # 使用 <fmt> 作为整数、字符串、浮点表达式的格式
                         （参见“help format”）
print -F<fmt> <exp>    # 使用给定格式但不输出左侧（变量名或表达式）
                         （参见“help format”）
print -o <exp>         # 以序数值的形式输出必须作为枚举的表达式的值 这里，
                         您也可以使用格式化字符串 (-f<fmt>)。对于非枚举型
                         表达式，忽略此选项。
print -- <exp>         # “--”代表标志参数的结尾。如果 <exp> 以正号或负
                         号开头，这会很有用（参见“help scope”，以了解
                         范围解决规则。参见“help redirection”，以重定向
                         “print”的输出并添加尾随注释。）
#
:rprint（命令）
%rprint - 使用 shell 引用规则输出表达式
rprint [-r|+r|-d|+d|-p|+p|-L|-l|-f<fmt>|-F<fmt>|--] <exp> 
                         输出表达式的值。未应用特殊引用规则，
                         因此“rprint a > b”将“a”值（如果存在）
                         放入“b”文件中（参见“help print”以了解标志）
#
:proc（命令）
%proc - 显示当前进程的状态
proc -map               # 显示带地址的装入对象列表
proc -pid               # 显示当前进程 id (PID)
#
:prog（命令）
%prog - 管理正被调试的程序和它们的属性
prog -readsyms          # 读取由于将 dbxenv run_quick 设置
                        # 为“on”而延迟的符号信息
prog -executable        # 输出可执行文件的完整路径；如果程序需要使用 -，
                        # 则输出“-”。
prog -argv              # 输出全部 argv，包括 argv[0]。
prog -args              # 输出 argv，不包括 argv[0]。
prog -stdin             # 输出“< <filename>”；如果使用 stdin，则为空。
prog -stdout            # 输出“> <filename>”或“>> <filename>”；
                        # 如果使用 stdout，则为空。-args、-stdin 和 -stdout 
                        # 的输出设计为：字符串可合并以及通过“run”重新使用。
#
:pwd（ksh 命令）
%pwd - 输出当前工作目录
pwd                    # 输出当前工作目录
#
:quit（命令）
%quit - Exit dbx
quit                   # 退出 dbx 并显示返回代码 0。与“exit”相同。
quit <n>               # 退出并显示返回代码 <n>。与“exit <n>”相同。
当 dbx 附加至某个进程时，该进程在退出之前被分离。
如果有不确定的信号，它们将被取消。使用“detach”进行严格控制。
#
:regexp（主题）
dbx 中的某些命令（“funcs”、“files”和“loadobject”）使用正规表达式
来指定命令行上的项目。您可以在“regcmp”的 Solaris 手册页的 3c 部分找
到这些正规表达式的正确语法。该命令的帮助描述中指定了与正规表达式匹配的
每个命令的细节。
#
:replay（命令）
%replay - 重新运行自上次执行“run”之后的调试命令
replay [-<num>]        # 重新运行自上次执行 run/rerun/debug 命令之后的
                       # 所有 <num> 命令或所有 - <num> 命令。

另请参见“help save”和“help restore”。
#
:rerun（命令）
%rerun - 不带参数运行程序
rerun                  # 不带参数开始执行程序
rerun <args>           # 通过 save 命令使用新参数开始执行程序

另请参见“help run”。
#
:run（命令）
%run - 使用参数运行程序
run                     # 使用当前参数开始执行程序
run <args>              # 使用新参数开始执行程序
                          使用 ^C 停止执行程序。
run ... >|>> <file>     # 设置输出的重定向
run ... < <file>        # 设置输入的重定向

当前没有可使用“run”或“runargs”命令重新定向 stderr 的方法。

另请参见“help rerun”、“help runargs”和“help prog”。
#
:runargs（命令）
%runargs - 更改目标进程的参数
runargs <args>          # 设置“run”命令所用的当前参数
runargs ... >|>> <file> # 设置“run”命令所用的输出重定向
runargs ... < <file>    # 设置“run”命令所用的输入重定向
runargs                 # 清除当前参数

使用“debug”命令自行检查当前参数。

另请参见“help prog”。
#
:restore（命令）
%restore - 将 dbx 恢复到先前保存的状态
restore [<filename>]   # 将 dbx 恢复到其保存时的状态。

另请参见“help save”和“help replay”。
#
:save（命令）
%save - 将命令保存至文件
save [-<num>] [<filename>] # 保存自上次对缺省文件或 <filename> 
                             执行过 run/rerun/debug 命令的所有命令
                             或全部 minus <num> 命令。

另请参见“help restore”和“help replay”。
#
:scopes（命令）
%scopes - 输出活动范围列表
scopes                 # 输出活动范围列表，包括命名空间。
#
:search（命令）
%search - 在当前源文件中向前搜索
search <string>        # 在当前文件中向前查找 <string>
search                 # 使用最后的搜索到的字符串来反复搜索     
#
:setenv（ksh 命令）
%setenv - 设置环境变量
setenv <name> <string> # 将环境变量 <name> 设置为 <string>
#
:source（命令）
%source - 在指定文件中执行命令
source <filename>      # 在文件 <filename> 中执行命令。未搜索到 $PATH。

另请参见“help .”。
#
:status（命令）
%status - 列出事件处理程序（断点等）
status                 # 输出 trace、when 和 stop 的状态
status <hid>           # 输出处理程序 <hid> 的状态
status -h              # 输出 trace、when 和 stop 的状态包括
                       # 隐藏部分。
status -s              # 同上，但是 dbx 可读取输出

                                (dbx) status -s > bpts 
                                ...
                                (dbx) source bpts

另请参见“help debug”下的“-r”标记。
#
:step（命令）
%step - 单步执行一源行或语句（正在单步进入调用）
step                   # 一步执行一行（单步进入调用）。
                       # 无法执行非活动线程。
step <n>               # 单步执行 <n> 行（单步进入调用）
step up                # ... 并跳出当前函数
step ... -sig <sig>    # ... 并释放指定信号
step to [<func>]       # 尝试单步进入当前源行中的 <func>。
                       # 如果未指定 <func>，则 <func> 将
                       # 成为最后被调用的 <func>，如汇编代码
                       # 为当前源行所指定的一样。
                       # 另请参见“help step to”

dbxenv 变量“step_events”控制跳步过程中断点是否可用。

step ... <tid>         # 跳过指定线程。不适用于“step up”。
step ... <lwpid>       # 跳过指定 LWP。

另请参见“stepi”以了解机器级步长。
另请参见“step_granularity”下的“help dbxenv”。
#
:step$$to (副标题)
在当前源行中试图进入最后汇编调用指令或者进入函数（如果指定）时，可能无法
执行调用（因条件转移）。在此情况下，不会执行调用或当前源行中没有调用，
step 将跳过当前源行。使用“step to”时，需要特别注意用户定义的赋值运算符。
#
:stepi（命令）
%stepi - 跳过一个机器指令（进入调用）
stepi                  # 一步跳过一个机器指令（步入调用）
stepi <n>              # 单步跳过 <n> 个机器指令（步入调用）
stepi -sig <sig>       # ... 并释放指定信号
stepi ... <lwpid>      # ... 指定 LWP 。
stepi ... <tid>        # ... 指定活动线程上的 LWP。
#
:stop（命令）
%stop - 设置源级断点
stop [ -update ]        # 立刻停止执行。仅在 WHEN 循环体中有效。
stop -noupdate          # 与 -update 相同，但是不更新 GUI 显示。
stop at <line>          # 在行中停止执行
stop in <func>          # 调用 <func> 时停止执行
stop inclass <clsname>  # 仅限于 C++: 在类/结构/联合或模板类的所有成员
                        # 函数上设置断点
stop inmember <name>    # 仅限于 C++: 在所有成员函数 <name> 上设置断点
stop infunction <name>  # 仅限于 C++: 在所有非成员函数 <name> 上设置断点

“stop”使用如下通用语法:

        stop <event-specification> [ <modifier> ]

发生指定事件时，停止进程。另请参见“stopi”以了解设置机器级断点的信息。
有关所有事件的列表和语法，请参见“help event specification”。
有关事件管理命令的综合讨论，请参见“help events”。
#
:stopi（命令）
%stopi - 设置机器级断点
stopi at <addr>         # 在 <addr> 位置上停止执行
stopi in <func>         # 调用 <func> 时停止执行。

除非程序因 stopi dbx 显示反汇编位置停止运行，否则 stopi 与“stop”相似。

“stopi”使用如下通用语法:

        stopi <event-specification> [ <modifier> ]

发生指定事件时，停止进程。有关所有事件的列表和语法，
请参见“help event specification”。
有关事件管理命令的综合讨论，请参见“help events”。
#
:thread（命令）
%thread - 列出或更改当前线程
thread                      # 显示当前线程
thread <tid>                # 切换至线程 <tid>。

下列变量中，没有 <tid> 表示当前线程。

thread -info [ <tid> ]      # 输出有关指定线程的所有信息
thread -hide [ <tid> ]      # “隐藏”指定（或当前）线程。它将不会显示在通用
                            # “线程”列表中。
thread -unhide [ <tid> ]    # “取消隐藏”指定（或当前）线程。
thread -unhide all          # “取消隐藏”所有线程。
thread -suspend <tid>       # 保持曾运行过的指定线程。线程列表中所示的挂起
                            # 的线程带有“S”。
thread -resume <tid>        # 撤消“-suspend”命令执行过的操作。
thread -blocks [ <tid> ]    # 列出锁定其它线程的指定线程所保持的所有锁
thread -blockedby [ <tid> ] # 显示指定线程锁定的同步对象（如果有）。
#
:threads（命令）
%threads - 列出所有线程
threads                   # 输出所有已知线程列表
threads -all              # 输出通常不会输出的线程（僵进程）
threads -mode all|filter  # 控制是否要“threads”输出所有线程或以缺省方式对
                          # 其进行过滤。启用过滤时，通过“thread -hide”隐
                          # 藏的线程不会显示出来。
threads -mode auto|manual # 在 GUI 下，启用自动线程列表更新
threads -mode             # 回显当前模式

各线程可能均会显示一个代码字母。“a”代表当前计划运行的“活动”线程。
“b”代表永久指定给某个 lwp 的“绑定”线程。
#
:sync（命令）
%sync - 显示有关指定同步对象的信息
sync -info <addr>       # 显示 <addr> 处 
                        # 同步对象的有关信息（仅限 Solaris）
#
:syncs（命令）
%syncs - 列出所有同步对象（锁）
syncs                   # 列出所有同步对象(锁)
                        # （仅限 Solaris）
#
:lwpid (主题)
这是 LWP 上系统句柄所用的术语。各种命令使用并接受用于指定 LWP 的语法
“l@<number>”。其中的 number 代表由 lwp_create() 返回并由 /proc 提供界
面的 LWP ID。“all”通常可被取代以表示所有 LWP。
#
:trace（命令）
%trace - 显示执行的源行，函数调用，或变量更改
trace -file <filename>  # 将所有跟踪输出指定给 <filename>。要将跟踪输出
                        # 还原为标准输出，请将“-”用于 <filename>。
                        # 跟踪输出始终位于 <filename> 后。该输出将在显
                        # 示 dbx 提示且退出应用时被清空。<filename> 绑定
                        # 后，在每次重新运行或恢复时总会被重新打开。
trace step              # 跟踪每个源行、函数调用然后返回。
trace next -in <func>   # 在指定函数中跟踪每个源行
trace at <line#>        # 跟踪指定源行
trace in <func>         # 跟踪指定函数的调用和返回情况
trace inmember <func>   # 跟踪所有名为 <func> 的成员函数的调用
trace infunction <func> # 调用所有名为 <func> 的函数时进行跟踪
trace inclass <class>   # 跟踪所有 <class> 成员函数的调用
trace change <var>      # 跟踪变量更改
...

“trace”使用如下通用语法：

        trace <event-specification> [ <modifier> ]

发生指定事件时，“跟踪”即被输出。
有关所有事件的列表和语法，请参见“help event specification”。
有关事件管理命令的综合讨论，请参见“help events”。

使用 dbxenv 变量 trace_speed 可设置跟踪速度。

源行跟踪（“step”事件规范）可通过使用非通用修饰符 -nosrc 
和 -nocalls 进行定制。
        -nocalls        取消进入/退出跟踪信息。
        -nosrc          取消输出源行内容。
                        取代跟踪输出的是：
                                trace: "<filename>":<lineno>
使用这两个修饰符可以减少执行跟踪的时间和磁盘空间。

请参见“tracei”以了解有关机器级跟踪的信息。

旧跟踪语法不再适用。（请参见“help old trace”以了解有关新旧语法
对照的信息）。

#
:old$$trace（主题）
以下每两行显示了新旧对应的跟踪语法，其中后者为新语法：

        trace                   # 跟踪每个源行
        trace step

        trace in <proc>         # 跟踪进程中的每个源行
        trace next -in <proc>

        trace <line#>           # 跟踪指定源行
        trace at <line#>        # （类似于“stop at”）

        trace <proc>            # 跟踪过程调用
        trace in <proc>         # （类似于“stop in”）

        trace var at <line#>    # 到达 <line> 时出现变量

        when at <line#> {
            echo at line $lineno in file \"$(basename $file)\": var = $[var];
        }

        trace <var> [in <proc>] # 跟踪变量的更改
        trace change <var> [ -in <proc> ]
#
:tracei（命令）
%tracei - 显示机器指令、函数调用或变量更改
tracei step              # 跟踪每个机器指令
tracei next -in <func>   # 在指定函数中跟踪各指令
tracei at <address>      # 在指定地址上跟踪指令
tracei in <func>         # 跟踪指定函数的调用和返回
tracei inmember <func>   # 跟踪所有名为 <func> 的成员函数的调用
tracei infunction <func> # 调用名为 <func> 的所有函数时进行跟踪
tracei inclass <class>   # 跟踪所有 <class> 的成员函数调用
tracei change <var>      # 跟踪变量的更改
...

tracei 实际上是“trace <event-specification> -instr”的简称，
其中 -instr 修饰符可使跟踪在指令粒度上而非源行粒度上进行，
而且发生事件时，信息将以反汇编格式而非源行格式输出。

请参见“help trace”以了解更多信息。
#
:unbutton（命令）
%unbutton - 删除 GUI 按钮
unbutton <cmd>         # 删除所有含有 <cmd> 的 GUI 按钮
unbutton -a            # 删除所有 GUI 按钮
                         除非在控制 GUI 时运行 dbx，否则此命令会被默认忽略。
#
:undisplay（命令）
%undisplay - 撤消“display”命令
undisplay <exp>, ...   # 撤消“display <exp>”命令
undisplay <n>, ...     # 撤消编号为 <n> 的“display”命令
undisplay 0            # 撤消所有“display”命令
#
:unhide（命令）
%unhide - 撤消“hide”命令
unhide 0               # 删除所有堆栈帧过滤器
unhide <regexp>        # 删除堆栈帧过滤器 <regexp>
unhide <num>           # 删除编号为 <num> 的堆栈帧过滤器
                         “hide”命令可列出带有编号的过滤器。
#
:unintercept（命令）
%unintercept - 撤消“intercept”命令（仅限于 C++）
unintercept <typename>    # 从“intercept”列表删除 <typename>
unintercept -a            # 从“intercept”列表删除所有类型
unintercept -x <typename> # 从“intercept -x”列表删除 <typename>
unintercept -x -a         # 从“intercept -x”列表删除所有类型
unintercept               # 列出截获类型

<typename> 可能是 -unhandled 或 -unexpected 中的一个。

另请参见“help intercept”。
#
:up（命令）
%up - 上移调用堆栈（移至“main”）
up                     # 上移调用堆栈一级
up <number>            # 上移调用堆栈 <number> 级
up -h [<number>]       # 上移调用堆栈，但是不跳过隐藏帧
#
:use（命令）
%use - 列出或更改目录搜索路径
此命令已过时，其用法已映射至以下“pathmap”命令：

    `use'  => `pathmap -s'
    `use <dir>' => `pathmap <dir>'

请参见“help pathmap”，以了解更多详细信息。

“use”命令在以后的版本中不再适用。
#
:whatis（命令）
%whatis - 输出表达式的类型或类型的声明
whatis [-n] [-r] <name>   # 输出无类型 <name> 的声明
whatis -t [-r] <type>     # 输出类型 <type> 的声明
whatis -e [-r] [-d] <exp> # 输出表达式 <exp> 的类型

                      -r : 输出有关基类的信息（仅限于C++）
                      -d : 显示动态类型，而非静态类型（仅限于 C++）
                           （另请参见“help c++ whatis”）
#
:when（命令）
%when - 对指定事件执行命令
when at <line> { cmd; }         # 到达 <line> 时执行命令
when in <proc> { cmd; }         # 调用 <proc> 时执行命令

“when”使用如下通用语法：

        when <event-specification> [ <modifier> ] { <cmd> ... ; }

发生指定事件时，执行 <cmd>。
请参见“help event specification”，以了解有关所有事件列表和语法的信息。
请参见“help events”，以了解有关事件管理命令的综合讨论。
另请参见“wheni”，以了解在指定低级事件上执行命令的信息。
#
:wheni（命令）
%wheni - 对指定低级事件执行命令
wheni at <addr> { cmd; }         # 到达 <address> 时执行命令

“wheni”使用如下通用语法：

        wheni <event-specification> [ <modifier> ] { <cmd> ... ; }

发生指定事件时，执行 <cmd>。
请参见“help event specification”，以了解有关所有事件列有和语法的信息。
请参见“help events”，以了解有关事件管理命令的综合讨论。
#
:where（命令）
%where - 输出调用堆栈
where                  # 输出过程回溯
where <num>            # 输出回溯中的 <num> 顶帧
where -f <num>         # 从帧 <num> 开始回溯
where -h               # 包插隐藏帧
where -l               # 包括库名和函数名
where -q               # 快速回溯（仅限于函数名）
where -v               # 冗余回溯（包括函数参数和行信息）

线程或 LWP ID 可能均遵循以上任一格式，以便获得指定实体的回溯。
另请参见“hide”
和“unhide”命令。
请参见 stack_verbose 变量下的“help dbxenv”。
#
:whereami（命令）
%whereami － 显示当前源行
whereami                # 如果不同，则显示与当前位置（堆栈顶部）对应的源行
                          以及当前帧对应的源行。
whereami -instr        # 同上，输出当前反汇编指令而并非源行除外。
#
:whereis（命令）
whereis － 输出给定名称的所有用法，或某个地址的符号名
whereis <name>          # 输出 <name> 的所有声明
whereis －a <address>   # 输出某个地址表达式的位置
#
:which（命令）
%which - 输出某个给定名称的全部限定
which [-n] <name>           # 输出 <name> 的全部限定
which -t <type>             # 输出类型为 <type> 的全部限定
#
:whocatches（命令）
%whocatches - 指明捕获 C++ 异常的位置。
whocatches <type>       # 如果在当前执行点抛出，指明捕获类型 <type> 
                          异常的位置。假定下一句执行的语句为“throw x”，
                          其中 x 为类型 <type>，并显示捕获异常的“catch”
                          子句的程序行号、函数名称和帧号。

                          如果捕获点位于执行抛出的同一个函数，则返回
                          “<type> is unhandled”。
:linux (topic)
%linux - Linux 专用的信息

Linux 上的 Dbx 限制 
------------------------

当 exec() 被调用时，Dbx 无法跟随派生进程，或更改为新的程序。
不支持 sysin 和 sysout 事件。不支持运行时检查和性能数据集合。

Ksh 中的“pipe”运算符仅限于 Linux 平台。任何需要访问目标进程
的 dbx 命令都不作为管道的一部分运行。例如：
   where | head -1 
可能会挂起。如果发生这种情况，使用 Ctrl-C 应该可以返回 dbx 
提示符处。dbx 会缓存大量信息，比如对于上例，下面的命令序列
起作用：
   where
   where | head -1

Linux 上的调试线程程序
------------------------------------

Linux OS 在支持调试线程的能力时会存在一些问题。这些问题可能
会给 dbx 用户带来困难。

1. 使用 libthread.so

如果程序使用 clone() 例程实现自身的线程样式，则 dbx 中的线程
支持不能正确识别线程。

2. 额外的 SIGSTOP 信号

Linux 中的线程库使用 SIGSTOP 信号作为其内部机制的一部分。
通常，dbx 会对用户隐藏这些信号，并允许用户从其他源监视真正
的 SIGSTOP 信号。偶尔，系统会以异常方式使用 SIGSTOP，dbx 会
认为它是用户生成的 SIGSTOP。如果发生这种情况，可以使用
“ignore”命令防止它。另请参见“help ignore”。

3. “cont”命令挂起

在 Linux 上，有时线程退出，但系统不将退出报告给 dbx。当使用
新的线程库时，这种情况发生的次数会减少 (NPTL)。

发生这种情况时，dbx 将会一直等待永不发生的事件。这种情况通常
是在 dbx 中发出“cont”命令后发生，但也可能会在“step up”、“step”、
“next”和其他命令后发生。有时 Ctrl-C 会唤醒 dbx，但有时有必要
终止 dbx 然后重试。

#
#
# Runtime checking stuff is here
#
:check（rtc 命令）
%check - 允许执行内存访问、泄漏或使用情况（RTC）检查

    输出运行时检查（RTC）的当前状态

    注意: 由此命令启用的功能将被“debug”命令重置为初始状态。

check -access

    打开访问检查。RTC 报告下列错误：
        baf     # 错误释放
        duf     # 重复释放
        maf     # 未对齐释放
        mar     # 未对齐读
        maw     # 未对齐写
        oom     # 内存不足
        rua     # 从未分配内存读
        rui     # 从未初始化内存读
        wro     # 写入只读内存
        wua     # 写入未分配内存

    缺省行为是在检测到访问错误后停止进程，可使用“rtc_auto_continue”
    dbxenv 变量更改。如果设为“on”，则将在文件中记录访问错误（文件名由
    “rtc_error_log_file_name”dbxenv 变量控制）。参见“help dbxenv”。
    
    缺省情况下，每个独特访问错误只在第一次发生时报告。可使用
    “rtc_auto_suppress”dbxenv 变量更改此行为（该变量设置缺省
    值为“on”）。参见“help dbxenv”。
    
check -leaks [-frames <n>] [-match <m>]

    打开泄漏检查。RTC 报告下列错误：
        aib     # 可能的内存泄漏 － 仅当指针指向块中央时发生
        air     # 可能的内存泄漏 － 指针指向仅存在于寄存器中的块
        mel     # 内存泄漏 － 没有指针指向块

    即使寄存器中指向块中央的地址同时为 <aib> 和 <air> 错误，
    但是这些错误仅报告为 <aib> 错误。
        
    打开泄漏检查时，程序存在时您可以自动收到泄漏报告。届时将报告包括可能
    的泄漏在内的所有泄漏。缺省情况下将生成一个非冗余报告（由 dbxenv 
    “rtc_mel_at_exit”控制）。但是，您也可以随时查看泄漏报告
    （参见“help showleaks”）。

    -frames <n> 表示在报告泄漏时最多将显示有 <n> 个不同堆栈帧。
    -match <m> 用于组合泄漏；如果两个或更多泄漏分配时的调用堆栈
    与 <m> 帧匹配，则这些泄漏将记录在单个合并泄漏报告中。

    <n> 的缺省值为 8 或 <m> 的值（取较大值）。
    <n> 的最大值为 16。对于 C++，<m> 的缺省值为 3，其它为 2。

check -memuse [-frames <n>] [-match <m>]

    打开内存使用（memuse）检查。check -memuse 表明了 check -leaks。
    除退出程序时的泄漏报告外，您还可获取块使用的情况（biu）报告。
    缺省情况下将生成一份非冗余的块使用情况报告（由 dbxenv 变量
    “rtc_biu_at_exit”控制）。执行程序时，您可以随时查看程序中内存
    的分配位置（参见“help showmemuse”）。

    -frames <n> 表明报告 memuse/ 泄漏时将显示最多 <n> 个不同堆栈帧。
    -match <m> 可用于合并此类报告；如果两个或更多泄漏分配时的调用堆
    栈与 <m> 帧匹配，则这些泄漏将记录在单个合并 memuse/ 泄漏报告中。

    <n> 的缺省值为 8 或 <m> 的值（取较大值）。<n> 的最大值为 16。
    <m> 对于 C++，其缺省值为 3，其它为 2。
    另请参见“check -leaks”。

check -all [-frames <n>] [-match <m>]

    等价于“check -access; check -memuse [-frames <n>] [-match <m>]”。
    dbxenv 环境变量值“rtc_biu_at_exit”不随“check -all”改变。
    因此，在缺省情况下，退出程序将不会生成内存报告。参见“help dbxenv”
    以获取变量 rtc_biu_at_exit 的说明。

check [<funcs>] [<files>] [<loadobjects>]

    等价于“check -all; suppress all; unsuppress all in <funcs> <files> 
    <loadobjects>”。您可使用此命令将 RTC 用于需要的地方。

注意缺省禁用的错误：

  要检测所有错误，RTC 不要求程序带有“-g”符号编译。
  但是，为了保证准确检测某些错误（通常从未初始化内存读取），
  则需要使用（-g）符号信息。由于此原因，如果没有可用的符号信息，
  某些错误将被禁用（如：“rui”表示 a.out，“rui + aib + air”
  表示共享库）。此行为可通过使用“suppress”和“unsuppress”更改。

参见“help uncheck”以获取有关关闭检查的信息。
参见“help suppress”以获取有关禁用错误的信息。
参见“help rtc”以获取有关 RTC 的介绍。

另请参见“help showleaks”和“help showmemuse”。
#
:uncheck（rtc 命令）
%uncheck － 禁止检查内存访问、泄漏或使用情况（RTC）
uncheck                         # 输出当前的检查状态
uncheck -access                 # 关闭访问检查
uncheck -leaks                  # 关闭泄漏检查
uncheck -memuse                 # 关闭内存使用检查（同时关闭泄漏检查）
uncheck -all                    # 等价于“uncheck -access; uncheck 
                                #   -memuse”
uncheck [<funcs>] [<files>] [<loadobjects>]
                                # 等价于“suppress all in 
                                # <funcs> <files> <loadobjects>;”
参见“help check”以获取有关打开检测的信息
参见“help suppression”以获取有关禁用错误的信息
参见“help rtc”以获取有关 RTC 的介绍。
#
:suppress（rtc 命令）
%suppress/unsuppress - 控制内存错误禁用 (RTC)

suppress               列出当前活动的禁用命令
suppress <err> <loc>   在命名位置禁用命名错误
suppress -r ...        删除禁用命令

suppress -last        禁用当前错误
suppress -reset ...   将禁用复位为缺省级别
suppress -d ...       控制非调试功能禁用
suppress -showall     显示内部禁用表入口

Suppress 和 unsuppress 命令被记录到一个列表中，并有累计效果。
例如，要在除 printf 以外的所以 libc 函数中禁用  BAF 错误，
请使用这两个命令：
  suppress baf in libc.so.1
  unsuppress baf in printf

unsuppress 命令通常使用和 suppress 相同的参数，
但有相反的效果。

suppress -reset
---------------
    suppress -reset         复位所有 loadobjects 禁用
    suppress -reset <loadobject> ...      ... 用于命名 loadobjects

suppress -d
-----------
   suppress -d 
     函数中禁用的错误列表，未被编译用于调试（缺省为禁用）。
     每个 loadobjects 都有一个这样的列表。  
     仅可使用“unsuppress -d” 命令来启用这些错误。
     
   suppress -d <errors>
     在所有 loadobjects 中禁用 <errors>。

suppress -d <errors> in <loadobjects>
     在命名 loadobjects 中禁用 <errors>。

   unsuppress -d ...
     允许所有或某些 loadobjects 中错误。
     此命令使用相同的参数，但有相反的结果。

suppress -r
-----------
   当“suppress” 命令显示当前活动的禁用命令列表时，
   此命令将显示每个命令的 ID 号码。
   该 ID 号码可用于从列表中删除该命令。

   suppress -r <id>       删除命名的禁用命令。
   suppress -r all        删除所有禁用命令。

suppress <errors> ...
---------------------
   suppress <errors>        禁用所有 <error> 
                                   
suppress <errors> in [<funcs>] [<files>] [<loadobjects>]
suppress <errors> at <line>
   suppress <errors> at "<file>":<line>
   suppress <errors> addr <addr>

                            在命名位置禁用 <errors> 

   unsuppress <errors>      允许所有 <errors> 
   unsuppress <errors> ...  在命名位置允许 <errors> 

   -stack 参数可用于 <errors> 之前，表示在命名位置调用的任何函数
   中都应该禁用该错误。例如，如果名为 __strange_libc_function 的
   函数导致错误，但是这些错误不是由于您的程序导致的，您不能对您
   的程序做任何操作，但是您可以禁用该函数中的所有错误，以及函数
   调用的各函数中的所有错误。

   suppress -stack all in __strange_libc_function 

错误类型
---------------                               
                                
<error> 由空格分隔，并可以是下列组合：

all     # 所有错误
aib     # 可能的内存泄漏 － 块中的地址
air     # 可能的内存泄漏 － 寄存器中的地址
baf     # 错误释放
duf     # 重复释放
mel     # 内存泄漏
maf     # 未对齐释放
mar     # 未对齐读
maw     # 未对齐写
oom     # 内存不足
rua     # 从未分配内存中读
rui     # 从未初始化内存中读
wro     # 向只读内存中写
wua     # 向未分配内存中写

biu     # 在使用的块（已分配内存）。尽管这不是错误， 您可以在禁用命令中
        # 使用“biu”，就像用 <error> 一样。

通常情况下，dbx 将自动禁用其遇到的每个错误（在错误发生位置）。
此自动禁用不会导致将命令列在禁用列表上，而且再次允许程序时，
影响将消失。此行为可使用 dbxenv 变量 rtc_auto_suppress 控制。

此行为与使用“suppress -last”命令不同，使用“suppress -last”将导致在
禁用列表中列出该命令，程序再次运行时，会沿用该命令。 

关于启用错误，参见“help unsuppress”。
参见“help rtc”以获取有关 RCT 的介绍。
#
unsuppress 命令用于撤消上一个 suppress 命令的影响，
或放松缺省的禁用规则。

详细信息请参见“help suppress”命令。
参见“help rtc”以获取有关 RCT 的介绍。
#
:showleaks（rtc 命令）
%showleaks leak - 报告上次“showleaks”命令（RTC）后的新内存泄漏
showleaks [-a] [-m <m>] [-n <num>] [-v]

   报告上次“showleaks”命令后的新内存泄漏。在缺省的非冗余情况下将输出每
   个“leak”记录的单行报告。“possible leaks”之后将报告“Actual leaks”。
   报告可按泄漏的合并大小排序。

    -a   显示所有已经产生的泄漏（不仅是上次“showleaks”命令后的
         新内存泄漏）。

    m <m>   用于合并泄漏；如果两个或更多泄漏分配时的调用堆栈与 <m> 帧匹配，
         则这些泄漏将记录在单个合并泄漏报告中。如果提供了 -m 选项，则它将
         覆盖 <m> 的全局值（由“check”命令指定）。

    -n <num> 在报告中最多显示 <num> 条记录。缺省值为显示所有记录。

    -v   生成冗余输出。缺省值为非冗余输出。

    参见“help check”。
:showmemuse（rtc 命令）
%showmemuse - 显示上次“showmemuse”命令（RTC）后使用的内存。
showmemuse [-a] [-m <m>] [-n <num>] [-v]

    showmemuse 可显示上次“showmemuse”命令后内存块的使用情况。
    每条“block in use”记录将输出一个单行报告。报告可按块的合
    并大小排序。上次“showleaks”命令后所有泄漏的块都将包括在报告中。

    -a   显示所有使用中的块（不仅是上次“showleaks”命令后的块）

    -m <m>   用于合并使用中的块报告。如果两个或更多块分配时的调用堆栈
         与 <m> 帧匹配，则这些块将记录在单个合并报告中。如果提供了 -m 
         选项，则它将覆盖 <m> 的全局值。

    -n <num> 在报告中最多显示 <num> 条记录。缺省值为 20。

    -v   生成冗余输出。缺省值为显示非冗余输出。

    <m> 缺省值为 2 或（如果已指定）由“check” 命令上次提供的全局值。
    <num> 缺省值为 20。

    参见“help check”。
:showblock（rtc 命令）
%showblock - 显示分配特定堆块的位置（RTC）
showblock -a <addr> 

    在打开内存使用检查或内存泄漏检查时，showblock 将显示地址 <addr> 的堆块
    详情。这些详情包括块分配的位置及其大小。（参见“help check”）
#
#
#
# Collector data is here
#
:collector（命令）
%collector - 收集性能数据（仅限 Solaris）

collector <command>           # 指定收集器命令
   enable                     # 启用收集器，打开新实验
   disable                    # 停止收集性能数据并关闭实验
   pause                      # 停止收集性能数据但不关闭实验
   resume                     # 暂停后继续性能数据收集
   profile <options>          # 指定分析设置
   synctrace <options>        # 指定 synctrace 设置
   hwprofile <options>        # 指定硬件计数器的分析设置
   heaptrace <options>        # 指定 heaptrace 设置
   mpitrace <options>         # 指定 mpitrace 设置
   sample <options>           # 指定 sampling 设置
   dbxsample <options>        # 指定当 dbx 停止进程时的 sampling 设置
   store <options>            # 实验文件控制和设置
   limit <options>            # 试验文件大小限制控制
   show <options>             # 显示当前 collector 设定
   archive <options>          # 指定实验终止时的归档模式 
   status                     # 查询当前实验的状态 
   version                    # 查询收集器库版本

要开始收集数据，请输入“collector enable”。
要结束数据收集，输入“collector disable”。

输入“collector show”可随时查看所有收集器设定。
另请参见“help collector mt”。


#
:collector$$profile（命令）
collector profile <options>     # 指定配置文件选项
    <on|off>                    # 指定配置文件数据收集模式
    timer <interval>            # 指定配置文件计时器周期（由浮点固定），
                                # 可在后面添加 m 表示毫秒，
                                # 或者使用 u 表示微秒。
#
:collector$$synctrace（命令）
collector synctrace <options> # 指定 synctrace 选项
    <on|off>                  # 指定 synctrace 数据收集模式
    threshold <microseconds>  # 指定 threshold 值（以毫秒为单位）
    threshold calibrate       # 自动计算出 Threshold 值#
#
:collector$$hwprofile（命令）
collector hwprofile <options>  # 指定硬件计数器选项
    <on|off>                   # 指定配置文件数据收集模式
    list                       # 输出可用计数器列表
    counter <name> <interval> [<name2> <interval2>]
                               # 指定硬件计数器名称和时间间隔
#
:collector$$dbxsample（命令）
collector dbxsample <options> # 指定 dbx 在进程停止时的取样行为
    <on|off>                  # 指定是否记录取样
#
:collector$$heaptrace（命令）
collector heaptrace <options> # 指定 heaptrace 选项
    <on|off>                  # 指定 heaptrace 数据收集模式
#
:collector$$mpitrace（命令）
collector mpitrace <options>  # 指定 mpitrace 选项
    <on|off>                  # 指定 mpitrace 数据收集模式
#
:collector$$sample（命令）
collector sample <options>        # 指定取样选项
    <periodic|manual>             # 指定取样模式
    period <seconds>              # 指定采样周期（以秒为单位）
    record <name>                 # 使用任意名称记录采样
#
:collector$$show（命令）
collector show <options>          # 显示一个或多个种类的设置
    <options> absent from cmd     # 显示所有设置
    all                           # 显示所有设置
    profile                       # 显示配置文件设置
    synctrace                     # 显示 synctrace 设置
    hwprofile                     # 显示 hwprofile 设置
    heaptrace                     # 显示 heaptrace 设置
    limit                         # 显示实验大小限制
    mpitrace                      # 显示 MPI 跟踪设置
    sample                        # 显示取样设置
    store                         # 显示存储设置
    archive                       # 显示归档设定
#
:collector$$store（命令）
collector store <options>         # 指定存储选项
    directory <string>            # 指定存储实验的目录
    experiment <string>           # 指定实验文件名
    group <string>                # 指定实验组名
#
:collector$$status（命令）
collector status              # 查询当前实验的状态
#
:collector$$archive（命令）
collector archive <option>       # 设置归档模式
    on                           # （缺省）正常归档
    off                          # 不归档
    copy                         # 将装入对象复制到试验，以方便移植
#
:collector$$mt（主题）
支持 MT 应用程序的数据收集。对于 MT 收集存在某些限制和局限：

o 您将无法收集在共享库初始部分执行的代码的信息（使用 a.out 即可）。

o 对多线程应用程序，您可以绑定到进程并启动收集器进行分析。
        您必须按照 collector.1 手册页的指令操作。
        
o 如果您正在收集同步追踪数据，您必须在开始程序的执行的时候获得 LD_PRELOAD 
        的 libcollector.so。

########################################################################
#################### Language Specific Information #####################
########################################################################
#
# C++ specific help is here
#
:c++（主题）
使用命令“help c++ <subtopic>”获取关于以下某个副标题的更多帮助。

    whatis       # 了解类定义
    printing     # 输出或显示继承的数据成员
    dynamic      # 了解关于对象指针的动态信息
    vfuncs       # 关于调试虚拟函数的信息
    rtti         # 使用运行时类型信息
    inclass      # 在某个类的所有成员函数上设置断点
    inmember     # 在所有重载的成员函数上设置断点
    inobject     # 在某个类的所有成员函数上设置断点
    infunction   # 在所有重载的非成员函数上设置断点
    overloaded   # 处理重载的函数和数据成员

或使用“help -k <keyword>”来寻找涉及关键字 <keyword> 的帮助主题。
#
:c++$$whatis（副标题）
当运行在一个 C++ 类或结构上时，命令“whatis”提供一个列表，其中列出
所有已定义函数（未定义函数不会列出）、静态数据成员、类友以及在该类中
显式定义的数据成员。指定“-r”（递归）选项将添加来自继承类的信息。

与“-e”标志一起使用时，“-d”标志使用表达式的动态类型。
要了解更多信息，请参见“help c++ dynamic”。

对于 C++，模板相关标识符显示如下：
所有模板定义通过“whatis -t”列出。
函数模板实例化通过“whatis”列出。
类模板实例化通过“whatis -t”列出。
#
:c++$$printing（副标题）
当您为“print”或“display”指定一个“-r”（递归）选项时，GUI 显示某个类
直接定义的数据成员以及从基类继承的数据成员。

这三个命令还使用“-d”或“+d”选项，以切换 dbxenv“output_dynamic_type”的
缺省行为。要了解更多信息，请参见“help c++ dynamic”。
#
:c++$$dynamic（副标题）
在 C++ 中，对象指针有两种类型：其静态类型（在源代码中定义）及其动态类型
（一个对象在任何类型转换之前的状态）。当您在“print”、“display”和
“whatis”命令中使用“-d”选项，或者将 dbxenv “ouput_dynamic_type”
设置为“on”时，dbx 有时可以提供关于某对象动态类型的信息。

总之，当一个对象含有虚拟函数表（“vtable”）时，dbx 可以使用 vtable 
中的信息来正确指出一个对象的类型。

如果在没有运行的进程时使用“-d”标记（或将 dbxenv“output_dynamic_type”
设置为“on”），则会产生“program is not active”错误消息，因为没有进程时
无法访问动态信息。如果您尝试通过虚拟继承来查找动态类型，将会产生“illegal 
cast on class pointers”的错误消息（在 C++ 中，从一个虚拟基类转换到一个
派生类是非法的）。
#
:c++$$vfuncs（副标题）
虚拟函数可以像其它函数一样使用“print”或“call”命令或其它执行函数
调用的命令来调用。

注释：该功能只在 Sun C++ compilers 3.0 或更高版本中被支持。
#
:c++$$rtti（副标题）
dbx 支持 C++ 的“dynamic_cast”和“typeid”运算符。当使用这两个运算符评估
表达式时，dbx 会调用编译器所允许的某些 rtti 函数。如果源代码没有显式地使用
这些运算符，编译器可能不产生这些函数，dbx 将无法评估表达式。
#
:c++$$inclass（副标题）
“inclass”事件说明符允许您在为一个指定类所定义的所有成员函数上设置断点。
它可以与“stop”、“when”和“trace”命令一起使用。参见“help event 
specification”。
#
:c++$$inmember（副标题）
事件说明符“inmember”允许您在任何类中定义的、具有指定名称的所有成员函数上
设置断点。它可以与“stop”、“when”和“trace”命令一起使用。
参见“help event specification”。
#
:c++$$inobject（副标题）
事件说明符“inobject”允许您在为 c++ 对象（C++ 类/结构/联合的指针）定义的
所有非静态成员函数上设置断点，并且只在通过该对象调用时停止。它可以与“stop”、
“when”和“trace”命令一起使用。如果 dbxenv 变量“output_dynamic_type”为
“on”，dbx 将使用该对象的动态类型。参见“help c++ dynamic”和“help event 
specification”。
#
:c++$$infunction（副标题）
事件说明符“infunction”允许您在已定义的、具有指定名称的所有非成员
函数上设置断点。它可以与“stop”和“when”命令一起使用。
参见“help event specification”。
#
:c++$$overloaded（副标题）
dbx 应能够确定您所引用的变量或函数，除非：

* 您只通过名称来引用一个重载的函数
* 您引用 `` 开头的函数或变量

考虑以下实例：

        int foo(double);
        int foo(int);
        int bar();
        class x {
                int bar();
        };

当您在一个非成员函数上停止时，您输入以下命令：

        stop in foo(int)

在全局函数 foo(int) 上设置断点。要在成员函数上设置断点，您可以使用以下命令：

        stop in x::bar()

如果您只输入以下命令：

        stop in foo

dbx 将无法确定您指的是全局函数 foo(int) 还是全局函数 foo(double)，被迫显示
一个重载菜单，要求您澄清。最后，如果您输入以下命令：

        stop in ``bar

dbx 将无法确定您指的是全局函数 bar() 还是成员函数 bar()，并显示一个重载菜单。
#
:fortran90
参见“help fortran”
#
:fortran77
参见“help fortran”
#
:f90
参见“help fortran”
#
:f77
参见“help fortran”
#
:fortran（主题）

断点
----
在 FORTRAN 77 中，主程序的名称是 MAIN，而不是 main。
为了在主程序中停止，您必须使用“stop in MAIN”。

表达式
------
系统新增一些支持功能，支持分析 FORTRAN 样式表达式、处理复数以及调用大多数 
FORTRAN 内部函数。由于 dbx 的标记扫描程序的非 FORTRAN 性质，
使用“print 1 .eq. 1”以避免出现“print 1.eq.1”之类情况是必要的。
#
########################################################################
########################### KSH-specific help topics ###################
########################################################################
# I18N - translate this topicname to match same word in `Other Topics' message
:编辑（ksh 标题）
请使用“help editing emacs”或“help editing vi”
#
# I18N - translate this topicname (only before $$) to match previous topic
:editing$$emacs（ksh 副标题）
请使用“set -o emacs”来启用 emacs 样式的编辑器。命令“bind”列出当前关键绑定
或更改这些绑定。一些更重要的缺省绑定是：

        ^A = 行开始                 ^B = 后退
        ^D = 磁带结束符或删除        ^E = 行结束
        ^F = 向前                   ^G = 终止
        ^K = 删除到行末              ^L = 刷新
        ^N = 下一个历史命令          ^P = 上一个历史命令
        ^R = 搜索历史命令            ^^ = 引号
        ^? = 向后删除字符             ^H =向后删除字符
        ^[b = 后一个字符             ^[d = 向前删除字符
        ^[f = 前一个字符             ^[^H = 向后删除字符
        ^[^[ = 完成                  ^[? = 列表命令

另请参见“help bind”和“help editing vi”
#
# I18N - translate this topicname (only before $$) to match previous topic
:编辑$$vi（ksh 副标题）
请使用“set -o vi”来启用 vi 样式的编辑器。命令“bind”列出当前关键绑定并
更改这些绑定。
这些命令（在命令模式下）是：

   a = 追加           A = 行尾追加
   c = 更改           d = 删除
   G = 行跳转         h = 后一个字符
   i = 插入           I = 行首插入
   j = 后一行         k = 前一行
   l = 行向前         n = 下一个匹配
   N = 前一个匹配     p = 后置 
   P = 前置           r = 重复
   R = 替换           s = 代替
   u = 取消操作       x = 删除字符
   X = 删除前一个字符   y = yank
   ~ = 格式调换       _ = 最后参数
   * = 展开           = = 列出展开式
   - = 前一行         + = 后一行
   sp = 前一字符      # = 注释出命令
   ? = 从开始搜索历史命令
   / = 从当前开始搜索历史命令   

在插入模式下，下列按键是特殊的：
   ^? = 删除字符     ^H =删除字符  
   ^U = 删除行       ^W =删除字

另请参见“help editing emacs”和“help bind”。
#
:path（ksh 主题）
缺省情况下，dbx 搜索 $PATH 来寻找命令。要禁止 $PATH 搜索，
输入“set +o path”。参见“help ksh options”和“help ksh PATH”。
#
:PATH（ksh 标题）
缺省情况下，dbx 搜索 $PATH 来寻找命令。要禁止 $PATH 搜索，
输入“set +o path”。参见“help ksh options”和“help ksh PATH”。
#
:ksh（主题）
命令语法和 KornShell 相同。分支与循环、环境变量、历史和命令行编辑全都受支持。
使用命令“help ksh <subtopic>”以获取以下指令的更多信息：

    aliases     # 内建别名的列表
    backslash   # “kprint”可识别的反斜杠换码的列表
    builtins    # 内建命令的列表
    differences # dbx 解释器和 ksh 间的已知差异
    environment # 预定义变量的列表
    expressions # 使用 ksh 表达式、$[] 语言表达式等。
    options     # “set -o：”选项
    syntax      # 简化的 ksh 语法
    variables   # 设置、测试、修改 ksh 变量
    <varname>   # 特定的预定义变量的用法

或使用“help -k <keyword>”来寻找涉及关键字 <keyword> 的帮助主题。
#
:ksh$$aliases（副标题）
预定义了以下别名：

        [='\['
        alias='kalias'
        echo='kprint'
        exception='print *$exception'
        functions='typeset -f'
        integer='typeset -i'
        nohup='nohup '
        pwd='kprint -r "$PWD"'
        r='fc -e -'
        suspend='kill -STOP $$'
        type='whence -v'
        x='examine'
#
:ksh$$backslash（副标题）
除非给出“-r”选项，否则“kprint”命令对下列字符序列进行特殊处理：

        \a              报警（响铃，ASCII 007）
        \b              后退键
        \c              禁止在新行终止，类似“-n”选项
        \f              换页
        \n              换行
        \r              回车
        \t              制表符
        \v              垂直制表符
        \\              反斜杠
        \nnn            （1 到 3 个八进制数）8 位字符，其
                        ASCII 码为 nnn

反斜杠也是引用字符。为了显示换页，可使用下列任何一个命令：

        (dbx) kprint -n \\f
        (dbx) kprint -n '\f'
        (dbx) kprint -n "\f"
#
:ksh$$builtins（副标题）
下列 ksh 命令已内建至 dbx：

    :           .               [               bg              bind
    break       builtin         cd              continue        dalias
    eval        exec            exit            export          false
    fc          fg              getopts         hash            jobs
    kalias      kill            kprint          let             read
    readonly    return          set             sh              shift
    test        times           trap            true            typeset
    ulimit      umask           unalias         unset           wait
    whence

请使用命令“help <cmdname>”来获得更多相关帮助。
或使用“help -k <keyword>”来寻找涉及关键字 <keyword> 的帮助主题。
#
:ksh$$differences（副标题）
dbx 命令解释器（pdksh）和“ksh88”之间的已知差异是：

(1) 不支持数组。
(2) 未实现“set -o”选项：allexport bgnice gmacs markdirs noclobber
    nolog privileged protected viraw.
(3) 新的“set -o”选项：hashall ignoresuspend path.
(4) 未实现“typeset”选项：-l, -u, -L, -R, -H, -Z.
(5) 新的“typeset”选项“-q”。
(6) 已内建 dbx 命令。
(7) 命令“bind”允许再绑定编辑函数。
(8) 语言表达式，如 $[p->x]。
(9) 十六进制数和八进制数的 C 语法。
(10) Csh 样式的历史访问。
(11) Csh 样式的别名参数。
(12)“print”命名为“kprint”。
(13) 新的“kprint”和“read”选项“-e”。
(14) 后引号是 dbx 范围转换运算符；请使用 $() 代替。
(15) [[ expr ]] 未实现。
(16) 新的模式运算符（如“@(...)”）未实现。
(17) 协同进程未实现。
(18) 不带参数的“kill”将终止目标进程。
#
:ksh$$environment（副标题）
预定义了以下标准 ksh 环境变量：
  CDPATH 
  COLUMNS 
  EXECSHELL 
  FCEDIT 
  HISTSIZE 
  HOME
  IFS 
  MAIL 
  MAILCHECK
  MAILPATH 
  OLDPWD 
  OPTARG 
  OPTIND 
  PATH 
  PPID 
  PS1 
  PS2 
  PS3 
  PS4 
  PS5 
  PWD 
  RANDOM 
  REPLY
  SECONDS 
  _ # - ? $ ! * @

参见“help ksh specialvars”，以了解非字母数字名称。有关其它详情，
请参见“help ksh <var>”。

许多变量的名称以“DBX_”开头。它们对应于“dbxenv”变量。
请参见“help dbxenv”，以了解这些变量的列表。

只读状态的变量为：dbxdir, havegui, mtfeatures, and version.
有关详情，请参见“help dbxdir”、“help havegui”、“help mtfeatures”
和“help version”。

变量“last_choice”通过重载转换被自动设置。
有关详情，请参见“help last_choice”。

以下是只读的 dbx 状态变量：

  ins lineno vlineno line
  func vfunc class vclass file vfile loadobj vloadobj scope vscope
  funcaddr caller
  newhandlerid handlerid firedhandlers
  proc prog
  lwp thread
  dllist dlobj
  exception
  sig sigstr sigcode sigcodestr
  exitcode
  falsehits
  syscode sysname

要了解每个变量的含义，请参见“help event variables”。

另外，寄存器的名称被保留。参见“help registers”。
#
:ksh$$expressions（副标题）
dbx 中有两种类型的表达式：ksh 表达式和语言表达式。
第一种类型只支持 32 位整数值以及下列运算符（与在 C 中一样）：

        || && | & ^ == != > < >= <= >> << + - * / % ! ~ ()
        = += -= *= /= %= &= |= ^= <<= >>=

要对一个 ksh 表达式求值，只需要将它限制在 (()) 中。对于一个 ksh 变量的引用，
可以使用‘$’，但这并不是必需的。它不能在一个赋值的左边被使用。

第二种类型支持目标语言的所有数据类型以及它的大部分运算符（赋值运算符除外）。
要对一个语言表达式示值，请将它限制在 $[] 中。$[] 可以出现在 (()) 中间，
但反之不行。以当前语言对 $[] 中的一个表达式求值（参见“help language”）。
“print”标志是可识别的；参见“help print”。

例如：

        (dbx) typeset -i x      # x 作为整数在内部存储
        (dbx) z=3 x=5           # z 的缺省值是一个字符串；不需要 (())
        (dbx)                   # 用于简单的整数赋值
        (dbx) ((ww = z << x))   # 这里需要使用 (())，空格是允许的
        (dbx) echo $ww        
        96
        (dbx) z=$[p->x[3]]      # z 被赋值（字符串）结果; p 为
        (dbx)                   # 目标进程中的一个指针
        (dbx) ((s = z/$[sizeof double])) # $[] 嵌入在 (()) 中

如果 dbx 知道变量的类型时（long、long long 以及相应的无符号类型），
则会将 L LL 和 U 作为变量值的后缀输出。以下实例列出了两种方法，
可以通过删除此后缀来将程序变量赋值成 ksh 变量。

        (dbx) whatis i
        long long i;
        (dbx) print i
        i = 8LL
        (dbx) z=$[-flld i] 
        (dbx) echo $z
        8
        (dbx) z=$[(int) i]
        (dbx) echo $z
        8
        (dbx) 

#
:ksh$$options（副标题）
使用“set -o”识别以下选项。如果是单字母的缩写，要放在圆括号内。

        emacs           emacs 编辑模式
        errexit         (-e) 发生错误时退出
        hashall         (-h) 记住所有已执行 UNIX 命令的完全路径
        ignoreeof       不在文件结尾处退出
        interactive     (-i) stdin 是一个终端
        keyword         (-k) 即使在参数列表中也将 var=value 视为赋值
        monitor         (-m) 在不同的进程组中运行后台作业
        noexec          (-n) 禁止命令执行
        noglob          (-f) 禁止通配符扩展
        nounset         (-u) 引用未设置的变量时报告错误
        path            没有找到命令时搜索 $PATH
        stdin           (-s) 从 stdin 获取命令
        trackall        (-h) 与“hashall”相同
        verbose         (-v) 在执行前回显每条命令
        vi              vi 编辑模式
        xtrace          (-x) 在求值后和执行前回显命令
#
:ksh$$specialvars（副标题）
以下特殊变量已预定义：

        $_      前一个简单命令的最后一个参数，同时也是
                检查邮件时使用的邮件文件路径名
        $#      位置参数的数量，$1 ...
        $-      在调用处所提供选项的设置
        $?      上一次命令执行的返回值，0 到 255。
                如果超出 127，则表示该命令被一个信号终止。
                 信号值等于 $? 减去 128。
        $$      此 dbx 进程的进程 ID
        $!      上一次后台进程的进程 ID
        $*      位置参数
        $@      位置参数

最后两个是相等的（加引号时除外）。"$*" 产生一个参数，其位置参数由空格分隔。
"$@" 产生 n 个参数，其中每个都加上 ""。如果位置参数是：
        a
        hi there
        foo

（也就是三个参数，其中一个包含空格），"$*" 则等于 

        "a hi there foo"

"$@" 则等于

        "a" "hi there" "foo"
#
:ksh$$CDPATH（变量）
如果变量不是由一个斜杠开头，CDPATH 变量将包含一系列由冒号分割的目录，
它们将被搜索用于“cd”命令的参数。如果设置了 $CDPATH，则缺省设置为不
搜索当前工作目录。它的缺省值为空。
#
:ksh$$COLUMNS（变量）
COLUMNS 变量反映终端的宽度。它是由内建命令行编辑器所使用。
#
:ksh$$EXECSHELL（变量）
变量 EXECSHELL 包含了在执行脚本时要使用的缺省 shell 的完全路径名。
缺省值是“/bin/sh”。
#
:ksh$$FCEDIT（变量）
FCEDIT 变量包含了“fc”命令的缺省编辑器的完整路径名。
隐式缺省值是“/bin/ed”。
#
:ksh$$HISTSIZE（变量）
HISTSIZE 变量包含历史中将要保存的命令数量。数值越大，占用的内存也越多。
缺省值是 15。
#
:ksh$$HOME（变量）
HOME 变量是“cd”命令的缺省参数，它是 dbx 寻找启动文件 .dbxrc 的地方，
同时也是路径名中扩展“~”的结果。
#
:ksh$$IFS（变量）
IFS 变量包含了“内部字段分割符”。它们是一些字符，用于将参数与命令区分开来。
缺省值是“space”、“tab”和“newline”。
#
:ksh$$MAIL（变量）
MAIL 参数包含了收入邮件文件的完整路径名。如果未设置 $MAILPATH（参见
“help ksh MAILPATH”），则会定期在此文件中查找收入邮件（参见
“help ksh MAILCHECK”）。
#
:ksh$$MAILCHECK（变量）
MAILCHECK 变量包含了 dbx 检查收入邮件之前的最少秒数。如果距上次检查已
过了 $MAILCHECK 秒，则会在输出提示之前先执行检查。如果 $MAILCHECK 是空
值或者 0，则会在每次提示前执行检查。如果 $MAILCHECK 未设置或被设置为非
数字值，则会禁用邮件检查。缺省值是 600 秒（10 分钟）。
#
:ksh$$MAILPATH（变量）
MAILPATH 变量包含了一个由冒号分割的文件列表，这些文件将接受检查以查找收入
邮件。每一个路径名后面可能都有一个问号，并且有一则要输出的消息。缺省消息
是“you have mail in $_”（$_ 变量将设置为完整路径）。如果 MAILPATH 没有
设置，dbx 就检查 $MAIL.  缺省情况下未设置。
#
:ksh$$OLDPWD（变量）
OLDPWD 变量包含了上一个工作目录的完整路径名。
它最初等同于 $PWD（参见“help ksh PWD”）。
#
:ksh$$OPTARG（变量）
使用参数解析选项时，OPTARG 变量会由“getopts”设置。它包含了参数，
但不包括选项字母。例如，如果位置参数是

        -a -bfoo +c -de

并且“getopts”被如下调用：

        while getopts ab:cdef opt
        do
                case $opt in
                a)      aflag=on ;;
                b)      bflag=$OPTARG ;;
                +c)     cflag=off ;;
                c)      cflag=on ;;
                d)      dflag=on ;;
                e)      eflag=on ;;
                f)      fflag=on ;;
                esac
        done

结果变量设置为

        aflag   on
        bflag   foo
        cflag   off
        dflag   on
        eflag   on
        fflag   (no change)
#
:ksh$$OPTIND（变量）
OPTIND 变量由“getopts”设置成下一个处理选项的索引。在任何函数或脚本开始时，
它被自动设置为 1。您可以对其进行手动设置，从而强制 getopts 处理一个特别的
位置参数。
#
:ksh$$PATH（变量）
PATH 变量包含了一个由冒号分割的目录列表，如果命令名称不包含斜杠并且已设置
“path”选项，则会在这些目录中搜索命令。参见“help path”。
#
:ksh$$PPID（变量）
PPID 变量包含了产生 dbx 的进程的进程 ID。
#
:ksh$$PS1（变量）
PS1 变量包含了“主”提示字符串。\$PS1 的值将在输出之前扩展，以便
        PS1='$PWD> '
在您的提示符中放置当前工作路径。“!”将替换为当前历史记录数。
使用“!!”可得到一个显式感叹号。$PS1 的缺省值是“($0)”（也就是说，
从中调用 dbx 的路径名会包含在圆括号里）。
#
:ksh$$PS2（变量）
PS2变量包含了“次”提示字符串。如果您在命令不完整的情况下按下 RETURN，
则会显示此提示。缺省值是“> ”。
#
:ksh$$PS3（变量）
PS3 变量包含了“select”命令的提示字符串。缺省值是“#?”。
#
:ksh$$PS4（变量）
PS4 变量目前没有被 dbx 使用。
#
:ksh$$PS5（变量）
PS5 变量包含了处于“adb”模式时的提示字符串。缺省值是“ADB> ”。
#
:ksh$$PWD（变量）
PWD 变量包含了当前工作目录的完整路径名。“pwd”命令仅回显 $PWD 的值。
#
:ksh$$RANDOM（变量）
RANDOM 变量实现了一个随机编号生成器。每次存取 RANDOM 的值时，它会返回一个
从 0 到 32767 之间的整数。您可以为 RANDOM 分配一个值，以便设置随机编号
生成器的籽数。
#
:ksh$$REPLY（变量）
将 REPLY 变量赋值为您对“select”命令的响应。
#
:ksh$$SECONDS（变量）
SECONDS 变量包含了调用 dbx 后的秒数。您可以将任何值分配给 SECONDS，
以便将计时器重置为 0。
#
:ksh$$syntax（副标题）
以下的规则不能构建一个正式的语法。它们仅仅是用一个简单的方式描述了
一般句法形式。

PIPELINE        ::=     CMDLIST [ | CMDLIST ]...

CMDLIST         ::=     COMMAND
                |       CMDLIST [ && PIPELINE ]...
                |       CMDLIST [ || PIPELINE ]...
                |       CMDLIST [ ; PIPELINE ]...
                |       CMDLIST & [ PIPELINE & ]...
                |       ( CMDLIST )
                |       { CMDLIST ; }
                |       FUNCTIONDEF

FUNCTIONDEF     ::=     function IDENT { CMDLIST; }
                |       IDENT () { CMDLIST; }

COMMAND         ::=     if CMDLIST; then CMDLIST;
                        [ elif CMDLIST; then CMDLIST; ]...
                        [ else CMDLIST; ] fi
                |       case WORD in [ PATTERN ) CMDLIST ;; ]... esac
                |       for IDENT [ in WORD... ] ; do CMDLIST; done
                |       select IDENT [ in WORD... ] ; do CMDLIST; done
                |       while CMDLIST; do CMDLIST; done
                |       until CMDLIST; do CMDLIST; done
                |       when WHENARGS { CMDLIST; }
                |       (( EXPRESSION ))
                |       time PIPELINE
                |       IDENT=VALUE... COMMAND
                |       FUNCTIONCALL
                |       BUILTIN
                |       UNIXCMD
#
:ksh$$variables（副标题）
Ksh 变量可以包含字符型或整数。缺省情况下，它们缺省是“string”类型。
要声明一个整数变量 x，请使用命令“typeset -i x”。
使用普通 ksh 语法来引用变量：

        $x              简单引用
        ${x}            简单引用，显式绑定名称     
        ${x-val}        如果 x 没有设置就代替“val”
        ${x:-val}       如果 x 没有设置或为空值就代替“val”
        ${x=val}        如果 x 没有设置就将“val”赋值给 x
        ${x:=val}       如果 x 没有设置或为空值就将“val”赋值给 x
        ${x+val}        如果 x 已经设置就代替“val”
        ${x:+val}       如果 x 已经设置并且不为空值就代替“val”
        ${x?val}        如果 x 没有设置就生成错误消息“val”
        ${x:?val}       如果 x 没有设置或为空值就生成错误消息“val”
        ${x#pat}        x 值，偏小左匹配模式
        ${x##pat}       x 值，偏大左匹配模式
        ${x%pat}        x 值，偏小右匹配模式
        ${x%%pat}       x 值，偏大右匹配模式
        ${#x}           x（格式化）值的长度

使用“typeset -i<base> x”将“x”声明为一个整数变量，并且输出基值 <base>
（从 2 到 36，含 2 和 36）。其它基值中的数字值可以输入为“<base>#<digits>”。
例如，数字 42（十进制）可以按如下方法输入：

        2#101010        3#1120          4#222           5#132
        6#110           7#60            8#52            9#46
        10#42           11#39           12#36           13#33
        14#30           15#2C           16#2A           17#28
        18#26           19#24           20#22           21#20
        22#1K           23#1J           24#1I           25#1H
        26#1G           27#1F           28#1E           29#1D
        30#1C           31#1B           32#1A           33#19
        34#18           35#17           36#16
其它“42”的有效形式有“052”和“0x2a”（分别对应于“c”语法中的八进制和
十六进制常量）。上例中的各种形式并不是重点。
#
########################################################################
########################## Ksh Commands ################################
########################################################################
::（ksh 语法）
%: - No-op
“:” 命令只会返回 0（真）。
#
:.（ksh 语法）
%. - 从一个文件读取命令
“. <file>”命令使 dbx 从 <file> 读取命令。任何变量赋值和函数定义都会影响
当前环境。如果已设置“path”选项，则搜索 \$PATH。

另请参见“help source”和“help ksh options”。
#
:[（ksh 语法）
%[ - “[ <expr> ]”是“test <expr>”的缩写。
“[ <expr> ]”命令是“test <expr>”的另一种语法。
参见“help test”以获得更多帮助。
#
:bg（ksh 命令）
%bg - 将一个作业放入后台
bg              # 将当前作业放入后台
bg %+           # 将当前作业放入后台
bg %-           # 将上一作业放入后台
bg %<n>         # 将作业编号 <n> 放入后台
bg %<str>       # 将以 <str> 开头的作业放入后台
bg %?<str>      # 将包含 <str> 的作业放入后台
                  “%”在所有情况下都是可选的。
#
:bind（ksh 命令）
%bind - 显示或修改 emacs 编辑键绑定
bind                    # 显示当前 emacs 编辑键绑定
bind <key>=<def>        # 将 <key> 绑定到 <def> 定义
bind <key>              # 显示 <key> 的当前定义
bind <key>=             # 删除 <key> 的绑定
bind -m <key>=<def>     # 将 <key> 定义为宏附带定义 <def> 的宏
bind -m                 # 与“bind”相同        

另请参见“help editing emacs”和“help editing vi”。
#
:break（ksh 关键字）
%break - 从“while”、“until”或“for”循环中跳出
break                   # 从封装循环（“while”、“until”或“for”）
                          中跳出。
break <n>               # 从 <n> 封装循环中跳出。
#
:builtin（ksh 命令）
%builtin - 使用命令的内建版本，忽略函数和别名
builtin <cmd> [<args>]  # 执行 <cmd>，禁止对函数或名为 <cmd> 的别名的
                          一般搜索。如果 <cmd> 不是一个内建函数，则会
                          显示一则错误消息。
#
:cd（ksh 命令）
%cd - 更改工作目录
cd                      # 将目录改为 $HOME
cd <dir>                # 将目录改为 <dir>。如果 <dir> 没有包含斜杠，
                          则搜索 $CDPATH。如果 <dir> 包含斜杠，则按原样
                          使用。在任何一种情况下，如果 <dir> 由一个“~”
                          开始，则用 $HOME 替换“~/”，或者用用户 <name> 
                          的 HOME 目录替换“~<name>”。
cd <old> <new>          # 将目录改为 <newdir>，<newdir> 是将当前目录名中
                          的 <old> 字符串替换为 <new> 后派生而来的。
cd -                    # 将目录改为 $OLDPWD
#
:continue（ksh 关键字）
%continue - 跳至下一次“while”、“until”或“for”循环。
continue                # 继续执行 ksh 命令并使用最近一个封装循环
                          （“while”、“until”或“for”）的下一次循环。
continue <n>            # 继续执行第 <n> 个封装循环的下一次循环。

参见“help cont”以了解进程控制。
#
:dalias（命令）
%dalias - 定义一个 dbx 类型(csh-style) 的别名
dalias                  #（Dbx 别名）列出所有当前已定义的别名
dalias <name>           # 列出 <name> 别名的定义（如果存在此类定义）
dalias <name> <def>     # 将 <name> 定义为 <def> 的一个别名。<def> 可以
                          包含空白。一个分号或新行即可结束定义。Dbx 接受
                          在别名中普遍使用的以下 csh 历史替代元语法：
                                !:<n>
                                !-<n>
                                !^
                                !$
                                !*
                          “!”通常需要加上反斜杠。例如：
                                dalias goto "stop at \!:1; cont; clear"
                          有关详细信息，请参见手册页 csh(1)。

另请参见“help alias”和“help kalias”。
#
:eval（ksh 命令）
%eval - 将文本求值为命令
eval <cmd> [<args>]     # 对命令 <cmd> 求值时将其视为通过键盘输入。
                          如果必须程序化地组织一个命令然后执行，
                          此命令将非常有用。实例：

                          (dbx) x='echo $$'
                          (dbx) $x
                          $$
                          (dbx) eval $x
                          1234
#
:exec（ksh 命令）
%exec - 执行一个新程序（终止 dbx）
exec <cmd> [<args>]     # 使 dbx 对给定的命令执行 exec()。此命令将导致 dbx 
                          被结束，并且新的命令将使用相同的进程 ID 来运行。
#
:exit（ksh 命令）
%exit - 退出 dbx
exit                    # 使 dbx 返回代码 0 并退出。与“quit”相同。
exit <n>                # 退出并返回代码 <n>。与“quit <n>”相同。
#
:export（ksh 命令）
%export - 标记要导出的特定环境变量
export                          # 列出所有已导出的 ksh 变量
export <name>                   # 将 <name> 变量标记为已导出
export <name>=<value>           # 将 <name> 变量标记为已导出并且
                                  赋给它一个新值
export <name1> <name2>...       # 将特定的变量标记为已导出
export <n1>=<v1> <n2>=<v2>...   # 其它。
                                已导出的变量拥有属性
                                “-x”（参见“help typeset”）。
#
:false（ksh 命令）
%false - 不做任何事并返回非零值
false                   # 不做任何事并返回非零值（255）
#
:fc（ksh 命令）
%fc -（修正命令）操作历史列表
fc                           # （修正命令）在最近的命令处调用（$FCEDIT）编辑。
                               当您离开编辑器时结果被执行。参见“help ksh 
                               FCEDIT”以获得更多信息。
fc -e <editor>               # 使用 <editor> 来代替 $FCEDIT 以编辑上一条命令
fc -l                        # 列出历史中的最后 16 条命令
fc -ln                       # 列出最后 16 条命令且不带历史编号
fc -lr                       # 列出倒数最后 16 条命令
fc -e - <cmd>                # 重新执行上一条匹配 <cmd> 的命令。
                               <cmd> 可以是一个正数（历史编号）、一个负数
                               （从当前历史编号中减去）、一个字符串（与以给
                               定字符串开始的命令相匹配）或空值（代表上一条
                               命令）。内建别名“r”设置为“fc -e -”。
fc -e - <old>=<new> <cmd>    # 和上面的一样，但是用 <new> 来代替 <old>
                               在执行命令前
fc -e -g - <old>=<new> <cmd> # 用 <new> 全局替换 <old>
#
:fg（ksh 命令）
%fg - 将一个作业放入前台
fg              # 将当前作业放入前台
fg %+           # 将当前作业放入前台
fg %-           # 将前一项作业放入前台
fg %<n>         # 将编号为 <n> 的作业放入前台
fg %<str>       # 将以 <str> 开头的作业放入前台
fg %?<str>      # 将包含 <str> 的作业放入前台
                  “%”在所有情况下都是可选的。
#
:getopts（ksh 命令）
%getopts - 解析选项的位置参数
getopts <opts> <name>           # 根据 <opts> 的值检查合法选项的位置参数
                                  （$1、$2 等等），并将结果赋值给 <name>。
                                  <opts> 是一个由选项字母组成的字符串。
                                  如果某个选项字母后面有一个冒号（“:”），
                                  则它需要一个参数。参见“help ksh OPTARG”
                                  处的实例。
getopts <opts> <name> <args>... # 使用给定参数而不是位置参数。
#
:hash（ksh 命令）
%hash - 操作被跟踪的别名（快速命令查找）
hash            # 列出被跟踪的别名
hash <cmd>      # 使 <cmd> 转换为一个被跟踪的别名
hash -r         # 复位所有被跟踪的别名。执行一条 UNIX 命令时，如果已设置
                  “hashall”选项并将命令作为一个简单名称（不带斜杠）给出，
                  则会将该名称作为所执行程序对应的路径名的被跟踪别名输入。
#
:jobs（ksh 命令）
%jobs - 列出所有现行任务
jobs            # 列出所有活动作业。这个列表包含了作业编号、当前作业
                  （“+”）和上一项作业（“-”）的指示器、进程 ID、
                  状态指示器（“Stopped”、“Running”、“Done”、
                  “Signal<n>”）以及命令的开始几个字符。参见“help fg”
                  和“help bg”以获得更多信息。
#
:kalias（ksh 命令）
%kalias - 定义一个 ksh 类型的别名
kalias                  #（ksh 别名）列出当前已定义的所有别名
kalias <name>           # 列出别名 <name> 的定义（如果存在此类定义）
kalias <name>=<def>...  # 将 <name> 定义为 <def> 的一个别名。如果 <def> 
                          包含空白，则必须加上引号。标准 ksh 别名语义的
                          一个区别是，“kalias”（并不只是“dalias”）
                          接受在别名中普遍使用的 csh 历史替代元语法。例如：
                                  dalias goto "stop at !:1; cont; clear"
                          请注意，与“kalias”不同的是“!”不需要加反斜杠。

另请参见“help alias”和“help dalias”。

#
:kprint（ksh 命令）
%kprint - (Korn print) 回显参数
kprint <arg>...         # (ksh print) 回显参数
kprint -n <arg>...      # 回显参数，不进行换行
kprint -e <arg>...      # 回显参数，展开反斜杠转义符（缺省设置）
kprint -r <arg>...      # 回显参数，不展开反斜杠转义符
                          （参见“help ksh backslash”）
kprint -u <n> <arg>...  # 将参数回显为文件描述符 <n>
kprint - <arg>...       # 回显参数。这保证了即使 <arg> 以一个“-”开头，
                          也不会被视为选项。内建别名“echo”等同于“kprint”。
#
:let（ksh 命令）
%let - 对 ksh 算术表达式求值
let <arg>...            # 对一个或多个算术表达式求值。如果上一个表达式
                          求值结果是非零，则返回代码为 0（真）；否则即
                          返回 1（假）
                          “let <arg>...”等同于“((<arg>...))”。
                          参见“help ksh expressions”以获得更多信息。
#
:read（ksh 命令）
%read - 从文件或标准输入中读取一行
read <name>             # 接受来自 stdin 的一行，将它赋值给 ksh 变量 <name>
read <n1> <n2>...       # 接受来自 stdin 的一行，将第一个字赋值为 <n1>，
                          第二个字赋值为 <n2>，等等。如果输入中的字数多
                          于名称，最后一个名称将接受行中剩余的所有字。
read <name>?<prompt>    # 在 stderr 上输出 <prompt>，然后接受来自 stdin 的
                          一行并将其赋值给 <name>。
read -e ...             # 将一行末尾处的反斜杠视为一行的延续字符（缺省）
read -r ...             # 对反斜杠不进行特殊处理
read -u <n> ...         # 从文件描述符 <n> 而不是从 stdin 中读取       
#
:readonly（ksh 命令）
%readonly - 将环境变量标记为不可更改
readonly                   # 用“-r”属性列出所有 ksh 变量。
readonly <name>...         # 设置给定变量的“-r”属性
readonly <name>=<val>...   # 为给定变量赋给一个新值并设置其“-r”属性。
                             参见“help typeset”以获得更多信息。
#
:return（ksh 命令）
%return - 从一个 ksh 函数返回
return                  # 使一个 ksh 函数返回上一条已执行命令的退出码
return <n>              # 使一个 ksh 函数返回退出码 <n>
#
:set（ksh 命令）
%set - 设置 ksh 选项或位置参数
set                     # 列出所有的 ksh 变量及其值
set <arg>...            # 将位置参数设置为 <arg>...
set -- <arg>...         # 设置位置参数，即使 <arg> 以一个短线开始
set -o <opt>            # 设置 <opt> 选项
set +o <opt>            # 清除 <opt> 选项
set -o                  # 列出当前已设置的所有选项
set +o                  # 列出当前已设置的所有选项
set -<opt>              # 设置带缩写 <opt> 的选项
set +<opt>              # 清除带缩写 <opt> 的选项。
                          参见“help ksh options”以获得更多信息
#
:sh（ksh 命令）
%sh - 从 $PATH 显式执行一个命令
sh <cmd> [<arg>...]     # 执行 <cmd>，禁止对别名、函数和内建函数进行
                          一般搜索。
#
:shift（ksh 命令）
%shift - 移位位置参数
shift                   # 将位置参数左移一个位置，去掉 $1
shift <n>               # 将位置参数左移 <n> 个位置，去掉前 <n> 个参数
#
:test（ksh 命令）
%test - 检查各种文件属性，比较字符串，等等。
test <expr>
     # 将 <expr> 求值为真时返回真 (0)，否则即返回假 (1)。
       以下运算符被识别为：
                          
            -r <file>       <file> 可读
            -w <file>       <file> 可写
            -x <file>       <file> 可执行
                            （可搜索，如果 <file> 是一个目录）
            -f <file>       <file> 是一个常规文件
            -d <file>       <file> 是一个目录
            -c <file>       <file> 是一个特殊字符 file
            -b <file>       <file> 是一个特殊块文件
            -p <file>       <file> 是一个已命名管道 (FIFO)
            -u <file>       <file> 有自己的 set-uid-bit 设置
            -g <file>       <file> 有自己的 set-gid-bit 设置
            -k <file>       <file> 有自己的 sticky bit 设置
            -s <file>       <file> 大于 0 字节
            -O <file>       <file> 属于该用户
            -G <file>       <file> 和该用户拥有相同的分组 ID
            -L <file>       <file> 是一个符号链接
            -S <file>       <file> 是一个特殊套接字文件
            -t <fd>         <fd> 是一个与 tty 关联的打开文件
                            描述符
            -z <string>     <string> 长度为 0
            -n <string>     <string> 长度为非 0
            -o <opt>        <opt> 选项已设置
            !               否定以下表达式
            -o              二进制“or”
            -a              二进制“and”
            (<expr>)        分组（必须被引用）

     注意：“-o”运算符只有在跟随它的字是“set”命令接受的选项之一时，
     才会被视为表示“选项”。参见“help ksh options”
#
:times（ksh 命令）
%times - 输出 dbx 和子进程的累计用户和系统时间
times           # 输出 dbx 及其所有子进程的累计用户和系统时间
#
:trap（ksh 命令）
%trap - 将 ksh 命令与信号或进程退出相关联
trap                      # 显示当前设置的陷阱以及操作
trap <action> <cond>...   # 无论发生何种 <cond>，都使 dbx 执行 <action>。
                            <action> 的可能值包括：

                              null      忽视条件
                              -         将处理重置为缺省值
                              omitted   与“-”相同
                              <cmd>     条件触发时执行命令
$<newline>        
                            <cond> 的有效值包括：

                              0         在 dbx 退出时发生
                              <n>       一个信号数
                              <name>    一个信号名；“kill -l”列出了
                                        有效名称
                              EXIT      与 0 相同
#
:true（ksh 命令）
%true - 不执行任何操作并返回 0
true                    # 不执行任何操作并返回 0
#
:typeset（ksh 命令）
%typeset - 设置环境变量的属性
typeset                 # 显示所有 ksh 变量的名称和属性
typeset -f              # 显示所有 ksh 函数的名称
typeset -x              # 与“export”相同（参见“help export”）
typeset -r              # 与“readonly”相同（参见“help readonly”）
typeset -i              # 显示所有带“-i”（整数）属性的 ksh 变量的名称和值
typeset -t              # 显示所有带“-t”（跟踪的）属性的 ksh 变量的名称和值
typeset -q              # 显示所有带“-q”（引用）属性的 ksh 函数的
                          名称
typeset -[xritq] <name> # 设置已命名变量或函数的属性
typeset +[xritq] <name> # 清除属性
typeset -i<n> <var>     # 为变量 <var> 设置整数属性和输出基类。
                          <n> 必须在 2 到 36 之间，包含 2 和 36。
#
:ulimit（ksh 命令）
%ulimit - 列出或更改不同的资源限制
ulimit                  # 显示当前文件大小限制（与“-f”相同）
ulimit -[cdmstf]        # 显示以下参数的当前硬限制：
                        #       -c      块内的核心文件大小
                        #       -d      数据段的大小（千字节）
                        #       -m      映射内存的最大值（千字节）
                        #       -s      堆栈段的大小（千字节）
                        #       -t      时间限制（秒）
                        #       -f      写文件的大小（块）
ulimit -[CDMSTF]        # 显示以上每一项的当前软限制
ulimit -[cdmstf] <n>    # 设置硬限制（只有超级用户才能设置硬限制）
ulimit -[CDMSTF] <n>    # 设置软限制（不能大于当前硬限制）
#
:umask（ksh 命令）
%umask - 限制新文件的读/写/执行权限
umask           # 以三位数的八进制数字显示当前 umask
umask <n>       # 将 umask 设置为给定值（解释为一个八进制数字）
                  umask 指定了在任何由此进程创建的文件许可内，
                  将哪些位设置为 0。典型的值有 022（分组或全体均不可写）
                  和 027（分组不可写，全体不能访问）
#
:unalias（dbx/ksh 命令)
%unalias - 删除别名定义
unalias <name>...       # 删除给定名称的别名定义
                          （如果存在此类定义）。
#
:unset（ksh 命令）
%unset - 删除环境变量的定义
unset <var>...          # 删除给定 ksh 变量的定义
                          （如果存在此类定义）。
unset -f <func>...      # 删除给定 ksh 函数的定义
                          （如果存在此类定义）。
#
:vitem（命令）
%vitem - 数据可视化接口
   vitem 命令是数据可视化 GUI 的接口。
   
vitem -new <array-expr>          # 创建新的可视化项
vitem <id> -replace <array-expr> # 替代一个已经存在的项
vitem <id>|all ... -update ontimer|onstop|ondemand 
                                 # 为给定项设置更新模式
vitem <id>|all ... -update now   # 刷新所有“ondemand”项
vitem <id>|all ... -enable       # 如给定项则允许刷新
vitem <id>|all ... -disable      # 如给定项则禁止刷新
vitem <id>|all -list             # 列出所有已知项
vitem <id>|all -list -s          # 列出所有已知项，并且可以使用
                                 # “source”cmd 对其重新读取。
vitem <id>|all -delete           # 删除给定项
vitem -timer <seconds>           # 设置区间计时器。
                                 # dbxs 单精度区间记时器同样共享用于
                                 # “timer”、“event specification”和
                                 # collector 命令。使用其中一项功能
                                 # 将会排斥其它功能。
#
:wait（ksh 命令）
%wait - 等待后台作业终止
wait            # 等待当前后台作业终止
wait <job>      # 等待指定后台作业终止。
                  参见“help fg”以了解 <job> 的有效语法。
                  此“%”是可选的。
#
:whence（ksh 命令）
%whence - 显示名称的含义（别名、函数、内建函数、命令）
whence <name>...        # 显示给定名称的含义。如果名称是一个关键字
                          或 ksh 函数，则仅显示名称。如果名称是一个
                          内建命令，则显示“builtin”和命令名。如果
                          名称是一个别名，则显示该别名的定义。
                          如果名称是一个被跟踪的别名或 UNIX 命令，
                          则显示该命令的完整路径。
whence -v <name>...     # 详细显示。如果是函数，则包含其定义。
########################################################################
######################## ksh keywords  #################################
########################################################################
%case - 多路分支：case <string> in <cases> esac
%do - 命令成组：while <test> do <cmds> done
%done - 命令成组：while <test> do <cmds> done
%elif - 条件执行：if then elif else fi
%else - 条件执行：if then elif else fi
%esac - 多路分支：case <string> in <cases> esac
%fi - 条件执行：if then elif else fi
%for - 对列表的循环：for <var> in <list> do <cmds> done
%function - 定义一个 ksh 函数：function <name> { <cmds> }
%if - 条件执行：if then elif else fi
%in - for ... in ... do ... done  or  case ... in ... esac
%select - 选择循环：select <var> in <list> do <cmds> done
%then - 条件执行：if then elif else fi
%time - 报告用户和系统时间：time <cmd>
%until - 循环直至条件为真：until <test> do <cmds> done
%while - 循环直至条件为真：while <test> do <cmds> done
%{ - 命令成组：{ <cmd>; <cmd>; }
%} - 命令成组：{ <cmd>; <cmd>; }
########################################################################
######################## Miscellaneous #################################
########################################################################
:dbxdir（dbx 变量）
这个预定的只读变量具有包含 dbx 可执行文件的目录的完全路径名。
#
:havegui（dbx 变量）
如果 dbx 在 GUI 下运行，“$havegui”的值为“true”；
否则为“false”。
#
:mtfeatures（dbx 变量）
如果线程或 LWP 命令已启用（并且目标进程使用 MT），
则“$mtfeatures”的值为“true”；否则为“false”。
即使线程命令不可用，LWP 命令仍然可用，在此情况下
“mtfeatures”的值仍为“true”。
#
:version（dbx 变量）
这个预定的只读变量包含了当前 dbx 版本字符串。
另请参见 -V 选项下的“help invocation”。
#
:last_choice（dbx 变量）
这个变量记录了在重载解析菜单中的上一次选择。
它主要被用于脚本中：

        function myprint {
                # 输出两次，一次以八进制，一次以十六进制
                # 如果存在，则再次使用相同的重载选择
                DBX_output_base=8 builtin print $*
                DBX_output_base=16 builtin print $* <<-EOF
                $last_choice
                EOF
        }
#
# Obsolete commands/syntax go here...
#
:/
“/”命令已废弃；请参见“help changes301”。
#
:?
“?”命令已废弃；请参见“help changes301”。
#
:=
“=”命令已废弃；请参见“help changes301”。
#
#########################################################
##################  RTC help topics #####################
#########################################################
:rtc（主题）

关于运行时检查 (RTC) 的帮助已编入各个副标题和命令中。
下面是与 RTC 有关的各个帮助主题。
运行时检查仅在 Solaris 上可用。

关于主题部分的帮助：

    introduction    # RTC 的简要介绍
    commands        # RTC 相关命令的简要描述
    dbxenvs         # 与 RTC 相关的 dbx 环境变量的描述
    api             # 一个支持用户定义堆分配器的接口
    limitations     # RTC 限制的讨论和解决方法
                    # 在某些程序中遇到
    attach          # 关于对附加程序使用 RTC 的提示
    batch           # 关于 RTC 批处理模式的注释
    mt              # 关于对多进程应用程序使用 RTC 的提示
    errors          # RTC 所用错误操作码的简要描述
    showmap         # 显示按地址排序的工具类型图表

关于 RTC 命令的帮助：
 
    check           # 允许检查内存访问、泄露或使用
    uncheck         # 禁止检查内存访问、泄露或使用
    suppress        # 禁止报告内存错误
    showleaks       # 报告上一次执行“showleaks”命令以来的新内存泄露
    showmemuse      # 显示上一次执行“showmemuse”命令以来使用的内存
    showblock       # 禁止检查内存访问、泄露或使用
    rtc -showmap    # 显示按地址排序的工具类型图表

:rtc$$introduction（副标题）
运行时检查 (RTC)是一种 dbx 功能，包含两个部分：内存访问检查和内存
使用/泄露检查。内存访问检查仅对 SPARC 有效。

访问检查将检查被调试应用程序对内存的不正确使用。RTC 将监控内存访问
（加载、存储和清空操作）并检查内存泄露（未清空且未被指针引用
的 malloc() [heap] 空间分配）。

访问检查使您能发现对超出范围的内存的加载或存储（这些操作可能会产生
不可预见的总线错误或段违例）；使用已释放的范围内内存执行的加载和存储
（通过 free() 调用用于堆内存，或者通过函数返回用于堆栈内存）；通过未
初始化的范围内内存执行的加载；以及不正确的 free() 调用，例如重复 
free() 或对 non-malloc() 空间的 free()。

内存使用/泄露检查包括对所有显著堆空间的跟踪，然后在需要时或程序终止
时扫描可用数据空间并识别未引用的空间。

Fortran 用户应当考虑使用 -stackvar 选项来获得 RTC 的所有优势。
参见 Fortran 手册，了解如何使用 -stackvar。

参见“help rtc”以进入与 RTC 相关的其它帮助主题。

#
#
:rtc$$commands（副标题）

与 RTC 相关的 dbx 命令分为三类：

1. 打开/关闭 RTC。
  
   此操作由“check”和“uncheck”命令控制。“check”可用于打开内存访问
   检查（仅限于 SPARC）、内存泄露和内存使用检查（参见“help check”和
   “help uncheck”）

2. 控制 RTC 所报告错误的范围和数量。

   此操作由“suppress”和“unsuppress”命令控制。这些命令使您可以更有力地
   控制 RTC 会话。参见“help suppress”和“help unsuppress”以获得详细信息。

3. 获得内存泄露和内存使用报告。

   一旦使用“check”命令打开了内存使用（或泄露）检查，就可以使用
   “showleaks”命令来获取泄露报告，并使用“showmemuse”命令来获取
   内存使用报告。您还可以使用“showblock”命令来获取有关堆块的详细
   分配情况。要显示工具指示图表，请使用“rtc -showmap”命令。
   参见“help showblock”、“help showleaks”、“help showmemuse”
   和“help rtc showmap”以获得详细信息。

参见“help rtc”以进入与 RTC 相关的其它帮助主题。

#
:rtc$$dbxenvs（副标题）

通过使用 dbx 环境变量，可以控制特定的 RTC 行为（参见“help dbxenv”）。
与 RTC 有关的 dbxenvs 如下所列：

dbxenv rtc_auto_continue <on | off>
        将 RTC 错误记录到 rtc_error_log_file_name
        并继续。缺省值：off

dbxenv rtc_auto_suppress <on | off>
        如果为“on”，则给定位置的 RTC 错误只会
        被报告一次。缺省值：on
        详细信息，请参见“suppress”命令。

dbxenv rtc_biu_at_exit <on | off | verbose>
        在打开内存使用检查时使用（通过“check -memuse”或通过
        “check -all”）。如果该变量的值为“on”，则会在程序
        退出时生成一个非冗余内存使用（使用中的块）报告。如果
        该值为“verbose”，则会在程序退出时生成一个冗余内存使
        用报告。值“off”将不产生输出。该变量对交互式
        “showmemuse”命令无效。缺省值：on

另请参见“help check”和“help showmemuse”。

dbxenv rtc_error_limit <num>
        将报告的 RTC 错误数量。
        缺省值：1000

dbxenv rtc_error_log_file_name <filename>
        如果已设置“rtc_auto_continue”，则会记录出现 RTC 错误的文件名。
        缺省值：/tmp/dbx.errlog.<uniqueID>

dbxenv rtc_mel_at_exit <on | off | verbose>
        该变量在打开泄露检查时使用。如果将该变量的值设置为“on”，
        则会在程序退出时生成一个非冗余内存泄露报告。如果该值为
        “verbose”，则会在程序退出时生成一个冗余内存泄露报告。
        值“off”将不产生输出。该变量对交互式“showleaks”命令
        无效。缺省值：on

参见“help rtc”以进入与 RTC 相关的其它帮助主题。

#
:rtc$$api（副标题）

    用于跟踪应用程序特定内存分配器的 RTC 函数。

泄露检查和访问检查都要求使用共享库 libc.so 内的标准堆管理例程。
这样可以便于 RTC 保持对程序中所有分配/释放的跟踪。很多应用程序
都将自己的内存管理例程写在 malloc-free 的顶端，或者完全重写这些
例程。如果您使用自己的分配器（RTC 称为“专用分配器”），RTC 将
不能自动跟踪它们，这样您就不会得到由于不正确使用而产生的泄露和
内存访问错误。

但是，RTC 提供了一个 API 以便使用“专用分配器”。此 API 允许专用分配器
获得与标准堆分配器相同的处理。这个 API 本身由头文件“rtc_api.h”提供，
并且被作为产品的一部分发布。手册页 rtc_api(3x) 详细说明了
RTC API 入口点。

专用分配器不使用程序堆时，可能会存在一些细小差别并报告 RTC 错误。
如果出现与标准堆块相关的内存访问错误，RTC 错误报告一般会包含堆块
分配的位置。在这种情况下不会报告。

参见“help rtc”以进入与 RTC 相关的其它帮助主题。

:rtc$$limitations（副标题）

访问检查需要加载对象内的一些符号信息。如果某个加载对象已完全剥离，RTC 可能
不会捕获所有错误。读取未初始化内存错误可能并不正确，因此将被禁止。您可以使
用“unsuppress rui”命令将其覆盖。要保留加载对象中的符号表，请在使用
“strip”时使用“-x”选项。

以下各项仅适用于 SPARC。

以下描述的 8M 问题在基于 UltraSaprc 的硬件上应该不会再发生，因为其中的 dbx 
具有调用陷阱句柄而不是使用分支的新功能。将控制权移交给陷阱句柄控制的过程非
常缓慢（最多需要 10 倍时间），但是不受 8M 限制的影响。只要硬件是 UltraSparc，
就会自动使用陷阱（如果需要）。通过使用系统命令“isalist”并检查结果是否含有
“sparcv8plus”，可以对此功能进行检查。“rtc -showmap”命令显示按地址排序的
工具类型图表。

为执行访问检查，dbx/RTC 会用分支到一个补丁区域的分支指令来替换每一个加载和
存储指令。该分支指令寻址范围为 8Mb。这意味着如果被调试程序用完了替换特定加
载/存储指令的所有 8Mb 地址空间，将没有空间来存放补丁区域。如果 RTC 不能截取
对内存的所有加载和存储指令，则无法提供准确的信息，从而会完全禁用访问检查。
泄露检查则不受其影响。

Dbx 在运行到此限制时内部应用一些策略，并在可以纠正此问题时继续。
在某些情况下，dbx 无法继续；如果出现此类情况，它会在输出错误消
息后关闭访问检查。

遇到此 8Mb 限制时应该怎么办：

1. 使用 32 位/sparcv8 来替代 64 位/sparcv9

    如果使用 -xarch=v9 编译的应用程序遇到 8M 问题，则可以尝试对该应用
    程序的 32 位版本进行内存检查。因为 64 位地址需要更长的补丁指令序列，
    因此使用 32 位地址可以减轻 8M 问题。如果这种解决方法不是很好，则可
    以在 32 位和 64 位程序上使用以下方法。

2. 尝试添加补丁区域目标文件。

    “rtc_patch_area”shell 脚本可用于创建特殊的 .o 文件，该文件可以
    连接到一个大型可执行程序或共享库的中间，以便提供更多补丁空间。
    该脚本的手册页是 rtc_patch_area(1)。

    如果 dbx 达到 8M 的限制，它会告诉您哪一个载入对象太大（主程序还是
    共享库），并且会输出该载入对象需要的完整补丁空间。

    为得到最优结果，特殊的补丁目标文件应当在可执行文件或共享库之间均匀
    地分配，并且应该使用缺省大小（8Mb）或更小。同样的，添加的补丁空间
    不要超过 dbx 所要求的10-20%。例如：如果 dbx 声称 a.out 需要 31Mb，
    则添加 4 个使用 rtc_patch_area 脚本创建的目标文件，每一个大小为 8Mb，
    并在可执行文件中大致均匀地分配它们。

    如果 dbx 在可执行文件中找到了显式补丁区域，则会打印补丁区域所跨的地址
    范围，这会有助于在连接行上正确地放置它们。
    

3. 尝试将较大的加载对象分解为较小的加载对象。

    将可执行文件或大型库中的目标文件分解成较小的目标文件分组。然后将它们
    连接成较小的部分。如果大文件是可执行文件，则将其分解成较小的可执行文
    件和一系列共享库。如果大文件是共享库，则将它分解成一系列较小的库。

    这样就允许 dbx 在不同共享对象之间为补丁代码寻找空间。

4. 尝试添加一个‘填充’的 .so 文件。

    此情况应仅在您绑定某一已启动进程时采用。

    执行时连接器可能会将各库紧密联系在一起，以便库与库的间隙中不会生成补丁
    空间。当 dbx 在 RTC 启用后运行可执行文件时，它会要求执行环境连接器在共
    享库间设置一个额外的间隙，但在启动 RTC 的情况下绑定并非由 dbx 启动的进程
    时，这些库可能彼此过于紧密。

    如果出现此情况，（且无法使用 dbx 启动程序），则您可以尝试使用 
    rtc_patch_area 脚本创建一个共享库，然后将它链接至其它共享库间的程序。
    您可以参见手册页：rtc_patch_area(1)，以了解更多详细信息。
    
想了解更多关于 RTC 的帮助主题，请参见“help rtc”。

#
:rtc$$attach（副标题）

RTC 支持跟随子进程以及 exec()（参见“help follow-fork”）。
除非已分配受影响的内存而无法检测到 RUI，否则 RTC 还可在绑定的进程上运行。
而且，进程启动时必须加载 rtcaudit.so。如果你正在绑定的进程是 64 位 sparcv9 
进程，则请使用 sparcv9 rtcaudit.so。如果产品安装在 /opt 中，则为：
      对于 sparcv9：  /opt/SUNWspro/lib/v9/rtcaudit.so
      对于其他：      /opt/SUNWspro/lib/rtcaudit.so
要预加载 rtcaudit.so：
      setenv LD_AUDIT <...path-to-librtc...>/rtcaudit.so（csh 语法）
注意：最好仅在需要时设置预加载 rtcaudit.so（绑定情况下）并切勿始终保持打开状态。
      例如，setenv LD_AUDIT ... ；启动您的应用程序；unsetenv LD_AUDIT

如果您要绑定的程序从某些其它程序派生/进行执行，
则您需将 LD_AUDIT（将会派生）设置为主程序。
LD_AUDIT 设置通过 fork 或 exec 被继承。如果用 32 位程序
派生/执行 64 位程序，则可能无法进行，反之亦然。

如果您具有 Solaris 的最新版本（Solaris 8 7/01 或更新版本），或者
您具有旧版本 Solaris 8 连接器修补程序，那么您应该使用 LD_AUDIT_32 
和 LD_AUDIT_64 它们仅分别影响 32 位和 64 位程序。 关于这些变量的
详细信息和使用方法，请查看连接器和库指南
要查看您的 Solaris 版本是否支持 LD_AUDIT_32，请使用“man ld.so.1”
命令并搜索“_64”输出。

想了解更多关于 RTC 的帮助主题，请参见“help rtc”。

#
:rtc$$batch（副标题）

运行时检查（RTC）的批接口实现在 dbx 交互模式以外使用 RTC。这可简化在 shell 
脚本中使用 RTC 的过程。为实现简化操作，还需一个名为“bcheck”的实用程序。
“bcheck”仅是一个 shell 脚本，此脚本会在启用“运行时检查”的同时运行 dbx 
下的程序。请参见 bcheck(1) 手册页，以了解更多详细信息。

想了解更多关于 RTC 的帮助主题，请参见“help rtc”。

#
:rtc$$mt（副标题）
运行时检查 (RTC) 支持多线程应用程序。

每次报告访问检查错误时（仅限于 SPARC），RTC 均会输出该错误发生时所在的
线程的 ID。RTC 生成的泄露报告包括程序中所有线程的泄露。

想了解更多关于 RTC 的帮助主题，请参见“help rtc”。

#
:rtc$$errors（副标题）

RTC 报告的错误一般分两类。访问错误和泄露。

运行访问检查时，RTC 可检测并报告以下类型的错误：
        baf     # 错误释放
        duf     # 重复释放
        maf     # 未对齐释放
        mar     # 未对齐读
        maw     # 未对齐写
        oom     # 内存不足
        rua     # 从未分配内存中读
        rui     # 从未初始化内存中读
        wro     # 向只读内存中写
        wua     # 向未分配内存中写

检查泄露时，RTC 会报告以下类型的错误：
        aib     # 可能的内存泄漏 － 只当指针指向块中央时发生
        air     # 可能的内存泄漏 － 指针指向的只存在于寄存器的块
        mel     # 内存泄漏 － 没有指针指向块

内存使用报告使用操作码 biu（块使用）。

想了解更多关于 RTC 的帮助主题，请参见“rtc help”。
:rtc$$showmap（副标题）
%showmap - 显示分支和捕获的地址范围 (RTC)

    此命令供专业用户使用，用于内部调试 dbx。适用于访问检查的 RTC 
    指令程序文本。视可用资源而定，该指令类型可以分支或捕获指令。
    “rtc -showmap”可报告按指令类型分类的程序文本的地址范围。
    该映射可被用于查找添加补丁空间目标文件的优化位置，并避免使用
    自动捕捉。请参见“help rtc 8M”，以了解更多详细信息。

#
:FAQ（标题）
                关于 dbx 的常见问题
                ====================================

A. 一般问题：
 A.1  Gdb 可进行 <something>，我如何在 dbx 中执行此操作？
 A.2  Dbx 无法再读我的 .dbxinit 文件！原因是什么？
 A.3  我如何启用命令行编辑功能？
 A.4  为什么“alias”不起作用？
 A.5  为什么 dbx 不断报告“foo is not defined in the current scope”？
         什么是 scope？
 A.6  为什么“set”不起作用？
 A.7  Dbx 无法找到我的源文件！
 A.8  我的程序在 dbx 下运行方式不同。
 A.9  我设置了一个断点，但无法实现。
 A.10 为何“whatis”输出中的 C++ 成员有时会丢失？
 A.11 为何运行时检查会有 8Mb 限制？
 A.12 如何使用 dbx 定位浮点异常？
 A.13 dbx 在何处创建所需的临时文件？
 A.14 如何运行含有很长参数列表的命令？

B. MT相关问题：
 B.1  何处获得 MT dbx？
 B.2  dbx 的主要 MT 功能是什么？
 B.3  您是否可以为指定线程限制范围？
 B.4  GUI 的主要 MT 功能是什么？
 B.5  如何实现线程编号？
 B.6  如何实现 LWP 编号？
 B.7  可在指定线程上设置断点吗？
 B.8  线程遇到断点时出现哪些情况？所有线程停止，
         还是遇到断点的线程停止？
 B.9  dbx 如何知道某应用程序是否是多线程？
 B.10 我应监视什么缺陷？
 B.11 我是否可以“强制”运行休眠线程？
 B.12 如何通知某一特定线程正在等待的其它线程？
         （例如，通过 thr_join）。
         从进程/线程检查器的线程列表启动时，我如何分辨来自
         不同 thr_create() 调用的线程 ID？
 B.13 从进程/线程检查器的线程列表启动时，
         我如何确定来自特定启动函数的线程 ID？
 B.14 绑定某一当前多线程进程时，哪些线程可激活？
 B.15 激活线程执行 thr_create 时，哪些线程可激活？
         （例如，执行过 thr_create() 的线程或通过 thr_create 创建
         的线程？）（换句话说，是否有与“follow_fork_mode”类似
         的“follow_thread_mode”？）
 B.16 激活线程执行 thr_exit 后，哪些线程（如果有）可激活？

--------------------------------------------------------------------------------

(A.1) Gdb 可进行 <something>，我如何在 dbx 中执行此操作？

下列表格列表大概相当于某些常见 gdb 命令的 dbx 命令：

GDB                     DBX                       获得更多信息
===                     ===                       ============

break <line>            stop at <line>            “help stop”
break <func>            stop in <func>            “help stop”
break *<addr>           stopi at <addr>           “help stopi”
break ... if <expr>     stop ... -if <expr>       “help event specification”
cond <n>                stop ... -if <expr>       “help event specification”
tbreak                  stop ... -temp            “help event specification”
watch <expr>            stop <expr>  [slow]       “help event specification”
watch <var>             stop modify &<var> [fast] “help event watchpoint”
catch <x>               intercept <x>             “help intercept”
info break              status                    “help status”
info watch              status                    “help status”
clear                   clear                     “help clear”
clear <fun>             delete <n>                “help delete”
delete                  delete all                “help delete”
disable                 handler -disable all      “help handler”
disable <n>             handler -disable <n>      “help handler”
enable                  handler -enable all       “help handler”
enable <n>              handler -enable <n>       “help handler”
ignore <n> <cnt>        handler -count <n> <cnt>  “help handler”
commands <n>            when ... { <cmds>; }      “help when”

backtrace <n>           where <n>                 “help where”
frame <n>               frame <n>                 “help frame”
info reg <reg>          print $<reg>              “help registers”

finish                  step up                   “help step”
signal <num>            cont sig <num>            “help cont”
jump <line>             cont at <line>            “help cont”
set <var>=<expr>        assign <var>=<expr>       “help assign”

x/<fmt> <addr>          x <addr>/<fmt>            “help examine”
disassem <addr>         dis <addr>                “help dis”

shell <cmd>             sh <cmd> [if needed]      “help sh”

info func <regex>       funcs <regexp>            “help funcs”
ptype <type>            whatis -t <type>          “help whatis”

define <cmd>            function <cmd>            “help ksh syntax”

handle <sig>            stop sig <sig>            “help event specification”
info signals            status; catch             “help status”、“help catch”

attach <pid>            debug - <pid>             “help debug”
attach <pid>            debug <a.out> <pid>       “help debug”
file <file>             [unnecessary]
exec <file>             debug <file>              “help debug”
core <file>             debug <a.out> <file>      “help debug”

set editing on          set -o emacs              “help editing”
set language <x>        language <x>              “help language”
set prompt <x>          PS1=<x>                   “help ksh PS1”
set history size <x>    HISTSIZE=<x>              “help ksh HISTSIZE”

set print object on     dbxenv output_dynamic_type on“help c++ dynamic”

show commands           history                   “help history”
dir <name>              pathmap <name>            “help pathmap”
show dir                pathmap                   “help pathmap”
info line <n>           listi <n>                 “help listi”
info source             file                      “help file”
info sources            files; modules            “help files”、“help modules”
forw <regex>            search <regex>            “help search”
rev <regex>             bsearch <regex>           “help bsearch”

--------------------------------------------------------------------------------

(A.2) Dbx 不再读我的 .dbxinit 文件！  原因是什么？

Dbx 不再支持旧的 .dbxinit 文件的兼容模式。
请参见“help .dbxinit”，以了解更多详细信息。

--------------------------------------------------------------------------------

(A.3) 如何启用命令行编辑功能？

您可以按多种方法启用命令行编辑功能。第一种，如果已设置 $FCEDIT、\$EDITOR 
或 $VISUAL，其值已选中。如果最后组件（即最后斜线后的组件）包含字符串
“emacs”，则会启用 emacs 模式。如果包含“vi”，则会启用 vi 模式。如果上述
三个环境变量均未设置，或列表中已设置的第一个不包含“emacs”或“vi”，则会
启用 emacs 模式。

您可以通过命令行（或在您的 .dbxrc 文件中）键入命令来启用 emacs 模式

        set -o emacs

Vi 模式类似于：

        set -o vi

要禁用命令行编辑功能，请输入

        set +o emacs +o vi

命令行。

--------------------------------------------------------------------------------

(A.4) 为何“alias”不起作用？

“alias”当前是“dalias”或“kalias”的预定义别名。请参见“help alias”、
“help dalias”、“help kalias”和“help startup”。

--------------------------------------------------------------------------------

(A.5) 为什么 dbx 不断报告“foo is not defined in the current scope”? 
    什么是 scope？

该消息表明当前执行点处没有可访问的名为“foo”的符号。请参见“help scope”，
以了解详细信息。

--------------------------------------------------------------------------------

(A.6) 为什么“set”不起作用？

“set”当前是 KornShell 的“set”命令；不再是“assign”的别名。
请参见“help assign”和“help set”。

--------------------------------------------------------------------------------

(A.7) Dbx 无法找到我的源文件！

编译源文件后，如果源文件不在原位置，或者您在另一台正在调试的机器上进行编译，
且编译目录未固定在同一路径名，则 dbx 会很难找到源文件。有关解决方案，
请参见“help pathmap”。

--------------------------------------------------------------------------------

(A.8) 我的程序在 dbx 下运行方式不同。

Dbx 可按以下方式明显影响程序的运行方式：

        第一个可用文件描述符在执行时可能不为 3，这是个错误，我们会尝试解决
        所有漏洞。所以如果您依靠已存在的文件描述符或将其用于索引表格等，
        则情况可能会有所改变。
        
        您可能忘记启用 -C 或打开了 RTC。

        您的 dbx 初始化脚本中可能具有您已忘记的曾设置过的环境变量。
        在 dbx 下运行时，堆栈基从不同地址启动。视 argv[] 环境和内容的不同，
        它可能也会有所不同。这会导致局部变量的分配稍有不同，且如果未对这些
        变量进行初始化，它们将获得不同的随机数。此问题可通过运行时检查
        检测到。参见“help check”。

        程序使用前未初始化 malloc() 的内存。此情况与前面类似。建议同前。

        程序通过一个坏指针引用了未初始化的内存。与前两种情况相同。
        建议同前。

        Dbx 必须捕获 LWP creation 和 dlopen 事件。这可能会严重影响计时。
        Dbx 同样会将上下文切换成信号，所以如果您常使用对计时敏感的信号，
        情况可能会有所不同。

        程序希望 mmap() 总是返回映射段同基地址。在 dbx 下运行会严重影响
        地址空间，使 mmap() 不可能返回到未使用 dbx 运行程序时的相同地址。
        要判断程序是否有问题，请查找所有 mmap() 的使用情况，并确保返回的
        地址确为程序使用的地址，而非硬编码地址。

        如果程序是多线程的，则可能包含数据争用或是基于线程计划产生的。
        在 dbx 下运行会在一定程度扰乱线程计划，并可能会导致程序以其它
        异常顺序执行线程。要检测到此类情况，请尝试使用“lock_lint”。

        查看在“GUI”（即使用“dbx”）以外运行时，或使用“adb”或“truss”
        是否会导致相同的问题。

将 Dbx 绑定至某一运行进程时，它应会稍有扰乱；
请尝试上述方法。参见“help debug”。

--------------------------------------------------------------------------------

(A.9) 我设置了一个断点，但无法实现。

请考虑下列可能因素：
        
        如果您在函数中设置了 bpt，则它可能会成为不是您所需要函数。
        使用“whereis <funcname>”以找出指定名称的函数数量。然后完全
        使用“stop”命令中“whereis”输出所示的语法。

        请参见（10）答案。

        如果断点是在 while 循环上，则您可能会在编译器转换表单代码时
        遇到填充问题：

                while (<cond> )
                        <stmt>

        to

                if (<cond>) {
                again:
                    <stmt>
                    if <cond>
                        goto again;
                }

        此情况下，在“while”上设置 bpt 相当于仅在外部“if”上设置 bpt。
        这是因为 dbx 不能处理映射到两个（或更多）不同地址的源行。

--------------------------------------------------------------------------------

(A.10) 为何输出“whatis”时有时会丢失 C++ 成员类型？

在下列 whatis 命令中，成员“stackcount”的类型会丢失：

        (dbx) whatis stack
        class stack {
        ...
            static stackcount; /*从未定义或分配*/
        ...
        };

未定义或分配类成员时，dbx 无法确定其类型。无可输出的类型。

--------------------------------------------------------------------------------

(A.11) 为何运行时检查会有 8Mb 限制？

只有访问检查有此限制。泄露检查不受影响。
 
要访问检查 dbx/RTC，请用分支到补丁空间的分支指令替换每个载入和存储指令。
此分支指令具有 8Mb 的范围。这意味着如果调试程序用完了 8Mb 的地址空间，
该地址空间内存在着被替代的特殊的 load 和 store指令，将会没有空间来存放补
丁区域。如果 RTC 不能拦截所有的对内存的 load 和 store 指令，它将无法提供
准确的信息，所以完全禁用访问检查。
 
当 Dbx 运行到这限制时它内部地提供了一些策略并在它能纠正这个问题时继续运行。
某些情况下 dbx 不能进行处理；出现此情况时，它会在输出错误信息后关闭访问检
查（有关可能的工作区，请参见“help rtc 8M”）。

--------------------------------------------------------------------------------
(A.12) 如何使用 dbx 定位浮点和整数异常？

您需要执行两步操作：

在 dbx 中写“catch FPE”。这将会在出现 FP 异常时随时终止进程。请注意，
一些整数异常，比如整数被零除和整数溢出，同样会在 SIGFPE 下出现。

但是，还不仅如此。f77 ieee 软件可将所有错误典型设置为静默（而非发出信号）。
您必须将下列内容添加到您的 FORTRAN 77 应用程序中：

        integer ieeer、ieee_handler、myhandler
        ieeer = ieee_handler（“set”、“all”、myhandler）
        ...
        
        integer function myhandler(sig, code, context)
        integer sig, code(5)
        call abort()
        end

这将导致 _all_ ieee 异常正常生成可能过多的 SIGFPE。

对于 Fortran95，所有错误均为非静默且会产生信号，因此您不需要采取
任何其它措施。

对于 C 或 C++ 程序，您可以执行以下操作：
        #include <ieeefp.h>

        main() 
        {
            fpsetmask(FP_X_INV|FP_X_OFL|FP_X_UFL|FP_X_DZ|FP_X_IMP);
            ...

有关这些函数的详细信息，请查阅相应的手册页。
        
您可以通过抽取 ieee_handler()/fpsetmask() 参数或使用 dbx 捕获命令
的替代命令来进一步处理异常：
        stop sig FPE
（作用相当于“catch FPE”或
        stop sig FPE <subcode>）
可以更好地控制。<subcode> 可以是下列之一：
        FPE_INTDIV      1       # 整数除以 0
        FPE_INTOVF      2       # 整数溢出
        FPE_FLTDIV      3       # 浮点除以 0
        FPE_FLTOVF      4       # 浮点溢出
        FPE_FLTUND      5       # 浮点下溢
        FPE_FLTRES      6       # 浮点不精确的结果
        FPE_FLTINV      7       # 无效的浮点操作
        FPE_FLTSUB      8       # 下标越界
        
这些信息您可以在“help signals”中查看。

注意“stop”和“catch”是独立的，而如果您要使用“stop FPE”，
还应使用“ignore FPE”。

另请参见您的 Fortran 文档中的“调试”附录。

--------------------------------------------------------------------------------

(A.13) dbx 在何处创建所需的临时文件？

    Dbx 将对所有其临时文件使用目录/tmp 或环境变量 TMPDIR 的值（如果已
    设置）。所有 dbx 临时文件均以“dbx.”开头且在 dbx 会话中是唯一的。
    终止 dbx 时，dbx 临时文件即会被删除。

--------------------------------------------------------------------------------

(A.14) 如何运行含有很长参数列表的命令？

    正确的做法是将“run”命令添加至各个文件，然后执行

        $ dbx a.out
        (dbx) stop at 100
        (dbx) source foo
    是的，输入行的长度具有硬限制。其长度是 10k。

--------------------------------------------------------------------------------

(B.1) 从何处获得 MT dbx？

    您不需要获得特定的 MT dbx。MT 功能是标准 dbx 固有的一部分。
    使用 4.0 dbx 版本，您不需再另行获取使用 MT 功能的许可。

--------------------------------------------------------------------------------

(B.2) dbx 的主要 MT 功能是什么？

    “threads”命令会提供所有已知线程的列表，并列出它们的当前状态、
    基函数、当前函数等。
    您可以检查各线程的堆栈跟踪。
    您可以恢复（“cont”）特定的一个线程或全部线程。
    您可以“step”或“next”一个特定线程。
    “thread”命令可帮助您在线程间进行浏览。

--------------------------------------------------------------------------------

(B.3) 您可以限制特定线程的范围吗？

   “dbx”可确保光标处于“当前”或“激活”线程。
    它可通过“thread”命令加以控制。仅将当前线程用作缺省
    线程的命令是“where”和“thread -info”。

--------------------------------------------------------------------------------

(B.4) GUI 的主要 MT 功能是什么？

    “threads”命令的 GUI 界面可显示“进程/线程检查器”中的最新线程列表。
    进程/线程检查器链接至“堆栈检查器”因此您可以快速有效地查看所有线程
    堆栈。

--------------------------------------------------------------------------------

(B.5) 如何实现线程编号？

    dbx 将各线程（类型为 thread_t）的 ID 识别为
    由“thr_create()”返回。语法为“t@<number>”。

--------------------------------------------------------------------------------

(B.6) 如何实现 LWP 编号？ 

    dbx 将各 LWP（类型为 lwpid_t ）的 ID 识别为
    /proc (man procfs(4)) 界面所显示的 ID。语法为“l@<number>”。

--------------------------------------------------------------------------------

(B.7) 可在指定线程设置断点吗？

    可以，按以下方式过滤常规断点即可实现：
        停止 in foo -线程 t@4
    其中“t@4”指 ID 为 4 的线程。

--------------------------------------------------------------------------------

(B.8) 线程遇到断点时，出现哪些情况？
    所有线程还是遇到断点的线程停止？ 

    所有线程停止。即所谓的“sympathetic stop”或“stop the world”。
    从查看 /proc 和 LWP 的观点来看，这是“同步”调试。

--------------------------------------------------------------------------------

(B.9) dbx 如何判断应用程序是否是多线程的？

    如果应用程序被链接至 -lthread，则 dbx 视其为多线程应用程序。

--------------------------------------------------------------------------------

(B.10) 我应通过 MT 监视什么缺陷？

    要使程序死锁很容易，您仅需恢复一个指定的线程而截阻其它线程，
    并占用恢复线程可能需要的资源。

    libthread 数据结构处于用户空间中，可能因出现坏指针错误被破坏。
    在此情况下，建议使用“lwps”和“lwp”的命令（相当于其线程等价值）
    调整 LWP 级别。

--------------------------------------------------------------------------------

(B.11) 我能否“强制”运行休眠线程？

    您不能这样做。以后的版本中，您可能可以这样做，但是通常情况下，
    调试 MT 应用程序时，推荐您采用“stand back and watch”方法而不要
    试图将您的意向强加于程序的自然执行流程。

--------------------------------------------------------------------------------

(B.12) 如何通知某一特定线程正在等待的其它线程？
    （即，通过 thr_join）。
    从进程/线程检查器的线程列表启动时，我如何分辨来自不同 
    thr_create() 调用的线程 ID？

    现在您还不能这样做。我们期待更为成熟的界面可以帮助 dbx 问询线程状态。

--------------------------------------------------------------------------------

(B.13) 从进程/线程检查器的线程列表启动时，我如何确定来自特定
    启动函数的线程 ID？

    众所周知，“基函数”是通过线程列表输出的。

--------------------------------------------------------------------------------

(B.14) 绑定某一当前多线程进程时，哪些线程可激活？

    这不确定。

--------------------------------------------------------------------------------

(B.15) 激活线程执行 thr_create 时，哪些线程可激活？（例如，执行过 
    thr_create() 的线程或通过 thr_create 创建的线程？）（换句话说，
    是否有与“follow_fork_mode”类似的“follow_thread_mode”？）

    当前线程与“创建线程”同时存在。在 follow_fork 类别中，
    它即为“parent”。请注意，Sun MT 机型没有真正的线程“fork”语义。
    没有线程树，没有同进程一样的父-子关系。thr_join() 仅是一个简化的虚饰。

--------------------------------------------------------------------------------

(B.16) 激活线程执行 thr_exit 后，哪些线程（如果有）可激活？

    Dbx 使虚拟“死”线程成为活动线程。该线程表示为“t@X”。

#
# We don't want to insert tabs so we don't have to worry about 
# people's stty settings 
# Local Variables:
# indent-tabs-mode: nil 
# End:
#
