ГЛАВА 5  УПРАВЛЕНИЕ ПРОЦЕССОМ ВЫПОЛНЕНИЯ ПРОГРАММЫ


     При отладке программы обычно выполняется какая-то ее часть и
проверяется  правильность  ее  работы  в  текущей  точке.   Turbo
Debugger   позволяет  управлять  процессом  выполнения  программы
различными способами. Вы можете:

     - выполнить одну машинную команду или одну  строку исходного
текста;

     -  выполнять вызовы процедур и функций, не входя в них;

     - включать   режим   "мультипликации"  отоадчика  (выполнять
непрерывную трассировку);

     - выполнять текущую процедуру  или  функцию  до  возврата  в
вызвавшую ее программу;

     -  выполнять программу до конкретного места;

     -  выполнять программу до точки останова;

     - менять     направление     выполнения     программы     на
противоположное.

     Сеанс отладки состоит  из  сменяющих  друг  друга  периодов,
когда  работает  либо  программа,  либо отладчик.  Когда работает
отладчик,  можно запустить отлаживаемую программу, выбрав одну из
команд  меню  Run  или нажав ее активную клавишу.  Когда работает
программа,  отладчик  запускается  вновь  либо  после  выполнения
определенного  фрагмента  программы,  либо когда вы прерываете ее
работу нажатием определенных клавиш,  либо когда  Turbo  Debugger
встречает точку останова.

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

Проверка текущего состояния программы
-----------------------------------------------------------------

     Под "состоянием программы" понимается следующее:

     - значения аргументов программы, заданных в командной строке
DOS;

     -  содержимое стека активных процедур и функций;

     -  текущее положение в исходном тексте или машинном коде;

     -  значения регистров;

     -  содержимое памяти;

     -  причину, по которой отладчик прервал выполнение программы;

     -  значения переменных программы.

     В следующих   разделах   рассматривается   работа  с  окнами
переменных  и  стека,  использование   локальных   меню   подокон
глобальных и  локальных  переменных,  команд  Origin  и Get Info.
Информацию о  том,  как   просматривать   и   изменять   значения
переменных программы см. в Главе 6.

Окно переменных (Variables)

     В этом  окне отображаются все переменные (имена и значения),
доступные в текущей точке программы.  Его можно использовать  для
поиска  переменных,  точное написание которых вы забыли.  Команды
локального меню  можно  использовать  для  проверки  и  изменения
значений переменных.  Кроме того,  этим окном удобно пользоваться
для проверки локальных переменных вызванной функции.


     Примечание: При отладке программы, написанной на языке Turbo
Pascal,  в переменные не будут организованы в алфавитном порядке.

     Окно Variables  открывается при помощи View|Variables.  Окно
Variables имеет два подокна:

     - подокно  Global  (верхнее)   показывает   все   глобальные
символические имена в программе.

     - подокно   Static   (нижнее)   показывает  все  статические
символические имена текущего модуля (модуля, которому принадлежит
текущий адрес  выполняемой программы,  CS:IP) и все символические
имена, локальные относительно текущей функции.

     В обоих подокнах слева указывается имя переменной,  а справа
-  ее  значение.  Если  Turbo  Debugger  не  может  найти никакой
информации о типе данных для данного  идентификатора,  он  ставит
справа от него четыре знака вопроса (????).

     Так же,  как для всех локальных меню,  для вызова локального
меню подокна глобальных переменных надо нажать  клавиши  Alt-F10.
Если  разрешено  использование  активных  клавиш  в  комбинации с
клавишей Ctrl,  для выбора этой команды можно нажать клавишу Ctrl
в сочетании с первой буквой данной команды.

     Если в   программе   имеются   функции,   которые  выполняют
рекурсивные вызовы,  либо если необходимо  просмотреть  локальные
переменные   вызванной   функции,  то  можно  проверить  значение
конкретного экземпляра локальных данных функции.  Для этого  надо
открыть  окно  стека,  выполнив  команду View/Stack,  переместить
выделяющий курсор  к  нужному  вызову  функции,  а  затем  нажать
клавиши  Alt-F10 и выбрать команду Locals.  В подокне статических
переменных окна переменных  будут  показаны  значения  для  этого
конкретного экземпляра вызова функции.

Локальное меню подокна глобальных переменных
--------------------------------------------

     В этом  локальном  меню   имеется   две   команды:   Inspect
(проверить) и Change (изменить).

     --------
     Inspect
     Change
     --------

Команда Inspect
---------------

     Открывает окно  проверки  (Inspector),  в  котором  показано
значение выбранной глобальной переменной. Работа с окном проверки
более подробно описана в главе 6.

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

     Если имеется локальная переменная,  имя которой совпадает  с
проверяемой   глобальной   переменной,  будет  показано  значение
глобальной переменной,  а не локальной.  Такое поведение  немного
отличается  от  обычного поведения окна проверки,  которое обычно
показывает  значение  переменной,  связанное  с  текущей   точкой
программы    (CS:IP).   Благодаря   этому,   пользователь   может
просматривать  значения  глобальных  переменных,  имена   которых
используются и для локальных переменных.

Команда Change
--------------

     Заменяет значение    выбранной    (выделенной)    глобальной
переменной значением, которое вводит пользователь в блоке диалога
Change. Turbo Debugger выполняет любое необходимое преобразование
типов  данных  точно  так же,  как если бы для изменения значения
использовался  оператор  присваивания  исходного   языка.   Более
подробная информация о присваивании и преобразовании типов данных
приведена в главе 9.

     Кроме этого,  можно изменить значение выбранной  переменной,
просто начав вводить новое значение. При этом появляется такое же
поле запроса, как если бы сначала была выбрана команда Change.

Локальное меню подокна статических переменных
---------------------------------------------

     Для вызова  лоокального  меню подокна статических переменных
нажмите клавиши Alt-F10.  Если разрешено  использование  активных
клавиш  в  комбинации  с  клавишей Crtl,  для выбора этой команды
можно нажать клавишу Ctrl в  сочетании  с  первой  буквой  данной
команды.

     В локальном  меню  подокна статических переменных имеются те
же две команды: Inspect и Change.

     -----------
     Inspect
     Change
     -----------


Команда Inspect
---------------

     Открывает окно проверки (Inspector),  в котором отображается
значение выбранной локальной переменной  модуля.  Более  подробно
работа с окном проверки описана в главе 6.

Команда Change
--------------

     Заменяет значение    выбранной    (выделенной)     локальной
переменной значением, которое вводит пользователь в блоке диалога
Change. Turbo Debugger выполняет любое необходимое преобразование
типов  данных  точно  так же,  как если бы для изменения значения
использовался  оператор  присваивания  исходного   языка.   Более
подробная информация о присваивании и преобразовании типов данных
приведена в главе 9.

     Кроме этого,  можно изменить значение выбранной  переменной,
просто начав вводить новое значение. При этом появляется такое же
поле запроса, как если бы сначала была выбрана команда Change.

Окно стека (Stack)

     Окно стека открывается по  команде  F10/View/Stack.  В  этом
окне приводится список всех активных процедур и функций. Первой в
списке является последняя вызванная  подпрограмма,  за  ней  идет
вызвавшая  ее  подпрограмма и т.д.  до самой первой процедуры или
функции  (в  программе  на  Паскале  это  основная  программа,  в
программе на Си это, обычно, функция с именем main()). Для каждой
процедуры  и  функции  приводятся  значения  всех  параметров,  с
которыми они были вызваны.


     Аналогичным образом   окно  Stack  выводит  имена  объектных
правил или компонениных функций класса,  перед которыми выводятся
имя объекта или тип класса, определяющий правило или компонентную
функцию:

     SHAPES.ACIRCLE(174, 360, 75.0) (Turbo Pascal)

     Для вызова  локального  меню  окна  стека  нажмите   клавиши
Alt-F10  или  клавишу  Ctrl  в  сочетании  с первой буквой нужной
команды меню, чтобы сразу выполнить эту команду.

Локальное меню окна стека
-------------------------

     Локальное меню содержит две команды: Inspect и Locals.

     -------------
     Inspect
     Locals
     -------------

Команда Inspect
---------------

     Открывает окно модуля (Module), расположенное возле активной
строки выбранной функции.  Если выбранная функция является первой
в  списке (вызвана последней),  в окне модуля указывается текущая
точка подпрограммы (содержимое регистров CS:IP).  Если  выбранная
функция   не   является   последней   вызванной   функцией,  окно
располагается  возле   строки   этой   функции,   которая   будет
выполняться  после  возврата  из  вызванной функции.

     Эту команду также можно вызвать, установив выделяющий курсор
на нужную функцию и нажав клавишу Enter.

Команда Locals
--------------

     Открывает окно   переменных,   в  котором  показываются  все
локальные  переменные  текущего   модуля,   а   также   локальные
переменные выбранной функции.  Если какая-либо функция рекурсивно
вызывает сама себя, в окне стека будет несколько экземпляров этой
функции.  Установив  выделяющий курсор на один из вызовов,  можно
просмотреть  значения  локальных  переменных  данного  экземпляра
функции.

Команда Origin локального меню

     Окно модуля  и  подокно  кода  окна процессора имеют в своих
локальных меню команду Origin. Эта команда позиционирует курсор в
текущую  точку  программы,  которой  соответствует  значение пары
регистров CS:IP.  Эта команда очень полезна в тех случаях,  когда
вы  просматривали текст программы и хотите вернуться в точку, где
было остановлено ее выполнение.

Просмотр состояния выполнения программы: команда Get Info

     Команду Get Info можно использовать для получения информации
об  использовании  памяти  и  о   причине   передачи   управления
отладчику. Эта и другая информация отображается в отдельном окне,
которое удаляется с экрана при нажатии любой клавиши. В этом окне
отображается следующая информация:

     -  имя отлаживаемой программы;

     -  описание причин останова программы;

     - количество  памяти,   используемой   DOS,   отладчиком   и
программой;

     - если имеется расширенная память, данные о ее использовании
приводятся справа от информации об основной памяти;

     -  список прерываний, перехваченных отлаживаемой программой;

     -  версия операционной системы DOS, в которой вы работаете;

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


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


     Stoped at_ (остановлена на...)

     Программа была  остановлена в результате выполнения одной из
команд:  Run/Execute To,  Run/Go to Cursor или Run/Until  Return.
Это сообщение выдается также при первой загрузке программы, когда
выполнен код начальной загрузки,  сформированный компилятором,  и
маркер выполнения установлен в начале текста программы.

     No program loaded (программа не загружена)

     Turbo Debugger был запущен без какой-либо программы. Никакой
код не может быть выполнен, пока не будет загружена программа или
не  будет сассемблирована часть команд с помощью команды Assemble
локального меню подокна кода окна процессора.

     Control Break (нажаты клавиши Ctrl-Break)

     Выполнение программы было остановлено в  результате  нажатия
клавиш  Ctrl-Break  после  того  как клавише Break была назначена
какаялибо другая функция.

     Trace (трассировка)

     Была выполнена одна строка  исходного  текста  или  машинная
команда по команде F7(Run|Trace).

     Breakpoint at_ (точка останова в...)

     При выполнении   программы   встретилась   точка   останова,
заданная для прерывания работы программы.  Текст после слова "at"
означает  адрес  команды программы,  на которой установлена точка
останова.

     Terminated, exit code_ (завершена, код выхода...)

     Работа программы  завершена.  Текст   после   слова   "code"
представляет    собой   код   выхода,   возвращаемый   программой
операционной системе DOS. Если программа не возвращает DOS какого
-либо   определенного   значения,   вместо   кода   выхода  может
отображаться какоето бессмысленное число. Программа не может быть
запущена, пока не будет загружена заново командой Run|Program
Reset.

     Loaded (загружена)

     Вы запустили отладчик Turbo Debugger, указав имя программы и
параметр,   который   предотвращает   выполнение  кода  начальной
загрузки,  сформированного компилятором.  Никакие команды еще  не
были   выполнены,   включая  те,  которые  устанавливают  стек  и
сегментные  регистры.  Это  означает,  что  если  вы  попытаетесь
проверить  какие-либо  данные  в  своей  программе,  вы  получите
неправильные значения.

     Step (шаг)

     Была выполнена одна строка  исходного  текста  или  машинная
команда   без   входа   в   функцию  с  помощью  команды  F8  или
F8(Run|Step Over).

     Interrupt (прервана)

     Была нажата клавиша прерывания  (обычно  Ctrl-Break),  чтобы
вернуть  управление  отладчику.  В  этом  случае работа программы
немедленно прерывается и снова запускается отладчик.

     Exception_ (особая ситуация)

     Вы использовали TD386,  когда  встретилась  особая  ситуация
процессора. Это   обычно   случается,  когда  программв  пытается
выполнить недопустимый для данного  процессора  код  операции.  В
документации по  процессору  Intel каждая особая ситуация лписана
подробно.

     Hardware deviсe driver stuck (конфликт драйвера аппаратного
                                   устройства)
     Вы используете аппаратный отладчик и  установили  аппаратную
точку останова  для  стековой  переменной,  конфликтующую с Turbo
Debugger. Прежде чем пойти дальше,  вы должны  убрать  эту  точку
останова.

     Divide by zero (деление на ноль)

     Ваша программа   выполнила   команду   деления,   в  которой
встретился нулевой делитель.

     Global breakpoint _ at__ (глобальная точка останова _ в _)

     Встретилась глобальная точка останова.  Вам сообщен ее номер
и адрес в программе).

Меню Run
-----------------------------------------------------------------

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

     -----------------------------
     Run                        F9
     Go to cursor               F4
     Trace into                 F7
     Step over                  F8
     Execute to...          Alt-F9
     Until return           Alt-F8
     Animate...
     Back trace             Alt-F4
     Instruction trace      Alt-F7
     -----------------------------
     Arguments...
     Program reset         Ctrl-F2
     -----------------------------


Команда Run [F9]

     Запускает программу  с  нормальной   скоростью   выполнения.
Управление возвращается к отладчику в одном из следующих случаев:

     -  работа программы завершена;

     -  встретилась точка останова с заданным действием;

     -  выполнение прервано нажатием клавиш Ctrl-Break.

Команда Go to Cursor [F4]   -------------------------------------

     Выполняет программу до строки,  на которой находится курсор,
в текущем окне модуля или  подокне  кода  окна  процессора.  Если
текущим  окном является окно модуля,  курсор должен находиться на
строке исходного текста в пределах какой-либо функции.


Команда Trace Into
[F7]   ---------------------------------------

     Выполняет одну строку исходного текста или машинную команду.
Если текущим является окно Module,  то  выполняется  одна  строка
исходного   кода,   однако,  если  текущим  окном  является  окно
процессора,  выполняется  одна  машинная  команда.  Если  текущая
строка  содержит  вызов  процедуры  или  функции,  Turbo Debugger
входит в эту подпрограмму.  Если же  текущее  окно  -  окно  CPU,
выполняется одна машинная команда.

     Turbo Debugger обрабатывает объектные правила и компонентные
функции класса как все прочие процедуры и функции.  F7  выполняет
трассировку исходного кода, если он имеется.

Команда Step Over
[F8]   ----------------------------------------

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

     Когда по  команде  Step  Over  выполняется  строка исходного
текста,  содержащая вызов процедуры или функции,  Turbo  Debugger
обрабатывает   этот  вызов  как  часть  данной  строки,  то  есть
подпрограмма выполняется за один  шаг  отладки,  и  вы  сразу  же
переходите  к  следующей  строке  текущей  подпрограммы,  либо  к
подпрограмме, вызвавшей текущую.

     Если по команде Step Over выполняется одна машинная команда,
Turbo Debugger обрабатывает отдельные команды как единую команду,
даже если они вызывают выполнение сразу нескольких  команд.  Ниже
приведен   полный   перечень   команд,   которые   обрабатываются
отладчиком Turbo Debugger как единая команда.

     CALL      Вызов подпрограммы (дальний и ближний)
     INT       Вызов подпрограммы обработки прерывания
     LOOP      Управление циклом с помощью счетчика CX
     LOOPZ     Управление циклом с помощью счетчика CX
     LOOPNZ    Управление циклом с помощью счетчика CX


     Кроме указанных за один шаг отладки выполняются команды REP,
REPNZ и REPZ,  за которыми следуют команды  CMPS,  CMPSB,  CMPSW,
LODSB,  LODSW,  MOVS,  MOVSB,  MOVSW,  SCAS,  SCASB, SCASW, STOS,
STOSB, STOSW.

     Turbo Debugger обрабатывает объектные правила и компонентные
функции класса как один оператор и обходит их, как обычные вызовы
процедур и функций.

Команда Execute To...
 [Alt-F9]  ---------------------------------

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

Команда Until Return
[Alt-F8]   ---------------------------------

     Выполняет программу  до  возврата  из  текущей   функции   в
вызвавшую  ее  подпрограмму.  Эта команда полезна в двух случаях:
если вы вошли в подпрограмму,  работа которой вас не  интересует,
случайно    выполнив   команду       Run/Trace   вместо   команды
    Run/Step,  либо  если   вы   уже   определили,   что   данная
подпрограмма   работает  правильно  и  нет  необходимости  дальше
отслеживать ее выполнение в пошаговом режиме.


Команда Animate
 [Alt-F4]   --------------------------------------

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

     После выбора  Run|Animate  отладчик  запросит  у  вас  время
задержки   между   последовательными  шагами  трассировки.  Время
задержки  измеряется  в  десятых  долях  секунды.  По   умолчанию
используется задержка равная 3.

Команда Back Trace
 [Alt-F4]   -----------------------------------

     При трассировке  программы  (при  помощи  F8   или   Alt-F8)
изменяет порядок  выполнения  на обратный.  Это удобно,  если при
отладке вы зашли за ту тлчку,  в которой предполагаете  ошибку  и
хотите вернуть выполнение программы назад.  Эта команда позволяет
возвратиться назад либо по шагам,  либо сразу к  заданной  иочке,
высвеченной в подокне Instructions или окне Execution History.

     Предупреждение! имеется  несколько ограничений.  См.  раздел
"Подокно Instructions".

Команда Instruction Trace [Alt-F7]

     Служит для выполнения одной машинной команды. Используется
для трассировки  прерываний,  либо  когда  вы  находитесь  в окне
Module и хотите трассировать процедуру или функцию, находящуюся в
модуле, в  который  не  включена отладочная информация (например,
библиотечная функция).

     Поскольку вы не будете попадать в  начало  исходной  строки,
эта команда обычно помещает вас в окно CPU.

Команда Arguments...

     Данная команда   позволяет   устанавливать  новые  аргументы
командной строки  при  вызове  программы.  Это   более   подробно
рассматривается в главе 5.

Команда Program Reset
 [Ctrl-F2]   -------------------------------

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

     Если вы  работаете в окне модуля или окне процессора,  то вы
не будете возвращаться в начало своей программы. Вместо этого, вы
останетесь точно в том же месте,  в котором вы были до выполнения
команды Program Reset.  Если вы выбираете команду  Program  Reset
только из-за того,  что вы выполнили на один оператор больше, чем
намеревались,  вы можете переместить курсор  на  несколько  строк
исходного текста  вверх  и нажать клавишу F4 или выбрать Run|Back
Trace, чтобы выполнить программу до этой строки,  вместо  Program
Reset.

Окно Execution History (истории выполнения)
-----------------------------------------------------------------

     Turbo Debugger  имеет   специальное   средство,   называемое
историей выполнения,  позволяющее  запоминать  команды по мере их
выполнения (при условии,  что вы трассируете код),  а также,  при
желании, записывать  вводимые  вами  нажатия  клавиш,  при помощи
которых вы приходите к той или иной точке  программы.  Вы  можете
изучать эти  команды и отменять их действие,  возвращаясь в точку
вероятной ошибки.  Если у нет EMS-памяти,  Turbo  Debugger  может
записать до 400 команд.  При наличии EMS-памяти можно записать до
3000 команд.

     Вы можете  изучать  историю  выполнения  в  окне   Execution
History, которое открывается при выборе View|Execution History.

     Это окно  имеет  два подокна:  подокно Instructions вверху и
подокно Keystroke Recording в нижней части экрана.

Подокно Instructions

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

     История выполнения позволяет отслеживать только  те команды,
что были  выполнены  по  команде  Trace Into (F7) или Instruction
Trace (Alt-F7).  Отслеживание выполняется также для команды  Step
Over, за исключением команд,  описанных на стр.84 оригинала.  При
использовании команды Run или при выполнении  прерывания  история
выполнения удаляется.  (Ее  запись возобновляется,  как только вы
возобновляете трассировку).

     Обратная трассировка вызова прерывания невозможна.

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

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

Локальное меню подокна Instructions
-----------------------------------

     -------------------
     Inspect
     Reverse execute
     -------------------
     Full history    Yes
     -------------------

     Локальное меню подокна Instructions содержит три команды:

Команда Inspect
---------------

     Данная команда  перемещает  вас  к  команде,  высвеченной  в
подокне Instructions.  Если  это  строка  исходного кода,  то она
показана вам  в  окне  Module;  если  исходного  кода   нет,   то
открывается окно CPU, с командами, высвеченными в подокне Code.

Команда Full History

(Выполнение в обратном направлении)
-----------------------------------

     Данная команда реверсирует  выполнение  программы  к  точке,
высвеченной в   подокне  Instructions.  Если  вы  выбрали  строку
исходного кода, то вы вернетесь в окно Module; в противном случае
появляется окно  CPU  с  высвеченной  линейкой  в  подокне  Code,
установленной в позиции команды.

     Предупреждение! Обратное выполнение по части  программцы, по
которой не было прямого выполнения, невозможно. Например, если вы
установили точку останова и нажали  F9  для  выполнения  до  этой
точки, история  выполнения в обратном направлении будет потеряна.
В этом случае, если вы желаете восстановить предыдущее состояние,
вы можете   воспользоваться   средством  воспроизведения  нажатий
клавиш окна Execution History, чтобы перезагрузить вашу программу
и выполнить ее в прямом направлении до данной точки.

     Предупреждение! Команда  INT  приводит  к  потере предыдущей
истории выполнения.  Выполнение  команд  в  обратном  направлении
после данной команды невозможно, если не были нажаты клавиши Alt-
F7 для трассировки прерывания.

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

     IN              INSW
     OUT             OUTSB
     INSB            OUTSW

Команда Full History
-------------------------------------

     Данная команда работает как переключатель вкл/выкл. Если она
установлена в положение On,  то обратная трассировка включена,  в
апротивном случае - выключена.

Подокно Keystroke Recording
(запись нажатий клавиш)   -----------

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

     Запись нажатий  клавиш  работает  в  сочетании  со средством
обратного выполнения   программы,   предоставляя    разнообразные
способы восстановления  нужной  точки  отладки.  Записываются все
нажатия клавиш,  как  те,  что  относятся  к   управлению   Turbo
Debugger, так  и  являющиеся  реакцией  на  действия отлаживаемой
программы. Нажатия клавиш записываются в  файл имя_программы.TDK,
где имя_программы - это имя отлаживаемой программы.

     Нижнее подокно   окна  Execution  History  используется  для
воспроизведения нажатий  клавиш  и  восстановления  точки  сеанса
отладки. Каждая  строка  в  списке  истории выполнения показывает
причину, по которой  Turbo  Debugger  пришлось  взять  управление
(точка останова, трассировка и т.д.) и текущую позицию в исходной
программе в  этот  момент.  Если  адрес  программы  соответствует
строке исходного кода,  то будет выведена эта строка. В противном
случае команда по этому адресу дизассемблируется.

     Параметр командной строки -k включает запись нажатий клавиш.
(См. стр.65    оригинала).    Вы    также    можете    установить
соответствующее умолчание при помощи TDINST.

Локальное меню подокна Keystroke Recording
------------------------------------------

     Локальное меню  подокна  Keystroke  Recording  содержит  две
команды: Inspect и Keystroke Restore.

     ------------------
     Inspect
     Keystroke restore
     ------------------

Команда Inspect
---------------

     Если вы высветили строку в подокне  Keystroke  Recording,  а
затем выбрали  в  локальном  меню команду Inspect,  то появляется
окно Module с курсором в той строке исходного кода, где произошло
нажатие клавиши.

     Если данная строка не соответствует позиции в исходном коде,
то открывается окно CPU с высвеченной позицией команды.

Команда Keystroke Restore
-------------------------

     Если вы  высветили  строку в подокне Keystroke Recording,  и
выбрали команду  Keystroke  Restore,  Turbo   Debugger   повторно
загрузит данную   программу   и   выполнит   их  до  высвеченного
контекста. Это особенно полезно,  если вы выполнили команду Turbo
Debugger, удалившую историю выполнения.


Прерывание выполнения программы
-----------------------------------------------------------------

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

     Кроме того,    прервать    выполнение    программы     может
потребоваться  в том случае,  если по какой-то непонятной причине
управление не возвращается отладчику.  Это может произойти в  том
случае,  когда  выполняемый  фрагмент  кода  содержит бесконечный
цикл: вы установили после этого фрагмента точку останова и ждете,
когда  он будет выполнен,  но эта точка останова никогда не будет
достигнута.

Клавиши Ctrl-Break

     Нажатие этой комбинации клавиш практически  всегда прерывает
выполнение  программы  и возвращает управление отладчику.  Работа
программы прерывается сразу же после нажатия этих клавиш, поэтому
иногда  может  показаться,  что  выполняется неожиданный фрагмент
программы.  Например, это может быть подпрограмма обработки ввода
с  клавиатуры  BIOS,  или команда из выполняемого в данный момент
цикла.  Нажатие клавиш Ctrl-Break не  может  прервать  выполнение
программы  в  следующих двух случаях (в этих случаях вам придется
перезагурзить свою систему):

     - программа   зациклилась   в   режиме,   когда    запрещены
прерывания;

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

     Если вы  отлаживаете  программу,  которой  самой   требуется
реагировать  на  клавиши  Сtrl-Break,  вы можете назначить другую
клавишу прерывания.  Для этого  надо  воспользоваться  программой
TDINST. Клавишей  прерывания  можно  назначить  любую  комбинацию
клавиш.

Завершение работы программы
-----------------------------------------------------------------

     Когда выполнение  программы завершается и происходит возврат
в  DOS,  управление  снова  передается   отладчику.   Он   выдает
сообщение,  показывающее  код  выхода,  который возвращается DOS.
После того,  как  работа  программы  завершилась,  вы  не  можете
выполнить ни одну из команд меню Run, пока не загрузите программу
заново с помощью команды Run/Program Reset.

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

Возобновление сеанса отладки
-----------------------------------------------------------------

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

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

Перезагрузка программы

     Для того   чтобы  заново  загрузить  программу,  которую  вы
отлаживали,  выполните  команду      Run/Program   Reset.   Turbo
Debugger  загрузить  программу  с  диска,  используя  все данные,
которые могли быть добавлены в нее после последнего сохранения на
диске.  Это самый безопасный способ повторного запуска программы.
Перезапуск путем  выполнения  начала  программы  может  оказаться
рискованным,    поскольку    для    многих   программ   требуется
инициализация отдельных  данных,  хранящихся  в  дисковом  файле.
Заметьте, что команда Program Reset оставляет без изменения точки
останова и отслеживаемые переменные.


Запись и воспроизведение нажатий клавиш в макросах

     Для записи последовательности нажатий клавиш,  которая часто
используется при отладке программ,  можно  использовать  макросы.
Например,   во   время   отладки   программы   часто  повторяется
последовательность  команд,  которая   выполняет   программу   до
определенного  места.  Это  может  оказаться  очень  утомительным
занятием.

     Чтобы обойти  эту  проблему,  можно  определить  макрос,   в
котором  будут  "записаны"  все  клавиши,  которые  вы нажимали с
момента  запуска  отладчика  до  того,  как  программа  войдет  в
желаемое  состояние.  В этот момент можно прервать запись нажатий
клавиш.  Если после этого потребуется вернуться к тому же  самому
месту программы,  все, что потребуется сделать, это воспроизвести
записанный макрос.

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

     Для того чтобы записать  весь  сеанс  отладки,  первое,  что
нужно  сделать  после  запуска  отладчика из DOS,  это определить
клавишу для  вызова  макроса.  Для  этого  надо  выбрать  команду
Options/Macros/  Create.  Отладчик  попросит  вас нажать клавишу,
которая будет назначена макросу.  Выберите  клавишу,  которой  не
назначена  какая-то  другая  функция,  например,  Shift и одна из
функциональных клавиш,  скажем Shift-F1.  Теперь выполняйте  свою
программу,  пока  не  обнаружите ошибку.

     В этой  точке  остановите  запись  макроса,  выбрав  команду
Macros/Stop Recording.  Теперь  сохраните  полученный  макрос  на
диске, выбрав команду Options/Save Options. Продолжайте выполнять
свою программу.  После того,  как в работе  программы  произойдет
сбой и вы будете вынуждены перезагрузить ее и Turbo Debugger, вам
достаточно будет нажать клавиши Shift-F1,  чтобы заново запустить
программу.

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

     Примечание: Когда  макрос  записывается в файл конфигурации,
вместе с ним записываются все параметры среды  отладчика, включая
параметры   открытых   окон   просмотра   и   расширенных   окон.
Следовательно, если вы записываете макрос, который открывает окно
просмотра,  и перед сохранением макроса не закрыли это окно, то в
следующий раз, когда вы будете восстанавливать параметры из файла
конфигурации,   это  окно  будет  автоматически  открываться  без
выполнения макроса.

Загрузка в отладчик новой программы
-----------------------------------------------------------------

     Для загрузки в отладчик новой программы надо выбрать команду
File/Open.

     Рис.5.5  Блок диалога Load Program

     Вы можете ввести имя файла  (с  расширением  .EXE)  в  блоке
ввода File Name, либо нажать Enter для активизации блока списка с
именами .EXE-файлов в текущей директории.  Переместите выделяющий
курсор к нужному файлу и нажмите клавишу Enter.

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

     После имени программы можно указать ее аргументы  точно  так
же, как это делается в командной строке DOS:

     myprog a b c

     Эта команда  загрузит  программу  MyProg с тремя аргументами
командной строки: a, b и c.

Изменение аргументов программы
-----------------------------------------------------------------

     Если при загрузке программы вы забыли задать какие-то нужные
аргументы,  вы можете воспользоваться командой Run  |  Arguments,
которая позволяет задавать и изменять аргументы.  Новые аргументы
вводите точно так же,  как если бы вы указывали  их  после  имени
программы в командной строке DOS.

     После того,  как вы введете новые аргументы,  Turbo Debugger
спросит у вас, хотите ли вы перезагрузить свою программу с диска.
Как  правило,  в  таких  ситуациях  следует  отвечать "Да" (Yes),
поскольку в большинстве случаев новые аргументы будут  влиять  на
работу программы только после ее загрузки.
