Ошибки в программировании. Примеры ошибок в языке Паскаль
Ошибки в
программировании бывают двух типов:
синтаксические и логические. Синтаксические
ошибки это неправильное написание
ключевых слов и символов языка
программирования. Все виды синтаксических
ошибок могут быть найдены компьютером
в 99 % случаев.
Логические ошибки
связаны с неправильной программной
реализацией логики алгоритма. В 99 %
случаев компьютер будет выполнять
программу, но результат работы будет
неправильный.
Примеры синтаксических
ошибок в языке Паскаль и их исправление:
1)
Не поставлена точка с запятой. После
пуска программы, нажатием клавиш
<Ctrl>+<F9>, в верхней строке экрана
появится написанное красным цветом
сообщение:
Error 85: «;»
expected.
(Ошибка 85: «;»
отсутствует.)
Редактор
установит курсор на следующий символ
после пропущенного знака. После нажатия
любой клавиши, сообщение об ошибке
исчезает, и редактор переходит в режим
вставки. Надо подвести курсор к нужному
месту, поставить точку с запятой — “;”
и продолжить работу.
2)
В описании переменных не записана
переменная, а в программе она присутствует.
После пуска программы, будет выдано
сообщение:
Error 3: Unknown identifier.
(Ошибка 3: Неизвестный
идентификатор.)
Курсор
будет установлен на эту переменную.
Надо исправить ошибку, т.е. записать
переменную в раздел описаний переменных
и продолжить работу.
3)
Не поставлена точка после оператора
end в конце программы. Сообщение компилятора
будет таким:
Error 10: Unexpected end of
file.
(Ошибка 10: Неправильный
конец файла.),
Курсор
установится на букву «e» в слове
«end». Надо поставить точку и снова
выполнить программу.
Выполнение программы. Ключевые кнопки
После
того, как программа набрана, можно
попробовать ее выполнить.
Для
этого нажимаем клавиши <Ctrl>+<F9>
(удерживая клавишу <Ctrl>, нажать
клавишу <F9>). Эту же операцию можно
выполнить, перейдя в основное меню,
нажав клавишу <F10>, а затем перемещением
указателя выбрать опцию Run и нажать
клавишу <Ввода>.
Теперь надо найти
в новом меню опцию RUN (пуск) и нажать
клавишу <Ввод>.
Если
не было ошибки при вводе текста, то,
спустя несколько секунд, произойдет
смена изображения на экране. Турбо
Паскаль предоставляет экран в распоряжение
работающей программы пользователя.
Такой экран называется окном
программы.
После
завершения прогона (работа программы
часто называется ее прогоном) на экране
вновь появится окно редактора с
текстом программы. Если Вы не успели
разглядеть изображение окна программы,
то нажмите Alt-F5. При этом окно редактора
скроется
и вы сможете увидеть результаты работы
программы. Чтобы вернуть экран в режим
воспроизведения окна редактора, надо
нажать на любую клавишу.
Первые ошибки и их исправление
1.
Не поставлена точка с запятой, например,
после оператора readln(a). После пуска
программы, нажатием клавиш <Ctrl>+<F9>,
в верхней строке экрана появится
написанное красным цветом сообщение:
Error 85: «;»
expected.
(Ошибка 85: «;»
отсутствует.)
Редактор
установит курсор на следующий символ
после пропущенного знака, в нашем
примере на переменную b. После нажатия
любой клавиши, сообщение об ошибке
исчезает и редактор переходит в режим
вставки. Надо подвести курсор к нужному
месту, поставить точку с запятой — “;”
и продолжить работу.
2.
В описании переменных не записана
переменная, а в программе она присутствует,
например переменная c. После пуска
программы, будет выдано сообщение:
Error 3: Unknown identifier.
(Ошибка 3: Неизвестный
идентификатор.)
Курсор
будет установлен на эту переменную, в
нашем примере на переменную c. Надо
исправить ошибку, т.е. записать переменную
c в раздел описаний переменных и продолжить
работу.
3.
Не поставлена точка после оператора
end в конце программы. Сообщение компилятора
будет таким:
Error 10: Unexpected end of
file.
(Ошибка 10: Неправильный
конец файла.),
курсор
установится на букву «e» в слове
«end». Надо поставить точку и снова
выполнить программу.
Помощь
в “PASCAL”.
В Турбо Паскаль
имеется справочная служба, охватывающая
все возможные вопросы по написанию
программ. Главное – это подсказки по
ключевым словам языка.
Меню
опции HELP
CONTENTS.
Выводит на экран содержание справочной
службы.
INDEX.
Выводит на экран алфавитный список всех
ссылок справочной службы. Вызывается
из редактора командой Shift-F1.
TOPIC
SEARCH.
Осуществляет поиск в окрестности курсора
зарезервированного слова или имени
стандартной процедуры (функции) и дает
соответствующую справку. Вызывается
из редактора командой Ctrl-F1.
PREVIOUS
TOPIC.
Выводит на экран предыдущее справочное
сообщение. Вызывается из редактора
командой Alt-F1.
HELP
ON
HELP.
Дает справку о том, как пользоваться
справочной службой. Отметим, что в
сообщениях справочной службы все
перекрестные ссылки выделяются цветом.
Вы можете подвести к любой из них
указатель мыши и двойным нажатием на
ее левую кнопку вызвать на экран
соответствующее справочное сообщение
(или сместить к ней указатель с помощью
клавиш перевода курсора и нажать Enter).
FILES.
С помощью этой опции Вы можете установить
нужные файлы справочной службы.
COMPILER
DIRECTIVES.
Показывает справку о директивах
компилятора.
RESERVED
WORDS.
Показывает справку о зарезервированных
словах.
STANDARD
UNITS.
Показывает справку о стандартных
модулях.
TURBO
PASCAL
LANGUAGE.
Показывает справку о языке Турбо Паскаль.
ERROR
MESSAGES.
Показывает справку о сообщениях об
ошибках.
ABOUT.
Выводит информацию об авторских правах
и версии Турбо Паскаля.
Лекция №7
Процедуры. Программирование рекурсивных
алгоритмов.
Дедуктивный
метод программирования
Программист
должен видеть в целом программу, которая
решает какую-то задачу, а потом разбивает
ее на отдельные части, составляет на
выбранном языке программирования эти
части программы, объединяет их в единое
целое и получает программу.
Итак,
весь творческий процесс можно разбить
(разумеется, чисто условно) на следующие
этапы:
1) основная идея
решения задачи;
2) общая конструкция
программы;
3)
выделение отдельных, элементарных
частей программы;
4)
практическая реализация на языке
программирования этих частей программы;
5)
объединение их в единую программу.
Такой
процесс программирования называют
структурным или нисходящим. Более
подробно с этим процессом мы познакомимся
позже, когда изучим хотя бы основы языка
программирования, но об отдельных
частях, «кирпичиках», составляющих
программу узнаем на этом занятии.
Подпрограммой
называется группа операторов, к которой
обращаются из основной программы
несколько раз. Иногда это может быть 2,
3 раза, а очень часто, каждый раз из
выполняемого цикла основной программы.
Вполне
понятно, что писать несколько раз
одинаковые группы операторов трудно,
проделывается много «технической»
работы, а в некоторых случаях просто
невозможно (если обращаться приходиться
каждый раз при выполнении цикла).
Для
облегчения такой работы и созданы
подпрограммы.
Использование
подпрограмм позволяет:
1)
сделать основную программу более
наглядной и компактной;
2) уменьшить объем
используемой памяти ЭВМ;
3) сократить время
отладки программы.
На
языке Паскаль подпрограммы
бывают двух видов, — это процедуры и
функции.
Процедуры
Рассмотрим
следующий простой пример, с помощью
которого попробуем разобраться в
конструкции процедур на Паскале.
Пример.
Составить программу, которая бы проверяла,
являются ли три числа взаимно простыми.
Мы
знаем, что числа называются взаимно
простыми, если их наибольший общий
делитель (НОД) равен 1. Значит, для решения
этой задачи нам придется дважды находить
НОД чисел. Если заданы три числа: a, b, c,
то найти НОД(a, b), а затем найти НОД(НОД(a,
b), c).
Дважды
писать операторы для нахождения НОД
нам не хочется, поэтому оформим операторы
для НОД в виде процедуры.
Посмотрите,
как это будет выглядеть в программе:
Program Problem1;
var
a, b, c, k : integer;
{———————————————————————————}
Procedure nod(a, b :
integer; var n : integer);
var
r
: integer;
begin
repeat
r := a mod b;
a := b; b := r
until
b = 0;
n := a
end;
{———————————————————————————}
begin
write(‘Введите
три натуральных числа ‘); readln(a,
b,
c);
nod(a,
b,
k);
a
:= k;
b
:= c;
nod(a,
b,
k);
if
k
= 1 then
writeln(‘Числа
взаимно простые’)
else
writeln(‘Числа не взаимно простые’)
end.
В
разделе описаний, после описания
переменных, записывается заголовок
процедуры: Procedure
Это
слово является служебным и зарезервировано
в Паскале. В одной строке с ним, через
пробел, записывается имя процедуры,
которое должно удовлетворять всем
требованиям, предъявляемым к именам,
основными из которых являются: начинаться
с буквы и не иметь пробелов, т. е.,
требования такие же, как и к имени
программы (имя нашей процедуры — nod):
Procedure
nod(a,
b
: integer;
var
n
: integer);
Далее,
в скобках, записываются имена переменных
и их типы, значения которых будут
вводиться
в процедуру из основной программы, в
нашем случае, их две (a, b) и они имеют тип
integer.
Сразу
надо заметить, что имена этих переменных
могут не совпадать с именами переменных
в основной программе, скажем мы могли
их обозначить m, n или любыми другими
именами.
После
точки с запятой и зарезервированного
слова var, записываются переменные и их
типы, значения которых будет являться
результатом работы процедуры и выводятся
из нее в основную программу. Такая
переменная в нашем примере одна — n. Она
выведет значение НОД чисел a и b. Ее имя
также может иметь одноименное в основной
программе и это нисколько не отразится
на работе процедуры.
Обратите
внимание,
что перед переменными, значения которых
вводятся
из основной программы, не ставится слово
var, а перед переменной, значение которой
выводится
в основную программу, это слово записано.
Это очень важное обстоятельство!
Так,
если поставить var перед a и b, то компилятор
будет воспринимать эти переменные как
выходные и вводимые для них значения
воспринимать не будет, и, наоборот, если
var не будет записано перед выходной
переменной, то компилятор воспримет ее
как входную и выводить ее значение в
основную программу не будет.
Дальнейшее
построение процедуры строится также,
как и основная программа на Паскале.
Описываются
переменные, которые будут участвовать
в ее работе, но их имена не должны
повторять имена уже описанных входных
и выходных параметров в заголовке
программы. Далее описываются необходимые
для работы операторы.
В
нашем примере процедура
nod будет такой:
Procedure
nod(a, b : integer; var n : integer);
var
r
: integer;
begin
repeat
r := a mod b;
a := b; b := r
until
b = 0;
n := a
end;
Основная
программа строится обычным образом, но
там, где необходимо найти НОД чисел,
обращается к процедуре. Как?
Для
этого обращаются к ней по имени, а в
скобках записывают фактические значения
входных переменных (в нашем случае для
переменных a и b), а также имена выходных
переменных (в нашем случае k).
Из
приведенного ниже участка программы
видно, что при первом обращении к
процедуре nod определяется НОД чисел a и
b (nod(a, b, k)) и результат запоминается в
переменную k, далее, изменяются значения
переменных a и b
и снова вызывается процедура nod, которая
уже находит НОД чисел k и c и результат
присваивает переменной k.
Вы можете видеть
основную часть программы:
begin
write(‘Введите
три натуральных числа ‘); readln(a, b, c);
nod(a,
b,
k);
a
:= k;
b
:= c;
nod(a,
b,
k);
if
k
= 1 then
writeln(‘Числа
взаимно простые’)
else
writeln(‘Числа не взаимно простые’)
end.
Сделаем
общие выводы для построения и работы
процедур
Процедуры
помещаются в разделе описаний и начинается
зарезервированным (служебным) словом
Procedure
Процедуре
обязательно
дается имя, которое должно удовлетворять
тем же требованиям, что и имена переменных,
т.е. это может быть одна или несколько
букв, комбинация букв и целых чисел, но
без пробелов, начинаться с буквы и т.д.
После
имени, в скобках записываются переменные
— параметры и их тип: входные, значения
которых используются для вычисления в
качестве аргументов.
Выходные
параметры — это те переменные, в которых
получается результат выполнения
процедуры.
Входные
и выходные параметры процедуры называются
формальными
параметрами.
Фактические,
конкретные, значения формальные параметры
должны получить в основной программе
после обращения к ней (а пока в процедуре
они являются не чем иным, как «пустышками«).
После
формальных параметров, описываются
переменные, которые необходимы
непосредственно для работы процедуры.
Это
параметры
процедуры.
Они нужны в ней, как и в любой другой
программе и описываются также. Их имена
должны отличаться от имен входных и
выходных параметров.
Надо
заметить, что процедура может быть
такой, что в ней не будет вообще параметров,
достаточно тех, которые будут введены
из программы.
Описание процедуры
имеет вид:
Procedure <имя>
(<входные параметры> : <их тип>;
var
<выходные
параметры> : <их тип>);
(раздел
описаний)
begin
(раздел
операторов)
end;
Она
помещается в основной программе в
разделе описаний.
По
входным и выходным параметрам процедуры
могут быть следующих типов:
1)
иметь и
входные и выходные параметры:
Procedure <имя>(<входные
параметры> : <их тип>;
var <выходные
параметры> : <их тип>);
Мы только
познакомились с программой такого типа.
2)
иметь входные параметры, но не иметь
выходных:
Procedure <имя>(<входные
параметры> : <их тип>);
3)
иметь выходные
параметры, но не иметь входных:
Procedure <имя>(var
<выходные параметры> : <их тип>);
4)
не иметь ни
входных, ни выходных параметров:
Procedure <имя>;
В
зависимости от этого различаются
процедуры по своей конструкции и
выполняемым функциям.
Далее
следует раздел операторов, который
составляется по тем же правилам, как и
в других программах.
Процедура
описана и после этого начинается основная
программа.
Как происходит
вызов подпрограммы — процедуры?
Обязательно
указывается имя процедуры. В скобках
задаются фактические
значения входных параметров и те
переменные, в которые будут «запоминаться»
выходные значения.
Рассмотрим
пример, где может быть использована
процедура второго типа: имеет входные
параметры, но не имеет выходных.
Пример.
Составить программу, которая устанавливает,
какие числа из заданного промежутка
[a; b] можно представить в виде суммы двух
квадратов целых чисел?
В
этой программе, нам придется проверять
каждое из чисел промежутка [a; b] можно
ли его представить в виде суммы квадратов
двух чисел, поэтому было бы разумно
разработать процедуру, которая бы
проверяла одно число и затем обращаться
к ней из основной программы для проверки
каждого числа из промежутка.
Процедуру
составим по следующему способу. Пусть
задано число n. Нам необходимо найти
такие два числа a и b, чтобы сумма их
квадратов была равна n, т.е. решить в
целых числах уравнение:
Возникает
естественное желание испытывать
натуральные числа от 1 и до …? А вот до
какого значения неизвестно. Если их
брать до числа n, то это будет слишком
много лишней и бесполезной работы.
Чтобы
выяснить этот вопрос, можно организовать
цикл, в
котором проверять сколько чисел a надо,
чтобы выполнялось неравенство:
Здесь, в качестве b взято наименьшее
натуральное число 1. Организовав такой
цикл, и подсчитав, сколько чисел a
потребуется, мы узнаем сколько чисел
надо просматривать, чтобы найти решение
уравнения.
Этот цикл может
быть таким:
a
:= 1; k := 1;
while
a*a + 1<=n do
begin
k
:= k + 1;
a
:= a + 1
end;
Теперь ясно, что
для испытания чисел, следует устроить
цикл от 1 до k:
for a := 1 to k do
Второй
цикл должен
быть для значений b. Но если его организовать
тоже от 1 до k, тогда могут повторяться
дважды одинаковые значения, только на
разных местах, например, для числа 20
могут быть выданы следующие значения:
22
+ 42
= 20 и 42
+ 22
= 20.
Чтобы
избежать повторения чисел, цикл для
чисел b можно организовать либо от 1 до
a, либо от k до а.
Нами выбран первый
вариант.
Процедура
Procedure to_square(n :
integer);
label
1;
var
a, b, k : integer;
begin
a := 1; k := 1;
while a*a + 1<=n
do
begin
k := k + 1;
a := a + 1
end;
for a := 1 to k do
for b := 1 to a do
if a*a + b*b =
n
then
begin
writeln(n,
‘=’, a, ‘*’, a,’ +’, b, ‘*’, b); goto 1
end;
1: end;
Процедура
выполнена с досрочным прерыванием
цикла, так как нет необходимости выяснять
всевозможные значения пар чисел,
удовлетворяющих этому уравнению, а
достаточно просто выяснить возможность
такого представления.
Выполнив
такую процедуру, не составляет труда
решить полностью задачу. Для этого в
основной программе выполнить цикл для
всех чисел из промежутка, и каждое из
которых, с помощью процедуры проверять.
Кстати говоря, эта процедура имеет
только один формальный
параметр —
входной,
— значение проверяемого числа из
промежутка и не имеет выходных параметров.
Программа
Program Problem2;
var
a, b, i : integer;
{———————————————————————————}
Procedure to_square(n :
integer);
label 1;
var
a,
b, k : integer;
begin
a := 1; k := 1;
while a*a + 1 <=
n do
begin
k := k + 1;
a := a + 1
end;
for a := 1 to k do
for b := 1 to a
do
if a*a + b*b =
n
then
begin
writeln(n,
‘=’, a, ‘*’, a, ‘+’, b,’*’, b); goto 1
end;
1: end;
{———————————————————————————}
begin
write(‘Введите
начало
промежутка
‘); readln(a);
write(‘Введите конец
промежутка ‘); readln(b);
write(‘Числа,
которые можно представить в виде суммы
‘);
writeln(‘квадратов
следующих
чисел’);
for i := a to b do
to_square(i);
end.
Синтаксические ошибки в языке Паскаль: как их распознать и устранить
Язык программирования Паскаль, созданный Никлаусом Виртом в 1970 году, популярен в настоящее время в образовательных учреждениях, а также в некоторых отраслях промышленности. Как и в любом языке программирования, в Паскале возможны синтаксические ошибки, которые могут привести к неправильной работе программы или даже к ее отказу. В этой статье мы рассмотрим, как распознать и устранить синтаксические ошибки в языке Паскаль.
Что такое синтаксические ошибки
Синтаксические ошибки — это ошибки, связанные с несоблюдением синтаксических правил языка программирования. В Паскале, как и в других языках программирования, каждая команда должна быть записана в соответствии со структурой языка. Синтаксические ошибки могут возникать, например, при отсутствии одного из необходимых элементов или при наличии лишнего элемента в команде.
Как распознать синтаксические ошибки в Паскале
Синтаксические ошибки могут возникать на любом этапе написания програмы в Паскале. Они могут возникнуть, когда пишется новый код или когда меняется уже написанный код. Наиболее часто встречаются синтаксические ошибки при компиляции программы.
Компиляция программы
Компиляция — это процесс преобразования исходного кода программы на языке Паскаль в машинный код, который может быть выполнен на компьютере. Во время компиляции, утилита компилятора проверяет синтаксис програмы и сообщает об ошибках, если они обнаружены.
При компиляции программы в Паскале, компилятор сообщает об ошибках следующим образом:
Error: Incompatible types
Error: Undefined identifier
Error: Expected ; but found :
Эти сообщения указывают на конкретные ошибки в програме, которые могут быть исправлены.
Как устранить синтаксические ошибки в Паскале
Синтаксические ошибки в Паскале могут быть устранены путем внесения соответствующих изменений в исходный код программы.
Исправление ошибок при компиляции
Во время компиляции программы, компилятор сообщает об ошибках в исходном коде. Эти ошибки могут быть исправлены путем изменения кода таким образом, чтобы соблюдались синтаксические правила языка программирования.
Например, если компилятор сообщает об ошибке «Error: Undefined identifier», это означает, что переменная, которая используется в программе, не была определена ранее. Для исправления этой ошибки необходимо определить переменную перед тем, как она будет использоваться:
var
x: integer; // определение переменной
begin
x := 1;
end.
Исправление ошибок при исполнении программы
Синтаксические ошибки в Паскале также могут возникать во время выполнения программы. Эти ошибки могут быть связаны с неправильными значениями переменных, делением на ноль и другими причинами.
Чтобы избежать ошибок при выполнении программы, следует убедиться, что все переменные корректно инициализированы и что все математические операции выполняются без ошибок.
Выводы
В статье мы рассмотрели, что такое синтаксические ошибки в языке программирования Паскаль, как их распознать и исправить. Синтаксические ошибки могут возникать на любом этапе написания програмы, но их можно решить с помощью изменения кода. Следует убедиться, что все переменные корректно инициализированы и что все математические операции выполняются без ошибок.
Содержание
Отладка программ в Turbo Pascal
Автор: volvo877 (он же и volvo71)
Ссылка на оригинал статьи
(не хватает картинок из статьи)
Каждый программист знает, что программу надо не только написать, иначе говоря —
«заставить работать», а еще и отладить, т.е. заставить ее работать правильно…
Для того, чтобы делать это быстро и эффективно, желательно научиться
пользоваться встроенными в IDE средствами отладки программ…
Интегрированная интерактивная среда разработки программ Borland Pascal (IDE)
включает в себя ряд средств, облегчающих разработку программ: автоматическое
управление проектами, средств обеспечения модульной структуры программы,
быструю компиляцию и простые в использовании оверлеи. Но, несмотря на все это,
Ваша программа все равно может содержать ошибки, что не позволит ей корректно
работать.
IDE для DOS Borland Pascal предоставляет вам инструментальные средства для
отладки программ, то есть поиска и исправления ошибок. В этой статье
описываются инструментальные средства и процедуры отладки программы в
интегрированной среде Борланд Паскаль (большинство описанных возможностей
применимо также к IDE FreePascal-я).
Что такое отладка?
Отладка — это процесс поиска и исправления ошибок в программе, препятствующих
корректной работе программы. Перед тем как углубиться в специфические средства
IDE, которые помогают при отладке, дадим краткое описание видов ошибок, которые
Вы можете наблюдать, и различного рода операций, которые будут использоваться
для их поиска.
Какие существуют виды ошибок?
Существует три основных типа ошибок:
-
Ошибки этапа компиляции
-
Ошибки этапа выполнения
-
Логические ошибки
Ошибки этапа компиляции
Ошибки этапа компиляции или синтаксические ошибки происходят, когда
исходный код программы нарушает правила синтаксиса Паскаля. Компилятор не
может скомпилировать программу, пока она не будет содержать только
допустимые операторы Паскаля. Когда компилятор встречает оператор, который он не может распознать, соответствующий файл выводится в окне
редактирования, курсор устанавливается на то место, которое не понял
компилятор, и выводится сообщение об ошибке.
Наиболее общей причиной ошибок этапа компиляции являются ошибки набора (опечатки), пропущенные точки с запятой, ссылки на неописанные переменные, передача неверного числа (или типа) параметров процедуры или функции и присваивание переменной значения неверного типа.
После исправления ошибки компиляцию необходимо выполнить заново. После устранения в программе всех синтаксических ошибок и ее успешной компиляции программа будет готова к выполнению и поиску ошибок этапа выполнения и логических ошибок.
Ошибки этапа выполнения
Ошибки этапа выполнения или семантические ошибки происходят, когда вы
запускаете успешно откомпилированную программу, которая при выполнении
делает что-то недопустимое. То есть, программа содержит допустимые
операторы Паскаля, но при выполнении этих операторов что-то происходит
неверно. Например, программа может пытаться открыть для ввода
несуществующий файл или выполнить деление на ноль.
Когда такая ошибка обнаруживается, выполнение программы завершается, и выводится сообщение следующего вида:
Run-time error ## at seg:ofs
Если Вы выполняете программу из IDE, она автоматически находит оператор,
вызвавший ошибку (как и в случае синтаксических ошибок). Если же программа выполняется вне IDE (EXE-файл запускается из командной строки или файлового менеджера ОС), то вы можете запустить IDE и, чтобы найти вызвавший ошибку оператор, использовать команду Search → Find Error, которая дает вам адрес сегмента и смещения (seg:ofs).
Логические ошибки
Логические ошибки — это ошибки проектирования и реализации программы. То
есть, операторы, используемые в программе, допустимы, и что-то делают, но
не то, что Вы предполагали. Эти ошибки часто трудно отследить, поскольку
IDE не может найти их автоматически, как синтаксические и семантические
ошибки. К счастью, IDE включает в себя также и средства отладки, помогающие вам найти логические ошибки.
Логические ошибки приводят к некорректному или непредвиденному изменению значений переменных, неправильному отображению графики или невыполнению кода тогда, когда это ожидается. В остальной части этой статьи обсуждаются методы отслеживания логических ошибок.
Иногда, когда программа делает что-то непредвиденное, причина достаточно очевидна, и Вы можете быстро исправить код программы. Но другие ошибки более трудноуловимы и вызываются в результате взаимодействия различных частей программы. В этих случаях лучше всего остановить вашу программу в заданной точке, пройти ее шаг за шагом и просмотреть состояние переменных и выражений.
Пошаговый прогон: какая разница между F4, F7 и F8?
Основной смысл использования встроенного отладчика состоит в управляемом
выполнении. Отслеживая выполнение каждой инструкции, Вы можете легко
определить, какая часть Вашей программы вызывает проблемы. В отладчике
предусмотрено пять основных механизмов управления выполнением программы,
которые позволяют вам:
-
Выполнять инструкции по шагам
-
Трассировать инструкции
-
Выполнять программу до заданной точки
-
Находить определенную точку
-
Выполнять сброс программы
Само по себе выполнение программы по шагам может быть недостаточно полезным, разве что поможет найти то место, где что-то происходит совершенно неверно. Но управляемое выполнение дает Вам возможность проверять состояние программы и ее данных, например, отслеживать вывод программы и ее переменные.
Что такое шаг?
Когда Вы отлаживаете программу, наименьшим выполняемым элементом является
строка. Это означает, что Вы можете управлять отладкой до уровня отдельной строки исходного кода программы. Поэтому, если на одной строке программы содержится несколько операторов Паскаля, эти операторы не могут быть отлажены индивидуально. С другой стороны, с целью отладки оператор можно разбить на несколько строк, каждая из которых будет выполняться за один шаг.
Все выполнение в отладчике, включая выполнение по шагам, трассировку и останов, основывается на строках. Подсвечивая строку, встроенный отладчик всегда сообщает Вам, какую строку он выполнит на следующем шаге (строка выполнения). Строка выполнения выводится цветом, отличным от нормального цвета. Благодаря этому Вы можете легко видеть, где находитесь.
Выполнение программы по шагам
Выполнение по шагам — это простейший способ выполнения программы по
элементарным фрагментам. Выбор команды Run → Step Over или нажатие клавиши F8 вызывает выполнение отладчиком всего кода в операторе, указанном строкой выполнения, включая любые вызываемые на ней процедуры или функции, пока управление не вернется обратно к вам. После этого строка выполнения указывает следующий выполняемый оператор.
Возьмем, например, следующую программу:
program StepTest; function Negate(X: Integer): Integer; begin Negate := -X; end; var I: Integer; begin for I := 1 to 10 do Writeln(Negate(I)); end.
Если в окне редактирования Вы выведете StepTest и нажмете клавишу F8, то строка выполнения перемещается на оператор begin в начале основного цикла, поскольку это первое, что выполняется в программе. Второе нажатие клавиши F8 выполняет begin и перемещает строку выполнения вниз до оператора for на следующей строке.
После этого нажатие F8 вызывает выполнение всего цикла for; на экран
пользователя выводятся числа от -1 до -10, а строка выполнения перемещается к end.
Хотя функция Negate и вызывается 10 раз, строка выполнения никогда на нее не перемещается. Выполнение по шагам позволяет отладчику не показывать детали любых вызовов для отдельной строки. Выполнение по шагам вызывает выполнение всего цикла for сразу, поэтому Вы не сможете видеть изменения в ходе выполнения цикла. Если же Вы хотите видеть подробности выполнения цикла, внесите в пример следующее простое изменение.
begin for I := 1 to 10 do WriteLn(Negate(I)); end.
Поскольку оператор Паскаля может занимать несколько строк, такая программа будет в точности эквивалентна предыдущей версии, и генерируемый код будет идентичен. Но поскольку оператор WriteLn теперь находится на отдельной строке, отладчик может интерпретировать его отдельно. Если теперь Вы будете нажимать клавишу F8, то увидите, что строка выполнения будет при выполнении цикла 10 раз возвращаться на WriteLn.
Трассировка программы
Трассировка программы во многом аналогична ее выполнению по шагам. Единственное исключение состоит в том, что когда встречается оператор вызова процедуры/функции, при трассировке эти процедуры и функции также выполняются по шагам, а при простом выполнении по шагам управление возвращается вам после завершения выполнения подпрограммы.
Например, чтобы выполнить трассировку кода в вышеприведенном примере, загрузите файл, затем выберите команду Run → Trace Into или нажмите клавишу F7. Когда Вы в первый раз делаете это, управление перемещается на оператор begin основной программы. Повторное нажатие F7 снова перемещает строку управления на оператор for. После этого нажатие клавиши F7 трассирует вызов функции Negate — строка выполнения перемещается на оператор begin в блоке функции. Если Вы продолжаете нажимать F7, строка выполнения перемещается по функции, а затем, когда Вы дойдете до оператора end, возвращается к оператору вызова.
Формат программы влияет на поведение строки выполнения при трассировке, хотя и не в такой степени как при пошаговом выполнении. Если код сформатирован как в первоначальном варианте приведенного выше примера, то трассировка оператора for приводит к выполнению 10 раз функции Negate. Если вы разобьете оператор for на две строки, то трассировка оператора end функции возвращает строку выполнения: ту строку основной программы, которая будет выполняться следующей. Первые девять раз это снова будет вызов функции. В десятый раз строка выполнения перемещается на оператор end программы.
Трассировка или выполнение по шагам?
Пошаговое выполнение и трассировка выполняют одно и то же действие, кроме того случая, когда строка выполнения находится на строке вызова процедуры/функции, или когда выполняется оператор begin в начале программы или модуля, который использует другие модули.
Выполнение begin в блоке begin..end основной программы вызывает код
инициализации для любого используемого в программе модуля в том порядке,
который указывается в операторе uses программы. Аналогично, выполнение
оператора begin в начале секции инициализации вызывает код инициализации для любых модулей, используемых в данном модуле. Выполнение по шагам и трассировка работает в этих случаях как и следовало ожидать — пошаговое выполнение begin выполняет всю инициализацию, возвращая управление на следующий оператор только после того, как все будет завершено; при трассировке выполняется трассировка кода инициализации.
Пошаговое выполнение и трассировка методов объектов
Если в программе используются объекты, отладчик ведет себя аналогично своему поведению в случае обычных процедур/функций. Пошаговое выполнение метода интерпретирует метод как один шаг, возвращая управление к отладчику после того как метод завершает выполнение. Трассировка метода загружает и выводит на экран код метода и трассирует его операторы.
Выполнение больших фрагментов
Иногда, конечно, нежелательно выполнять по шагам всю программу только для того, чтобы добраться до того места, где возникает проблема. Отладчик дает Вам возможность выполнять сразу большой фрагмент программы до той точки, где вы хотите начать выполнение по шагам.
Чтобы задать в программе точку, до которой она должна выполняться, а затем остановиться, используйте команду Run → GoTo Cursor или клавишу F4. (Этим вы сообщите отладчику, что не хотите выполнять программу по шагам, пока не достигнете заданной точки.) Установите курсор на той строке, где вы хотите возобновить управление отладкой, затем нажмите клавишу F4. Заметим, что Вы можете сделать это как в начале сеанса отладки, так и когда уже выполните часть программы по шагам или протрассируете.
Внимание: С использованием этой команды связана одна особенность: если Вы хотите, чтобы программа выполнилась до определенной строки, и устанавливаете курсор внутри модуля (Unit), то этого не произойдет, Вы просто получите ошибку Cannot Run a Unit , и этим все закончится, т.к. IDE понимает это действие, как приказ запустить модуль, чего делать нельзя. Требуется объяснить IDE, чего Вы от нее хотите примерно так: «Запусти основную программу, и только потом выполни все, до текущего положения курсора». Для этого надо зайти в меню Compile → Primary File, указать системе основной файл (НЕ модуль) Вашего приложения, и
только после этого установить курсор внутрь модуля, и нажать F4…
Казалось бы, что поменялось? А вот что: теперь IDE точно знает — основным
файлом приложения является тот, который был установлен, как Primary File,
следовательно, совершенно нет необходимости запускать МОДУЛЬ, достаточно
запустить основной файл, и остановиться тогда, когда выполнение дойдет до
нужной строки в модуле.
Что такое окно Watches и как им пользоваться?
Выполнение программы по шагам или ее трассировка могут помочь Вам найти ошибки в алгоритме программы, но обычно желательно также знать, что происходит на каждом шаге со значениями отдельных переменных. Можно, конечно, по-старинке добавлять в необходимые места программы оператор WriteLn, который распечатает значение контролируемой переменной (а иногда просто нет другого выбора, например, при компиляции крупных проектов на Турбо Паскале возникает необходимость вообще отказаться от IDE, и пользоваться автономной версией компилятора — TPC — запускаемой из командной строки), но если уж есть возможность пользоваться средой программирования — то лучше использовать для контроля за переменными одно из специальных средств IDE: окно Watches (Просмотр) или диалоговое окно Evaluate and Modify (Вычисление и модификация).
Оба средства вычисления и просмотра работают на уровне выражений, поэтому важно определить, что считается выражением. Выражение состоит из констант, переменных и структур данных, скомбинированных с помощью операций и большинства встроенных функций. Почти все, что вы можете использовать в правой части оператора присваивания, может также использоваться в качестве отладочного выражения.
Элементы выражений отладчика
┌────────────────┬────────────────────────────────────────────────────┐ │Элемент │Допустимые значения │ │выражения │ │ ├────────────────┼────────────────────────────────────────────────────┤ │ │Все допустимые типы: Boolean, Byte, Char, │ │Константы │перечислимый тип, Integer, Longint, Real, Shortint, │ │ │Word и строковый тип. │ ├────────────────┼────────────────────────────────────────────────────┤ │Переменные │Все типы, включая типы, определенные пользователем. │ ├────────────────┼────────────────────────────────────────────────────┤ │ целочисленный│Любое целочисленное выражение с переменными │ │тип │границами диапазона. │ ├────────────────┼────────────────────────────────────────────────────┤ │ тип с │Любые выражения с плавающей точкой или целочисленные│ │плавающей точкой│выражения; лишние значащие цифры отбрасываются. │ ├────────────────┼────────────────────────────────────────────────────┤ │ │Любое символьное выражение, включая печатаемые │ │ символьный │символы в одинарных кавычках, целочисленные │ │тип │выражения, тип которых приведен к типу Char, и │ │ │контанты ASCII (#xx). │ ├────────────────┼────────────────────────────────────────────────────┤ │ булевский тип│True, False и все булевские выражения. │ ├────────────────┼────────────────────────────────────────────────────┤ │ перечислимый │Любые совместимые перечислимые константы или │ │тип │целочисленные выражения в рамках диапазона, тип │ │ │которых приведен к совместимому перечислимому типу. │ ├────────────────┼────────────────────────────────────────────────────┤ │ │Любые совместимые указатели или выражения с │ │ указатель │приведенными к ним типами; функция Ptr с │ │ │соответствующим параметрами. │ ├────────────────┼────────────────────────────────────────────────────┤ │ │Любая строковая константа (текст в одинарных │ │ строковый тип│кавычках); строковые переменные; строковые │ │ │выражения, состоящие из конкатенированных строковых │ │ │констант и переменных. │ ├────────────────┼────────────────────────────────────────────────────┤ │ │Любая множественная константа; любое выражение, │ │ множество │совместимое с множественным типом, в котором │ │ │используются операции +, - и *. │ ├────────────────┼────────────────────────────────────────────────────┤ │Приведение типа │Соблюдаются стандартные правила Паскаля. │ ├────────────────┼────────────────────────────────────────────────────┤ │Операции │Все операции Borland Pascal. │ ├────────────────┼────────────────────────────────────────────────────┤ │Встроенные │Все функции, допустимые в выражениях-константах. │ │функции │ │ ├────────────────┼────────────────────────────────────────────────────┤ │Массивы │Массивы Borland Pascal - Mem, MemL, MemW. │ └────────────────┴────────────────────────────────────────────────────┘
Разберем использование окна Watches
Вначале это окно нужно отобразить на экране. Делается это выбором пункта
меню Debug → Watch. На экране появится пустое окно с соответствующим заголовком.
Теперь запускаем программу в пошаговом режиме (нажатием клавиши F7, или
выбором меню «Run → Trace Into»), в редакторе устанавливаем курсор на
название переменной, за которой будем «следить», и жмем Ctrl+F7 (или меню
«Debug → Add Watch…») и подтверждаем выбор нажатием «Ok»… Всё…
Переменная добавлена в окно Watches, и можно наблюдать за ее значением на Watch каждом шаге выполнения программы…
Примечание: Если выбрать переменную для просмотра без предварительного
отображения пустого окна Watches на экране, ничего страшного не произойдет: IDE автоматически откроет окно Watches самостоятельно.
Например, после выполнения выделенной строки
i := 15;
значение переменной i будет уже равно не 0, а 15…
В окне Watches могут отображаться любые типы констант/переменных, объявленных в программе. Например, если описан массив …
const arr: array[1 .. 10] of integer = ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
… то можно просмотреть одновременно (!!!) как весь этот массив, так
и его левую и правую части… Для этого достаточно ввести во втором и Просмотр третьем случае не только название массива, но и стартовый элемент, и массива (через запятую) число повторений.
Кроме массивов и переменных встроенных типов возможно просматривать Просмотр также и записи (либо в простом формате — только имя переменной, либо в записи специальном — с добавлением спецификатора R.
Все возможные спецификаторы перечислены в таблице (перед любым спецификатором можно указать количество повторений, а если не нужно преобразовывать тип переменной, то сам спецификатор можно не указывать, чем я уже пользовался выше, при выводе части массива arr):
┌──────┬─────────────┬────────────────────────────────────────────────────────┐ │ │Тип, на │ │ │Символ│который он │Функция │ │ │влияет │ │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │$, H │целочисленные│Шестнадцатиричный. Выводит целочисленные значения с │ │или X │типы │префиксом $, включая те, которые содержатся в структуре │ │ │ │данных. │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │ │Char, │Символьный. Выводит специальные символы для кодов ASCII │ │C │строковые │0..31. По умолчанию такие символы выводятся в виде │ │ │типы │значений #xx. │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │ │целочисленные│Десятичный. Выводят целочисленные значения в десятичном │ │D │типы │виде (включая те, которые содержатся в структурах │ │ │ │данных). │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │Fn │с плавающей │С плавающей точкой. Выводит n значащих цифр, где n лежит│ │ │точкой │в диапазоне 2..18 (по умолчанию - 11). │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │ │ │Дамп памяти. Выводит n байт памяти, начиная с адреса, │ │nM │все │указываемого выражением. Если n не задано, то по │ │ │ │умолчанию оно равно значению размера в байтах типа │ │ │ │переменной. │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │P │указатели │Указатель. Выводит указатели в формате сегм:смещ (а не │ │ │ │Ptr(сегм:смещ), как это делается по умолчанию. │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │R │записи, │Запись. Выводит имена полей, например, (X:1;Y:10; Z:5) │ │ │объекты │вместо (1, 10,5). │ ├──────┼─────────────┼────────────────────────────────────────────────────────┤ │ │ │Строки. Выводит символы ASCII 0..31 в виде #xx. │ │S │Char, строки │Использует только для модификации дампов памяти (см. │ │ │ │выше nM). │ └──────┴─────────────┴────────────────────────────────────────────────────────┘
Окно Evaluate and Modify
Но кроме простого просмотра значений той или иной переменной или выражения,
существует средство, позволяющее вам в любой момент вычислять выражения и
изменять на этапе выполнения значения переменных. Этим средством и является
диалог Evaluate and Modify (Вычисление и модификация).
Вычисление выражений
Чтобы вычислить выражение, выбираем команду Debug → Evaluate/Modify или нажимаем клавиши Ctrl+F4. Отладчик выводит диалоговое окно Evaluate and Modify (Вычисление и модификация). Здесь (в поле ввода Expression) можно занести любое допустимое выражение , или выбрать его из списка ранее вычисленных при помощи этого же диалога выражений и отредактировать.
После нажатия на Enter или щелчка мышью на кнопке Evaluate (Вычислить), текущее значение выражения будет показано в поле Result (Результат).
Примечание: если в поле Expression введено выражение, которое не может быть вычислено интегрированной средой, то в поле Result появится вот такая надпись: «Cannot evaluate this expression».
Модификация переменных
Кроме этого, во время отладки с помощью диалогового окна Evaluate and Modify существует возможность поменять значение переменной на любое другое, чтобы проверить работу программы с другим, вновь присвоенным значением переменной. Для этого нужно установить курсор на имени переменной, и выбрать в меню Debug → Evaluate/Modify… (или просто нажать Ctrl+F4)…
В появившемся окне в поле Expression (Выражение) достаточно ввести имя переменной (или ничего не делать, если имя уже введено), и нажать кнопку Evaluate… Текущее значение выбранной переменной будет отображено в поле Result. Если оно же отображается и в поле New Value, это значит, что у Вас есть возможность прямо сейчас поменять это значение на любое другое (разумеется, совместимое по присваиванию с типом выбранной переменной; присваивать строке целому числу Вам никто не позволит, также, как и, например, записать в целочисленную переменную значение 3.14159), и применить новое значение переменной, не перезапуская программу…
Например, допустим, что программа имеет вид:
var i: integer; begin for i := 1 to 20 do writeln(i); readln; end.
, и Вам захотелось попасть в точку, где распечатывается значение i = 20 (желание далеко не самое сумасшедшее, представьте, например, что вместо простого распечатывания значения i там будет вызов какой-нибудь функции, которую надо прогнать пошагово при определенном значении i, да еще и функция может быть длинной и долго выполняться), но не очень хочется нажимать F7 почти 20 раз и приходить в нужную точку «естественным путем». Что делаем? А вот что:
Добавляем значение i в окно Watches, начинаем выполнять программу пошагово (F7)… Я остановился, когда значение i было равно трем, хотя это же самое можно было сделать и сразу после входа в цикл, то есть как только i стало равно единице.
Теперь ставим курсор под название переменной i и жмем Ctrl+F4 для вызова нужного нам окна… Состояние экрана, которое должно получиться, видно на скриншоте…
Переходим в поле New Value (как я говорил, если в нем записано текущее значение переменной, то нам будет позволено его сменить), печатаем в нем значение 20, и жмем на «Modify»…
Как видим, значение i в Watches тоже поменялось на 20, теперь спокойно закрываем окно «Evaluate and Modify» (кнопкой Cancel), и продожлжаем выполнять программу пошагово…
Таким образом, мы пропустили все НЕинтересующие нас в данном случае шаги,
выполнение которых могло занять значительное время…
Окно Call Stack — что это такое?
В IDE Паскаля есть еще одно очень удобное средство отладки — просмотр стека вызовов подпрограмм. Представьте себе, что программа имеет не только основную часть, но и несколько процедур/функций, вызывающих друг друга. В таком случае при пошаговой отладке становится сложно держать в памяти, какая именно процедура вызвала ту, что выполняется сейчас, и куда, соответственно, вернется управление после завершения текущей подпрограммы.
Да и не нужно этого держать в голове. Для этого существует такое средство, как «Call Stack» (вызывается из меню Debug → Call Stack или просто Ctrl+F3). Например, пусть наша программа имеет вид:
function fact(n: longint): longint; begin if n = 0 then fact := 1 else fact := n * fact(n - 1); end; function b(n: longint): integer; begin b := 2 * fact(n); end; begin writeln( b(10) ); end.
Если начать выполнять ее пошагово, очень скоро можно запутаться в том, что именно сейчас выполняется (факториал какого числа вычисляется в данный момент, к примеру), и что еще осталось НЕзавершенным. А если программа будет в 10 раз длиннее, и будет содержать не 2, а 10 процедур/функций? В таком случае достаточно вызвать окно Call Stack (способ вызова — выше), и посмотреть, что именно в данный момент выполняется (то есть находится на першине стека вызовов), и что еще выполняться будет (находится ниже в списке), вплоть до Program, обозначающего, самый нижний уровень — основную программу…
Вот, например, в данном случае: выполняется функция вычисление факториала 8, которая вызвана из нижестоящей в списке функции вычисления факториала 9, которая в свою очередь… Ну, дальше все понятно… При продолжении пошагового выполнения этой программы в окно Call Stack будут добавляться новые и новые вызовы Fact (7), Fact(6), … до Fact(0); потом рекурсия начнет раскручиваться обратно…
Кстати, Call Stack — незаменимый помощник именно при работе с рекурсивными подпрограммами, поскольку дает возможность контролировать последовательность вызовов рекурсивной функции, и на ранней стадии определить, например, бесконечную рекурсию…
Например, здесь — совершенно очевидно, что рекурсивная функция оформлена неверно (отсутствует ветка Else), сразу после того, как в окне Call Stack появились вызовы f (-1) и f(-2)…
Еще одно полезное применение окна Call Stack — если вы случайно начали трассировку кода, который хотели бы выполнить за один шаг. В стеке вызовов вы можете найти тот вызов, который начали трассировать по ошибке, затем выбрать команду Run to Cursor, чтобы выполнить за один шаг остальную часть вызова.
Что такое точки останова программы?
Кроме всех вышеперечисленных возможностей, значительно облегчающих жизнь программисту, в IDE Паскаля встроено еще одно средство, очень мощное и эффективное (при правильном использовании)… Это — работа с точками останова программы (BreakPoints).
Точка останова — это обозначенная в коде программы позиция, в которой вы хотите прекратить выполнение программы и вернуть выполнение отладчику. В этом смысле точка останова работает аналогично команде GoTo Cursor, при которой программа выполняется обычным путем до достижения определенной точки. Основное различие состоит в том, что вы можете задать несколько точек останова и точки останова, которые будут срабатывать не при каждом их достижении.
Допустим, есть следующая программа:
const parameter = 10; function f(x: integer): integer; begin f := 10 * parameter - sqr(x); end; var i, j: integer; arr: array[1 .. 20] of real; begin for i := 1 to 20 do begin j := f(i); arr[i] := (15 * j / parameter) + i / j - 8; end; { ... } end.
(не обольщайтесь, программа может быть не в 17, а в 1700 строк длиной, и функция f может быть гораздо более сложной, так же как и способ ее вызова)…
Естественно, запустив эту программу, получаем:
Runtime error 200 at 0006:0004.
, из чего заключаем, что где-то в программе происходит деление на 0. Ну, где
оно происходит, понятно. А вот на какой итерации? Чему равно i, при котором
происходит эта ошибка? Можно, конечно, воспользоваться старым и проверенным
способом, и сделать так:
const parameter = 10; function f(x: integer): integer; begin f := 10 * parameter - sqr(x); end; var i, j: integer; arr: array[1 .. 20] of real; begin for i := 1 to 20 do begin j := f(i); writeln('j = ', j); arr[i] := (15 * j / parameter) + i / j - 8; end; { ... } end.
, после чего нам будут распечатаны все значения j, для которых программа отработала нормально, и еще одно, при котором как раз и произошло «Деление на Ноль». Но для этого нужно вносить изменения в программу. А можно обойтись без её изменений… Используя точку останова…
Для этого проделаем следующее… Во-первых, добавим переменную i в список Watches, так как нам нужно найти именно «при каком i программа вылетает».
Далее — установим курсор на той строке программы, где происходит деление, и выберем в меню пункт «Debug → Add Breakpoint…» Экран примет вид, показанный на снимке справа.
Примечание: строка, на которую устанавливается BreakPoint, должна содержать выполняемый код и не может быть комментарием, описанием или пустой строкой…
В поле Condition внесем условие, при котором следует остановить программу (условие вводится так же как и при использовании условных операторов в программе, только Условный If здесь присутствовать не должно), и подтверждаем установку BreakPoint-а нажатием кнопки «Ok»:
Строка, в которой установлен хотя бы один BreakPoint (а устанавливать можно несколько точек останова для программы, причем даже на одной строке, но с разными условиями, может быть установлено более одного BreakPoint-а) меняет цвет на красный…
Если теперь запустить программу (обычным способом — через Ctrl+F9, или пошагово, не имеет значения), то как только значение j в Условный выделенной строке станет равным 0, прогон программы будет приостановлен с выдачей вот такого сообщения:
Как видим (в окне Watches), происходит это при i = 10… Что и требовалось
определить…
Чтобы просмотреть, какие BreakPoint-ы были установлены в программе, достаточно зайти в меню «Debug → BreakPoints», и будет выведен список всех точек останова для данной программы:
Нажатием на «Clear All» можно удалить все точки останова сразу, «Delete» удалит только подсвеченный BreakPoint, а «Edit»-ом можно отредактировать текущий (подсвеченный) BreakPoint — подкорректировать условие, поменять номер строки, в которой должна производиться проверка, изменить счетчик числа проходов (задание для точки останова счетчика проходов сообщает отладчику, что останавливать программу нужно не при каждом достижении точки останова, а только на n-ый раз. То есть, если счетчик проходов равен 3, то отладчик останавливает программу только при третьем достижении данной точки останова) и т.д.
Поиск нужного места
IDE предусматривает два способа поиска в программе заданного места. Простейший способ предоставляет команда Find Procedure (Поиск процедуры) из меню Search. Эта команда запрашивает у Вас имя процедуры или функции, затем находит соответствующую строку в файле, где определяется эта подпрограмма. Этот подход полезно использовать при редактировании, но его можно комбинировать с возможностью выполнения программы до определенной точки, чтобы пройти программу до той части кода, которую вы хотите отладить.
Повторное выполнение (сброс программы)
В ходе сеанса отладки иногда желательно начать все сначала. Выберите команду Run → Reset Program или нажмите клавиши Ctrl+F2. Это приведет к полному сбросу, так что выполнение по шагам, или трассировка начнется в начале основной программы.
Отслеживание вывода программы
При выполнении программы по шагам часто полезно просмотреть вывод программы, называемый экраном пользователя. IDE предоставляет несколько способов просмотра экрана пользователя.
Переключение экранов
В любой момент сеанса отладки вы можете выполнять переключение экрана IDE и экрана пользователя. Чтобы вывести экран пользователя, нажмите клавиши Alt+F5. Чтобы вернуться в IDE, нажмите любую клавишу или щелкните «мышью».
Окно Output
IDE для DOS предусматривает для экрана пользователя окно, которое называется окном вывода. Выбрав команду меню Debug → Output, вы можете открыть (вывести на передний план) активное окно, содержащее вывод программы. Настроить размер этого окна можно аналогично окну редактирования.
СООБЩЕНИЯ КОМПИЛЯТОРА ОБ ОШИБКАХ
§ Если в меню Options?Linker?Link Buffer, установлен параметр Memory, переключите его в значение Disk.
§ Возможно программа слишком велика, чтобы компилироваться в таком объеме памяти. Следует разбить ее на два или более модуля.
§ несоответствующее количество begin и end (не забудьте, что оператор case также заканчивается словом end);
§ включаемый файл заканчивается в середине раздела операторов. Каждый раздел операторов должен целиком помещаться в одном файле;
§ незаконченный комментарий.
§ несовместимые типы переменной и выражения в операторе присваивания;
§ несовместимые типы фактического и формального параметров в обращении к процедуре или функции;
§ тип выражения, несовместимый с типом индекса при индексировании массива;
§ несовместимые типы операндов в выражении.
§ Идентификатору функции можно присваивать значения только внутри раздела операторов данной функции.
§ Объектный файл .obj определяет идентификаторы PUBLIC, которые не находятся в сегменте CODE.
§ Идентификатор обозначает абсолютную переменную.
§ Идентификатор обозначает процедуру или функцию типа inline.
§ Файл .com содержит ссылки с размерами в байтах на перемещаемые идентификаторы. Такая ошибка происходит в случае, если вы используете операторы HIGH и DOWN с перемещаемыми идентификаторами или если вы ссылаетесь в директивах DB на перемещаемые идентификаторы.
§ Операнд ссылается на перемещаемый идентификатор, который не был определен в сегменте CODE или в сегменте DATA.
§ Операнд ссылается на процедуру EXTRN или функцию EXTRN со смещением, например CALL SortProc+8.
§ Процедуры или функции были описаны с помощью описания forward, но их определение не найдено.
§ Вы пытаетесь осуществить приведение типа выражения, когда разрешается только ссылка на переменную, процедуру или функцию.
§ Вы пытаетесь присвоить константу вне диапазона переменной.
§ Вы пытаетесь передать константу вне диапазона в качестве параметра процедуре или функции.
Размер локальных переменных, описанных в программе или функции, не может превышать 64 Кбайт.
1
Error 1: Out of memory
Нехватка памяти
Это сообщение выводится, когда компилятору не хватает памяти
2
Error 2: Identifier expected
Ожидался идентификатор
Возможно, имя вашего идентификатора совпадает со служебным словом
3
Error 3: Unknown identifier
Неизвестный идентификатор
Этот идентификатор не был описан
4
Error 4: Duplicate identifier
Идентификатор продублирован
Этот идентификатор уже исполь-зовался в текущем блоке программы
5
Error 5: Syntax error
Синтаксическая ошибка
В тексте найден неправильный символ
6
Error 6: Error in real constant
Ошибка в константе действительного типа
Возможно, вы поставили десятичную запятую вместо десятичной точки
7
Error 7: Error in integer constant
Ошибка в константе целого типа
Константы, выходящие за пределы диапазона типа longint описы-ваются как действительные числа
8
Error 10: Unexpec—ted end of file
Неожиданный конец файла
Количество операторов Begin и End не сбалансирована
9
Error 11: Line too long
Строка слишком длинная
Длина строки не должна превышать 127 символов
10
Error 12: Type identifier expected
Ожидается иденти-фикатор типа
Этот идентификатор не обозначает тип, как это должно быть
11
Error 15: File not found
Файл не найден
Файл не был найден ни в текущем каталоге, ни в других каталогах
12
Error 20: Variable identifier expected
Ожидается идентификатор переменной
Этот идентификатор не обозначает переменной, как должен был
13
Error 21: Error in type
Ошибка в типе
Этот символ не может начинать описание типа
14
Error 25: Invalid string length
Неправильная длина строки
Описанная максимальная длина строки должна быть в диапазоне 1…255
15
Error 26: Type mismatch
Несоответствие типов
Несовместимые типы переменной и выражения в операторе присваива-ния, несовместимые типы операн-дов в выражении, несовместимые типы формальных и фактических параметров в вызванной подпрограмме
16
Error 31: Constant expected
Ожидается константа
17
Error 32: Integer or real constant expected
Ожидается целая или действительная константа
18
Error 34: Invalid function result type
Неправильный тип результата функции
Правильными типами результата функции являются все простые типы
19
Error 36: BEGIN expected
Ожидается оператор Begin
20
Error 37: END expected
Ожидается оператор End
21
Error 38: Integer expression expected
Ожидается целое выражение
Предыдущее выражение должно быть целого типа
22
Error 41: Operand types do not match operator
Типы операндов не отвечают оператору
Оператор не может быть применён к операндам указанного типа
23
Error 42: Error in expression
Ошибка в выражении
Этот символ не может присутствовать в выражении
24
Error 50: DO expected
Ожидается служебное слово do
25
Error 54: Of expected
Ожидается служебное слово of
26
Error 57: THEN expected
Ожидается служеб-ное слово Then
27
Error 58: TO or DOWNTO expected
Ожидается служеб-ное слово to или downto
28
Error 62: Division by zero
Деление на нуль
Предыдущая операция пытается выполнить деление на нуль
29
Error 92: «[» or «(.» expected
Тут должна быть открывающая квадратная скобка
Вместо открывающей квадратной скобки можно использовать «(.»
30
Error 93: «]» or «).» expected
Квадратные скобки не закрыты
Вместо закрывающей квадратной скобки можно использовать «).»
31
Error 98: Integer variable expected
Ожидается переменная целого типа
32
Error 103: Integer or real variable expected
Ожидается пере-менная целого или вещественного типа
33
Error 108: Over—flow in arithmetic operation
Переполнение в арифметической операции
Результат предыдущей операции выходит за пределы использованного типа данных.
34
Error 113: Error in statement
Ошибка в операторе
Оператор не может начинаться с этого символа