Отладка программ пользователя в Tubro Pascal
Думаю,
вы не раз сталкивались с тем, что программа отказывалась работать так, как
надо. Часто эти ошибки приводят к тому, что решение задачи заходило в тупик.
Тут и приходят на помощь обширные средства отладки программ Turbo Pascal.
Обычно эти средства используются редко, а зря. Умелая отладка программы
позволяет избежать многих подводных камней и создавать идеальные программы.
Введение.
Turbo
Pascal предлагает сверхусовершенствованную среду, с автоматическим управлением
проектом, модульной организацией программ, высокой скоростью компиляции, с
легко используемыми оверлеями. Но даже используя все эти предоставленные
средства, программы пользователя могут содержать ошибки, которые приводят к
неправильной работе программы.
В
помощь пользователю Turbo Pascal предоставляет средства, необходимые для
отладки его программы, способствующие устранению всех ошибок в программе, ее
тщательному тестированию и выполнению. Turbo Pascal позволяет легко определять
местоположение ошибок во время компиляции и во время выполнения программы, а
также позволяет включать или выключать автоматический контроль ошибок во время
выполнения программы.
Особенно
важно то, что Turbo Pascal имеет мощный и гибкий отладчик исходного уровня,
который позволяет пользователю выполнять программу построчно, просматривать
выражения и модифицировать переменные по мере необходимости. Отладчик встроен в
интегрированную среду разработки (IDE) Turbo Pascal; пользователь может
редактировать, компилировать и отлаживать программу даже не выходя из Turbo
Pascal. Для больших или сложных программ, которые требуют использования всего
диапазона средств отладки от машинного языка до вычисления выражений Паскаля,
Turbo Pascal полностью поддерживает автономный отладчик фирмы Borland, Turbo
Debugger.
Типы ошибок.
Существует
три основных типа программных ошибок: ошибки времени компиляции, ошибки времени
выполнения и логические ошибки.
Ошибки
компиляции.
Ошибки
компиляции или синтаксические ошибки встречаются, когда забывают объявить
переменную, передают ошибочное количество параметров процедуры, при назначении
действительного значения целочисленной переменной. Это означает, что
записываются операторы, которые не согласуются с правилами Паскаля.
Turbo
Pascal не закончит процесс компиляции программы пользователя (генерацию
машинного кода), пока все синтаксические ошибки не будут удалены. Если Turbo
Pascal обнаружит синтаксическую ошибку во время компиляции программы, он
останавливает компиляцию, входит в исходный текст, указывает местоположение
ошибки позиционированием курсора и выводит сообщение об ошибке в окно Edit. Как
только пользователь исправит ошибку, он сможет начать процесс компиляции снова.
Если
используется версия командной строки (TPC.EXE), Turbo Pascal будет выводить
ошибочный оператор, номер строки и сообщение об ошибке. Затем пользователь
может войти в любой используемый им редактор, найти заданную строку, исправить
ошибку и перекомпилировать программу. Для дополнительной информации о
сообщениях об ошибках см. Приложение А в Руководстве программиста.
Ошибки
времени выполнения.
Другой
тип ошибок - ошибки времени выполнения программы или семантические ошибки. Они
встречаются, когда пользователь компилирует синтаксически корректную программу,
которая пытается сделать что-нибудь запрещенное во время ее выполнения,
например, открывает несуществующий файл для ввода или производит деление на 0.
В этом случае Turbo Pascal выводит на экран следующее сообщение об ошибке:
Runtime error ## at seg:ofs (Ошибка выполнения # в сегменте: смещение) и
останавливает выполнение программы пользователя.
При
использовании интегрированной среды Turbo Pascal определяет местоположение
ошибки выполнения автоматически, осуществляя переход в окно редактирования для
соответствующего исходный файл.
Если
пользователь выполняет программу в среде MS-DOS, он будет возвращаться в
MS-DOS. Пользователь может загрузить модуль TURBO.EXE и использовать опции
Search/Find error для локализации позиции ошибки в исходной программе
(убедитесь, что опция Destination установлена в Disk). Для обнаружения ошибки
пользователь может также использовать и опцию /F для компилятора командной
строки (TPC.EXE).
(Более
полное объяснение опций командной строки TPC.EXE приведено в главе 9
"Компилятор командной строки".)
Логические
ошибки.
Программа
пользователя может содержать и логические ошибки. Это означает, что программа
делает то, что ей указали вместо того, что хотелось бы. Может отсутствовать
инициализация переменной; могут оказаться ошибочными вычисления; рисунки,
изображенные на экране, выглядят неправильно; программа может просто работать
не так, как было задумано. Такие ошибки находятся с большим трудом, и
интегрированный отладчик поможет вам в этом случае наилучшим образом.
Интегрированный отладчик Turbo Pascal.
Некоторые
ошибки времени выполнения (логические ошибки) незаметны и трудны для
прослеживания. Другие ошибки могут скрываться за неуловимым взаимодействием
разделов большой программы. В этих случаях необходимо интерактивное выполнение
программы, во время которого производится наблюдение за значениями определенных
переменных или выражений. Вам хотелось бы, чтобы Ваша программа останавливалась
при достижении определенного места так, чтобы просмотреть, как она проработала
этот кусок. Вам хотелось бы остановиться и изменить значения некоторых
переменных во время выполнения программы, изменить определенный режим или
проследить за реакцией программы. И вам хотелось бы сделать это в режиме, когда
возможно быстрое редактирование, перекомпилирование и повторное выполнение
программы.
Интегрированный
отладчик Turbo Pascal имеет все описанные выше возможности и даже более того.
Он представляет собой встроенную часть интегрированной усовершенствованной
среды Turbo Pascal (IDE): для использования предлагаются две основные функции
меню (Run, Debug), а также некоторые клавиши для команд отладчика. Для
дополнительной информации об IDE горячих клавишах см. главу 7 "Справочник
по IDE" или справочную информацию о Turbo Pascal.
Что
может делать отладчик.
Интегрированный
отладчик работает очень просто. Ему не требуются специальные инструкции в Вашем
коде, он не увеличивает размер Вашего .EXE файла и не требует перекомпиляции
для создания отдельного .EXE файла после окончания отладки.
Если
Ваша программа разделена на ряд модулей, исходный код каждого из них
автоматически загружается в редактор при трассировке.
Если
Вы используете оверлеи, отладчик автоматически обрабатывает их внутри IDE,
которая выполняет переключения между компилятором, редактором и отладчиком.
Обзор
возможностей отладчика:
Трассировка.
F7
Run/Trace
Into Вы можете выполнить одну строку вашей программы, затем прерваться и
посмотреть на результаты. При вызове процедуры или функции внутри вашей
программы, Вы можете задать режим выполнения вызова как одного шага или режим
трассировки этой процедуры или функции строка за строкой.
Вы
можете так же трассировать вывод Вашей программы строка за строкой. Вы можете
так же установить, чтобы экран переключался по необходимости или использовать
два монитора. Вы можете так же установить экран вывода в отдельном окне.
Переход
на курсор. F4
Run/Go
to Сursor Вы можете передвинуть курсор на определенную строку в Вашей
программе, а затем указать отладчику выполнить программу до достижения этой
строки. Это позволяет обходить циклы или другие утомительные участки программы,
это также позволяет перебираться в то место программы, откуда Вы хотите начать
отладку.
Прерывание.
С
помощью команды Debug/Breakpoints Вы можете пометить строки в Вашей программе
как точки прерывания. Когда в процессе выполнения Вашей программы достигается
точка прерывания, выполнение программы приостанавливается и отображается
исходный текст и курсор останавливается на строке с точкой прерывания. Затем Вы
можете проверить значения переменных, начать трассировку или выполнить
программу до другой точки прерывания. Вы можете подключить условие к точке
прерывания. Вы можете также прерваться в любой точке Вашей программы, нажав
клавишу Ctrl-Break. Произойдет остановка на следующей строке исходной
программы, как если бы в этой строке была установлена точка прерывания.
Наблюдение.
Debug/Watches
Пользователь имеет возможность задавать для просмотра в окне Watch некоторые
объекты (переменные, структуры данных, выражения). Просматриваемые данные
меняются, отражая текущие изменения в программе при пошаговом выполнении.
Вычисление/модификация
Ctrl-F4.
Debug/Evaluate/Modify
Пользователь может вызвать окно Evaluate, что проверить значения переменных,
структуру данных и выражения в интерактивном режиме. Используя окно Evaluate,
Вы можете изменить значение любой переменной, включая строки, указатели,
элементы массива и поля записей. Это обеспечивает простой механизм для
проверки, как Ваш код реагирует на определенную установку значений или условий.
Поиск.
Пользователь
может быстро находить объявления процедур или функций, даже если программа
разбита на несколько модулей (Search/Find Рrocedure). Во время трассировки Вы
можете быстро вернуться обратно из вызовов процедур или функций и проверить
параметры каждого вызова (Window/Call Stack).
Подготовка
к использованию отладчика.
До
начала отладки Вы должны понимать, что основным элементом выполнения в
отладчике является строка, а не оператор. Более точно наименьшим элементом
выполнения является строка. Если на одной строке находится несколько
операторов, они будут выполняться вместе при нажатии F7. С другой стороны, если
один оператор размещен на нескольких строках, то при нажатии F7 будет выполняться
весь оператор. Все команды выполнения основываются на строках, включая
пошаговую отладку и точки прерывания; строка, на которой находится выполнение,
всегда отмечена курсором выполнения.
Прежде,
чем начать отладку программы, Вы должны задать для компилятора Turbo Pascal
инструкцию по генерации таблицы символов и таблицы номеров строк этой
программы. Таблица символов представляет собой небольшую базу данных со всеми
используемыми идентификаторами - константами, типами, переменными, процедурами
и информацией о номерах строк. Директивы компилятора $D+ и $L+ делают это по
умолчанию; они соответствуют элементам меню Options/Compiler/Debug Information
и Options/Compiler/Local Symbols. Так же по умолчанию установлена опция
Options/Debugger/Integrated, которая генерирует отладочную информацию в
выполнимом файле.
Директива
{$D+} генерирует таблицу номеров строк, которая устанавливает соответствие
между объектным кодом и исходным модулем. Директива {$L+} генерирует локальную
отладочную информацию, а именно, строит список идентификаторов, локальных для
каждой процедуры или функции, для того, чтобы отладчик мог хранить информацию о
них в процессе отладки. Когда Вы используете директивы компилятора, разделяйте
их запятыми и без пробелов, и ставя $ только перед первой директивой; например
{$D+,L+}.
Примечание:
Вы можете отключить эти переключатели для сохранения памяти или дискового
пространства во время компиляции.
Когда
Вы выполняете пошаговую отладку, Turbo Pascal будет иногда переключаться на
экран пользователя, выполнять Ваш код, а затем возвращаться в интегрированную
среду, ожидая следующей команды. Вы можете управлять переключением экрана с
помощью установок Options/Debugger/Display Swapping, которые могут принимать 3
значения:
Smart:
Это режим по умолчанию. Среда IDE переключается на экран пользователя, когда
программа обращается к видеопамяти или при вызове программы.
Always:
Переключение на экран пользователя происходит на каждом шаге.
None:
Переключение экранов не происходит. Интегрированная среда остается видимой все
время. Если в программе предусматривается вывод на экран или требуется ввод
информации, текст будет писаться на экране среды. Вы можете восстановить окна
интегрированной среды, выбирая Ё/Refresh Display.
Начало
сеанса отладки.
Наиболее
быстрый способ начать отладку состоит в загрузке программы и выборе команды
Run/Trace Into (F7). Программа будет компилироваться. Когда компиляция
завершится, редактор отобразит на дисплей тело основной программы с индикацией
строки выполнения на первом операторе begin. Пользователь может начать
трассировку программы с этого места (нажать клавиши F7 или F8) или использовать
другие методы которые приведены ниже.
Если
пользователю необходимо начать отладку с определенного места программы, он
может выполнить программу до этого места, а затем остановиться. Для этого,
загрузите нужный раздел исходного модуля в редактор и передвиньте курсор на
строку, где Вы желаете остановиться. Затем можно поступить двумя способами:
-
Выбрать команду Run/Goto Cursor (или нажать клавишу F4), которая будет
выполнять программу пользователя до достижения строки, помеченной курсором, а
затем останавить работу программы.
-
Задать на указанной строке точку прерывания (выбрать команду Debug/Toggle
Breakpoint или нажать на Ctrl-F8), затем выполнить программу (выполнить команду
Run/Run или нажать Ctrl-F9); остановка будет происходить каждый раз при
достижении заданной строки. Вы можете задать несколько точек прерывания, в этом
случае программа будет делать остановку всякий раз при достижении какой-либо из
этих точек.
Рестарт
сеанса отладки.
Если
в процессе отладки программы возникает необходимость начать все сначала, то
нужно выполнить команду Program Reset из меню Run. Система отладки повторно
инициализируется, и команда следующего шага вернет вас к первой строке главной
программы. При этом производится закрытие всех файлов, которые были открыты
программой, очистка стека всех вложенных программ, которые вызывались
программой, и освобождение всего использованного пространства кучи. Переменные программы,
однако, не будут повторно инициализированы или подвержены модификации
какого-нибудь другого вида. (Turbo Pascal никогда не инициализирует переменные
автоматически). Однако, начальные значения типированных констант программы
будут восстановлены.
Turbo
Pascal также предлагает рестарт, если Вы производите какие-либо изменения в
программе во время отладки. Например, если Вы изменяете часть программы, а
затем выбираете любую команду выполнения (нажимаете клавиши F7, F8, F4, Ctrl-F9
и т.д.), Вы получите сообщение : Source modified, rebuild? (Y/N) (исходный
модуль модифицирован, нужно повторить сборку? да/нет ). Если Вы отвечаете Y,
Turbo Pascal будет перекомпилировать программу и возобновит отладку программы с
начала. Если Вы ответите N, Turbo Pascal предполагает, что Вы уверены в своих
действиях, и продолжает сеанс отладки дальше. (Любые изменения в программе,
которые Вы произвели, не будут влиять на ее выполнение до тех пор, пока Вы не
перекомпилируете программу). Если Вы добавили или удалили строки программы,
курсор выполнения не реагирует на эти изменения, и может оказаться, что будет
выделяться ошибочная строка.
Окончание
сеанса отладки.
В
процессе отладки программы Turbo Pascal хранит трассу того, что Вы делаете и
где находитесь в данный момент. Так как пользователь может в процессе отладки
загружать и даже редактировать различные файлы, Turbo Pascal не интерпретирует
загрузку другого файла в редактор, как конец сеанса отладки. Поэтому, если вы
желаете выполнить или отладить другую программу, нужно выполнить команду
Run/Program Reset (клавиша Ctrl -F2).
Трассировка Вашей программы.
Простейшая
техника отладки - это пошаговая отладка, которая трассирует внутри процедур и
функций. Загрузите программу RANGE.PAS в Turbo Pascal.
{$D+,L+}
{Для
того, чтобы обеспечить
полную
генерацию отладочной информации}
{$R-}
{Для того, чтобы отключить проверку диапазона}
program RangeTest;
var
List:array [1..10] of integer;
Indx:integer;
begin
for Indx:=1 to 10 do
List[Indx]:=Indx;
Indx:=0;
while (Indx
begin
Indx:=Indx+1;
if List[Indx]>0 then
List[Indx]:=-List[Indx]
end;
for Indx:=1 to 10 do
writeln(List[Indx]);
end.
Начните
отладку, нажав клавишу F7. Это пошаговая команда. Turbo Pascal произведет
компиляцию автоматически, а затем подготовится к пошаговой обработке этой
программы. Заметим, что курсор выполнения расположен на операторе begin (строка
7). Помните, что курсор выполнения помечает следующую строку программы, которая
должна быть выполнена.
Нажмите
клавишу F7 несколько раз. Курсор выполнения переместится на оператор
List[Indx]:=Indx и остановится. Это значит, что строка выполняется в цикле.
Выберите
команду Debug/Watches/Add Watch (Ctrl-F7) для просмотра в окне Add Watch. Вы
можете просматривать значения переменных, структур данных или выражений в окне
Watch.
То,
что появится в окне Add Watch зависит от того, где располагается курсор, когда
Вы нажимаете на клавишу Ctrl-F7. Если курсор расположен на первой букве любой
алфавитно-цифровой строки, внутри строки или сразу за ней, строка будет
копироваться в окно Add Watch и подсвечиваться. Так, если курсор был
спозиционирован на слове Indx, то Indx появится в окне. Если в окне необходимо
что-либо изменить, начните набор на клавиатуре и первоначальное выражение и
подсветка исчезнут.
Как
только появится окно Add Watch, независимо от его содержимого, можно добавить в
него текст, если нажать клавишу Ў (которая копирует дополнительный текст из
редактора). Поместите List в окно, используя Ў, и нажмите Enter. Тогда в окне
Watch в нижней части экрана появится строка:
List
: (1,2,0,0,0,0,0,0,0,0)
Cнова
нажмите клавишу Ctrl-F7, наберите слово Indx и нажмите Enter. Indx будет первым
в списке в окне Watch:
Indx
: 3
List
: (1,2,0,0,0,0,0,0,0,0)
Нажмите
клавишу F7 снова и Вы увидите, что значения Indx и List в окне Watch изменятся,
отражая работу Вашей программы.
Как
только Вы войдете в цикл while, Вы снова увидите, что значения Indx и List
изменяются шаг за шагом. Заметим, что эти изменения в окне Window отражают
действия каждой строки цикла после нажатия клавиши F7.
Продолжайте
нажимать на клавишу F7, пока не достигнете начала цикла while, c Indx равным
10. Во время прохождения через цикл, Вы можете наблюдать как изменяются
значения в окне Watch. Когда выполняется оператор
List
[ Indx ] := - List [ Indx ];
значение
Indx изменится на -11. Если Вы продолжаете нажимать на F7, то обнаружится, что
вы вошли в бесконечный цикл.
Таким
образом, если Вы наберете такую программу, она будет компилироваться и
выполняться. Получается бесконечный цикл, так как цикл while выполняется 11
раз, а не 10, и последнее значение переменной Indx равно 11. Так как массив
List содержит только 10 элементов, значение List(11) будет указывать на
некоторую позицию памяти вне массива List. Из-за способа распределения переменных
уже окажется, что значение List(11) займет в памяти тоже место, что и
переменная Indx. Это значит, что при Indx=11, запись:
List
[Indx] := - List [Indx]
идентична
записи
Indx
:= -Indx.
Так
как значение переменной Indx равно 11, этот оператор изменит ее значение на
-11. В результате в программе начнется повторное выполнение цикла. Этот цикл
теперь изменяет дополнительные байты в месте, соответствующем List[-11..0]. И
т.к. значение Indx никогда не будет заканчивать цикл со значением большим или
равным 11, то цикл никогда не закончится.
Важно
отметить то, что используя лишь две клавиши (F7 и Ctrl - F7), через несколько
минут, Вы быстро и легко прослеживаете промежуточные значения переменных и
находите ошибку.
Пошаговое
выполнение программы.
Различие
между командами Trace Into (F7) и Step Over (F8) в том, что при использовании
F7 осуществляется трассировка внутри процедур и функций, в то время как
использование F8 приведет к обходу вызовов подпрограмм. Эти команды имеют
особое значение при выполнении оператора begin основной программы, если
программа использует модули, имеющие раздел инициализации. В этом случае,
использование F7 приведет к трассировке раздела инициализации каждого модуля,
что позволяет увидеть, что инициализируется в каждом модуле. При использовании
F8 эти разделы не будут трассироваться, и курсор выполнения переходит на
следующую строку после begin.
Рассмотрим
следующий (неполный) пример программы:
($D+,L+)
program TestSort;
const
NLMax=100;
type
NumList=array[1..NLMax] of integer;
var
List : NumList;
I,Const : word;
procedure Sort ( var L:NumList;
Cnt:Integer);
begin
(sort the list) (сортировка списка)
end; (of proc sort) (процедуры Sort)
begin
randomize;
Count:=NLMax;
for I:=1 to Count do
List[I] := Random(1000);
sort(List,Count);
for I:=1 to Count do
Write(List[I] :8);
Readln
end.
{программы TestSort}
Предположим,
что Вы отлаживаете процедуру Sort. Вы хотите осуществить трассировку процедуры
Sort, включая проверку значения внутри List до вызова Sort. Однако, выполнять
100 раз инициализацию внутри List очень утомительно. Есть ли способ выполнять
цикл, не останавливаясь на каждой выполняемой строке.
Да,
фактически, существует несколько способов. Во-первых, Вы могли бы выделить этот
цикл в отдельную процедуру и нажать клавишу F8 для того, чтобы обойти ее
трассировку, но это слишком нерационально. Во-вторых, Вы могли бы установить
внутри программы точку прерывания. Мы объясним, что это за точки прерывания, и
как они используются немного позже. В конце концов, Вы могли бы использовать
команду Run/Go to Cursor (F4). Переместите курсор на строку с вызовом Sort, а
затем нажмите на клавишу (F4). Ваша программа будет выполняться до достижения
строки, помеченной курсором. Курсор выполнения переместится на эту строку; затем
Вы можете начать трассировку с этого места, нажимая на клавишу F7, для того,
чтобы можно было сделать трассировку внутри Sort.
Команда
Run/Goto Cursor (F4) действует на вложенных уровнях вызовов подпрограмм, даже
если их исходный код находится в другом файле. Например, Вы могли бы разместить
курсор где-либо внутри процедуры Sort и нажать на клавишу F4; программа
выполнялась бы до этой строки. По существу, Sort могла бы быть выделена в
отдельный модуль, отладчик бы уже знал, когда нужно остановиться и что
отобразить.
Существуют
три случая, когда команда Go to Cursor (F4) не будет выполнять программу до
отмеченной курсором строки.
Первый,
когда Вы расположили курсор между двумя выполняемыми строками; например, на
пустой строке или строке с комментариями. В этом случае программа будет
выполняться до следующей строки, содержащей оператор, который может быть
выполнен.
Второй
случай, когда курсор расположен вне процедурного блока, например, на операторе
объявления переменной или операторе program. Отладчик будет выводить сообщение
"no code generated for this line" (для этой строки код не
генерируется).
Третий
случай, когда Вы располагаете курсор на строке, которая никогда не выполняется.
Например, строка располагается выше курсора выполнения (предполагается, что вы
находитесь не в цикле) или строка является частью else - условного оператора,
когда выражение if имеет значение true. В этом случае отладчик будет
действовать так, как если бы выполнялась команда Run/Run (Ctrl-F9); программа
будет выполняться до конца или до точки прерывания.
Предположим,
что Вы трассируете процедуру Sort,затем хотите завершить работу программы и
посмотреть выходные результаты. Каким способом сделать это? Сначала нужно
переместить курсор к последнему оператору end основной части программы, а затем
выполнить команду Run/Go to Cursor (F4). Или проще, нужно выполнить команду
Run/Run (Ctrl-F9). Она позволяет отладчику продолжить нормальное выполнение
программы пользователя. Программа будет выполняться до конца, или до тех пор,
пока Вы не достигнете точки прерывания или не будет нажат Ctrl-Break.
Использование
точек прерывания.
Точки
прерывания являются важным инструментом отладки. Точка прерывания подобна знаку
остановки, введенному в программу пользователя. Когда программа встречает такую
точку, она останавливает свое выполнение и ожидает дальнейших отладочных
инструкций.
Примечание:
Вы можете иметь до 16 активных точек прерывания.
Заметим,
что точки прерывания существуют только во время сеанса отладки; они не
сохраняются в файле .EXE, если программа компилируется на диск. Чтобы задать
точку прерывания, используйте обычные команды редактирования для перемещения
курсора на каждую строку программы, где Вы хотите сделать паузу. Каждый раз
выполняйте команду Debug/Toggle Breakpoint (Ctrl-F8). Когда строка отмечается
как точка прерывания, она высвечивается. Это не должна быть пустая строка,
комментарии, директивы компиляции; объявления констант, типов, меток,
переменных; заголовком программы, модуля, процедуры или функции. Как только Вы
задали точки прерывания, выполняйте программу с помощью команды Run/Run
(клавиша Ctrl-F9). Сначала программа будет выполняться нормально. Когда
встретится точка прерывания, программа остановится. Соответствующий исходный
файл (основная программа, модуль или включенный файл) загружается в окно Edit,
которое визуализируется на экране и курсор выполнения помещается на строку с
точкой прерывания.
Заметим,
что точка прерывания не высвечивается, когда на ней находится курсор
выполнения. Если какие-либо переменные или выражения были добавлены в окно
Watch, то они также выводятся на дисплей со своими текущими значениями.
Затем,
пользователь может использовать любой режим отладки.
Вы
можете осуществлять пошаговое выполнение программы, используя команду Run /
Trace Into, Step Over или Go to Cursor (F7, F8 или F4). Вы можете проверить или
изменить значения переменных.
Вы
можете добавить или удалить выражения из окна Watch.
Можно
назначить или удалить точки прерывания.
Можно
просмотреть выходные результаты программы, используя команду Windows/User
Screen (Alt-F5).
Вы
можете перезапустить программу сначала ( Run/Program Reset и, затем, команду
пошагового выполнения).
Можно
продолжить выполнение до следующей точки прерывания (или до конца программы),
выполнив команду Run/Run (Ctrl-F9).
Для
удаления точки прерывания из строки переместите курсор на данную строку и,
выполнив команду Debug/Toggle Breakpoint (или нажмите Ctrl-F8) еще раз. Эта
команда включает или отключает точку прерывания в строке; если она используется
для строки с точкой прерывания, то строка становится нормальной.
Давайте
вернемся к примеру, который был рассмотрен ранее.
begin
{основная часть программы Test.Sort}
Randomize;
Count := NLMax;
for I := 1 to Count do
List [I] := Random (1000);
Sort ( List,Count );
for I := 1 to Count do
Write ( List [I] : 8 );
Readln
end. {программа Test.Sort}
Как
уже говорилось, идея была в том, чтобы обойти первоначальный цикл и начать
трассировку с вызова процедуры Sort. Новый вариант. Передвиньте курсор на строку
с вызовом процедуры и выполните команду Debug/Toggle Breakpoint ( Ctrl-F8),
которая отметит строку, как точку прерывания. Теперь выполните программу до
этой точки, используя команду Run/Run (Ctrl-F9 ). Когда программа достигнет
этой строки, она остановится и позволит Вам начать отладку.
Использование
Ctrl-Break.
Кроме
назначения точек прерывания, пользователь может сделать немедленную остановку
во время выполнения программы, используя клавишу Ctrl-Break. Это означает, что
можно прервать работу программы в любое время. Когда Вы нажимаете на клавишу
Ctrl-Break, выполнение программы прекращается. Вы возвращаетесь в редактор,
курсор выполнения расположен на следующей строке программы, и программа готова
к дальнейшему пошаговому выполнению.
Фактически,
отладчик автоматически подключает DOS, BIOS и другие сервисные функции. Он
знает, является ли текущий выполняющийся код программой DOS, программой BIOS
или программой пользователя. Когда Вы нажимаете на клавишу Ctrl-Break, отладчик
ждет, пока программа выполняется сама. Затем он делает пошаговое выполнение
инструкций машинного уровня, пока следующая инструкция не будет в начале строки
исходного кода на Паскале. С этого момента отладчик прекращает работу,
перемещает курсор выполнения на эту строку и предлагает Вам нажать на клавишу
ESC.
Примечание:
Если пользователь нажимает на клавишу Ctrl-Break второй раз еще до того, как
отладчик находит и отображает следующую строку исходного кода для выполнения,
то отладчик завершает работу и не пытается найти строку исходного кода. В этом
случае, процедуры выхода не выполняются, что означает, что файлы, видеорежим и
распределение памяти DOS могут быть не полностью очищены.
Просмотр
значений.
Выполнение
программы предоставляет много информации, но не в том объеме, как хотелось бы.
Может возникнуть необходимость просмотреть за тем, как изменяются значения
переменных во время выполнения программы. Рассмотрим процедуру Sort из
предыдущей программы:
procedure
Sort ( var L : NumList; C : word );
var
Top,Min,k : word;
Temp : integer;
begin
for Top := 1 to C-1 do
begin
Min := Top;
for k := Top+1 to C do
if L[k] Top then
begin
Temp := L[Top];
Top := L[Min];
L[Min] := Temp;
end;
end;
end;
{процедуры Sort}
Примечание:
Измените NLMax в теле программы на 10 так, чтобы Вы могли работать с меньшим
массивом.
В
этой процедуре есть ошибки, будем просматривать ее (используя команду Run/Trace
Into или клавишу F7) и наблюдать за значениями переменных L, Top, Min и k.
Отладчик
дает возможность пользователю задать объекты для просмотра во время выполнения
Вашей программы. Как Вы и предполагаете, объектами просмотра являются
переменные, структуры данных и выражения, расположенные в окне Watch, где
отображаются их текущие значения, обновляемые по мере выполнения каждой строки
программы. Давайте вернемся к предыдущему примеру. Установить объекты
наблюдения просто.
Передвигайте
курсор к каждому идентификатору и выполняйте команду Debug/Watch/Add Watch
(Ctrl -F7) для добавления каждого выражения в окно Watch.
Результат
может выглядеть так:
k
: 21341
Min
: 51
Top
:21383
L
: (163,143,454,622,476,161,850,402,375,34)
Предполагается,
что Вы только что вошли в процедуру Sort, курсор выполнения расположен на
начальном операторе begin. (Если Вы еще не вошли в процедуру Sort, то для
каждого выражения в окне Watch будет появляться сообщение "unknown
identifier" (неизвестный идентификатор), пока Вы не войдете в процедуру).
Заметим, что переменные K, Min и Top имеют произвольные значения, т.к. они еще
не были инициализированы. Значения переменной L, предположительно, тоже должно
быть произвольным; они не будут таковыми при выполнении всей программы; все они
должны быть неотрицательными и лежать в интервале от 0 до 999.
Если
нажать на клавишу F7 четыре раза, то мы продвинемся к строке if L[k]Top then,
назад к вершине внешнего цикла, и снова вниз к строке if L[k]
k
: 3
Min
: 2
Top
: 2
L
: ( 34,143,454,622,476,161,850,402,375,34 )
Теперь
Вы можете заметить две вещи. Первое, последнее значение переменной L(34),
которое является также и наименьшим значением, скопировалось в первое значение
L, и значение, которое уже было там раньше (163), исчезло. Второе, переменные
Min и Top имели одинаковые значения во время трассировки процедуры. Фактически,
Вы можете заметить, что переменная Min получает значение переменной Top, но она
никогда не изменяется где-либо еще. Однако, ниже цикла располагается проверка:
if
MinTop then.
Или
эта проверка ошибочна, или существует какое-то несоответствие между этими двумя
частями процедуры. Оказывается, ошибочна пятая строка программы. Она должна
выглядеть так:
Min
:= k, вместо L[Min] := L[k].
Исправьте
строку, переместите курсор к первоначальному оператору begin в процедуре Sort и
выполните команду Run/Go to Cursor (F4). Так как Вы изменили программу, на
экране появится окно с вопросом Source modified, rebild? (Y/N) (исходный модуль
модифицирован, нужна ли сборка? Да/Нет). Ответьте Y. Программа будет
перекомпилироваться, начнется ее выполнение, затем произойдет остановка на
начальном операторе begin процедуры Sort. Теперь программа работает верно.
Значение первого элемента теперь не меняется на наименьшее из значений
элементов массива L, происходит обмен-перемещение значения первого элемента
массива на место, где до этого располагался элемент с наименьшим значением.
Затем процесс повторяется со второй позицией, третьей и т.д., пока список
элементов не будет отсортирован полностью.
Список литературы
Для
подготовки данной работы были использованы материалы с сайта http://bestcode.org/