10. интерфейс командной строки

все кнопки, на которые вы щелкаете в ddd, в результате переводятся в команды отладчика; они показываются в консоли отладчика. вы также можете набирать и редактировать эти команды непосредственно.

10.1 ввод команд

вы можете общаться с командным интерфейсом подчиненного отладчика в консоли отладчика. вводите команды в подсказке -- это `(gdb)' для gdb, `(dbx)' для dbx, `(ladebug)' для ladebug, `>' для xdb, `>' и `нить[глубина]' для jdb, или `(pydb)' для pydb, или `db<>' для perl. вы можете использовать любые команды отладчика; для ввода набирайте клавишу return.

10.1.1 завершение команд

при использовании gdb или perl вы можете завершать команды и аргументы, нажимая tab. это работает в консоли отладчика, а также во всех остальных текстовых окнах.

gdb может дополнить для вас остаток слова команды, если есть только один вариант; он также может в любое время показать допустимые варианты следующего слова команды. это работает для команд gdb, подкоманд gdb и имен символов вашей программы.

нажимайте клавишу tab всякий раз, когда вы хотите, чтобы gdb дополнил остаток слова. если есть только один вариант, gdb дополняет слово и ждет, пока вы завершите команду (или нажмете ret для ее ввода). например, если вы наберете

(gdb) info bre tab

gdb дополнит остаток слова `breakpoints', поскольку это единственная подкоманда info, начинающаяся на `bre':

(gdb) info breakpoints

теперь вы можете либо нажать ret, чтобы запустить команду info breakpoints, либо нажать забой и ввести что-то еще, если `breakpoints' -- это не та команда, которую вы собирались ввести. (если бы вы были точно уверены, что хотите info breakpoints, вы могли бы просто набрать ret сразу после `info bre', применив возможность сокращения команд, а не дополнение.)

если есть несколько вариантов следующего слова, то когда вы нажимаете tab, ddd издает звуковой сигнал. вы можете либо набрать больше знаков и попробовать снова, либо просто нажать tab второй раз; gdb покажет все варианты завершения этого слова. например, вы можете захотеть установить точку останова на подпрограмме, чье имя начинается на `make_', но когда вы набираете b make_tab, ddd просто пищит. если вы снова нажмете tab, будут показаны имена всех функций из вашей программы, которые так начинаются. если вы еще раз нажмете tab, вы будете проходить по списку завершений, например:

(gdb) b make_ tab

ddd выдает сигнал; снова нажмите tab и увидите вот это:

make_a_section_from_file     make_environ               
make_abs_section             make_function_type         
make_blockvector             make_pointer_type          
make_cleanup                 make_reference_type        
make_command                 make_symbol_completion_list
(gdb) b make_ tab

ddd предоставляет одно дополнение за другим:

(gdb) b make_a_section_from_file tab
(gdb) b make_abs_section tab
(gdb) b make_blockvector tab

показав возможные варианты, gdb копирует незавершенный ввод (в этом примере `b make_'), чтобы вы могли закончить команду -- повторно нажав tab или введя остаток вручную.

иногда вам нужна такая строка, которая хотя логически и является "словом", но содержит скобки или другие знаки, которые gdb обычно не включает в свое понятие слова. чтобы завершение слов работало в таких случаях, вы можете заключать слова в командах gdb в одиночные кавычки (').

наиболее вероятна ситуация, когда вам это понадобилось для набора имени функции си++. это так, потому что си++ допускает перезагрузку функций (разные определения одной функции, отличающиеся типом аргумента). например, когда вы хотите поставить точку останова, вам может понадобиться указать, имеете ли вы в виду версию name, принимающую параметр int, name(int), или же версию, принимающую параметр float, name(float). чтобы использовать завершение слов в этой ситуации, наберите в начале имени функции одиночную кавычку '. это предупреждает gdb о том, что когда вы нажимаете tab, чтобы запросить завершение слова, ему следует принять во внимание больше информации, чем обычно:

(gdb) b 'bubble( tab
bubble(double,double)    bubble(int,int)
(gdb) b 'bubble(

в некоторых случаях ddd может понять, что для завершения имени требуется поставить кавычки. когда это происходит, ddd вставляет кавычку за вас (завершая в то же время насколько может), если вы сначала не набрали ее:

(gdb) b bub tab

ddd изменяет введенную вами строку на показанную ниже и
выдает звуковой сигнал:

(gdb) b 'bubble(

вообще, ddd может понять, когда нужна кавычка (и вставляет ее), если в момент запроса завершения перезагруженного символа вы еще не начали набирать список аргументов.

если вы предпочитаете использовать клавишу tab для переключения между объектами, снимите установку `edit => preferences => general => tab key completes in all windows'. это полезно в том случае, если фокус клавиатуры управляется указателем мыши (смотрите ниже), а у клавиши tab нет особого назначения. если эта установка включена, клавиша tab завершает только в консоли отладчика.

данная установка привязана к такому ресурсу:

ресурс: globaltabcompletion (класс globaltabcompletion)

если это `on' (по умолчанию), клавиша tab завершает аргументы во всех окнах. если это `off', tab завершает аргументы только в консоли отладчика.

10.1.2 история команд

вы можете повторить предыдущие и последующие команды, нажимая стрелки up и down, соответственно. это подставляет более ранние или более поздние команды в командную строку; чтобы применить текущую команду, нажмите return.

если вы введете пустую строку (просто нажмете return в подсказке отладчика), будет повторена последняя команда.

`commands => command history' показывает историю команд.

вы можете запустить поиск предыдущих команд, нажав ctrl+b. это вызывает режим наращиваемого поиска, где вы можете ввести строку, которую следует искать в предыдущих командах. чтобы повторить поиск, нажмите ctrl+b еще раз, а для поиска в обратном направлении используйте ctrl+f. чтобы вернуться в обычный режим, нажмите esc или наберите любую команду управления курсором.

история команд автоматически сохраняется при выходе из ddd. вы можете выключить эту возможность, установив следующий ресурс в значение `off':

ресурс: savehistoryonexit (класс savehistoryonexit)

если это `on' (по умолчанию), история команд автоматически сохраняется при выходе из ddd.

10.2 ввод команд с терминала

вместо того чтобы вводить команды с консоли отладчика, вы, возможно, предпочтете набирать их в окне терминала, из которого был вызван ddd.

когда ddd вызывается с ключом --tty, он включает tty-интерфейс, принимая команды отладчика со стандартного ввода и пересылая вывод отладчика на стандартный вывод, как если бы подчиненный отладчик был вызван непосредственно. в остальном все функциональные возможности ddd остаются такими же.

по умолчанию, если ddd был вызван с ключом --tty, консоль отладчика закрыта. чтобы открыть ее, используйте `view => debugger console'.

ddd можно настроить на использование библиотеки `readline' для чтения команд со стандартного ввода. эта библиотека gnu предоставляет единый пользовательский интерфейс для программ, управляемых из командной строки. ее преимущества: редактирование команд "на месте" в стиле gnu emacs или vi, подстановка из истории, как в csh, и сохраняемая между сеансами отладки история команд. см. раздел `command line editing' в debugging with gdb, для получения дополнительной информации о редактировании командой строки через tty-интерфейс.

10.3 интегрирование ddd

вы можете запускать ddd как подчиненный отладчик в других интерфейсах для отладчиков, комбинируя их возможности с возможностями ddd.

чтобы запустить ddd в качестве подчиненного отладчика в другой интерфейсной программе, нужно настроить ее так, чтобы вместо ее подчиненного отладчика работал бы `ddd --tty'. когда ddd вызывается с ключом --tty, он включает tty-интерфейс, принимая команды отладчика со стандартного ввода и пересылая вывод отладчика на стандартный вывод, как если бы подчиненный отладчик был вызван непосредственно. в остальном поведение ddd не меняется.

в том случае, если ваш интерфейс отладчика использует ключ gdb -fullname, чтобы gdb сообщал позиции исходного кода, --tty задавать не обязательно. ddd распознает ключ -fullname, понимает, что его вызвали из другой интерфейсной программы, и автоматически задействует tty-интерфейс.

если запустить ddd с ключом -fullname, консоль отладчика и окно исходного кода изначально выключены, так как предполагается, что их предоставит внешний интерфейс. если же нужно, вы можете зайти в меню `view' и включить эти окна.

10.3.1 использование ddd с emacs

чтобы интегрировать ddd с emacs, наберите в emacs m-x gdb или m-x dbx, чтобы запустить сеанс отладки. в подсказке введите ddd --tty (и потом --dbx или --gdb, если нужно) и имя отлаживаемой программы. далее действуйте как обычно.

10.3.2 использование ddd с xemacs

чтобы интегрировать ddd с xemacs, установите переменную gdb-command-name равной `"ddd"', вставив в свой файл `~/.emacs' следующую строку:

(setq gdb-command-name "ddd")

кроме того, можно вычислить это выражение, нажав esc : и введя его непосредственно (esc esc в xemacs 19.13 и более ранних).

чтобы запустить из xemacs сеанс отладки ddd, используйте `m-x gdb' или `m-x gdbsrc'. далее работайте как обычно.

10.3.3 использование ddd с @acronym{xxgdb}

чтобы интегрировать ddd с @acronym{xxgdb}, вызовите xxgdb так:

xxgdb -db_name ddd -db_prompt '(gdb) '

10.4 определение кнопок

для упрощения взаимодействия с ddd вы можете добавлять свои собственные командные кнопки. можно добавлять кнопки внизу консоли отладчика (`кнопки консоли'), окна исходного кода (`кнопки исходника') или окна данных (`кнопки данных').

для определения отдельных кнопок служит редактор кнопок, вызываемый через `commands => edit buttons'. редактор кнопок показывает текст, где каждая строка содержит команду для одной кнопки. щелчок на `ok' создает соответствующие этому тексту кнопки. если текст пуст (по умолчанию), кнопки не создаются.

в качестве простого примера, предположим, что вы хотите создать кнопку `print i'. вызовите `commands => edit buttons' и введите в редакторе кнопок строку `print i'. затем щелкните на `ok'. тогда внизу консоли отладчика появится кнопка с именем `print i' -- попробуйте применить ее! чтобы удалить эту кнопку, снова откройте редактор кнопок, очистите строку `print i' и нажмите `ok'.

если команда кнопки содержит `()', строка `()' будет автоматически заменяться на содержимое поля аргумента. к примеру, кнопка с именем `return ()' будет выполнять команду gdb `return', передавая ей текущее содержимое поля аргумента.

по умолчанию ddd выключает все кнопки, чьи команду не поддерживаются подчиненным отладчиком. чтобы задействовать их, снимите переключатель `enable supported buttons only' в редакторе кнопок.

кроме того, ddd позволяет задавать для определяемых пользователем кнопок управляющие последовательности и метки. см. раздел 10.4.1 настройка кнопок, для получения подробностей.

10.4.1 настройка кнопок

ddd позволяет определять дополнительные командные кнопки; см. раздел 10.4 определение кнопок. данный раздел описывает ресурсы, контролирующие определяемые пользователем кнопки.

ресурс: consolebuttons (класс buttons)

разделяемый переводами строки список кнопок, которые следует добавить внизу консоли отладчика. каждая кнопка отдает команду, определяемую ее именем.

следующие знаки имеют специальное значение:

• команды, завершающиеся на ..., вставляют в консоль отладчика свое имя и пробел.
• команды, завершающиеся на управляющий знак (то есть `^', после которого стоит буква или `?'), вставляют указанный управляющий знак.
• строка `()' заменяется на текущее содержимое поля аргумента.
• строка, заданная ресурсом `labeldelimiter' (обычно `//') разделяет имя команды и метку кнопки. если метка не указана, вместо нее используется имя команды с первой заглавной буквой.

следующие имена кнопок зарезервированы:

`apply'

послать заданную команду отладчику.

`back'

искать ранее выбранную позицию в исходном коде.

`clear'

очистить текущую команду.

`complete'

завершить текущую команду.

`edit'

редактировать текущий исходный файл.

`forward'

искать следующую выбранную позицию в исходном коде.

`make'

вызвать программу `make', используя последние заданные ей аргументы.

`next'

показать следующую команду.

`no'

ответить на текущую подсказку отладчика `no'. эта кнопка видима, только если отладчик задает вопрос, на который можно ответить да/нет.

`prev'

показать предыдущую команду.

`reload'

перезагрузить исходный файл.

`yes'

ответить на текущую подсказку отладчика `yes'. эта кнопка видима, только если отладчик задает вопрос, на который можно ответить да/нет.

по умолчанию значение этого ресурса пусто -- кнопки на консоли не создаются.

вот несколько примеров, которые можно вставить в файл `~/.ddd/init'. это установки ddd 1.x:

ddd*consolebuttons: yes\nno\nbreak^c

эта установка создает еще несколько кнопок:

  ddd*consolebuttons: \
  yes\nno\nrun\nclear\nprev\nnext\napply\nbreak^c

также смотрите ресурсы `databuttons', `sourcebuttons' и `toolbuttons'.

ресурс: databuttons (класс buttons)

разделяемый переводами строки список кнопок, которые следует добавить внизу окна данных. каждая кнопка отдает команду, задаваемую ее именем. синтаксис подробно описан для ресурса `consolebuttons' выше.

по умолчанию значение этого ресурса пусто -- кнопки в окне данных не создаются.

ресурс: sourcebuttons (класс buttons)

разделяемый переводами строки список кнопок, которые следует добавить внизу окна исходного кода. каждая кнопка отдает команду, задаваемую ее именем. синтаксис подробно описан для ресурса `consolebuttons' выше.

по умолчанию значение этого ресурса пусто -- кнопки в окне исходного кода не создаются.

вот несколько примеров, которые можно вставить в файл `~/.ddd/init'. это установки ddd 1.x

ddd*sourcebuttons: \
  run\nstep\nnext\nstepi\nnexti\ncont\n\
  finish\nkill\nup\ndown\n\
  back\nforward\nedit\ninterrupt^c

эта установка создает несколько кнопок, которых нет в панели команд:

  ddd*sourcebuttons: \
  print *()\ngraph display *()\nprint /x ()\n\
  whatis ()\nptype ()\nwatch ()\nuntil\nshell

более профессиональная установка использует настраиваемые метки кнопок.

  ddd*sourcebuttons: \
  print *(()) // print *()\n\
  graph display *(()) // display *()\n\
  print /x ()\n\
  whatis () // what is ()\n\
  ptype ()\n\
  watch ()\n\
  until\n\
  shell

смотрите также ресурсы `consolebuttons' и `databuttons' выше и ресурс `toolbuttons' ниже.

ресурс: toolbuttons (класс buttons)

разделяемый переводами строки список кнопок, которые следует добавить к панели команд или командной панели инструментов (см. раздел 3.3.1.1 выключение панели команд). каждая кнопка отдает команду, задаваемую ее именем. см. раздел 10.4 определение кнопок, подробное описание синтаксиса кнопок.

по умолчанию значение этого ресурса равно

ddd*toolbuttons: \
run\nbreak^c\nstep\nstepi\nnext\nnexti\n\
until\nfinish\ncont\n\kill\n\
up\ndown\nback\nforward\nedit\nmake

для каждой кнопки нужно указать положение на панели команд, используя ресурсы `xmform'. инструкции смотрите в файле ресурсов по умолчанию `ddd'.

если значение ресурса `toolbuttons' пусто, панель команд не создается.

следующие ресурсы определяют кнопки более подробно:

ресурс: labeldelimiter (класс labeldelimiter)

строка, используемая для отделения меток от команд и клавиатурных эквивалентов. по умолчанию `//'.

ресурс: verifybuttons (класс verifybuttons)

если `on' (по умолчанию), проверять каждую кнопку на предмет, действительно ли ее команда поддерживается подчиненным отладчиком. если такая команда неизвестна, кнопка выключается. если этот ресурс равен `off', проверка не производится: все команды принимаются "как есть".

10.5 определение команд

кроме команд для точек останова (см. раздел 5.1.8 команды точек останова), ddd также позволяет вам определять свои команды. определяемая пользователем команда -- это последовательность команд, которой вы присвоили собственное имя как отдельной команде. эту новую команду можно вводить в подсказке отладчика или вызывать по кнопке.

10.5.1 определение простых команд с использованием gdb

кроме команд для точек останова (см. раздел 5.1.8 команды точек останова), ddd также позволяет вам записывать последовательности команд в качестве новой, определенной пользователем команды gdb. определяемая пользователем команда -- это последовательность команд gdb, которой вы придали новое имя как команде. в ddd для этой цели служит редактор команд, который вызывается через `commands => define command'.

команда gdb создается в пять шагов:

1. введите имя команды в поле `command'. используйте ниспадающий список справа, если хотите выбрать уже определенную команду.
2. щелкните на `record', чтобы начать запись последовательности команд.
3. теперь отдавайте ddd команды. в процессе записи ddd не выполняет команды, а просто записывает их. записанные команды показываются в консоли отладчика.
4. чтобы остановить запись, щелкните на `end' или введите в подсказке gdb слово `end'. чтобы отменить запись, щелкните на `interrupt' или нажмите esc.
5. щелкните на `edit >>', чтобы отредактировать записанные команды. когда вы закончите с этим, щелкните на `edit <<', и редактор команд закроется.

когда команда определена, вы можете вводить ее в подсказке gdb. кроме того, любую определенную пользователем команду можно применить, щелкнув на `apply'.

для удобства работы вы можете назначить для новой команды кнопку. если включить одно из положений `button', в указанном месте добавится кнопка с этой командой. если вы хотите отредактировать эту кнопку, выберите `commands => edit buttons'. см. раздел 10.4 определение кнопок, обсуждение этой темы.

когда выполняются определенные пользователем команды gdb, команды, составляющие ее определение, не печатаются. ошибка в любой из команд последовательности приводит к останову выполнения.(33)

команды, которые обычно запрашивают подтверждение, не задают вопросов при интерактивном использовании, если они находятся внутри определенной пользователем команды. многие команды gdb, которые обычно печатают сообщения о том, что они делают в данный момент, не выводят этих сообщений при использовании из определенной пользователем команды.

чтобы сохранить все определения команд, используйте `edit => save options'.

10.5.2 определение команд с аргументами с использованием gdb

если вы хотите передать определяемой пользователем команде аргументы, вы можете включить переключатель `()' в редакторе команд. это приводит к двум результатам:

• во время записи команд все ссылки на поле аргумента воспринимаются символьно, а не буквально. значение поля аргумента фиксировано и равно `$arg0', так gdb обозначает аргумент определяемой пользователем команды. когда gdb будет выполнять эту команду, он заменит `$arg0' на текущий аргумент команды.
• когда команде придается кнопка, после команды дописывается текущее содержимое поля аргумента.

в процессе определения команды вы можете как угодно переключать кнопку `()', переходя от символьной подстановки поля аргумента к буквальной.

в качестве примера давайте определим команду contuntil, она будет устанавливать точку останова по заданному аргументу и продолжать выполнение.

1. введите в поле `command' слово `contuntil'.
2. включите переключатель `()'.
3. теперь щелкните на `record', и начнется запись. заметьте, что содержимое поля аргумента сменилось на `$arg0'.
4. щелкните на `break at ()', чтобы создать точку останова. обратите внимание, записанная команда ссылается на `$arg0'.
5. щелкните на `cont', чтобы продолжить выполнение.
6. завершите запись, щелкнув на `end'. заметьте, что поле аргумента восстановило свое первоначальное значение.
7. наконец, щелкните на одном из положений `button'. это создает кнопку `contuntil ()', где `()' будет заменяться на текущее содержимое поля аргумента -- и, таким образом, передаваться команде `contuntil'.
8. теперь вы можете использовать кнопку `contuntil ()' или вводить команду `contuntil' в подсказке gdb. (если вы планируете использовать ее часто, вы, возможно, захотите определить команду `cu', которая вызывает `contuntil' со своим аргументом. это хорошее упражнение.)

у команд с аргументами есть маленький недостаток: у определяемой пользователем команды gdb нет никакой возможности получить доступ ко всему списку аргументов целиком; обрабатывается только первый аргумент (до пропуска). в будущих выпусках gdb это может измениться.

10.5.3 определение команд с использованием других отладчиков

если ваш подчиненный отладчик позволяет определять свои собственные последовательности команд, вы также можете использовать эти пользовательские команды из ddd; просто вводите их в подсказке отладчика.

однако, вы можете столкнуться с некоторыми проблемами:

• ddd не знает, что делает пользовательская команда, в отличие от хорошо документированных команд отладчика. это может привести к несогласованности между ddd и подчиненным отладчиком. к примеру, если ваша пользовательская команда `bp' устанавливает точку останова, ddd может показать ее не сразу, поскольку он не знает, что `bp' изменяет состояние точек останова.
• вы не можете использовать команды ddd `graph' внутри пользовательской команды. это естественно, так как пользовательские команды интерпретируются подчиненным отладчиком, а он не знает о командах ddd.

для решения этих проблем ddd предоставляет простое средство, так называемые автокоманды. если ddd получает от подчиненного отладчика какой-либо вывод вида `префикс команда', он интерпретирует команду, как если бы она была введена в подсказке отладчика. префикс -- это определяемая пользователем строка, например `ddd: '.

допустим, вы хотите определить команду gd, которая служит сокращением для graph display. все, что должна сделать команда gd -- выдать строку

ddd: graph display аргумент

где аргумент -- это аргумент gd. при использовании gdb этого можно достичь с помощью команды echo. вставьте в свой файл `~/.gdbinit' такие строки:

define gd
  echo ddd: graph display $arg0\n
end

чтобы закончить подготовку, вы должны также установить ресурс `autocommandprefix' в значение префикса, который вы написали в команде, `ddd: '. напишите в файле `~/.ddd/init':

ddd*autocommandprefix: ddd:\ 

(не забудьте поставить после обратной косой черты пробел.)

теперь ввод gd foo в подсказке отладчика будет иметь тот же эффект, что и graph display foo.

пожалуйста, обратите внимание: для своих команд вам лучше выбрать какой-нибудь другой префикс, не `ddd: '. это нужно делать, потому что автокоманды создают проблему с защитой, ведь выполнять можно любые команды. только представьте себе, что некая злобная программа пишет во время отладки строку вроде `префикс shell rm -fr ~'! поэтому обязательно придумайте свой собственный префикс; его длина должна быть не меньше трех знаков.